.NET （一）委托第一讲：什么是委托

1.为何要使用委托？

生活中的委托就是委托他人帮咱们去办一件事情，程序中的委托相似。看下面的例子

    class Class1
    {
        static void Main(String[] args)
        {
            List<int> list = new List<int>();
            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Add(4);
            list.Add(5);

            //过滤偶数
 Even(list);

            ObjectDumper.Write(list);
        }

        //过滤集合中的偶数
        public static void Even(List<int> list)
        {
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i] % 2 != 0)
                {
                    list.RemoveAt(i);
                    i--;
                }
            }
        }

        //过滤集合中的奇数
        public static void Odd(List<int> list)
        {
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i] % 2 == 0)
                {
                    list.RemoveAt(i);
                    i--;
                }
            }
        }
    }

经过上面的例子咱们发现 Even()方法 和 Odd()方法只有一行代码不一样，使用委托能够将方法当成参数传递，这样作的好处是使程序之间的耦合下降，同时节省代码。

改造上面的代码以下：

   class Class2
    {
        //声明委托
        public delegate bool Cal(int num);
        static void Main(String[] args)
        {
            List<int> list = new List<int>();
            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Add(4);
            list.Add(5);

            //过滤偶数
            Cal cal = new Cal(Even);
            MyCal(list, cal);

            ObjectDumper.Write(list);
        }

       

        public static bool Even(int num)
        {
            if (num % 2 == 0)
            {
                return true;
            }
            return false;
        }
        public static bool Odd(int num)
        {
            if (num % 2 != 0)
            {
                return true;
            }
            return false;
        }

        public static void MyCal(List<int> list,Cal cal)
        {
            for (int i = 0; i < list.Count; i++)
            {
                if (cal(list[i]))
                {
                    list.RemoveAt(i);
                    i--;
                }
            }
        }

    }

委托描述的是方法的签名（包括参数类型、个数、返回值），上面声明一个委托 Cal ，和 咱们要调用的方法同样，接收一个 int类型的参数，返回bool类型。

public delegate bool Cal(int num);

使用New关键字建立委托：

Cal cal = new Cal(Even);

最后调用cal，获得全部偶数项的集合

MyCal(list, cal);

咱们在 MyCal(List<int> list,Cal cal) 方法中，传递了一个委托 做为参数，Cal描述的是 Even 或者Odd方法的签名，这样能够在调用的时候决定 是过滤奇数 仍是 过滤偶数。

这和咱们直接调用Even或Odd方法有什么不一样，不是更麻烦了吗，接着往下看：

咱们能够将过滤的方法改为以下代码：

MyCal(list, delegate(int i)
            {
                if (i % 2 == 0)
                {
                    return true;
                }
                return false;
            });

正由于MyCal方法接收的是一个委托，因此咱们能够在不定义Even或Odd的时候，使用匿名委托。

这样省去了没必要要的代码，使结构看起来更简单，也不须要预先定义好方法，在调用的时候咱们临时决定。

.NET 还给咱们提供了更进一步的简化，使用Lambda表达式：

//代码演进
//lamada
MyCal(list, (i) => { return i % 2 == 0 ? true : false; });

i表示输入参数 (i) => { return i % 2 == 0 ? true : false; } 是一条lambda语句，标识过滤偶数。

完整的代码以下：

//声明委托
        public delegate bool Cal(int num);
        static void Main(String[] args)
        {
            List<int> list = new List<int>();
            list.Add(1);
            list.Add(2);
            list.Add(3);
            list.Add(4);
            list.Add(5);

            MyCal(list, (i) => { return i % 2 == 0 ? true : false; });

            ObjectDumper.Write(list);
        }

        public static void MyCal(List<int> list, Cal cal)
        {
            for (int i = 0; i < list.Count; i++)
            {
                if (cal(list[i]))
                {
                    list.RemoveAt(i);
                    i--;
                }
            }
        }

这样作是否是比开始的时候简单多了，不管后面再怎么添加新的过滤方式，咱们只须要修改咱们的lambda语句，其余的都不须要变更，这就是委托的魅力。