Question

我有以下课程：

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

和包含FactoryOrders列表的集合

List<FactoryOrder>()

这是示例数据

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

我的要求是合并工厂订单的文本，其中orderNo是顺序的，并保留合并的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并不是最简单的方法。使用简单的循环。

您可以先使用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：

http://fs1.directupload.net/images/150619/9bmfc7xk.jpg

Answer 2

我不确定是否可以使用单个可理解的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有一个构造函数接受Text和OrderNo。

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 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();

正如你所看到的，在这里发生的事情并不是那么简单，而且当有很多＆＃34;很多时候，它的表现很糟糕。项目，因为一遍又一遍地访问不断增长的字典。

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

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

5 个答案: