Linq 下的扩展方法太少了，您期待的 MoreLinq 来啦

一：背景

1. 讲故事

前几天看同事在用 linq 给内存中的两个 model 做左连接，用过的朋友都知道，你一定少不了一个叫做 DefaultIfEmpty 函数，这玩意吧，本来很流畅的 from...in...join, 突然搞进来这么一个函数，真的是恶心他妈给恶心开门，恶心到家了，简化后的代码如下：


    class User
    {
        public int UserID { get; set; }
        public string Email { get; set; }
    }

    class Order
    {
        public int OrderID { get; set; }
        public string OrderTitle { get; set; }
        public int UserID { get; set; }
    }

    static void Main(string[] args)
    {
         var userList = new List<User>()
            {
                new User(){ UserID=1, Email="[email protected]"},
                new User(){ UserID=2, Email="[email protected]"},
            };

            var orderList = new List<Order>()
            {
                new Order(){ OrderID=1, OrderTitle="订单1", UserID=1},
                new Order(){ OrderID=2, OrderTitle="订单2", UserID=1}
            };

            var query = from u in userList
                        join o in orderList on u.UserID equals o.UserID into grp
                        from item in grp.DefaultIfEmpty()
                        select new { UserID = u.UserID, OrderTitle = item?.OrderTitle };       
    }

之所以出现这个情况是因为不管是查询关键词还是扩展方法，都并没有直接对 leftjoin 和 rightjoin 底层支持，只能通过变通的方式去实现，这就很尴尬了，比如说上面的这段代码，你很难在多天之后还能准确理解这里的 DefaultIfEmpty 是用来干嘛的，那现在问题的关键在于，有没有什么方法让底层支持或者有可信的第三方帮我封装好，还真巧，在 github 上还真有一个 morelinq 项目：https://github.com/morelinq/M...，看 md 是给 Enumerable 扩展了 60，70 个方法，如虎添翼呀，接下来一起来探索下吧。

二： MoreLinq 下的探索

1. 安装

安装非常简单，用 nuget 跑一下 Install-Package morelinq -Version 3.3.2 即可。

2. LeftJoin / RightJoin / FullJoin

在 morelinq 中就提供了左外，右边，全连接，这就很🐂👃了，提高开发效率，让我们更加专注业务，这里就使用 leftjoin 来改造刚才的代码,代码如下：


            var query2 = userList.LeftJoin(orderList, u => u.UserID, o => o.UserID,
                                                      u => new { UserID = u.UserID, OrderTitle = default(string) },
                                                      (u, o) => new { UserID = u.UserID, OrderTitle = o.OrderTitle });

怎么样，一句链式就搞定了，而且代码还非常好理解。

第一个参数：join 集合第二个参数：source 集合的关联 id 第三个参数：join 集合的关联 id 第四个参数：source 存在，join不存在应该返回的 model 架构第五个参数：source,join 都存在应该返回的 model 架构

刚才也说到了有60，70个扩展方法，大家可以去趴一趴其他有趣的东西，这里我推荐几个给大家演示一下，毕竟还是非常实用的。

3. Shuffle

从字面意思上看就是洗牌，挺实用的一个方法，很多时候我希望在一个集合中随机抽取一条记录，比如说我有10套邮件模板，当用户下订单之后，我希望可以随机抽一套模板给用户，以防被 qq邮箱放入垃圾箱中，原来我需要是用 new guid 来实现,如下代码：


            var list = new List<int>() { 1, 3, 5, 7, 9, 11, 12 };

            var query = list.OrderBy(m => Guid.NewGuid());

            Console.WriteLine(string.Join(",",query));

---- output -----

11,7,9,12,5,3,1

现在就简单多了，直接使用 Shuffle 搞定。


            var list = new List<int>() { 1, 3, 5, 7, 9, 11, 12 };

            var query = list.Shuffle();

            Console.WriteLine(string.Join(",", query));

----- output ------

5,1,9,12,7,3,11

4. Insert

有时候我需要在 IEnumerable 集合的指定位置插入一个集合，举个例子， A= { 1, 3, 5, 7, 9, 11, 12 }, B ={8}, 我希望将 8 插入到 7 和 9 之间，在现有的 Enumerable 下只有 Concat 和 Append 方法，无法做到指定插入，这个需求又可以被 moreqlinq 搞定啦。。。代码如下：


            IEnumerable<int> list = new List<int>() { 1, 3, 5, 7, 9, 11, 12 };

            var query = list.Insert(new List<int>() { 8 }, 4);

            Console.WriteLine(string.Join(",", query));

可以看到往一个集合的指定位置插入一个集合就是这么轻松如意，太爽啦~~~

5. ForEach

不知道什么原因，至今在 IEnumerable 下都没有提供 ForEach 扩展方法，我这个升斗小民反正是体会不到这么设计的哲学在哪里，在原来你只能 ToList 立即执行，要么使用 foreach 进行延期遍历，现在就方便多了，简化的代码如下：


            IEnumerable<int> list = new List<int>() { 1, 3, 5, 7, 9, 11, 12 };

            list.ForEach(m =>
            {
                Console.Write(m+" ");
            });

6. ToDataTable

对在看的各位大佬估计都用不上，对我们公司几个 10 ＋年的项目，那是万万不能少哈，如有能用得上的，可以简单看一下：

非常简单，不过我还是好奇一下它是怎么做到的，可以用 ilspy 去翻翻它的源码：


public static TTable ToDataTable<T, TTable>(this IEnumerable<T> source, TTable table, params Expression<Func<T, object>>[] expressions) where TTable : DataTable
{
    MemberInfo[] members = PrepareMemberInfos(expressions).ToArray();
    members = BuildOrBindSchema(table, members);
    Func<T, object[]> func = CreateShredder<T>(members);
    table.BeginLoadData();
    try
    {
        foreach (T item in source)
        {
            DataRow dataRow = table.NewRow();
            dataRow.ItemArray = func(item);
            table.Rows.Add(dataRow);
        }
        return table;
    }
    finally
    {
        table.EndLoadData();
    }
}

private static IEnumerable<MemberInfo> PrepareMemberInfos<T>(ICollection<Expression<Func<T, object>>> expressions)
{
    if (expressions == null || expressions.Count == 0)
    {
        return typeof(T).GetMembers(BindingFlags.Instance | BindingFlags.Public).Where(delegate(MemberInfo m)
        {
            if (m.MemberType != MemberTypes.Field)
            {
                PropertyInfo propertyInfo = m as PropertyInfo;
                if ((object)propertyInfo != null && propertyInfo.CanRead)
                {
                    return propertyInfo.GetIndexParameters().Length == 0;
                }
                return false;
            }
            return true;
        });
    }
    try
    {
        return expressions.Select(GetAccessedMember);
    }
    catch (ArgumentException innerException)
    {
        throw new ArgumentException("One of the supplied expressions is not allowed.", "expressions", innerException);
    }
    MemberInfo GetAccessedMember(LambdaExpression lambda)
    {
        Expression expression = lambda.Body;
        if (expression.NodeType == ExpressionType.Convert || expression.NodeType == ExpressionType.ConvertChecked)
        {
            expression = ((UnaryExpression)expression).Operand;
        }
        MemberExpression memberExpression = expression as MemberExpression;
        if (memberExpression == null || memberExpression.Expression.NodeType != ExpressionType.Parameter)
        {
            throw new ArgumentException($"Illegal expression: {lambda}", "lambda");
        }
        return memberExpression.Member;
    }
}

从上面源码大概可以看到，将 List 转成 DataTable 支持两种方式，要么反射，要么 Expression 解析树，默认用的是反射，性能要稍微低一点。