3

我无法理解如何做到这一点。

我有一个对象集合

{ object1, object2, object3, object4 }

我想把这个集合分解成一个集合的集合，这样我最终得到的东西看起来像

{ { object1, object2}, {object2, object3}, {object3, object4} }

我已经找到了如何将集合分成更小的集合，但是每个集合中前一个项目的重复让我头疼。

非常感谢任何帮助！

我当前的块方法（取自这里的另一个问题）是

    public static IEnumerable<IEnumerable<T>> Chunk<T>(this IEnumerable<T> source, int size)
    {
            return source.Select((x, i) => new { Index = i, Value = x })
                        .GroupBy(x => x.Index / size)
                        .Select(x => x.Select(v => v.Value));
    }

编辑 这行得通，但是有更好的方法吗？

    public static ICollection<ICollection<T>> BreakUp<T>(this IEnumerable<T> polylines, int size)
    {
        var results = new Collection<ICollection<T>>();
        results.Add(new Collection<T>());

        var x = 0;
        for (var i = 0; i < polylines.Count(); i++)
        {
            results[x].Add(polylines.ElementAt(i));

            if (results[x].Count() % size == 0 && i != polylines.Count() - 1)
            {
                x++;
                results.Add(new Collection<T>());
                results[x].Add(polylines.ElementAt(i));
            }
        }

        return results;
    }
4

3 回答 3

8

您可以像这样简化代码：

public static IEnumerable<IEnumerable<T>> BreakUp<T>(IEnumerable<T> this source, int size)
{
    var max = source.Count();
    int i = 0;
    while (i < max)
    {
        var current = source.Skip(i).Take(size);
        if (current.Count() > 1)
            yield return current;
        i += size -1;
    }
}

测试：

void Main()
{
    Console.WriteLine("Example 1");
    var source = new Int32[] {1, 2, 3, 4, 5};

    foreach (var i in BreakUp(source, 2))
        Console.WriteLine(i);

    Console.WriteLine("Example 2");

    foreach (var i in BreakUp(source, 4))
        Console.WriteLine(i);
}

这是一个source只迭代一次的解决方案：

public static IEnumerable<IEnumerable<T>> BreakUp<T>(IEnumerable<T> this source, int size)
{
    using(var e = source.GetEnumerator())
    {
        T last = default(T);
        bool has_last = false;
        while(e.MoveNext())
        {
            var current = new List<T>(size);
            if(has_last)
                current.Add(last);

            last = (T)e.Current;
            current.Add(last);

            while(current.Count < size && e.MoveNext())
            {
                last = (T)e.Current;
                current.Add(last);
                has_last = true;
            }

            yield return current;
        }
    }
}

结果：

在此处输入图像描述

于 2012-08-01T06:46:52.510 回答
2

如果你只需要这样分组

{ { object1, object2}, {object2, object3}, {object3, object4} }

那么下面的代码就足够了

return source.Zip(source.Skip(1), (o1, o2) => new List<T> { o1, o2 });

编辑：

可变数量元素的解决方案：

{ { object1, object2, object3}, {object2, object3, object4}, {object3, object4, object5} }

source.TakeWhile((o,i) => i <= source.Count() - size)
      .Select((o,i) => source.Where((lo,li) => li >= i && li < i + size));
于 2012-08-01T06:50:56.093 回答
2

这可能不像其他解决方案那样简洁，但它只迭代source一次。

public static IEnumerable<List<T>> BreakUp<T>(this IEnumerable<T> source, int size)
{
    var max = source.Count();
    int start = 0;
    var enumerator = source.GetEnumerator();
    enumerator.MoveNext();
    // We use "max - 1" instead of "max" to avoid adding a list of length 1
    while (start < max - 1)
    {
        int current = 0;
        List<T> list = new List<T>();
        list.Add(enumerator.Current);
        current++;

        while(current < size && enumerator.MoveNext())
        {
            list.Add(enumerator.Current);
            current++;
        }
        yield return list;
        start += size - 1;
    }
}
于 2012-08-01T19:16:51.897 回答