拉姆达表达式的一些常用知识

1、Distinct()方法的使用。

通常我们使用 list.Distinc()的时候，默认的是使用 public static IEnumerable Distinct(this IEnumerable source);该方法，但是这样去重的话，是根据每个对象的是否相同来去重，没法达到根据某个对象的属性来去重。

如果想根据某个属性来去重的话，就需要拓展一下 public static IEnumerable Distinct(this IEnumerable source,IEqualityComparer comparer);

如下代码。

拓展类：

   public class MyEqualityComparer : IEqualityComparer
    {
        private Func keyFunc;

        private IEqualityComparer comparer;

        public MyEqualityComparer(Func keyFunc, IEqualityComparer comparer)
        {
            this.keyFunc = keyFunc;
            this.comparer = comparer;
        }

        public MyEqualityComparer(Func keyFunc)
            : this(keyFunc, EqualityComparer.Default)
        {
        }


        public bool Equals(T x, T y)
        {
            return comparer.Equals(keyFunc(x), keyFunc(y));
        }

        public int GetHashCode(T obj)
        {
            return comparer.GetHashCode(keyFunc(obj));
        }
    }

　拓展方法：

 public static class ExtensionsMethod
    {
        /// 

        /// 拓展distinct
        /// 
        /// 源类型
        /// 委托返回类型（根据V类型，排除重复项）
        /// 拓展源
        /// 委托（执行操作）
        /// 
        public static IEnumerable Distinct(this IEnumerable source, Func func)
        {
            return source.Distinct(new MyEqualityComparer(func));
        }
    }

方法使用：

           #region List Distinct 去重

            var list=new List()
            {
                new Student(){Age = "18",Name = "zhangsan"},
                new Student(){Age = "18",Name = "lisi"},
                new Student(){Age = "19",Name = "zhangsan"},
            };

            var listDistinct = list.Distinct();

            var listMyDistinct = list.Distinct(c => new {c.Name}).ToList();

            #endregion 

2、System.Linq.Expressions.Expression的使用。

有个集合，我们想把几个lambda表达式合并起来使用的话，这个方法就很有用

如下代码：

 System.Linq.Expressions.Expression> pre = s => false;
            System.Linq.Expressions.Expression> expression = e => false;

            expression.And(c => c != "");

            List preList = new List()
            {
                "huage",
                "zhangsan",
                "lisi",
                "wangwu",
                "zhaolu",
                "tianqi"
            };

            preList.Remove(null);
            preList.Remove("huage");

            if (preList.Contains("zhangsan"))
            {
                pre = pre.Or(c => c.Contains("zhangsan"));
            }

            if (preList.Contains("wangwu"))
            {
                pre = pre.Or(c => c.Contains("wangwu"));
            }

            var listStra = preList.Where(pre.Compile()).ToList();

　常用的拓展方法

 public static class ExtensionsMethod
    {
        public static Expression> True() { return f => true; }

        public static Expression> False() { return f => false; }

        public static Expression> Or(this Expression> expression1,
            Expression> expression2)
        {
            var invokedExpression = Expression.Invoke(expression2, expression1.Parameters
                .Cast());

            return Expression.Lambda>(Expression.Or(expression1.Body, invokedExpression),
                expression1.Parameters);
        }

        public static Expression> And(this Expression> expression1,
            Expression> expression2)
        {
            var invokedExpression = Expression.Invoke(expression2, expression1.Parameters
                .Cast());

            return Expression.Lambda>(Expression.And(expression1.Body,
                invokedExpression), expression1.Parameters);
        }

    }