C#泛型 IList<>

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace IList_IEnumable
{
    class Users
    {
        public string Name;
        public int Age;
        public Users(string _name, int _age)
        {
            Name = _name;
            Age = _age;
        }
    }

    class Program
    {
        //ConvertIListtolist<T>是说明这个方法是一个泛型方法       
        //(IList<T> gblist)是一个IList<T>类型 名字为gblist的参数（其实就是一个形参）
        //where T : class是一个参数类型约束，指定T必须是class类型
        public static List<T> ConvertIListtolist<T>(IList<T> gblist) where T : class
        {
            if (gblist != null || gblist.Count >= 1)
            {
                List<T> list = new List<T>();
                for (int i = 0; i < gblist.Count; i++)
                {
                    T temp = (T)gblist[i]; //IList元素复制到List中
                    if (temp != null)
                    {
                        list.Add(temp);
                    }
                }
                return list;
            }
            return null;
        }


        static void Main(string[] args)
        {
            Users u = new Users("张三",25);
            IList<Users> mylist = new List<Users>();
            mylist.Add(u);
            u = new Users("李四", 22);
            mylist.Add(u);

            //遍历mylist
            foreach (Users i in mylist)
            {
                Console.WriteLine(i.Name);
            }
            Console.ReadKey();

            //或者用这种方式
            List<Users> list = ConvertIListtolist<Users>(mylist);

            Console.WriteLine(list[0].Name);
            Console.WriteLine(list[1].Name);

            
        }

       

        
    }
}<span style="font-size:18px;">
</span>

====================================================================================

泛型类是使用，及概念

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace 泛型
{
    //定义一个泛型类，该类有两个类型参数，分别是T,S  
    public class Test<T,N>
    {
        private T Name { get; set; } 
        private N Age { get; set; }
        //构造函数，初始化两个属性
        public Test(T name,N age)
        {
            this.Name = name;
            this.Age = age;
        }

        public void SetValue()
        {
            Console.WriteLine("Hi,我的名字叫{0}，我今年{1}岁", Name, Age);
        }
    
    }
    class Program
    {
        static void Main(string[] args)
        {
            //使用string，int来实例化Test<T,N>类。这里调用了带两个参数的构造函数
            Test<string, int> t = new Test<string, int>("tom", 25);
            t.SetValue();
            Console.ReadKey();                     
            
        }
    }
}

继承泛型类

上面的例子不是很恰当，目的是让初学泛型的你了解一下泛型的定义及实例化方法，如上，我们定义了一个泛型类，那么如何实现C#泛型类的继承呢？这里需要满足下面两点中的任何一点即可：

1、泛型类继承中，父类的类型参数已被实例化，这种情况下子类不一定必须是泛型类；

2、父类的类型参数没有被实例化，但来源于子类，也就是说父类和子类都是泛型类，并且二者有相同的类型参数；

 //如果这样写泛型继承的话，显然会报找不到类型T，S的错误。
    //public class TestChild : Test<T, S> { }

    //正确写泛型类继承的写法应该是这样的
    public class TestChild : Test<string, int> { }
    public class TestChild<T, S> : Test<T, S> { }
    public class TestChild<T, S> : Test<string, int> { }

继承泛型接口

接着我们来看看泛型接口，其创建以及继承规则和上面说的泛型类是一样的，看下面的代码：

接口中只能包含方法、属性、索引器和事件的声明。不允许声明成员上的修饰符，即使是pubilc都不行，因为接口成员总是公有的，也不能声明为虚拟和静态的。如果需要修饰符，最好让实现类来声明。

接口默认访问符是internal
接口的成员默认访问修饰符是public 

    public interface IList<T> 
    {
        T[] GetElements(); //定义了一个GetElements()方法，这个方法的返回值类型为T类型的数组。相当于 pulbic string[] GetElements()
    }

    public interface IDictionary<K, V> //定义一个泛型接口，该接口有两个类型参数，分别是K,V ；如果是普通的数组就这样声明public interface IDictionary
    {
        void Add(K key, V value);
    }

    //定义一个List<T>泛型类，让它继承IList<T>,IDictionary<int ,T>泛型接口
    //泛型接口的类型参数要么已经实例化
    //要么来源于实现类声明的类型化参数
    class List<T> : IList<T>, IDictionary<int, T> 
    {
        public T[] GetElements() //实现泛型接口
        {
            return null;
        }

        public void Add(int index, T value) //实现泛型接口
        {
            Console.WriteLine ("第{0}项的值是{1}",index,value);
        }
    }