泛型（带点委托）

泛型类：

    //泛型类
    class MyClass<T>
    {

        private T _val;

        public T Val
        {
            get { return _val; }
            set { _val = value; }
        }

        public MyClass(T[] _names)
        {
            this.names = _names;
        }

        private T[] names = null;


        public void Show()
        {
            foreach (T item in names)
            {
                Console.WriteLine(item);
            }
        }
    }

            MyClass mc = new MyClass(new string[] { "A", "B", "C" });
            MyClass<int> mc = new MyClass<int>(new int[] { 10, 20, 30 });
            MyClass<string> mc = new MyClass<string>(new string[] { "A", "B", "C" });
            mc.Show();
            Console.Read();

泛型方法：

    //泛型方法
    public class Person
    {
        //方法后直接写<T>就表示是一个泛型方法
        public void Show<T>(T msg)
        {
            Console.WriteLine(msg);
        }
    }

使用：

            Person p = new Person();
            //p.Show<string>("aaaaaa");

            //p.Show<int>(123);
            //对于泛型方法下面的两种调用方式都是正确的。没写的时候会自动识别
            p.Show("aaaaaa");
            p.Show<string>("fdsfds");

            Console.Read();

泛型接口：

    //泛型接口
    public interface IFlyable<T>
    {
        void Fly(T msg);

        T GetTValue(T msg);
    }

实现：

    //编写一个类来实现泛型接口
    //一个普通类实现了泛型接口
    public class SupperMan : IFlyable<string>
    {

        #region IFlyable<string> 成员

        public void Fly(string msg)
        {
            Console.WriteLine(msg);
        }

        #endregion
    }

    //泛型类实现泛型接口,尖括号内可以不是T，单多数定义为T，
    //泛型类实现泛型接口，当泛型类是什么类型，就把该类型给泛型接口
    //where 是限制条件

    public class SpiderMan<YZK, W> : IFlyable<YZK> where YZK : new()
    {

        #region IFlyable<YZK> 成员

        public void Fly(YZK msg)
        {
            throw new NotImplementedException();
        }

        #endregion

        #region IFlyable<YZK> 成员


        public YZK GetTValue(W msg)
        {
            return new YZK();
        }

        #endregion
    }

 泛型委托：

注意，以后只要用到委托，基本上不用我们自己定义，.NET都已经给我们定义好了

public delegate void M1Delegate(string msg);

//泛型委托
public delegate void MGenericDelegate<T>(T arg);

#region 泛型委托
            //M1Delegate md = M1;
            //md("aaaaaaaa");
            //Console.Read();

            //M1Delegate md = M2;

            //Console.Read();
            //MGenericDelegate<string> md = M1;
            //md("aaaa");

            //MGenericDelegate<int> md = M2;
            //md(1000);

            MGenericDelegate<double> md = M3;
            md(993.5);
            Console.Read();






static void M1(string msg)
        {
            Console.WriteLine(msg);
        }
        static void M2(int msg)
        {
            Console.WriteLine(msg);
        }
        static void M3(double msg)
        {
            Console.WriteLine(msg);
        }
        static void M4(float msg)
        {
            Console.WriteLine(msg);
        }
        static void M5(Person msg)
        {
            Console.WriteLine(msg);
        }

系统内置泛型委托：

Func，无论多少泛型，永远最后一个泛型是返回值类型

Action没有返回值，泛型都是参数

list.where() 括号内是一个泛型委托

#region 系统内置的泛型委托
            //只要是Action委托都是无返回值的。一或以上个参数用泛型Action，无参无返回值用Action

            //1.存储无参数无返回值的方法
            Action md = () => { Console.WriteLine("无参数无返回值。"); };
            md();
            Console.Read();


            //2.有两个参数没有返回值
            Action<string, int> md = (s, i) => { Console.WriteLine(s + "   " + i); };
            md("aaaaaaa", 10);
            Console.Read();



            //当需要存储带返回值的方法的时候,就需要使用另外一个泛型委托Func

            //返回值是string
            Func<string> fn = T1;

            string ss = fn();
            Console.WriteLine(ss);
            Console.Read();


            //返回值是string类型，参数是一个int类型
            Func<int, string> fn = n => n.ToString();
            Console.WriteLine(fn(10));
            Console.Read();

            Func<int, int, string> fn = T2;
            Console.WriteLine(fn(12, 5));
            Console.Read();

            Action<string>
            #endregion

 泛型约束：

    //使用泛型约束，约束了T只能是值类型
    class MyClass<T> where T : struct
    {

    }


    //使用泛型约束，约束了T只能是引用类型不能是值类型
    class MyClass<T> where T : class
    {

    }

    //限制T必须是实现了某个接口的类型,要求T必须是实现了IComparable接口的子类型对象或者就是该接口类型对象 
    class MyClass<T> where T : IComparable
    {
    }


    //要求T必须是Person类型，或者是Person类的子类
    class MyClass<T> where T : Person
    {
    }

    //要求T必须是Person类型，或者是Person类的子类
    class MyClass<T, V>
        where T : Person
        where T : new() //要求将来传递进来的类型必须具有一个无参数的构造函数
        where V : T
    {
    }


    //对T没有要求，但是V必须是T类型或者T类型的子类型
    class MyClass<T, V>
        where V : T
    {
    }