委托/lambda表达式/事件

委托

委托是执行安全的类,它的使用方式与类类似(即都需要定义再实例化),不同在于,类在实例化之后叫对象或类的实例，但委托在实例化后仍叫委托,委托可以把函数作为参数传递.

语法声明:

delegate <return type> <delegate-name> <parameter list>

委托使用的步骤:

1. 声明委托类型（delegate关键字）
2. 使用该委托类型声明一个委托变量并增加方法
3. 调用委托执行方法

定义两个方法

public void ChineseSayHi()
{
    Console.WriteLine("你好");
}

public static void EnglishSayHi()
{
    Console.WriteLine("Hello");
}

第一步:委托定义,根据返回值和参数定义不同的委托,意义:任何一个无返回值且无参数的方法都可以使用这个委托来调用

 public delegate void MyDelegate();

第二步:实例化委托变量并增加方法

MyDelegate myDelegate = new MyDelegate(new Program().ChineseSayHi); //C#1.0及更高版本中使用这种方式

也可以是静态方法

MyDelegate myDelegate = new MyDelegate(EnglishSayHi);

C# 2.0 提供了更简单的方法来编写前面的声明

MyDelegate myDelegate = EnglishSayHi

在 C# 2.0 和更高版本中，还可以使用匿名方法来声明和初始化委托

MyDelegate myDelegate = delegate () { Console.WriteLine("匿名方法初始化委托"); };

在 C# 3.0 和更高版本中，还可以通过使用 lambda 表达式声明和实例化委托

//TODO

第三步:调用委托执行方法,因为myDelegate是委托类型的一个变量.所以C#编译器会用myDelegate.Invoke()代替myDelegate(),所以这两种方式都可以

myDelegate();
myDelegate.Invoke();

委托数组

定义Math类提供两个静态方法接收一个double类型的参数,用于计算倍数和阶乘

class Math
    {
        public static double MultipleTwo(double value)
        {
            return value * ;
        }
        public static double Square(double value)
        {
            return value * value;
        }
    }

添加MathOperation操作方法,传递委托和double类型参数

class Program
    {
        public delegate double MyDelegate(double value);

        static void Main(string[] args)
        {
            //定义委托数组
            MyDelegate[] myDelegates = {
                Math.MultipleTwo,
                Math.Square
            };
            //使用委托数组
            for (int i = ; i < myDelegates.Length; i++)
            {
                MathOperation(myDelegates[i], 3.7);
                MathOperation(myDelegates[i], 3.0);
            }
            Console.ReadKey();
        }
        public static void MathOperation(MyDelegate myDelegate, double value)
        {
            var result = myDelegate(value);
            Console.WriteLine("Delegate is {0},value is {1}", myDelegate,result);
        }
    }

上面都是通过自己定义委托类型来使用的,除了为每个参数和返回类型定义一个新委托类型之外,还可以使用Action<T>和Func<T>委托

Action<T>:表示引用一个void返回类型的方法,可以传递最多16种不同的参数类型,没有泛型参数的Action类可调用没有参数的方法

Func<T>:Func<T>允许调用带返回类型的方法,可以传递16种不同类型的参数和一个返回类型,Func<out TResult>委托类型可以调用带返回类且无参数的方法

Action<T>实例

 Action action = EnglishSayHi;
 action.Invoke();

Func<T>实例

Func<double, double>[] func = {
                Math.MultipleTwo,
                Math.Square
            };

 总结

1：Action用于没有返回值的方法（参数根据自己情况进行传递）

2：Func恰恰相反用于有返回值的方法（参数根据自己情况传递）

3：记住无返回就用Action，有返回就用Func

多播委托
之前的每个委托都只包含一个方法调用,调用委托的次数与调用方法的次数相同,如果要调用多个方法,就需要多次显式调用这个委托,但是委托中也可以包含多个方法,称为多播委托,多播委托可以按顺序调用多个方法,为此委托的签名必须返回void,否则就只能得到委托最后调用的最后一个方法的结果

Func<double, double> func = Math.MultipleTwo;
func += Math.Square;
var result = func(3.0);
Console.WriteLine(result);

MyDelegate myDelegate = Math.MultipleTwo;
myDelegate += Math.Square;
var result2 = myDelegate(3.0);
Console.WriteLine(result2);
Console.ReadKey(); 

只返回了3.0阶乘的值

这里需要再回头仔细了解一下看这种说法到底是否正确:即多播委托返回值必须为void

多播委托使用+=和-=,在委托中增加或删除方法调用

class Program
{
    public delegate double MyDelegate(out double value);

    static void Main(string[] args)
    {
        Action action = Print.First;
        action += Print.Second;
        action();
        Console.ReadKey();
    }
}
class Print
{
    public static void First()
    {
        Console.WriteLine("FirstMethod");
    }
    public static void Second()
    {
        Console.WriteLine("SecondMethod");
    }
}

如果要使用多播委托,就要知道对同一个委托调用方法链的顺序并未正式定义,因为要避免编写依赖于特定顺序调用方法的代码

