根据条件合并List<T>中的两个或多个T

Question

我有以下 class:

public class FactoryOrder
    {
        public string Text { get; set; }
        public int OrderNo { get; set; }        
    }

和包含工厂订单列表的集合

List<FactoryOrder>()

这里是示例数据

FactoryOrder("Apple",20)
FactoryOrder("Orange",21)
FactoryOrder("WaterMelon",42)
FactoryOrder("JackFruit",51)
FactoryOrder("Grapes",71)
FactoryOrder("mango",72)
FactoryOrder("Cherry",73)

我的要求是合并FactoryOrders中orderNo顺序的Text，合并后的FactoryOrder保留低orderNo - 所以结果输出将是

   FactoryOrder("Apple Orange",20) //Merged Apple and Orange and retained Lower OrderNo 20
    FactoryOrder("WaterMelon",42)
    FactoryOrder("JackFruit",51)
    FactoryOrder("Grapes mango Cherry",71)//Merged Grapes,Mango,cherry and retained Lower OrderNo 71

我是 Linq 的新手，所以不知道该怎么做。任何帮助或指点将不胜感激

Answer 1

我不确定这是否可以使用单个可理解的 LINQ 表达式来完成。什么是简单的枚举：

    private static IEnumerable<FactoryOrder> Merge(IEnumerable<FactoryOrder> orders)
    {
        var enumerator = orders.OrderBy(x => x.OrderNo).GetEnumerator();

        FactoryOrder previousOrder = null;
        FactoryOrder mergedOrder = null;

        while (enumerator.MoveNext())
        {
            var current = enumerator.Current;

            if (mergedOrder == null)
            {
                mergedOrder = new FactoryOrder(current.Text, current.OrderNo);
            }
            else
            {
                if (current.OrderNo == previousOrder.OrderNo + 1)
                {
                    mergedOrder.Text += current.Text;
                }
                else
                {
                    yield return mergedOrder;
                    mergedOrder = new FactoryOrder(current.Text, current.OrderNo);
                }
            }

            previousOrder = current;
        }

        if (mergedOrder != null)
            yield return mergedOrder;
    }

这假设 FactoryOrder 有一个接受文本和订单号的构造函数。

Answer 2

如评论所述，如果您的逻辑如此严重地依赖于连续的项目，那么 LINQ 并不是最简单的方法。使用一个简单的循环。

您可以先用 LINQ 订购它们：orders.OrderBy(x => x.OrderNo )

var consecutiveOrdernoGroups = new List<List<FactoryOrder>> { new List<FactoryOrder>() };
FactoryOrder lastOrder = null;
foreach (FactoryOrder order in orders.OrderBy(o => o.OrderNo))
{
    if (lastOrder == null || lastOrder.OrderNo == order.OrderNo - 1)
        consecutiveOrdernoGroups.Last().Add(order);
    else
        consecutiveOrdernoGroups.Add(new List<FactoryOrder> { order });

    lastOrder = order;
}

现在您只需要用每个组的加入名称构建 FactoryOrder 的列表。这是 LINQ 和 String.Join 可以派上用场的地方：

orders = consecutiveOrdernoGroups
    .Select(list => new FactoryOrder 
    { 
        Text    = String.Join(" ", list.Select(o => o.Text)),
        OrderNo = list.First().OrderNo // is the minimum number
    })
    .ToList();

Result 你的样本：

Answer 3

刚写了一个方法，比较紧凑，性能也不错:

    static List<FactoryOrder> MergeValues(List<FactoryOrder> dirtyList)
    {            
        FactoryOrder[] temp1 = dirtyList.ToArray();
        int index = -1;
        for (int i = 1; i < temp1.Length; i++)
        {
            if (temp1[i].OrderNo - temp1[i - 1].OrderNo != 1) { index = -1; continue; }
            if(index == -1 ) index = dirtyList.IndexOf(temp1[i - 1]); 
            dirtyList[index].Text += " " + temp1[i].Text;                
            dirtyList.Remove(temp1[i]);
        }
        return dirtyList;
    }

Answer 4

使用副作用的 Linq 实现：

