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>() { , , , , , , ,  };
             List<int> listresult = list.FindAll(n => n > );
             for (int i = ; 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(,);
             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