C# 带LINQ和不带LINQ的线性搜索之间的差异

使用比较变量的常规搜索算法与使用lambda运算符的常规搜索算法有什么区别

他们在内部做了哪些不同的事情，您如何尽可能简单地描述？两个版本都向用户提供相同的输出

//LINQ: 
Console.WriteLine("Search for a word: ");
string userInput = Console.ReadLine();
var entries = logbook.Where(entry => entry.Any(item =>item.IndexOf(userInput, StringComparison.OrdinalIgnoreCase) > -1));
foreach (var entry in entries)
{   
    Console.WriteLine(string.Join(", ", entry));    
}
break;

//Regular foreach: 
Console.WriteLine("Search for a word: ");

string userInput = Console.ReadLine();
foreach (string[] logs in logbook)
{
    if (logs[0] == userInput)
        Console.WriteLine("Word found!\n\nTitle: " + logs[0] + "\nText: " + logs[1] + "\n");
    else if (logs[1] == userInput)
        Console.WriteLine("Word found!\n\nTitle: " + logs[0] + "\nText: " + logs[1]);
}

---

我希望您已经准备好阅读一些代码。我已经更改了您的代码，使其具有可比性

foreach版本

以下是使用

foreach

的代码版本：

public static void Main()
{
    Console.WriteLine("Using foreach");
    string userInput = "1";
    var logbook = new List<string[]> { new string[] { "1", "2" } };
    foreach (string[] logs in logbook)
    {
        if (logs[0] == userInput)
            Console.WriteLine("Word found!\n\nTitle: " + logs[0] + "\nText: " + logs[1] + "\n");
        else if (logs[1] == userInput)
            Console.WriteLine("Word found!\n\nTitle: " + logs[0] + "\nText: " + logs[1]);
    }
}

如果您注意

Main

方法中的代码，它将利用编译器生成的类来完成其工作

---

我曾经做过上述工作。

如果您能给我们提供可比较的代码片段，这将非常有帮助-例如，您的第二段代码根本不使用

关键字

，第一段代码要求

用户输入

，但随后忽略了它，这表明您可能打算使用

userInput

而不是

关键字

。。。但这不是您实际测试过的代码。同样，您的第二段代码执行与第一段代码完全不同的比较。（如果您编辑问题以使代码更具可比性，请注意格式设置-我重新格式化了它以使其更具可读性，如果您编辑，请执行同样的操作。）您的问题没有真正定义好。。。。有什么区别？。。如果嵌套数组中有100个字符串而不是2个字符串，该怎么办？那么第二个版本就不太可能是你想要的了。输出也不同。。那么基本上你想比较哪两种情况？并比较哪些参数？性能/内存/可读性/可扩展性…@GiladGreen抱歉，我的问题更广泛，因为这两个问题只是一个例子。当我使用代码时，我可以在列表中的数组中搜索这两个字符串。我只是好奇，在这种情况下，lambda one与普通的for one有何不同。不过，您仍然让代码做完全不同的事情。在如此多的情况下，当他们给出不同的结果时，问哪个版本更清晰是没有意义的。

public static void Main()
{
    Console.WriteLine("Using foreach");
    string b = "1";
    List<string[]> list = new List<string[]>();
    List<string[]> arg_2F_0 = list;
    string[] expr_1F = new string[2];
    expr_1F[0] = "1";
    string[] expr_27 = expr_1F;
    expr_27[1] = "2";
    arg_2F_0.Add(expr_27);
    List<string[]> list2 = list;
    List<string[]>.Enumerator enumerator = list2.GetEnumerator();
    try
    {
        while (enumerator.MoveNext())
        {
            string[] current = enumerator.Current;
            bool flag = current[0] == b;
            if (flag)
            {
                string[] expr_64 = new string[5];
                expr_64[0] = "Word found!\n\nTitle: ";
                string[] expr_6C = expr_64;
                expr_6C[1] = current[0];
                string[] expr_73 = expr_6C;
                expr_73[2] = "\nText: ";
                string[] expr_7B = expr_73;
                expr_7B[3] = current[1];
                string[] expr_82 = expr_7B;
                expr_82[4] = "\n";
                Console.WriteLine(string.Concat(expr_82));
            }
            else
            {
                bool flag2 = current[1] == b;
                if (flag2)
                {
                    Console.WriteLine("Word found!\n\nTitle: " + current[0] + "\nText: " + current[1]);
                }
            }
        }
    }
    finally
    {
        ((IDisposable)enumerator).Dispose();
    }
}

public static void Main()
{
    Console.WriteLine("Using lambda");
    string userInput = "1";
    var logbook = new List<string[]> { new string[] { "1", "2" } };
    var entries = logbook.Where(entry => entry.Any(item => item.IndexOf(userInput, StringComparison.OrdinalIgnoreCase) > -1));
    foreach (var entry in entries)
    {
        Console.WriteLine(string.Join(", ", entry));
    }
}

[CompilerGenerated]
private sealed class <>c__DisplayClass0_0
{
    public string userInput;

    public Func<string, bool> <>9__1;

    internal bool <Main>b__0(string[] entry)
    {
        IEnumerable<string> arg_20_0 = entry;
        Func<string, bool> arg_20_1;
        if ((arg_20_1 = this.<>9__1) == null)
        {
            arg_20_1 = (this.<>9__1 = new Func<string, bool>(this.<Main>b__1));
        }
        return arg_20_0.Any(arg_20_1);
    }

    internal bool <Main>b__1(string item)
    {
        return item.IndexOf(this.userInput, StringComparison.OrdinalIgnoreCase) > -1;
    }
}

public static void Main()
{
    Program.<>c__DisplayClass0_0 <>c__DisplayClass0_ = new Program.<>c__DisplayClass0_0();
    Console.WriteLine("Using lambda");
    <>c__DisplayClass0_.userInput = "1";
    List<string[]> list = new List<string[]>();
    List<string[]> arg_3A_0 = list;
    string[] expr_2A = new string[2];
    expr_2A[0] = "1";
    string[] expr_32 = expr_2A;
    expr_32[1] = "2";
    arg_3A_0.Add(expr_32);
    List<string[]> source = list;
    IEnumerable<string[]> enumerable = source.Where(new Func<string[], bool>(<>c__DisplayClass0_.<Main>b__0));
    IEnumerator<string[]> enumerator = enumerable.GetEnumerator();
    try
    {
        while (enumerator.MoveNext())
        {
            string[] current = enumerator.Current;
            Console.WriteLine(string.Join(", ", current));
        }
    }
    finally
    {
        if (enumerator != null)
        {
            enumerator.Dispose();
        }
    }
}