我学习，我记录.(linq--where)

需求：一个集合中筛选出符合条件的。

思路是定义一个，循环集合中变量，判断是否符合条件，添加到新的集合

  var List1 = new List<int>();
            foreach (int i in list)
            {
                if (i > 222)
                {
                    List1.Add(i);
                }
            }

            //帅选集合中元素小于222的
            var list2 = new List<int>();
            foreach(int x in list)
            {
                if (x < 222)
                {
                    list2.Add(x);
                }
            }

View Code

思考: 需求不同，支持判断是否符合条件这个步骤是变化的，其余的都是不变的。

将可变的逻辑抽出，用委托封装,接收一个参数，返回一个bool

 public static List<int> NewWhere(List<int> items, Func<int,bool> func)
        {
            List<int> list = new List<int>();
            foreach(var item in items)
            if (func.Invoke(item))
            {
                    list.Add(item);
            }
            return list;
        }

扩展方法：定义在静态中的静态方法中，第一个参数类型前加上this关键字的方法，即为该类型的扩展方法,顾名思义，给该类型增加一个方法

如上例中，给List<int> 增加一个筛选方法，

        public static List<int> newWhere(this List<int> items, 
            Func<int,bool>func)
        {
            List<int> list = new List<int>();
            foreach(var item in items)
            {
                if (func.Invoke(item)) list.Add(item);
            }
            return list;
        }
//调用
   var iResult =  list.newWhere(p => p > 0);

假设这个方法不只是要给list<int> 用

  /// 接受一个委托,一个IEnumerable 类型的参数
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="items"></param>
        /// <param name="func"></param>
        /// <returns></returns>
        public static IEnumerable<T> NewWhere<T>(
            this IEnumerable<T> items, Func<T, bool> func)
        {
           var list = new List<T>();
            foreach(var item in items)
            {
                if (func.Invoke(item))
                {
                    list.Add(item);
                }
            }
            return list;
        }

我学习我记录，linq-where 的本质。

总结，在动手之前，想想怎么做，分到聚体的步骤，抽出相同的逻辑步骤一层层封装。

我学习，我记录.(linq--where)

猜你喜欢