var groupId = 0;
var previous = Int32.MinValue;
var grouped = GetItems()
    .OrderBy(x => x.OrderNo)
    .Select(x =>
    {
        var @group = x.OrderNo != previous + 1 ? (groupId = x.OrderNo) : groupId;
        previous = x.OrderNo;
        return new
                {
                    GroupId = group,
                    Item = x
                };
    })
    .GroupBy(x => x.GroupId)
    .Select(x => new FactoryOrder(
       String.Join(" ", x.Select(y => y.Item.Text).ToArray()), 
       x.Key))
    .ToArray();

foreach (var item in grouped)
{
    Console.WriteLine(item.Text + "\t" + item.OrderNo);
}

输出：

Apple Orange    20
WaterMelon  42
JackFruit   51
Grapes mango Cherry 71

或者，使用生成器扩展方法消除副作用

public static class IEnumerableExtensions
{
    public static IEnumerable<IList<T>> MakeSets<T>(this IEnumerable<T> items, Func<T, T, bool> areInSameGroup)
    {
        var result = new List<T>();
        foreach (var item in items)
        {
            if (!result.Any() || areInSameGroup(result[result.Count - 1], item))
            {
                result.Add(item);
                continue;
            }
            yield return result;
            result = new List<T> { item };
        }
        if (result.Any())
        {
            yield return result;
        }
    }
}

你的实现变成了

var grouped = GetItems()
    .OrderBy(x => x.OrderNo)
    .MakeSets((prev, next) => next.OrderNo == prev.OrderNo + 1)
    .Select(x => new FactoryOrder(
        String.Join(" ", x.Select(y => y.Text).ToArray()),
        x.First().OrderNo))
    .ToList();

foreach (var item in grouped)
{
    Console.WriteLine(item.Text + "\t" + item.OrderNo);
}

输出相同，但代码更易于遵循和维护。

Answer 5

LINQ + 顺序处理 = Aggregate.

并不是说使用 Aggregate 总是最好的选择。 for(each) 循环中的顺序处理通常会产生更好的可读代码（请参阅 Tim 的回答）。无论如何，这是一个纯 LINQ 解决方案。

它循环遍历订单并首先将它们收集在一个字典中，其中第一个 Id 个连续订单为 Key，订单集合为 Value。然后它使用 string.Join:

产生结果

Class:

class FactoryOrder
{
    public FactoryOrder(int id, string name)
    {
        this.Id = id;
        this.Name = name;
    }

    public int Id { get; set; }
    public string Name { get; set; }
}

程序：

IEnumerable<FactoryOrder> orders =
    new[]
    {
        new FactoryOrder(20, "Apple"),
        new FactoryOrder(21, "Orange"),
        new FactoryOrder(22, "Pear"),
        new FactoryOrder(42, "WaterMelon"),
        new FactoryOrder(51, "JackFruit"),
        new FactoryOrder(71, "Grapes"),
        new FactoryOrder(72, "Mango"),
        new FactoryOrder(73, "Cherry"),
    };


var result = orders.OrderBy(t => t.Id).Aggregate(new Dictionary<int, List<FactoryOrder>>(),
    (dir, curr) =>
    {
        var prevId = dir.SelectMany(d => d.Value.Select(v => v.Id))
            .OrderBy(i => i).DefaultIfEmpty(-1)
            .LastOrDefault();
        var newKey = dir.Select(d => d.Key).OrderBy(i => i).LastOrDefault();
        if (prevId == -1 || curr.Id - prevId > 1)
        {
            newKey = curr.Id;
        }
        if (!dir.ContainsKey(newKey))
        {
            dir[newKey] = new List<FactoryOrder>();
        }
        dir[newKey].Add(curr);

        return dir;
    }, c => c)
    .Select(t => new
                 {
                     t.Key, 
                     Items = string.Join(" ", t.Value.Select(v => v.Name))
                 }).ToList();

如您所见，这里发生的事情并不是很简单，而且当有 "many" 项时它可能表现不佳，因为不断增长的字典被一遍又一遍地访问。

这是一种冗长的说法：不要使用聚合。

根据条件合并List<T>中的两个或多个T

Merge two or more T in List<T> based on condition

c#

linq

collections