.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语句，其他的都不需要变动，这就是委托的魅力。