两个列表字符串的并发 foreach 迭代答案

【问题标题】：Concurent foreach iteration of two list strings两个列表字符串的并发 foreach 迭代
【发布时间】：2013-06-17 18:48:50
【问题描述】：

假设我有两个 List<string>。这些是从读取文本文件的结果中填充的

列表所有者包含：

cross
jhill
bbroms

列出受让人包含：

Chris Cross
Jack Hill
Bryan Broms

在从 SQL 源读取期间（SQL 语句包含连接）...我会执行

    if(sqlReader["projects.owner"] == "something in owner list" || sqlReader["assign.assignee"] == "something in assignee list")
    {
       // add this projects information to the primary results LIST
       list_by_owner.Add(sqlReader["projects.owner"],sqlReader["projects.project_date_created"],sqlReader["projects.project_name"],sqlReader["projects.project_status"]);

       // if the assignee is not null, add also to the secondary results LIST
       // logic to determine if assign.assignee is null goes here 

       list_by_assignee.Add(sqlReader["assign.assignee"],sqlReader["projects.owner"],sqlReader["projects.project_date_created"],sqlReader["projects.project_name"],sqlReader["projects.project_status"]);
    }

我不想最终使用嵌套的 foreach。

FOR 循环可能就足够了。有人向我提到了 ZIP，但不确定在我的情况下这是否是更可取的途径。

【问题讨论】：

iterate through both lists 是指仅比较alpha 中的第一项与beta 中的第一项，然后将第二项与第二项进行比较，以此类推向前？如果是这样，只需使用常规的 for 循环。
你考虑过只使用LINQ的.Contains吗？（比如 'alpha.Contains(result["chestA.item"]))` 还是我误解了你的支票？似乎根本不需要任何嵌套。也许你会连续有两个循环，但这只是O(2*n)，它仍然是O(n)。
这感觉需要澄清一下。您有两个大小相同的列表，并且您想对它们做什么 what，究竟是什么？你从 SQL 源代码中读到了什么？你想用你的清单做什么？您是说您正在获得一对项目（A 和 B）并且您正在尝试查看 (A) 是否在列表 alpha 中或 (B) 是否在列表 beta 中？
感谢您的帮助，我添加了一些说明（希望有帮助）

标签： c# list foreach

【解决方案1】：

一个循环遍历两个列表（假设两个列表具有相同的计数）：

    for (int i = 0; i < alpha.Count; i++)
    {
        var itemAlpha = alpha[i] // <= your object of list alpha
        var itemBeta = beta[i] // <= your object of list beta
        //write your code here
    }

【讨论】：

+1。不要让事情变得比他们需要的更复杂。

【解决方案2】：

根据您的描述，您根本不需要迭代。

这是您需要的： http://msdn.microsoft.com/en-us/library/bhkz42b3.aspx

用法：

if ((listAlpga.contains(resultA) || (listBeta.contains(resultA)) {
   // do your operation
}

列表迭代将隐式发生在contains 方法中。这就是 2n 次比较，而 n*n 用于嵌套迭代。

如果你需要走那条路，你最好在每个列表中一个接一个地进行顺序迭代。

【讨论】：

请注意，Contains 在内部将迭代数据结构。你不需要显式地迭代它。
还要注意，如果你有一个比字符串更复杂的对象，你可以重载对象的包含函数。
或者使用FirstOrDefault，你可以使用任何你想要的谓词，然后检查结果是否为空（即尚未找到） - 或者如果FirstOrDefault找到它，则使用它。跨度>
糟糕，我正在编辑以在您输入评论时使隐式迭代更加明确。无论如何谢谢:)

【解决方案3】：

这个列表可能更好地表示为List<KeyValuePair<string, string>>，它将两个列表值配对在一个列表中。

【讨论】：

【解决方案4】：

对此有多种选择。最不“痛苦”的应该是陈旧的for 循环：

for (var index = 0; index < alpha.Count; index++)
{
    var alphaItem = alpha[index];
    var betaItem = beta[index];

    // Do something.
}

另一种有趣的方法是使用索引 LINQ 方法（但您需要记住它们是懒惰地评估的，您必须使用生成的可枚举），例如：

alpha.Select((alphaItem, index) => 
{
    var betaItem = beta[index];

    // Do something
})

如果直接使用枚举器，也可以枚举两个集合：

using (var alphaEnumerator = alpha.GetEnumerator())
using (var betaEnumerator = beta.GetEnumerator())
{
    while (alphaEnumerator.MoveNext() && betaEnumerator.MoveNext())
    {
        var alphaItem = alphaEnumerator.Current;
        var betaItem = betaEnumerator.Current;

        // Do something
    }
}

【讨论】：

【解决方案5】：

Zip（如果您需要对）或Concat（如果您需要组合列表）是同时迭代 2 个列表的可能选项。

【讨论】：

【解决方案6】：

我喜欢做这样的事情来枚举并行列表：

int alphaCount = alpha.Count ;
int betaCount  = beta.Count  ;
int i = 0 ;

while ( i < alphaCount && i < betaCount )
{
  var a = alpha[i] ;
  bar b = beta[i] ;
  // handle matched alpha/beta pairs
  ++i ;
}

while ( i < alphaCount )
{
  var a = alpha[i] ;
  // handle unmatched alphas
  ++i ;
}

while ( i < betaCount )
{
  var b = beta[i] ;
  // handle unmatched betas
  ++i ;
}

【讨论】：