Peuvent tous être "pour" boucles d'être remplacé par un LINQ déclaration?

Sûr. Heck, vous pouvez remplacer arithmétique avec des requêtes LINQ:

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

Mais vous ne devriez pas.

Le but d'une expression de requête est de représentent une opération de requête. Le but d'une boucle "for" est d'itérer sur une instruction particulière, de façon à avoir ses effets secondaires exécutée plusieurs fois. Ceux-ci sont souvent très différents. J'encourage le remplacement des boucles dont le but est simplement de requête de données de haut niveau ainsi que des constructions plus clairement des requêtes sur les données. Je déconseille vivement de remplacer des effets secondaires de la génération de code avec des interprétations de la requête, si cela est possible.

En fait, votre code n'quelque chose qui est fondamentalement très fonctionnelle, à savoir qu'il réduit une liste de chaînes de caractères d'une chaîne unique en concaténant les éléments de la liste. Le seul impératif chose à propos de ce code est l'utilisation d'un StringBuilder.

Le code fonctionnel cela rend beaucoup plus facile, en fait, car il n'a pas besoin d'un cas comme le votre code ne. Mieux encore, .NET déjà a cette opération mise en œuvre, et sans doute plus efficace que votre code¹⁾:

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

(Oui, l'appel à ToArray() est ennuyeux, mais Join est une très ancienne méthode et est antérieure à LINQ.)

Bien sûr, une “meilleure” version de Join pourrait être utilisée comme ceci:

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

La mise en œuvre est assez simple – mais encore une fois, à l'aide de la StringBuilder (pour la performance), il est impératif.

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();
}

---

¹⁾ Sans avoir regardé la mise en œuvre dans le réflecteur, je suppose que String.Join fait un premier passage sur les cordes afin de déterminer la longueur totale. Cela peut être utilisé pour initialiser la StringBuilder en conséquence, sauvant ainsi de coûteuses opérations de copie plus tard.

ÉDITION par SLaks: Ici est la source de référence pour la partie pertinente de String.Join de .Net 3.5:

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) == '
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!");
} 
', "String must be null-terminated!");
} 

Je pense que le plus important ici est que, pour éviter la confusion sémantique, votre code ne doit être superficiellement fonctionnel lorsqu'il est fait fonctionnelle. En d'autres termes, veuillez ne pas utiliser d'effets secondaires dans les expressions LINQ.

En général, vous pouvez écrire une expression lambda à l'aide d'un délégué qui représente le corps d'un foreach cycle, dans votre cas, quelque chose comme :

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

et puis il suffit d'utiliser dans un ForEach de la méthode d'extension. Si c'est une bonne idée dépend de la complexité de l'organisme, dans le cas où il est trop gros et trop complexe, vous n'aurez probablement pas obtenir quelque chose de lui, sauf pour la confusion possible 😉