C#接口和泛型类

1.定义：

定义为一个约束，实现接口的类或者结构必须遵守该约定。借口是类之间交互的一个协议。定义了类之间的交互标准。

接口是类之间相互交互的一个抽象，把类之间需要交互的内容抽象出来定义成接口。

接口只包含成员定义，不包含成员的实现。接口不会继承自任何的 System.Object 派生类型。接口仅仅是一个包含着一组虚方法的抽象类型

成员的实现需要在继承的类或者结构中实现接口的成员包括静

态方法、索引器、常数、事件以及静态构造器。不能实例化一个接口

.NET 框架中的接口

(1) IComparable 接口

IComparable 接口定义通用的比较方法。由类型使用的 IComparable 接口提供了一种比较多个对象的标准方式。如果一个类要实现与其它对象的比较，则必须实现 IComparable 接口

(2) IEnumerable 接口

IEnumerable 接口公开枚举数，该枚举数支持在集合上进行简单迭代。
IEnumerable 接口可由支持迭代内容对象的类实现

(3) IEnumerator 接口

IEnumerator 接口支持在集合上进行简单迭代。是所有枚举数的基接口。
枚举数只允许读取集合中的数据，枚举数无法用于修改基础集合。

(4) ICollection 接口

ICollection 接口定义所有集合的大小、枚举数和同步方法。ICollection
接口是 System.Collections 命名空间中类的基接口。

(5) IDictionary 接口
IDictionary 接口是基于 ICollection 接口的更专用的接口。IDictionary 实现
是键/值对的集合，如 Hashtable 类。

（6) IList 接口

IList接口实现是可被排序且可按照索引访问其成员的值的集合，如ArrayList类

泛 型 的接 口 ， 如 IComparable<T> 、

IEnumerable<T> 、 IEnumerator<T> 、 ICollection<T> 、 IDictionary<T> 和
IList<T>等。泛型接口的功能与非泛型接口的功能一样，只不过适用于更多的类

System.Collections 名称空间中的“内置”集合划分成了三种类别：

(1) 有序集合：仅仅实现 ICollection 接口的集合，在通常情况下，其数据项的
插入顺序控制着从集合中取出对象的顺序。System.Collections.Stack 和
System.Collections.Queue 类都是 ICollection 集合的典型例子

(2) 索引集合：实现 Ilist 的集合，其内容能经由从零开始的数字检索取出，就
象数组一样。System.Collections.ArrayList 类是索引集合的一个例子

(3) 键式集合：实现 IDictionary 接口的集合，其中包含了能被某些类型的键值
检索的项。IDictionary 集合的内容通常按键值方式存储，可以用枚举的方式排
序检索。

2、接口与抽象类

抽象类(Abstract Class)和接口在定义与功能上有很多相似的地方，在程序
中选择使用抽象类还是接口需要比较抽象类和接口之间的具体差别

抽象类是一种不能实例化而必须从中继承的类，抽象类可以提供实现，也可
以不提供实现。子类只能从一个抽象类继承。抽象类应主要用于关系密切的对象。
如果要设计大的功能单元或创建组件的多个版本，则使用抽象类。
接口是完全抽象的成员集合，不提供实现。类或者结构可以继承多个接口。
接口最适合为不相关的类提供通用功能。如果要设计小而简练的功能块，则使用
接口

 public interface IBook
    {
        void ShowBook();
        string GetTitle();
        int GetPages();
        void SetPages(int pages);
    }

　　

public class NewBook:IBook
    {
        public string title;
        public int pages;
        public string author;
        public NewBook(string title, string author, int pages)
        {
            this.title = title;
            this.author = author;
            this.pages = pages;
        }
        
        public void ShowBook()
        {
            Console.WriteLine("Title:{0}", title);
            Console.WriteLine("Author:{0}", author);
            Console.WriteLine("Pages:{0}", pages);
        }

        public string GetTitle()
        {
            return title;
        }

        public int GetPages()
        {
            return pages;
        }

        public void SetPages(int pages)
        {
            this.pages = pages;
        }
    }

　　

 static void Main(string[] args)
        {
            NewBook newBook = new NewBook("C#编程", "laoshi", 500);
            newBook.ShowBook();
            Console.ReadKey();
        }

　　基于 object 的容器的 C#实现如下：

 public class Container
    {
        readonly int m_Size; //容器的容量
        int m_ContainerPointer; //容器指针，指示最后一个元素的位置
        object[] m_Items; //容器数组，存放数据
        //无参构造器
        public Container() : this(100)
        {
            m_ContainerPointer = -1;
            m_Size = 100;
        }
        //有参构造器
        public Container(int size)
        {
            m_Size = size;
            m_Items = new object[m_Size];
            m_ContainerPointer = -1;
        }

        //获取容器元素个数属性
        public int Count
        {
            get {
                return m_ContainerPointer;
            }
        }
        //容器是否为空
        public bool IsEmpty
        {
            get {
                return (m_ContainerPointer == -1);
            }
        }
        //容器是否已满
        public bool IsFull
        {
            get {
                return (m_ContainerPointer == m_Size - 1);
            }
        }
        //在容器的尾部插入一个元素
        public void Insert(object item)
        {
            if (IsFull)
            {
                Console.WriteLine("Container is full");
                return;
            }
            else if (IsEmpty)
            {
                m_Items[++m_ContainerPointer] = item;
            }
            else {
                m_Items[++m_ContainerPointer] = item;
            }
        }
        //从容器的尾部删除一个元素
        public object Delete()
        {
            if (m_ContainerPointer >= 0)
            {
                return m_Items[m_ContainerPointer--];
            }
            return null;
        }
    }

　　1.存在性能问题  2.类型安全  3.工作效率

2、泛型的概念
通过泛型可以定义类型安全的并且对性能或工作效率无损害的类

public class Container<T>
    {
        readonly int m_Size; //容器的容量
        int m_ContainerPointer; //容器指针，指示最后一个元素的位置
        T[] m_Items; //容器数组，存放数据
        //构造器
         public Container() : this(100)
        {
            m_ContainerPointer = -1;
            m_Size = 100;
        }
        //构造器
        public Container(int size)
        {
            m_Size = size;
            m_Items = new T[m_Size];
            m_ContainerPointer = -1;
        }
        //获取容器元素个数属性
        public int Count
        {
            get {
                return m_ContainerPointer;
            }
        }
        //容器是否为空
        public bool IsEmpty
        {
            get {
                return (m_ContainerPointer == -1);
            }
        }
        //容器是否已满
        public bool IsFull
        {
            get {
                return (m_ContainerPointer == m_Size - 1);
            }
        }
        //在容器的尾部插入一个元素
        public void Inset(T item)
        {
            if (IsFull)
            {
                Console.WriteLine("Container is full!");
                return;
            }
            else if (IsEmpty)
            {
                m_Items[++m_ContainerPointer] = item;
            }
            else {
                m_Items[++m_ContainerPointer] = item;
            }
        }
        //从容器的尾部删除一个元素
        public object Delete()
        {
            if (m_ContainerPointer >= 0)
            {
                return m_Items[m_ContainerPointer--];
            }
            return null;
        }

    }