C# 从列表中获取一组项目，并根据需要执行某些操作

我有一个列表中的项目列表。从这个列表中，我需要取前1000个项目并提交一个包，然后再取另外1000个项目并提交一个包。如果列表中没有1000个，我需要提交包含所有项目的包。为此，我编写了以下代码，在修改集合时返回一个错误

List<SyncQueue> tempMassiveSyncQueue=massiveSyncQueue;
while (tempMassiveSyncQueue.Count != 0)
{
    int MassivePackageFileCount =Convert.ToInt32(ConfigurationManager.AppSettings["MassivePackageFileLimit"]);
     massiveSyncQueues = tempMassiveSyncQueue;
    List<SyncQueue> tempMassivePackageSyncQueue=new List<SyncQueue>();
     if (massiveSyncQueues.Count > 1000
     {
         var massivePackageSyncQueue = (massiveSyncQueues.Take(1000)).ToList<SyncQueue>();
         tempMassivePackageSyncQueue = massivePackageSyncQueue;

         SubmitPackage(massivePackageSyncQueue);
     }

     if (tempMassivePackageSyncQueue.Count != 0)
     {
         foreach (var massivesynq in tempMassiveSyncQueue)
         {
             foreach (var deleteId in tempMassivePackageSyncQueue.Where(id => id.SyncQueueId == massivesynq.SyncQueueId))
             {
                 tempMassiveSyncQueue.Remove(massivesynq);
             }
         }
     }


     else
     {
         SubmitPackage(massiveSyncQueues);

     }
    massiveSyncQueues = null;
}

List tempMassiveSyncQueue=massiveSyncQueue；
while（tempMassiveSyncQueue.Count！=0）
{
int MassivePackageFileCount=Convert.ToInt32（ConfigurationManager.AppSettings[“MassivePackageFileLimit”]）；
MassiveSyncqueue=临时MassiveSyncqueue；
List tempMassivePackageSyncQueue=新列表（）；
如果（massiveSyncQueues.Count>1000
{
var massivePackageSyncQueue=（massiveSyncQueues.Take（1000））.ToList（）；
tempMassivePackageSyncQueue=massivePackageSyncQueue；
提交包装（massivePackageSyncQueue）；
}
if（tempMassivePackageSyncQueue.Count！=0）
{
foreach（tempMassiveSyncQueue中的var massivesynq）
{
foreach（tempMassivePackageSyncQueue.Where（id=>id.SyncQueueId==massivesynq.SyncQueueId）中的变量deleteId）
{
删除（massivesynq）；
}
}
}
其他的
{
提交包（massiveSyncQueues）；
}
massiveSyncQueues=null；
}

---

有人能帮上忙吗？

您的问题是，您正在调整设置foreach构造边界的集合

请尝试对正在循环的集合使用ToList（），因为这样会在内存中创建一个新列表：

    foreach (var massivesynq in tempMassiveSyncQueue.ToList())
{
    foreach (var deleteId in tempMassivePackageSyncQueue.Where(id => id.SyncQueueId == massivesynq.SyncQueueId).ToList())
    {
        tempMassiveSyncQueue.Remove(massivesynq);
    }
}

---

您的问题是您正在调整集合，foreach构造的边界是在该集合上设置的

请尝试对正在循环的集合使用ToList（），因为这样会在内存中创建一个新列表：

    foreach (var massivesynq in tempMassiveSyncQueue.ToList())
{
    foreach (var deleteId in tempMassivePackageSyncQueue.Where(id => id.SyncQueueId == massivesynq.SyncQueueId).ToList())
    {
        tempMassiveSyncQueue.Remove(massivesynq);
    }
}

---

在第1行中，您设置了tempMassiveSyncQueue=massiveSyncQueue，但在while循环中，您设置了massivesyncquee=tempMassiveSync

“修改集合”错误通常发生在您修改正在循环的集合时。这就是为什么您需要首先创建一个独立于原始集合的集合副本并循环该集合的原因

在while循环之前，您需要将massivesyncquee中的所有项添加到tempmasivesyncquee。然后，您需要使用代码在临时列表中循环。在第二个循环中，您正在从正在循环的列表中删除项。我假设您是要从massivesyncquee而不是临时列表中删除项

请尝试以下操作：

List<SyncQueue> tempMassiveSyncQueue = new List<SyncQueue>();
foreach(var item in massiveSyncQueue)
{
   tempMassiveSyncQueue.Add(item);
}
while (tempMassiveSyncQueue.Count != 0)
{
int MassivePackageFileCount = Convert.ToInt32(ConfigurationManager.AppSettings["MassivePackageFileLimit"]);
List<SyncQueue> tempMassivePackageSyncQueue=new List<SyncQueue>();
 if (massiveSyncQueues.Count > 1000
 {
     var massivePackageSyncQueue = (massiveSyncQueues.Take(1000)).ToList<SyncQueue>();
     tempMassivePackageSyncQueue = massivePackageSyncQueue;

     SubmitPackage(massivePackageSyncQueue);
 }

 if (tempMassivePackageSyncQueue.Count != 0)
 {
     foreach (var massivesynq in massiveSyncQueue)
     {
         foreach (var deleteId in tempMassivePackageSyncQueue.Where(id => id.SyncQueueId == massivesynq.SyncQueueId))
         {
             massiveSyncQueue.Remove(massivesynq);
         }
     }
 }


 else
 {
     SubmitPackage(massiveSyncQueues);

 }
massiveSyncQueues = null;

List tempMassiveSyncQueue=newlist（）；
foreach（massiveSyncQueue中的变量项）
{
添加（项）；
}
while（tempMassiveSyncQueue.Count！=0）
{
int MassivePackageFileCount=Convert.ToInt32（ConfigurationManager.AppSettings[“MassivePackageFileLimit”]）；
List tempMassivePackageSyncQueue=新列表（）；
如果（massiveSyncQueues.Count>1000
{
var massivePackageSyncQueue=（massiveSyncQueues.Take（1000））.ToList（）；
tempMassivePackageSyncQueue=massivePackageSyncQueue；
提交包装（massivePackageSyncQueue）；
}
if（tempMassivePackageSyncQueue.Count！=0）
{
foreach（massivesyncquee中的变量massivesynq）
{
foreach（tempMassivePackageSyncQueue.Where（id=>id.SyncQueueId==massivesynq.SyncQueueId）中的变量deleteId）
{
massivesyncquee.Remove（massivesynq）；
}
}
}
其他的
{
提交包（massiveSyncQueues）；
}
massiveSyncQueues=null；

---

}

在第1行中设置了tempMassiveSync=MassiveSync，但在while循环中设置了MassiveSync=tempMassiveSync

“修改集合”错误通常发生在您修改正在循环的集合时。这就是为什么您需要首先创建一个独立于原始集合的集合副本并循环该集合的原因

在while循环之前，您需要将massivesyncquee中的所有项添加到tempmasivesyncquee。然后，您需要使用代码在临时列表中循环。在第二个循环中，您正在从正在循环的列表中删除项。我假设您是要从massivesyncquee而不是临时列表中删除项

请尝试以下操作：

List<SyncQueue> tempMassiveSyncQueue = new List<SyncQueue>();
foreach(var item in massiveSyncQueue)
{
   tempMassiveSyncQueue.Add(item);
}
while (tempMassiveSyncQueue.Count != 0)
{
int MassivePackageFileCount = Convert.ToInt32(ConfigurationManager.AppSettings["MassivePackageFileLimit"]);
List<SyncQueue> tempMassivePackageSyncQueue=new List<SyncQueue>();
 if (massiveSyncQueues.Count > 1000
 {
     var massivePackageSyncQueue = (massiveSyncQueues.Take(1000)).ToList<SyncQueue>();
     tempMassivePackageSyncQueue = massivePackageSyncQueue;

     SubmitPackage(massivePackageSyncQueue);
 }

 if (tempMassivePackageSyncQueue.Count != 0)
 {
     foreach (var massivesynq in massiveSyncQueue)
     {
         foreach (var deleteId in tempMassivePackageSyncQueue.Where(id => id.SyncQueueId == massivesynq.SyncQueueId))
         {
             massiveSyncQueue.Remove(massivesynq);
         }
     }
 }


 else
 {
     SubmitPackage(massiveSyncQueues);

 }
massiveSyncQueues = null;

List tempMassiveSyncQueue=newlist（）；
foreach（massiveSyncQueue中的变量项）
{
添加（项）；
}
while（tempMassiveSyncQueue.Count！=0）
{
int MassivePackageFileCount=Convert.ToInt32（ConfigurationManager.AppSettings[“MassivePackageFileLimit”]）；
List tempMassivePackageSyncQueue=新列表（）；
如果（massiveSyncQueues.Count>1000
{
var massivePackageSyncQueue=（massiveSyncQueues.Take（1000））.ToList（）；
tempMassivePackageSyncQueue=massivePackageSyncQueue；
提交包装（massivePackageSyncQueue）；
}
if（tempMassivePackageSyncQueue.Count！=0）
{
foreach（massivesyncquee中的变量massivesynq）
{
foreach（tempMassivePackageSyncQueue.Where（id=>id.SyncQueueId==massivesynq.SyncQueueId）中的变量deleteId）
{
massivesyncquee.Remove（massivesynq）；
}
}
}
其他的
{
提交包（massiveSyncQueues）；
}
massiveSyncQueues=null；

---

}

将跳过合并到您的逻辑中

int loopCount = 0;
While(true)
{
    var ListToProcess = massiveSyncQueue.Skip(loopCount*1000).Take(1000);

    SubmitPackage(ListToProcess);

    if(ListToProcess.Count < 1000)   // We know there are no more in the list massive list.
    {
        break;
    }
    loopCnt++;
}

int loopCount=0；
While（true）
{
var ListToProcess=massiveSyncQueue.Skip（loopCount*1000）.Take（1000）；
SubmitPackage（ListToProcess）；
if（ListToProcess.Count<1000）//我们知道列表中没有更多的内容。
{
打破
}
loopCnt++；
}

将跳过合并到您的逻辑中

int loopCount = 0;
While(true)
{
    var ListToProcess = massiveSyncQueue.Skip(loopCount*1000).Take(1000);

    SubmitPackage(ListToProcess);

    if(ListToProcess.Count < 1000)   // We know there are no more in the list massive list.
    {
        break;
    }
    loopCnt++;
}

int loopCount=0；
While（true）
{
var ListToProcess=massiveSyncQueue.Skip（loopCount*1000）.Take（1000）；
SubmitPackage（ListToProcess）；
if（ListToProcess.Count<1000）//我们知道列表中没有更多的内容。
{
打破
}
loopCnt++；
}

试试这个

int count=1;
while(tempMassivePackageSyncQueue.Count>1000)
{


    var massivePackageSyncQueue = (massiveSyncQueues.skip(count*1000).Take(1000)).ToList<SyncQueue>();
         tempMassivePackageSyncQueue = massivePackageSyncQueue;

         SubmitPackage(massivePackageSyncQueue);
    count++;

}
var massivePackageSyncQueue = (massiveSyncQueues.skip(count*1000).Take()).ToList<SyncQueue>();
         tempMassivePackageSyncQueue = massivePackageSyncQueue;

         SubmitPackage(massivePackageSyncQueue);

int count=1；
while（tempMassivePackageSyncQueue.Cou