C#委托的学习

------------恢复内容开始------------

一.系统内置（预定义）的委托类型

1. Action委托
   1. 不带返回值
   2. 可以指向一个没有返回值，没有参数的方法

   3.  1 class Program
       2     {
       3         static void PrintString()
       4         {
       5             Console.WriteLine("hello world.");
       6         }
       7         static void PrintInt(int i)
       8         {
       9             Console.WriteLine(i);
      10         }
      11         static void PrintString(string str)
      12         {
      13             Console.WriteLine(str);
      14         }
      15 
      16         static void PrintDoubleInt(int x, int y)
      17         {
      18             Console.WriteLine(x + " " + y);
      19         }
      20         /// <summary>
      21         /// Action委托不带返回值
      22         /// </summary>
      23         /// <param name="args"></param>
      24         static void Main(string[] args)
      25         {
      26             //Action a = PrintString; //action是系统内置（预定义)的一个委托类型，他可以指向一个没有返回值，没有参数的方法
      27 
      28             //Action<int> a =PrintInt;//定义了一个委托类型，这个类型可以指向一个没有返回值，有一个int参数的方法
      29 
      30             //Action<string> a = PrintString;//定义了以哦个委托类型，这个类型可以指向一个没有返回值，有string参数的方法，在这里系统会自动寻找匹配的方法
      31 
      32             Action<int, int> a = PrintDoubleInt;
      33             a(24, 45);
      34 
      35             Console.ReadKey();
      36             //action 可以后面通过泛型去指定action指向的方法的多个参数的类型，参数的类型跟后面声明的委托类型是对应着的
      37         }
      38     }

   4. 可以指向一个没有返回值，有一个或者多个参数的方法（最多参数16个）
2. Func委托
   1. 必含一个返回值
   2. 最后一个类型表示返回值类型，前面的表示参数类型

   • •  1 using System;
        2 using System.Collections.Generic;
        3 using System.Linq;
        4 using System.Text;
        5 
        6 namespace _00_Func委托
        7 {
        8     /// <summary>
        9     /// Func 必含一个返回值
       10     /// 最后一个类型表示返回值类型，前面的表示参数类型
       11     /// </summary>
       12     class Program
       13     {
       14         static int Test1()
       15         {
       16             return 1;
       17         }
       18         static int Test2(string str)
       19         {
       20             Console.WriteLine(str);
       21             return 100;
       22         }
       23         static int Test3(int i, int j)
       24         {
       25             return i + j;
       26         }
       27         static void Main(string[] args)
       28         {
       29             //Func<int> a = Test1;//func中的泛型类型指定的是 方法发返回值类型
       30             //Console.WriteLine(a());
       31 
       32             //Func<string, int> a = Test2; //Func后面可以跟很多类型，最后一个类型是返回值类型，前面的类型是参数类型，参数类型必须跟指向的方法的参数类型按照顺序对应
       33 
       34             Func<int, int, int> a = Test3;//func后面必须指定一个返回值类型，参数可以有0-16个，先写参数类型，最后一个是返回值类型
       35             int aa = a(1, 5);
       36 
       37             //Console.WriteLine(a("读大"));
       38             Console.ReadKey();
       39         }
       40     }
       41