> 委托
- 当要把方法传递给其他方法时，就需要使用委托。
  

> 声明委托
- 使用委托时
    - 首先必须定义要使用的委托，对于委托，定义它就是告诉编译器这种类型的委托表示哪种类型的方法。
    - 然后，必须创建该委托的一个或多个实例。编译器在后台将创建表示该委托的一个类。
- 声明委托的语法如下：
```
delegate void IntMethodInvoker(int x)；
声明了一个委托IntMethodInvoker，并指定该委托的每个实例都可以包含一个方法的引用，该方法带有一个int参数，并返回void。
委托的类型安全性非常高。在定义委托时，必须给出它所表示的方法的签名和返回类型等全部细节。
```
- 理解委托的一种好方式是把委托视为给方法的签名和返回类型指定名称。

 
```
定义一个委托TwoLongsOp，该委托表示的方法有两个long型参数，返回类型为double。
delegate double TwoLongsOp(long first,long second);
或者定义一个委托，它表示的方法不带参数，返回一个string型的值
delegate string GetAStringent();
```
- 实际上，“定义一个委托”是指“定义一个新类”，委托实现为派生自基类System.MulticastDelegate的类，System.MulticastDelegate又派生自基类System.Delegate。

> 使用委托
- 在int值上调用ToString()方法的一种相当复杂的方式
```
private delegate string GetAString();
public static void Main()
{
    int x=40；
    GetAString firstStringMethod=newGetAString(x.ToString);
    WriteLine($"String is (fistStringMethod{})");
}
```
> 简单的委托示例
- 定义一个类MathOperations，它有两个静态方法，对double类型的值执行两种操作。然后使用该委托调用这些方法。
```
class MathOperation
{
    public static double MultiplyByTwo(double value)=>value*2;
    public static double Square(double value)=>value*value;
}
调用这些方法
using static System.Console；
namespace Wrox.ProCSharp.Delegates
{
    delegate double DoubleOp(double x);
    class Program
    {
        static void Main()
        {
            DoubleOp[] operations=
            {
                MathOperation.MultiplyByTwo,
                MathOperations.Square
            };
            for(int i=0;i<operations.Length;i++)
            {
                WriteLine($"Using operations[{i}]:");
                ProcessAndDisplayNumber(operations[i],2.0);
                ProcessAndDisplayNumber(operations[i],7.94);
                ProcessAndDisplayNumber(operations[i],1.414);
                WriteLine();
            }
        }
        static void ProcessAndDisplayNumber(DoubleOp action,double value)
        {
            double result =action(value);
            WriteLine($"Value is {value},result of operation is {result}");
        }
    }
}
```

> Action<T>和Func<T>委托

- 泛型Action<T>委托表示引用一个void返回类型的方法。这个委托类存在不同的变体，可以传递至多16种不同的参数类型。没有泛型参数的Action类可调用没有参数的方法。Action<in T>调用带一个参数的方法，Action<in T1,in T2>调用带两个参数的方法，Action<in T1,in T2，in T3,in T4,in T5,in T6,in T7,in T8>调用8个参数的方法。
- Func<T>允许调用带返回类型的方法。与Action<T>类似，Func<T>也定义了不同的变体，至多也可以传递16个参数类型和一个返回类型。Func<out TResult>委托类型可以调用带返回类型且无参数的方法，Func<in T,out TResult>调用带一个参数的方法，func<in T1,in T2,in T3,in T4,out TResult>调用4个参数的方法。

- delegate double DoubleOp(double x);
- 除了声明自定义委托DoubleOp之外，还可以使用Func<int T,out TResult>委托。可以声明一个该委托类型的变量，或者声明该委托类型的数组
```
<double ,double>[] operations=
{
    MathOperations.MultiplyByTwo,
    MathOperations.Square
};
使用委托，并将ProcessAndDisplayNumber()方法作为参数：
static void ProcessAndDisplayNumber(Func<double,double>action,double value)
{
    double result=action(value);
    WriteLine{$"Value is{value},result of operation is {result}"}
}
```
**BubbleSorter示例**
- 编写一个类BubbleSorter，它实现一个静态方法Sort(),这个方法的第一个参数是一个对象数组，把该数组按照升序重新排列。
- 进行冒泡排序的方法如下：
```
bool swapped=true;
do
{
    swapped=false;
    for(int i=0;i<sortArray.Length-1;i++)
    {
        if(sortArray[i]>sortArray[i+1])
        {
            int temp=sortArray[i];
            sortArray[i]=sortArray[i+1];
            sortArry[i+1]=temp;
            swapped=true;
        }
    }

    
}while(swapped);
```
- 定义BubbleSorter类
```
class BubbleSorter
{
    static public void Sort<T>(IList<T> sortArray,Func<T,T,bool>comparison)
    {
        bool swapped=true;
        do
        {
            swapped=false;
            for (int i=0;i<sortArray.Count-1;i++)
            {
                if(comparison(sortArray[i+1],sortArry[i]))
                {
                    T temp=sortArray[i];
                    sortArray[i]=sortArray[i+1];
                    sortArray[i+1]=temp;
                    swapped=true;
                }
            } 
        }while(swapped);
    }
}
```
- 为了使用这个类，需要定义另一个类，从而建立要排序的数组。假定Mortimer Phones移动电话公司有一个员工列表，要根据他们的薪水进行排序。每个员工分别由类Employee的一个实例表示，
```
class Employee
{
    public Employee(string name,decimal salary)
    {
        Name=name;
        Salary=salary;
    }
    public string Name{get;}
    public decimal Salary{get;private set;}
    public override string ToString()=>$"{Name},{Salary:C}";
    public static bool CompareSalary(Employee e1,Employee e2)=>e1.Salary<e2.Salary;
}
```
- 为了匹配Func<T,T,bool>委托的签名，在这个类中必须定义CompareSalay，它的参数是两个Employee引用，并返回一个布尔值。
```
using static System.Console;

namespace Wrox.ProCSharp.Delegates
{
    class Program
    {
        static void Main()
        {
            Employee[] employees=
            {
                new Employee("Bugs Bunny",20000),
                new Employee("Elmer Fudd",10000),
                new Employee("Daffy Duck",25000),
                new Employee("Wile Coyote",1000000.38m),
                new Employee("Foghorn Leghorn",23000),
                new Employee("RoadRunner",50000)
            };
            BubbleSorter.Sort(employee，Employee.CompareSalary);
            foreach(var employee in employees)
            {
                WriteLine(employee);
            }
        }
    }
}
```