可以用 LINQ 语句替换所有“for”循环吗？

Question

是否可以将以下 'foreach' 编写为 LINQ 语句，我想更一般的问题可以将任何 for 循环替换为 LINQ 语句。

我对任何潜在的性能成本不感兴趣，只对在传统命令式代码中使用声明性方法的潜力感兴趣。

    private static string SomeMethod()
    {
        if (ListOfResources .Count == 0)
            return string.Empty;

        var sb = new StringBuilder();
        foreach (var resource in ListOfResources )
        {
            if (sb.Length != 0)
                sb.Append(", ");

            sb.Append(resource.Id);
        }

        return sb.ToString();
    }

干杯

AWC

Answer 1

从技术上讲，是的。

任何foreach 循环都可以使用ForEach 扩展方法转换为LINQ，例如MoreLinq 中的方法。

如果您只想使用“纯”LINQ（仅内置扩展方法），您可以滥用Aggregate 扩展方法，如下所示：

foreach(type item in collection { statements }

type item;
collection.Aggregate(true, (j, itemTemp) => {
    item = itemTemp;
    statements
    return true;
);

这将正确处理 any foreach 循环，甚至是 JaredPar 的答案。 编辑：除非它使用ref / out 参数、不安全代码或yield return。
难道你敢在实际代码中使用这个技巧。

---

在您的具体情况下，您应该使用字符串Join 扩展方法，例如这个：

///<summary>Appends a list of strings to a StringBuilder, separated by a separator string.</summary>
///<param name="builder">The StringBuilder to append to.</param>
///<param name="strings">The strings to append.</param>
///<param name="separator">A string to append between the strings.</param>
public static StringBuilder AppendJoin(this StringBuilder builder, IEnumerable<string> strings, string separator) {
    if (builder == null) throw new ArgumentNullException("builder");
    if (strings == null) throw new ArgumentNullException("strings");
    if (separator == null) throw new ArgumentNullException("separator");

    bool first = true;

    foreach (var str in strings) {
        if (first)
            first = false;
        else
            builder.Append(separator);

        builder.Append(str);
    }

    return builder;
}

///<summary>Combines a collection of strings into a single string.</summary>
public static string Join<T>(this IEnumerable<T> strings, string separator, Func<T, string> selector) { return strings.Select(selector).Join(separator); }
///<summary>Combines a collection of strings into a single string.</summary>
public static string Join(this IEnumerable<string> strings, string separator) { return new StringBuilder().AppendJoin(strings, separator).ToString(); }

Answer 2

事实上，您的代码做了一些基本非常功能的事情，即它通过连接列表项将字符串列表减少为单个字符串。关于代码唯一必要的事情是使用StringBuilder。

实际上，函数式代码使这变得更容易，因为它不需要像您的代码那样的特殊情况。更好的是，.NET 已经已经实现了这个特定的操作，并且可能比你的代码更有效¹⁾：

return String.Join(", ", ListOfResources.Select(s => s.Id.ToString()).ToArray());

（是的，对ToArray() 的调用很烦人，但Join 是一种非常古老的方法并且早于LINQ。）

当然，Join 的“更好”版本可以这样使用：

return ListOfResources.Select(s => s.Id).Join(", ");

实现相当简单——但再一次，使用StringBuilder（为了性能）使其变得势在必行。

public static String Join<T>(this IEnumerable<T> items, String delimiter) {
    if (items == null)
        throw new ArgumentNullException("items");
    if (delimiter == null)
        throw new ArgumentNullException("delimiter");

    var strings = items.Select(item => item.ToString()).ToList();
    if (strings.Count == 0)
        return string.Empty;

    int length = strings.Sum(str => str.Length) +
                 delimiter.Length * (strings.Count - 1);
    var result = new StringBuilder(length);

    bool first = true;

    foreach (string str in strings) {
        if (first)
            first = false;
        else
            result.Append(delimiter);
        result.Append(str);
    }

    return result.ToString();
}

---

¹⁾ 在没有查看反射器中的实现的情况下，我猜String.Join 第一次遍历字符串以确定总长度。这可用于相应地初始化StringBuilder，从而节省以后昂贵的复制操作。

由 SLaks 编辑：这是来自 .Net 3.5 的 String.Join 相关部分的参考来源：

string jointString = FastAllocateString( jointLength );
fixed (char * pointerToJointString = &jointString.m_firstChar) {
    UnSafeCharBuffer charBuffer = new UnSafeCharBuffer( pointerToJointString, jointLength); 

    // Append the first string first and then append each following string prefixed by the separator. 
    charBuffer.AppendString( value[startIndex] ); 
    for (int stringToJoinIndex = startIndex + 1; stringToJoinIndex <= endIndex; stringToJoinIndex++) {
        charBuffer.AppendString( separator ); 
        charBuffer.AppendString( value[stringToJoinIndex] );
    }
    BCLDebug.Assert(*(pointerToJointString + charBuffer.Length) == '\0', "String must be null-terminated!");
} 

Answer 3

当然。哎呀，您可以用 LINQ 查询替换 算术：

http://blogs.msdn.com/ericlippert/archive/2009/12/07/query-transformations-are-syntactic.aspx

但你不应该。

查询表达式的目的是表示查询操作。 “for”循环的目的是遍历特定语句，以便多次执行其副作用。这些通常非常不同。我鼓励使用更清楚地查询数据的更高级构造来替换目的仅仅是查询数据的循环。我强烈反对用查询理解替换产生副作用的代码，尽管这样做是可能的。

Answer 4

我认为这里最重要的是，为了避免语义混淆，您的代码应该只有在实际上功能时才表面上功能。换句话说，请不要在 LINQ 表达式中使用副作用。

Answer 5

您问题中的特定循环可以像这样声明性地完成：

var result = ListOfResources
            .Select<Resource, string>(r => r.Id.ToString())
            .Aggregate<string, StringBuilder>(new StringBuilder(), (sb, s) => sb.Append(sb.Length > 0 ? ", " : String.Empty).Append(s))
            .ToString(); 

至于性能，您可以预期性能会下降，但这对于大多数应用程序来说是可以接受的。

Answer 6

一般情况下是的，但有些特殊情况非常困难。例如，在一般情况下，如果没有大量黑客攻击，以下代码不会移植到 LINQ 表达式。

var list = new List<Func<int>>();
foreach ( var cur in (new int[] {1,2,3})) {
  list.Add(() => cur);
}

原因是使用 for 循环，可以看到迭代变量如何在闭包中捕获的副作用。 LINQ 表达式隐藏了迭代变量的生命周期语义，并防止您看到捕获它的值的副作用。

注意。上面的代码不等价于下面的 LINQ 表达式。

var list = Enumerable.Range(1,3).Select(x => () => x).ToList();

foreach 示例生成一个 Func<int> 对象列表，它们都返回 3。LINQ 版本生成一个 Func<int> 列表，它们分别返回 1,2 和 3。这就是使这种捕获方式难以移植的原因。

Answer 7

通常，您可以使用代表 foreach 循环主体的委托编写 lambda 表达式，在您的情况下类似于：

resource => { if (sb.Length != 0) sb.Append(", "); sb.Append(resource.Id); }

然后简单地在 ForEach 扩展方法中使用。这是否是一个好主意取决于身体的复杂性，如果它太大太复杂，除了可能的混乱之外，你可能不会从中获得任何好处；）