C# 白话系列之——白话委托

今天看到首页有个委托的文章，但大都写的太专业，而且没有实用的例子场景。正好昨天做了一个有关委托的功能，所以也来凑个热闹，用白话掰掰

一、委托是什么

我们都知道数据类型，简单点的如，想给一个变量赋值整数，那就要定义一个 int类型的变量

int var=5;

想给一个变量赋值字符串那就定义一个string类型的变量

string var ="test";

复杂点的就是自己定义一个类，然后就可以定义类变量 

MyClass myClass= new MyClass();

现在我们有如下一个方法，怎样把这个方法可以赋值给一个变量呢？

        public string GetMessage(string messageType)
        {
            string ret = "";

            switch (messageType)
            {
                case "error":
                    ret = "错误消息";
                    break;
                case "warning":
                    ret = "警告消息";
                    break;
                default:
                    ret = "未知消息";
                    break;
            }
            return ret;
        }

这个就要委托来登场了。先看实现

        delegate string MessageDelegate(string messageType);
        public void Test()
        {
            MessageDelegate myMessage = GetMessage;

            string ret = myMessage("error");
        }

定义一个类大家都会 ，用 class 关键字来定义一个类MyClass

        class MyClass
        {
        }

同理，用 delegate 关键字来定义一个委托 MessageDelegate。

一定要有这个一个概念，我们用 delegate 关键字定义的委托（MessageDelegate）是一个数据类型。

int 类型的变量用来赋值整数的，string类型的变量用来赋值字符串的，而委托类型的变量是用来赋值函数的。

当然因为每个函数的参数不同，返回的数据不同，所以在定义委托的时候也就指明了这个委托类型的变量可接受的函数。

delegate string MessageDelegate(string messageType);

如上面定义的MessageDeletegate委托数据类型，用MessageDeletegate定义的变量（myMessage）只能接受 有一个string类型的参数并且有一个sting返回值的函数（GetMessage）

MessageDelegate myMessage = GetMessage;

delegate void MyDelete(int i);

上面定义的这个MyDelete委托类型对应的函数是有一个int类型的参数，并且没有返回值。

二、委托的使用

在.net中委托基本随处可见，最常用的就是Action、Func和Predicate，它们分别有很多重载，自己可以看看。

public delegate void Action();
public delegate TResult Func<out TResult>();
public delegate bool Predicate<in T>(T obj);

现在有这么一个功能：

现在有一个int类型的集合，把所有的偶数乘以2，输出到一个新集合中。

测试数据：

            List<int> myList = new List<int>();
            for (int i = 0; i < 10; i++)
            {
                myList.Add(i);
            }

普通方法实现：

            List<int> retList = new List<int>();
            for (int i = 0; i < myList.Count; i++)
            {
                if (myList[i] % 2 == 0)
                {
                    retList.Add(myList[i] * 2);
                }
            }

用委托方法实现：

            List<int> retList = new List<int>();

            myList.ForEach((data) =>
            {
                if (data % 2 == 0)
                {
                    retList.Add(data * 2);
                }
            });

当然这个ForEach是.net提供的扩展方法，再加上lambda表达式实现。

这个还不足以说明委托的好处。

如果我们再把问题放宽点，现在有一个int类型的集合，如果里面的数字满足某个条件，则执行某个动作。

        public void MyOperation(List<int> myList, Func<int, bool> func, Action<int> action)
        {
            for (int i = 0; i < myList.Count; i++)
            {
                if (func(myList[i]))
                {
                    action(myList[i]);
                }
            }
        }

现在在把第一个问题实现下：

            MyOperation(myList, (d) =>
            {
                return d % 2 == 0;
            }, (d) =>
            {
                retList.Add(d * 2);
            });

可以近一步写成扩展方法，这个有跑题有点远了。

上面这个例子主要是说明了一点：

委托是一个函数类型的数据类型（对比int是一个整数类型的数据类型），可以把委托当做参数变量来传递。

然而因为委托变量的值是函数，这样就可以把一个函数当做参数传递到另外一个函数中。

如上面提到的：

写一个对集合操作的函数，如果集合里面的某个元素满足某个条件，则执行某个动作。