.net 委托的使用方法以及使用委托的好处

使用之前先大概了解一下，什么是委托？

从字面意思来理解：我委托某一个人帮我做一件事情，比如，我由于某些原因不能像小红表白，那么我请小明帮我去跟小红表白，那么我请小明帮我表白的这种行为，就叫做委托

A 请求 B 帮我获取或者传递的行为，就叫做委托

 

委托的声明方法：

//无返回值无参数委托的定义方法
public delegate void NoReturnPara();

无参数，无返回值方法：

public void DoNothing()
{
    // 没有参数，没有返回值
}

 

给委托赋值的几种方式

//实例化委托，并传入方法
NoReturbNoPara noreturn = new NoReturbNoPara(this.DoNothing);
//LinqToObject
NoReturbNoPara noreturn = () => { };
//直接赋值
NoReturbNoPara noreturn = this.DoNothing;

//调用委托的方法

noreturn.Invoke()

上面展示的是委托的基本定义于使用方法，现在实际B/S项目中基本摒弃了这种写法，转而使用封装好的泛型委托来使用

使用方法：

//无返回值，无参数委托，不需要单独声明
Action act = this.DoNothing;

//无返回值，有参数委托，参数类型为泛型
Action<string> act = p => { };

//返回类型为string，参数类型为string的委托
Func<string,string> func = p => p;

//返回类型为bool，参数类型为string的委托
Func<string,bool> func = p => p.Equals('');

 

下面写几个简单的demo演示一下

    /// <summary>
    /// 扩展方法
    /// </summary>
    public static class DelegateExtend
    {
        /// <summary>
        /// 模仿Linq的Where操作
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="scoure">数据源</param>
        /// <param name="func">委托（自定义bool条件）</param>
        /// <returns></returns>
        public static IEnumerable<T> ExtWhere<T>(this IEnumerable<T> scoure, Func<T, bool> func)
        {
            //遍历数据源的数据
            foreach (var item in scoure)
            {
                //请求委托完成条件的筛选返回bool
                bool bResult = func(item);
                //把通过筛选提交的数据源，返回出去
                if (bResult)
                {
                    yield return item;
                }
            }
        }
    }

下面来调用这个方法，看一下委托的具体使用方法

　　 /// <summary>
    /// 实体模型
    /// </summary>
    public class Student
    {
        /// <summary>
        /// ID
        /// </summary>
        public string Id { get; set; }
        /// <summary>
        /// 名称
        /// </summary>
        public string Name { get; set; }
    }

 　　　　　　 //查询出所有数据
            IEnumerable<Student> student = sql.QueryList<Student>();
            //定义一个匿名方法，并赋值给委托
            Func<Student, bool> func = delegate(Student s)
            {
                //自定义代码逻辑，返回bool类型
                return s.Id.Equals("1");
            };
            //传入委托
            IEnumerable<Student> list = student.ExtWhere(func);

　　　　　　  //第二种方法，使用linq语法（自定义逻辑）
            IEnumerable<Student> list1 = student.ExtWhere(p => p.Id.Equals("1"));

上面就是一个简单但很常见的委托使用场景

从侧面理解一下这段代码，

ExtWhere 是我要做的一件事情，但这件事情里面我需要一个bool类型的返回结果，那么我委托func去帮我获取到这个bool类型的结果

我刚开始的时候，对委托的理解觉得很困难，总感觉晕晕的，但是自己没事多练习练习之后，就会很好理解了

上面的demo很好的解释了使用委托的好处

解耦：抽出自定义逻辑，保留相同的逻辑，使代码分离

最大限度的简化代码：解耦的同时，又减少了代码量（自定义逻辑，可以避免相同逻辑的代码重复）