c# - 按键/属性将列表分组为子列表而不更改列表顺序(只需按属性切入列表)

Question

我四处寻找这个，我确信我只是想念它，因为我对 Linq 不是那么好。

我有一个如下所示的列表:

type=a, value=aaaa
type=a, value=bbbb
type=b, value=cccc
type=d, value=dddd
type=d, value=eeee
type=d, value=ffff
type=a, value=gggg
type=b, value=hhhh
type=b, value=iiii
type=b, value=jjjj

我想将其分成子列表，而不进行排序(我需要保持原始顺序)。我想取回这些列表，按照列表列表或类似列表的顺序:

List 1
type=a, value=aaaa
type=a, value=bbbb

List2
type=b, value=cccc

List 3
type=d, value=dddd
type=d, value=eeee
type=d, value=ffff

List 4
type=a, value=gggg

List 5
type=b, value=hhhh
type=b, value=iiii
type=b, value=jjjj

我想循环不是最好的答案。

非常感谢任何想法。

stackoverflow.com 万岁!

克里斯

四个答案后编辑:

我检查了以下答案: * 神秘性 * 伯特·埃文斯 * 风险马丁 *大卫.s

他们都工作得很好。伯特·埃文斯 (Bert Evans) 提出了性能问题，在这种情况下，这对我来说不是一个大问题，但为了帖子的缘故，我做了一些快速检查。

我没有修改任何人的代码，只是计时它在相当短的列表上执行 4,000 次这样的操作。

Risky 的回答是最快的。伯特的回答只是慢了一点。

david 和 Enigmativity 几乎没有任何慢，真的。

我将 Risky 的答案标记为已接受，因为它的表现以及早期指向相关帖子，然后回来提供答案。

不过，我同意 Bert 的可读性最强。

老实说，我不知道我会使用哪一个...实际上，我会使用 Enigmativity 的解决方案，因为它已经考虑到我只需要每个子组的值和一个键。

Answer 1

使用来自 answer 的略微修改的扩展方法还有这个answer :

public static IEnumerable<IGrouping<int, T>> GroupConsecutive<T>(this IEnumerable<T> set, Func<T, T, bool> predicate)
{
    var i = 0;
    var k = 0;
    var ranges = from e in set
                    let idx = ++i
                    let next = set.ElementAtOrDefault(idx)
                    let key = next == null ? k : predicate(e, next) ? k : k++
                    group e by key into g
                    select g;
    return ranges;
}

给定一个类:

public class Foo
{
    public string Type { get; set; }
    public string Value { get; set; }
}

你可以这样做:

List<Foo> list = new List<Foo>()
{
    new Foo() { Type = "a", Value = "aaaa" },
    new Foo() { Type = "a", Value = "bbbb" },
    new Foo() { Type = "b", Value = "cccc" },
    new Foo() { Type = "d", Value = "dddd" },
    new Foo() { Type = "d", Value = "eeee" },
    new Foo() { Type = "d", Value = "ffff" },
    new Foo() { Type = "a", Value = "gggg" },
    new Foo() { Type = "b", Value = "hhhh" },
    new Foo() { Type = "b", Value = "iiii" },
    new Foo() { Type = "b", Value = "jjjj" }
};

var groups = list.GroupConsecutive((a, b) => a.Type == b.Type);

foreach (var group in groups)
{
    Console.WriteLine("List " + group.Key);
    foreach (var item in group)
    {
        Console.WriteLine("Type=" + item.Type + "    Value=" + item.Value);
    }
    Console.WriteLine();
}

结果看起来像这样:

List 0
Type=a    Value=aaaa
Type=a    Value=bbbb

List 1
Type=b    Value=cccc

List 2
Type=d    Value=dddd
Type=d    Value=eeee
Type=d    Value=ffff

List 3
Type=a    Value=gggg

List 4
Type=b    Value=hhhh
Type=b    Value=iiii
Type=b    Value=jjjj