Question

所以，为了保持简短，我有一些代码，我循环遍历字符串拆分的结果并将它们添加到列表中，如果它们在循环之前没有发生过。这是代码。

var res = new List<string>();
foreach(string s in input.Split(new[] { ", " }, 
              StringSplitOptions.RemoveEmptyEntries))
{
    if(res.All(p => p != s))
        res.Add(s);
}

但是在我写完这段代码后，Visual Studio说我可以将部分循环转换为LINQ。但是，我对这是否有效持怀疑态度。

基本上，我的问题是，lambda表达式是在每个单独的循环上执行，还是在开头只执行一次？

var res = new List<string>();
foreach (string s in input.Split(new[] { ", " }, 
              StringSplitOptions.RemoveEmptyEntries)
                          .Where(s => res.All(p => p != s)))
{
    res.Add(s);
}

Answer 1

以下是对List<int> vals = new List<int> {1, 1, 2, 2, 3, 4}; var res = new List<int>(); foreach (int s in vals.Where(s => { Console.WriteLine("lambda"); return s % 2 == 0; })) { Console.WriteLine("loop"); }个查询进行延迟评估的示例。

lambda
lambda
lambda
loop
lambda
loop
lambda
lambda
loop

输出将是

foreach

正如您所看到的，仅当{{1}}循环

需要下一个元素时才会评估lambda

Answer 2

基本上你只是想获得不同的价值观：

var res = input.Split(new[] { ", " }, StringSplitOptions.RemoveEmptyEntries)
               .Distinct()
               .ToList();

Answer 3

我构建于Dmitry's answer并使输出更加冗长，以向您展示实际发生的事情。另请注意，作为Ufuk noted，有更好的方法来实现不同值的列表。

随意为您自己测试一下，并在此dotnetfiddle中稍微玩一下。

以下是示例：

List<int> input = new List<int> {1, 1, 2, 2, 3, 4};
var res = new List<int>();
foreach (int s in input.Where(s => 
            { 
                Console.WriteLine("lambda: s=" + s);
                Console.WriteLine("lambda: " + s + " contained in res? " + res.Contains(s));
                return !res.Contains(s);
            }))
{
    res.Add(s);
    Console.WriteLine("loop: " + s + " added to res");
    Console.WriteLine();
}

它产生以下输出：

lambda: s=1
lambda: 1 contained in res? False
loop: 1 added to res

lambda: s=1
lambda: 1 contained in res? True
lambda: s=2
lambda: 2 contained in res? False
loop: 2 added to res

lambda: s=2
lambda: 2 contained in res? True
lambda: s=3
lambda: 3 contained in res? False
loop: 3 added to res

lambda: s=4
lambda: 4 contained in res? False
loop: 4 added to res

LINQ Lambdas何时在foreach循环中执行

3 个答案: