相关疑难解决方法(0)

有没有什么方法可以将项目索引作为每个拆分的分隔符List<SomeObject>分成几个单独的列表SomeObject？

让我举例说明:

我有一个List<SomeObject>,我需要一个List<List<SomeObject>>或List<SomeObject>[],所以这些结果列表中的每一个将包含一组3个原始列表项(顺序).

例如.:

• 原始清单: [a, g, e, w, p, s, q, f, x, y, i, m, c]

• 结果列表: [a, g, e], [w, p, s], [q, f, x], [y, i, m], [c]

我还需要将结果列表大小作为此函数的参数.

我刚看了.NET Framework 的Skip/ Takeextension方法的源代码(在IEnumerable<T>类型上),发现内部实现正在使用该GetEnumerator方法:

// .NET framework
    public static IEnumerable<TSource> Skip<TSource>(this IEnumerable<TSource> source, int count)  
    {
        if (source == null) throw Error.ArgumentNull("source"); 
        return SkipIterator<TSource>(source, count); 
    }

    static IEnumerable<TSource> SkipIterator<TSource>(IEnumerable<TSource> source, int count) 
    {
        using (IEnumerator<TSource> e = source.GetEnumerator()) 
        {
            while (count > 0 && e.MoveNext()) count--;
            if (count <= 0) 
            { 
                while (e.MoveNext()) yield return e.Current;
            } 
        } 
    }

假设我有IEnumerable<T>1000个元素(底层类型是List<T>).如果我正在做list.Skip(990)会怎么样.拿(10)？在进入最后十个元素之前,它是否会通过990首元素进行迭代？(这就是我的理解).如果是,那么我不明白为什么微软没有实现这样的Skip方法:

    // Not tested... just to show the …

我有很多使用LINQ的例子,如何根据每个列表中的最大项将列表划分为子列表.但在这种情况下,我有兴趣使用sizemb作为权重来跳转子列表 - 每个列表的最大总文件大小为9mb.

    public class doc
    {
        public string file;
        public int sizemb;
    }

    var list = new List<doc>()
    {
         new doc { file = "dok1", sizemb = 5 },
         new doc { file = "dok2", sizemb = 5 },
         new doc { file = "dok3", sizemb = 5 },
         new doc { file = "dok4", sizemb = 4 },
    };

    int maxTotalFileSize = 9;

然后,上面的清单应分为3个清单.如果任何"文件"超过9mb,则应该在他们自己的列表中.

我在这里做了一个非LINQ版本:

        var lists = new List<List<doc>>();
        foreach (var item in list)
        {
            //Try and …

我有一维一维的数组:

int[] array = { 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32,33, 34,40,41,42,43, 44};

我想将这个1D数组划分为4行5列的2D数组,其中前5个值进入第1行,后5个进入第2行,依此类推.最终结果应如下所示:

array2D:

[[10, 11, 12, 13, 14]
[20, 21, 22, 23, 24]
[30, 31, 32, 33, 34]
[40, 41, 42, 43, 44]]

实际上,阵列将更长(可能超过100行),但列数为5,行数可以分为5.我已经简化了例如.这是我到目前为止所尝试的:

int[] array = { 10, 11, 12, 13, 14, 20, 21, 22, 23, 24, 30, 31, 32,33, 34,40,41,42,43, 44};
int[,] array2D = new int[(array.Length/5),5];

int count_0 = 1;
int count_1 = 1;
int count_2 = 1;
int …

我有一个列表,Message以及他们的项目长度size,this.Size = JsonConvert.SerializeObject(Data).Length;.

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

public class Message
{
    public Data Data { get; set; }
    public int Size { get; set; }

    public Message(Data Data)
    {
        this.Data = Data;
        this.Size = JsonConvert.SerializeObject(Data).Length;
    }
}

现在我有下面的数据集,我想将列表拆分成多个列表,每个列表应该只有50个字节(例如).

注 - 以 50为例,我的实际大小为1 MB,没有单个消息大于1MB

我试过下面,但是如何计算总大小并按照chunksize去分组,

.GroupBy(x => x.ItemSize / chunkSize)

还是以不同的方式？

var messages = new List<Message>
{
    new Message(new Data{ …

我正在做一个 POC，将字符串列表分成批次并异步处理每个批次。但是当我运行该程序时，它总是采用第一组项目（根据批量大小为 3）。那么任何人都可以帮助我如何移动到下一组项目。 Take是我写的一个扩展方法。我尝试使用async/await模式。

提前致谢

public class Program
{
    public static async Task Main(string[] args)
    {
        var obj = new Class1();
        List<string> fruits = new()
            {
                "1",
                "2",
                "3",
                "4",
                "5",
                "6",
                "7",
                "8",
                "9",
                "10"
            };
        
        await Class1.Start(fruits);
        Console.ReadLine();
    }
}

public class Class1
{
    private const int batchSize = 3;
    public static async Task Start(List<string> fruits)
    {
        if (fruits == null)
            return;

        var e = fruits.GetEnumerator();
        while (true)
        {    
            var batch = e.Take(3); // always …

我有一个程序,将文件的内容读入某种列表或数组.此列表/数组可以包含任意数量的项目.我需要将它分成更小的组,每组50个项目,然后对每个组中的每个项目进行一些处理.

List<string> stuffFromFile = new List<string>();

while ((line = fileReader.ReadLine()) != null)
      {
           stuffFromFile.Add(line);
      }

我一直在网上查看一些关于如何分块的例子,但说实话,我并不真正理解这些例子,其中一些似乎过于复杂.我只需要一些简单的东西,将原始的项目列表分组/拆分/分成50个组,然后让我遍历每个组中的每个项目,直到处理完成.

读入的项目总数很可能不是我可以均匀划分50的数字,因此最后一组最有可能包含少于50个项目,但仍然需要像其他项目一样进行处理.

有人可以帮忙吗？这听起来应该很简单,但我真的不知道该怎么做.我已经看到了使用LINQ的例子,但我也不理解它.