C#泛型委托及约束

泛型委托：

namespace 泛型委托
{
    public delegate void Mydelegate<T>(T msg);
    class Program
    {

        static void Main(string[] args)
        {
            //Mydelegate<int> myDelgate = M1;
            //M1(5);
            Mydelegate<string> mydelgate = M4;
            M4("abcd");
            Console.ReadKey();

        }
        #region 泛型委托
        public static void M1(int msg)
        {
            Console.WriteLine(msg);
        }
        public static void M2(double msg)
        {
            Console.WriteLine(msg);
        }
        public static void M3(float msg)
        {
            Console.WriteLine(msg);
        }
        public static void M4(string msg)
        {
            Console.WriteLine(msg);
        }
        public static void M5(Person msg)
        {
            Console.WriteLine(msg);
        }
        #endregion
    }
    class Person { };

}

    class Program
    {

        static void Main(string[] args)
        {

            List<int> list = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8 };
            List<int> listresult = list.FindAll(n => n > 4);
            for (int i = 0; i < listresult.Count; i++)
            {
                Console.WriteLine(listresult[i]);
            }
            Console.ReadKey();
        }

    }

系统内置的泛型委托

    class Program
    {

        static void Main(string[] args)
        {

            #region 系统内置的泛型委托
            //action委托无返回值
            Action<int, int> md = (int n1, int n2) => { Console.WriteLine(n1 + n2); };
            md(3,4);
            Console.ReadKey();

            //当需要存储带返回值的方法的时候,就需要使用另外一个泛型委托Func
            Func<string> md1 = () => System.DateTime.Now.ToShortDateString();
            Console.WriteLine(md1());
            Console.ReadKey();
            #endregion
       
        }

    }

泛型约束

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

    }
    //表示引用类型使用泛型约束，约束了T只能是引用类型
    class MyClass2<T> where T : class
    {

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

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

    }
    //要求T必须是Person类型，或者是Person类的子类型,而且T必须具有一个无参的构造函数
    class MyClass5<T>
        where T : Person
        where T : new()
    {

    }
    //要求V必须是T类型或者T的子类型
    class MyClass6<T, V> where V : T
    {

    }

    class Person { };
    #endregion