C# 委托,Lambda表达式,事件

本文章参考sikiC#高级篇，转载请注明出处。

什么是委托

　　如果我们要把方法当做参数来传递的话，就要用到委托。简单来说委托是一个类型，这个类型可以赋值一个方法的引用。

声明委托与使用

　　声明委托有四种方式。一种是原生的，另外三种是C#系统内置的委托类型。

　　四种声明方式分别为delegate, Action, Func, 

　　在C#中使用一个类分为两个阶段，首先定义这个类，告诉编译器这个类由什么字段和方法组成，然后使用这个类实例化对象。在我们使用委托的时候，也需要经过这两个阶段，首先定义委托，告诉编译器我们这个委托可以指向哪些类型，然后，创建该委托的实例。

　　delegate定义和使用方式如下：

    class Program
    {
        delegate void IntMethodInvoker(int x);

        static void Test1(int x)
        {
            Console.WriteLine("int值为：" + x);
        }

        static void Test2(string s)
        {
            Console.WriteLine("string值为：" + s);
        }

        static void Main(string[] args)
        {
            // 委托的几种赋值方式
            // 1.将写好的函数赋值给委托（直接赋给委托的实例）
            IntMethodInvoker method = Test1;

            // 2.用new的形式将写好的函数赋值给委托（用了委托的构造函数）
            method = new IntMethodInvoker(Test1);

            // 以下操作是违法的，因为method中的参数为int，而Test2中参数为string无法赋值给委托
            //method = Test2;

            // 运行委托
            method(123);
        }
    }

　　这个委托只能指向一个返回值为void有一个int参数的方法，其他方法是无法指向的。

　　Action的定义和使用方式：

　　格式：

　　Action

　　Action<in T>

　　Action<in T1,in T2>

　　Action<in T1,in T2 ... in T16>

　　Action委托是一个最多允许有16个参数的无返回类型的委托。

    class Program
    {
        //Action委托定义方式
        static Action<int> actionMethod;

        static void Test1(int x)
        {
            Console.WriteLine("int值为：" + x);
        }

        static void Test2(string s)
        {
            Console.WriteLine("string值为：" + s);
        }

        static void Main(string[] args)
        {
            //Action委托赋值方式
            actionMethod = Test1;

            //Action委托使用方式
            actionMethod(123);
        }
    }

　　Func的定义和使用方式：

　　格式：（类似于Action，多一个返回参数）

　　Func<out TResult>

　　Func<in T,out TResult>

　　Func<in T,in T2 ... in T16,out TResult>

　　Func委托是一个最多允许16个参数的必有返回值的委托。

    class Program
    {
        //Func委托定义方式
        static Func<int,int> funcMethod;

        //委托函数
        static int Test(int x)
        {
            return x;
        }

        static void Main(string[] args)
        {
            //Func委托赋值方式
            funcMethod = Test;

            //Func委托使用方式
            Console.WriteLine(funcMethod(123));
        }
    }

多播委托

　　前面使用的委托都只包含一个方法的调用，但是委托也可以包含多个方法，这种委托叫做多播委托。使用多播委托就可以按照顺序调用多个方法，多播委托只能得到调用最后一个方法的结果，一般我们把多播委托的返回类型声明为void（一般使用Action委托）。

    class Program
    {
        static Action<int> actionMethod;

        static void Test1(int x)
        {
            Console.WriteLine("Test1值为：" + x);
        }

        static void Test2(int x)
        {
            Console.WriteLine("Test2值为：" + x);
        }

        static void Main(string[] args)
        {
            // 多播委托
            actionMethod = Test1;
            actionMethod += Test2; //添加一个委托的引用

            if (actionMethod != null) //当委托没有指向任何一个函数时，调用会有异常。
                actionMethod(123); //会把123参数传给所有引用的函数，

            actionMethod -= Test2; //删除一个委托的引用

        }
    }

取得多播委托中所有方法的委托

    class Program
    {
        static Action<int> actionMethod;

        static void Test1(int x)
        {
            Console.WriteLine("Test1值为：" + x);
        }

        static void Test2(int x)
        {
            Console.WriteLine("Test2值为：" + x);
        }

        static void Main(string[] args)
        {
            // 多播委托
            actionMethod = Test1;
            actionMethod += Test2; //添加一个委托的引用

            //取得多播委托中所有方法的委托
            Delegate[] delegates = actionMethod.GetInvocationList();
            //遍历所有委托
            foreach (Delegate d in delegates)
            {
                //动态调用委托
                d.DynamicInvoke(123);
            }
        }
    }

匿名方法

　　到目前为止，使用委托，都是先定义一个方法，然后吧方法给委托的实例。但还有另外一种使用委托的方式，不用去定义一个方法，应该说是使用匿名方法（方法没有名字）

    class Program
    {
        static void Main(string[] args)
        {
            //匿名方法声明与实现
            Func<int, int, int> func = delegate (int a, int b)
              {
                  return a + b;
              };

            //匿名方法的使用
            int sum = func(6, 6);

            Console.WriteLine(sum);
        }
    }

Lambda表达式-表示一个方法的定义

　　从C#3.0开始，可以使用Lambda表达式代替匿名方法。只要有委托参数类型的地方就可以使用Lambda表达式。上面的代码可以修改为:

    class Program
    {
        static void Main(string[] args)
        {
            //Lambda表达式声明与实现
            Func<int, int, int> func = (a, b) =>
            {
                return a + b;
            };

            //Lambda表达式所写的委托的使用
            int sum = func(6, 6);

            Console.WriteLine(sum);
        }
    }

　　Lambda运算符 “=>” 的左边列出了需要的参数，如果是一个参数可以直接写 a=>,如果多个参数就使用括号括起来，参数之间以 “，” 间隔

　　多行语句

　　如果Lambda表达式只用一条语句，在方法块内就不需要花括号和return语句，编译器会自动添加。如上面的代码可以修改为：

    class Program
    {
        static void Main(string[] args)
        {
            //Lambda表达式声明与实现(单条语句)
            Func<int, int, int> func = (a, b) => a + b;

            //Lambda表达式所写的委托的使用
            int sum = func(6, 6);

            Console.WriteLine(sum);
        }
    }

事件

　　事件（event）基于委托，为委托提供了一个发布/订阅机制（观察者模式），我们可以说事件是一种具有特殊签名的委托。

　　什么是事件？

　　　　事件是类或对象向其他类或对象通知发生的事情的一种特殊签名的委托。

　　事件的声明

　　　　public event 委托类型 事件名;

　　　　事件使用event关键词来声明，它的返回类型是一个委托类型。

事件与委托的联系和区别

　　事件是一种特殊的委托，或者说是受限制的委托，是委托一种特殊应用，只能施加+=，-=操作符。二者本质上是一个东西。

　　event ActionHandler Tick; //编译成创建一个私有的委托示例，和施加在其上的add，remove方法。

　　event只允许用add，remove方法来操作，这导致了它不允许在类的外部被直接触发，只能在类的内部适合的时机触发。委托可以在外部被触发，但是别这么用。

　　使用中，委托常用来表达回调，事件表达外发的接口。

　　委托和事件支持静态方法和成员方法，delegate(void *pthis, f_ptr)，支持静态返方法时，pthis传null支持成员方法时，pthis传被通知对象。

　　委托对象里的三个重要字段是，pthis，f_ptr，pnext，也就是被通知对象引用，函数指针/地址，委托链表的下一个委托节点。