如何在 C# 中通过 Linq 对字典进行分块？

Question

我有一本字典，我需要将其分块以列出一组中的 9 个字典项和下一组中的其他 9 个项，依此类推...，

试过这段代码，

    public static List<List<DictionaryEntry>> ChunkDict(Dictionary<string,string> theList, int chunkSize) 
    { 
        List<List<DictionaryEntry>> result = theList.Select((x, i) => 
            new { data = x, indexgroup = i / chunkSize })
            .GroupBy(x => x.indexgroup, x => x.data)
            .Select(g => new List<DictionaryEntry>(g)).ToList(); 
        return result; 
    } 

但它没有编译，出现错误：错误 398 'System.Collections.Generic.List.List(System.Collections.Generic.IEnumerable)' 的最佳重载方法匹配有一些无效参数

我该怎么做？

Answer 1

我写这篇文章是为了做到这一点：

public static class EnumerableExtensions
{
    public static IEnumerable<IEnumerable<TElement>> Partition<TElement>(this IEnumerable<TElement> @this, int partitionSize)
    {
        if (@this == null) throw new ArgumentNullException("this");

        return new PartitionedEnumerable<TElement>(@this, partitionSize);
    }

    private sealed class PartitionedEnumerable<TElement> : IEnumerable<IEnumerable<TElement>>
    {
        #region Public

        public PartitionedEnumerable(IEnumerable<TElement> elements, int partitionSize)
        {
            this.elements = elements;
            this.partitionSize = partitionSize;
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            return GetEnumerator();
        }

        public IEnumerator<IEnumerable<TElement>> GetEnumerator()
        {
            IEnumerator<TElement> elementEnumerator = this.elements.GetEnumerator();

            var partition = new List<TElement>();
            while (elementEnumerator.MoveNext())
            {
                partition.Add(elementEnumerator.Current);

                if (partition.Count == partitionSize)
                {
                    yield return partition;
                    partition = new List<TElement>();
                }
            }

            if (partition.Count > 0) yield return partition;
        }

        #endregion

        #region Private

        private readonly IEnumerable<TElement> elements;
        private readonly int partitionSize;

        #endregion
    }
}

例子：

IDictionary<string, string> dictionary = ...;
foreach (IEnumerable<KeyValuePair<string, string>> triplet in dictionary.Partition(3))
{
    ... // use the triplet
}

如果您希望它们作为字典返回：

IEnumerable<Dictionary<string, string>> partitioned = dictionary.Partition(3)
                                                                .Select(_ => _.ToDictionary());

Answer 2

使用来自this answer的示例代码：

public static IEnumerable<IEnumerable<T>> Split<T>(this IEnumerable<T> list, int parts)
{
    int i = 0;
    var splits = from name in list
                 group name by i++ % parts into part
                 select part.AsEnumerable();
    return splits;
}

也许您可以修改它以适用于您的字典列表。

Answer 3

你试过了吗？

    public static Dictionary<int,List<Dictionary<string,string>> ChunkDict(Dictionary<string,string> theList, int chunkSize) 
    { 
        var result = theList.Select((x, i) => 
            new { data = x, indexgroup = i / chunkSize })
            .GroupBy(x => x.indexgroup)
            .Select(new KeyValuePair<int, List<Dictionary<string,string>>>(x.Key, x.ToList())).ToDictionary(); 
        return result; 
    } 

编辑：

可能需要一点修改，我什至没有编译这段代码。

Answer 4

这是我写的一个分块算法，可以帮助你

public static IEnumerable<IEnumerable<TResult>> SelectChunk<TSource, TResult>(
        this IEnumerable<TSource> source, Func<TSource, TResult> selector, int chunkSize)
    {
        IEnumerator<TSource> enumerator = source.GetEnumerator();
        while(true)
        {
            if (!enumerator.MoveNext())
                break;
            var resultArray = new TResult[chunkSize];
            for (int i = 0; i < chunkSize; i++)
            {
                resultArray[i] = selector(enumerator.Current);
                if (i == chunkSize-1 || !enumerator.MoveNext())
                    break;
            }
            yield return resultArray;
        } 
    }

编辑

下面是你如何使用它：

dictionary.SelectChunk(s => s, 9).Select(s => s.ToList).ToList()

Answer 5

您没有访问组项目中的数据，试试这个：

    public static void Main(string[] args)
    {
        var dict = new Dictionary<string, string> { { "1", "one" }, { "2", "two" }, { "3", "three" }, { "4", "four" }, { "5", "five" }, { "6", "six" } };
        var lists = ChunkDict(dict, 2);
        var i = 0;
        foreach (var list in lists)
        {
            Console.WriteLine("List with index {0} has count {1}", i, list.Count);
            foreach (var dictionaryEntry in list)
            {
                Console.WriteLine(dictionaryEntry.Key + ": " + dictionaryEntry.Value);
            }
            i++;
        }
        Console.ReadLine();
    }

    public static List<List<KeyValuePair<string, string>>> ChunkDict(Dictionary<string, string> theList, int chunkSize)
    {
        var result = theList.Select((x, i) =>
            new { data = x, indexgroup = i / chunkSize })
            .GroupBy(x => x.indexgroup, x => x.data)
            .Select(y => y.Select(x => x).ToList()).ToList();
        return result;
    }