C#高级编程读书——委托，Lamda表达式，事件

委托是寻址方法的.Net版本，在C++中，函数指针是指向内存位置的指针，是类型不安全的。

委托是类型安全的类，定义了返回类型和参数的类型。

包含对一个方法或多个方法的引用。

委托将方法作为参数传递给另一个方法。

应用场景：

启动线程和任务

通用库类

事件

声明委托：

delegate void ADelegateSample(int x);
//该委托的实例可以包含一个方法的引用
//该方法带有一个int参数
//该方法返回值类型为void

delegate double ADelegateSample2(long first,long second);
//该委托的实例可以包含一个方法的引用
//该方法带两个long类型的参数
//该方法返回值类型为double

delegate string ADelegateSample3();
//该委托的实例可以包含一个方法的引用
//该方法不带参数
//该方法返回值类型为string

委托的定义可使用常见修饰符，如public，private，protected

委托实例1：

private delegate string GetAString();
static void Main(string[] args)
{
    int x = 40;
    //委托推断：为了减少输入量，只需要委托实例，就可以只传送地址名称
    GetAString firstStrMath = new GetAString(x.ToString);//带参实例化委托
    Console.WriteLine("String1 is {0}", firstStrMath());//使用委托显示字符串
    Console.WriteLine("String1 is {0}", x.ToString());
    Console.ReadKey();
}    

在C#中，委托在语法上总是接受一个参数的构造函数，这个参数就是委托引用的方法。这个方法必须匹配最初定义委托时的签名。

调用的是方法名不是方法，故不能写“()”（即将方法的地址传给委托变量）,也不能将其传给委托变量。委托推断可在需要委托实例的任何地方使用。

实例1扩展：调用实例方法和静态方法

 struct Currency
    {
        public uint Dollars;
        public ushort Cents;
        public Currency(uint dollars, ushort cents)
        {
            this.Dollars = dollars;
            this.Cents = cents;
        }
        public override string ToString()
        {
            return string.Format("${0}.{1,2:00}", Dollars, Cents);
        }

        public static string GetCurrencyUnit()
        {
            return "Dollar";
        }       
    }

使用实例：

private delegate string GetAString();
static void Main(string[] args)
{
    int x = 40;
    GetAString secStrMath = (x + 10).ToString;
    Console.WriteLine("String0 is {0}", secStrMath());

    Currency balance = new Currency(34, 50);

    secStrMath = balance.ToString;//实例方法
    Console.WriteLine("String1 is {0}", secStrMath());


    secStrMath = new GetAString(Currency.GetCurrencyUnit);//静态方法
    Console.WriteLine("String2 is {0}", secStrMath());
    Console.ReadKey();
}
   

委托实例2：

 class MathOperationd
    {
        public static double MutiplyByTwo(double value)
        {
            return value * 2;
        }
        public static double Square(double value)
        {
            return value * value;
        }
    }

delegate double DoubleOp(double x);      
static void Main(string[] args)
{
    //实例化委托数组
    DoubleOp[] operations =
    {
        MathOperationd.MutiplyByTwo,
        MathOperationd.Square
    };
    Func<double, double>[] operations =
    {
        MathOperationd.MutiplyByTwo,
        MathOperationd.Square
    };

    for(int i = 0; i < operations.Length; i++)
    {
        Console.WriteLine("Using operations[{0}]:", i);
        ProcessAndDisplayNumber(operations[i], 2.0);//传递委托
        ProcessAndDisplayNumber(operations[i], 7.56);
        ProcessAndDisplayNumber(operations[i], 8.01);
        ProcessAndDisplayNumber(operations[i], 2.316);
        Console.WriteLine();
    }
        Console.ReadKey();  
}

private static void ProcessAndDisplayNumber(DoubleOp doubleOp, double value)
{
    double result = doubleOp(value);
    Console.WriteLine("value is {0},result of operation is {1}", value, result);
}

 Action<T> 和 Func<T> 委托

 Action<T> 表示引用一个void返回类型的方法。

该委托类存在不同的变体，可传递至多16中不同的参数类型。

Func<T>允许调用带返回类型的方法。

Func<out TResult> 可调用带返回值且无参数的方法；

Func<in T, out TResult> 调用带一个参数的方法 ，以此类推，最多可有16个参数。

//定义
Func<double, double>[] operations =
{
    MathOperationd.MutiplyByTwo,
    MathOperationd.Square
};
//使用
private static void ProcessAndDisplayNumber(Func<double, double> doubleOp, double value)
{
    double result = doubleOp(value);
    Console.WriteLine("value is {0},result of operation is {1}", value, result);
}