使用多播委托,意味着多播委托里包含一个逐个调用的委托集合,如果集合其中一个方法抛出异常.整个迭代就会停止

class Program
    {
        public delegate double MyDelegate(out double value);

        static void Main(string[] args)
        {
            Action action = Print.First;
            action += Print.Second;
            action();
            Console.ReadKey();
        }
    }
    class Print
    {
        public static void First()
        {
            Console.WriteLine("FirstMethod");
            throw new Exception("Error");
        }
        public static void Second()
        {
            Console.WriteLine("SecondMethod");
        }
    }

委托只调用了第一个方法,因为第一个方法抛出了异常,委托的迭代停止,不再调用Second()方法

使用Delegate的GetInvocationList()方法自己迭代方法列表

            Action action = Print.First;
            action += Print.Second;
            Delegate[] delegates = action.GetInvocationList();
            foreach (Action item in delegates)
            {
                try
                {
                    item();
                }
                catch (Exception error)
                {
                    Console.WriteLine(error.Message);
                }
            }
            Console.ReadKey();

修改后,程序在捕获异常后,会迭代下一个方法

匿名类型

之前要使用委托,方法必须已经存在,还有另外一种使用委托的方式,即通过匿名方法,匿名方位作为委托参数的一部分;如果某个方法只被使用一次，这种情况下，除了创建委托语法的需要，没有必要创建独立的具名方法。因此，匿名方法应运而生

static void Main(string[] args)
        {
            Action action = delegate ()
            {
                Console.WriteLine("匿名方法打印Hello");
            };
            Action<string> action2 = delegate (string name)
            {
                Console.WriteLine("你好,我叫{0}", name);
            };
            Func<double, double> func = delegate (double value)
            {
                Console.WriteLine("Value={0}", value * );
                return value * ;
            };
            action();
            action2("Wang");
            func(3.0);
            Console.ReadKey();
        }

lambda表达式

C#3.0开始,可以使用一种新的语法把实现代码赋予委托,这就是lambda表达式,Lambda表达式取代了匿名方法，作为编写内联代码的首先方式

lambda运算符"=>"左边列出了需要的参数,右边定义了赋予lambda变量的方法实现代码

无参数

Action action = () =>
{
      Console.WriteLine("无参数");
};

一个参数

Action<string> action2 = param =>
{
       Console.WriteLine("你好,我叫{0}", param);
};

 多个参数

Action<int, int> action2 = (a, b) =>
{
       Console.WriteLine("Sum:{0}", a + b);
};

如果lambda表达式只有一句.方法块内就可以省略花括号和return语句,这时编译器会添加一条隐式的return语句

 Func<double, double> func = param => param * param;

等价于

Func<double, double> func = param =>
{
    return param * ;
};

 闭包

通过lambda表达式可以访问表达式块外部的变量,称为闭包,编译器会创建匿名类,使用构造函数来传递外部变量,构造函数取决于从外部传递进来的变量个数

static void Main(string[] args)
        {
            int x = ;
            Action<int> action = p =>
            {
                Console.WriteLine("lambda表达式调用外部变量,Sum :{0}", p + x);
            };
            Action<int> action2 = delegate (int p)
            {
                 Console.WriteLine("匿名函数调用外部变量,Sum {0}", p + x);
            };
            action();
            action2();
            Console.ReadKey();
        }

这里需要后续着重学习一下,包括闭包的陷阱等等

事件 

事件基于委托,为委托提供了一种发布/订阅机制.

事件定义语法

<访问修饰符> event 委托名 事件名;

看到一个孩子他妈叫他爸和儿子回家吃饭的例子,觉着很生动.这里就用这个例子学习一下

 class Program
    {
        static void Main(string[] args)
        {
            Mum mum = new Mum();
            //事件订阅
            mum.EatEvent += new Mum.myDelegate(new Son().Eat);
            mum.EatEvent += new Mum.myDelegate(new Father().Eat);
            mum.Call();
            Console.ReadKey();
        }
    }
    /// <summary>
    /// 发布器
    /// </summary>
    public class Mum
    {
        //定义委托,用这个委托定义处理事件的方法类型
        public delegate void myDelegate();

        //根据委托定义事件,这里的事件是吃饭
        public event myDelegate EatEvent;

        public void Call()
        {
            Console.WriteLine("Mum:饭做好了,过来吃饭");
            //触发事件
            EatEvent();
        }
    }
    class Son
    {
        //事件处理方法,与Mum类中的委托方法签名一致
        public void Eat()
        {
            Console.WriteLine("Son:游戏打完我就过去");
        }
    }
    class Father
    {
        public void Eat()
        {
            Console.WriteLine("Father:好的我马上过来");
        }
    }

 event与EventHandler

待补充...

参考:

http://www.cnblogs.com/jujusharp/archive/2011/08/04/2127999.html

https://www.cnblogs.com/HQFZ/p/4903400.html

https://www.cnblogs.com/wangjiming/p/8300103.html