委托 Action<>,Func<>,Predicat<>

Action是无返回值的泛型委托，参数0~16个

Func是有返回值的泛型委托，参数0~16个

Predicate<>是返回bool类型的委托，参数为有且仅有一个

如果说lambda是为了简化委托的后半部分方法体的初始化，那么Func他们就是为了简化委托的定义部分（前半部分）。

Predicat<>

public delegate int DelegateProcess(int num1, int num2);

        public void Init()
        {
            //第一种写法
            DelegateProcess process = new DelegateProcess(Multiply);

            //第二种写法
            DelegateProcess process1 = Multiply;

            //第三种写法  匿名委托
            DelegateProcess process2 = delegate (int a, int b)
            {
                return a * b;
            };

            //第四种写法 Lamdba表达式
            DelegateProcess process3 = (int a, int b) => { return a * b; };

            var result1 = process(1, 2);

            var result2 = Get(process);
        }
        public int Multiply(int a, int b)
        {
            return a * b;
        }

        public int Get(DelegateProcess process)
        {
            //参数逻辑处理
            var arg1 = 4 * 5;
            var arg2 = 3;
           return process(arg1, arg2);
        }

 

Func<>

        /// <summary>
        /// Func<T>匿名委托写法 委托的最后一个参数都为方法的返回值类型，剩下的都为方法的参数类型
        /// </summary>
        public void Init2()
        {
            //Func<T>
            //方式一
            //Func中的最后一个参数为委托封装的方法的返回值类型，前面剩下的为委托封装的方法的传入参数类型
            Func<int, int, string> factory = (int a, int b) => { return (a * b).ToString(); };
            var cc = GetStr("", factory);
            //方式二
            var ss = GetVal("", (a, b) => { return a * b; });

        }

        /// <summary>
        /// 返回一个int 类型的结果
        /// </summary>
        /// <param name="s"></param>
        /// <param name="factory"></param>
        /// <returns></returns>
        private int GetVal(string s, Func<int, int, int> factory)
        {
            return factory(1, 3);
        }

        /// <summary>
        /// 返回一个string类型的结果
        /// </summary>
        /// <param name="s"></param>
        /// <param name="factory"></param>
        /// <returns></returns>
        private string GetStr(string s, Func<int, int, string> factory)
        {
            return factory(1, 3);
        }

Action<>

        /// <summary>
        /// Action<T> Action是可以有0~16个参数的无返回值委托
        /// </summary>
        public void Init1()
        {
            Action<int, int> factory = (int a, int b) => { Console.WriteLine(a * b); };
            var result = Create(factory);
        }

        public int Create(Action<int, int> factory)
        {
            //参数逻辑处理
            var arg1 = 4 * 5;
            var arg2 = 3;
            factory(arg1, arg2);
            factory?.Invoke(arg1, arg2);
            return 1;
        }

应用：

当在数据访问层不想定义实体来封装数据结果，就可以利用Func<T1, T2, TResult> 委托来处理

  public IEnumerable<TResult> GetAllUser<TResult>(Func<User, Person, TResult> itemFactory)
  {
       var results = from u in _userRepository.GetAll()
                     join p in _personRepository.GetAll() on u.Id equals p.uId
                     select new { User = u, Person = p };
       IList<TResult> resultItems = new List<TResult>();
       foreach (var item in results.ToList())
       {
        resultItems.Add(itemFactory(item.User, item.Person));
       }
      return resultItems;
 }

在应用层

 var query = userDao.GetAllUser((u, p) =>
            {
                return new { u.Id, u.LoginName, pId = p.Id, p.Name };
            });

在linq 的Select方法中也用了委托Func<>

        //
        // 摘要:
        //     Projects each element of a sequence into a new form.
        //
        // 参数:
        //   source:
        //     A sequence of values to invoke a transform function on. 一个值序列，要对该序列调用转换函数
        //
        //   selector:
        //     A transform function to apply to each element. 应用于每个元素的转换函数
        //
        // 类型参数:
        //   TSource:
        //     The type of the elements of source.源元素的类型
        //
        //   TResult:
        //     The type of the value returned by selector.返回值的类型
        //
        // 返回结果:
        //     An System.Collections.Generic.IEnumerable`1 whose elements are the result of
        //     invoking the transform function on each element of source.
        //
        // 异常:
        //   T:System.ArgumentNullException:
        //     source or selector is null.
        public static IEnumerable<TResult> Select<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, TResult> selector);

TSource表示传入参数的类型，TResult表示返回值的参数类型

调用处：

方式一

IEnumerable<CameraConfigDto> list = _cameraConfigRepository.GetAll().Where(c => c.EquipmentId == equipmentId).Select(new Func<CameraConfig, CameraConfigDto>(delegate (CameraConfig e)
            {
                return new CameraConfigDto() { };
            }));

方式二

 IEnumerable<CameraConfigDto> list = _cameraConfigRepository.GetAll().Where(c => c.EquipmentId == equipmentId).Select(delegate(CameraConfig e) {
                 return new CameraConfigDto() { };
            });

方式三

var list=_repository.GetAll().Where(c => c.EquipmentId == equipmentId).Select(delegate(CameraConfig e) {
                 return new CameraConfigDto() { };
            });