Utilisation de LINQ pour concaténer des chaînes

Quelle est la façon la plus efficace d'écrire à l'ancienne:

StringBuilder sb = new StringBuilder();
if (strings.Count > 0)
{
    foreach (string s in strings)
    {
        sb.Append(s + ", ");
    }
    sb.Remove(sb.Length - 2, 2);
}
return sb.ToString();

... dans LINQ?

Cette réponse montre l'utilisation de LINQ ( Aggregate) comme demandé dans la question et n'est pas destinée à un usage quotidien. Parce que cela n'utilise pas un, StringBuilderil aura des performances horribles pour de très longues séquences. Pour une utilisation régulière du codeString.Join comme indiqué dans l'autre réponse

Utilisez des requêtes agrégées comme celle-ci:

string[] words = { "one", "two", "three" };
var res = words.Aggregate(
   "", // start with empty string to handle empty list case.
   (current, next) => current + ", " + next);
Console.WriteLine(res);

Cela produit:

, un deux trois

Un agrégat est une fonction qui prend une collection de valeurs et renvoie une valeur scalaire. Les exemples de T-SQL incluent min, max et sum. VB et C # prennent en charge les agrégats. VB et C # prennent en charge les agrégats en tant que méthodes d'extension. En utilisant la notation par points, on appelle simplement une méthode sur un IEnumerable objet .

N'oubliez pas que les requêtes agrégées sont exécutées immédiatement.

Plus d'informations - MSDN: requêtes agrégées

Si vous voulez vraiment utiliser Aggregateuse variant using StringBuilderpropose en commentaire par CodeMonkeyKing qui serait à peu près le même code que regular String.Joinincluant de bonnes performances pour un grand nombre d'objets:

 var res = words.Aggregate(
     new StringBuilder(), 
     (current, next) => current.Append(current.Length == 0? "" : ", ").Append(next))
     .ToString();

return string.Join(", ", strings.ToArray());

Dans .Net 4, il y a une nouvelle surcharge pour string.Joincela accepte IEnumerable<string>. Le code ressemblerait alors à:

return string.Join(", ", strings);

Pourquoi utiliser Linq?

string[] s = {"foo", "bar", "baz"};
Console.WriteLine(String.Join(", ", s));

Cela fonctionne parfaitement et accepte tout IEnumerable<string>autant que je me souvienne. Pas besoin de Aggregatequoi que ce soit ici qui est beaucoup plus lent.

Avez-vous examiné la méthode d'extension d'agrégat?

var sa = (new[] { "yabba", "dabba", "doo" }).Aggregate((a,b) => a + "," + b);

Exemple réel de mon code:

return selected.Select(query => query.Name).Aggregate((a, b) => a + ", " + b);

Une requête est un objet qui a une propriété Name qui est une chaîne, et je veux les noms de toutes les requêtes de la liste sélectionnée, séparés par des virgules.

Voici l'approche combinée Join / Linq sur laquelle j'ai opté après avoir examiné les autres réponses et les problèmes abordés dans une question similaire (à savoir que l'agrégation et la concaténation échouent avec 0 élément).

string Result = String.Join(",", split.Select(s => s.Name));

ou (si ce sn'est pas une chaîne)

string Result = String.Join(",", split.Select(s => s.ToString()));

• Facile
• facile à lire et à comprendre
• fonctionne pour les éléments génériques
• permet d'utiliser des objets ou des propriétés d'objet
• gère le cas des éléments de longueur 0
• pourrait être utilisé avec un filtrage Linq supplémentaire
• fonctionne bien (au moins d'après mon expérience)
• ne nécessite pas la création (manuelle) d'un objet supplémentaire (par exemple StringBuilder) à implémenter

Et bien sûr, Join s'occupe de la virgule finale embêtante qui se glisse parfois dans d'autres approches ( for, foreach), c'est pourquoi je cherchais une solution Linq en premier lieu.

Vous pouvez utiliser StringBuilderdans Aggregate:

  List<string> strings = new List<string>() { "one", "two", "three" };

  StringBuilder sb = strings
    .Select(s => s)
    .Aggregate(new StringBuilder(), (ag, n) => ag.Append(n).Append(", "));

  if (sb.Length > 0) { sb.Remove(sb.Length - 2, 2); }

  Console.WriteLine(sb.ToString());

(Le Selectest là juste pour montrer que vous pouvez faire plus de choses LINQ.)

données de performances rapides pour le cas StringBuilder vs Select & Aggregate sur 3000 éléments:

Test unitaire - Durée (secondes)
LINQ_StringBuilder - 0,0036644
LINQ_Select.Aggregate - 1,8012535

    [TestMethod()]
    public void LINQ_StringBuilder()
    {
        IList<int> ints = new List<int>();
        for (int i = 0; i < 3000;i++ )
        {
            ints.Add(i);
        }
        StringBuilder idString = new StringBuilder();
        foreach (int id in ints)
        {
            idString.Append(id + ", ");
        }
    }
    [TestMethod()]
    public void LINQ_SELECT()
    {
        IList<int> ints = new List<int>();
        for (int i = 0; i < 3000; i++)
        {
            ints.Add(i);
        }
        string ids = ints.Select(query => query.ToString())
                         .Aggregate((a, b) => a + ", " + b);
    }

J'utilise toujours la méthode d'extension:

public static string JoinAsString<T>(this IEnumerable<T> input, string seperator)
{
    var ar = input.Select(i => i.ToString()).ToArray();
    return string.Join(seperator, ar);
}

Par « voie LINQ super cool », vous pourriez parler de la façon dont LINQ rend la programmation fonctionnelle beaucoup plus acceptable avec l'utilisation de méthodes d'extension. Je veux dire, le sucre syntaxique qui permet d'enchaîner les fonctions de manière visuellement linéaire (l'une après l'autre) au lieu de s'emboîter (l'une dans l'autre). Par exemple:

int totalEven = Enumerable.Sum(Enumerable.Where(myInts, i => i % 2 == 0));

peut être écrit comme ceci:

int totalEven = myInts.Where(i => i % 2 == 0).Sum();

Vous pouvez voir comment le deuxième exemple est plus facile à lire. Vous pouvez également voir comment plus de fonctions peuvent être ajoutées avec moins de problèmes d'indentation ou les parens de fermeture Lispy apparaissant à la fin de l'expression.

Beaucoup d'autres réponses indiquent que String.Joinc'est la voie à suivre, car c'est la plus rapide ou la plus simple à lire. Mais si vous prenez mon interprétation de la ` ` façon LINQ super cool '', la réponse est d'utiliser String.Joinmais de l'envelopper dans une méthode d'extension de style LINQ qui vous permettra d'enchaîner vos fonctions d'une manière visuellement agréable. Donc, si vous voulez écrire, il sa.Concatenate(", ")vous suffit de créer quelque chose comme ceci:

public static class EnumerableStringExtensions
{
   public static string Concatenate(this IEnumerable<string> strings, string separator)
   {
      return String.Join(separator, strings);
   }
}

Cela fournira un code aussi performant que l'appel direct (au moins en termes de complexité de l'algorithme) et dans certains cas, rendra le code plus lisible (selon le contexte), surtout si un autre code du bloc utilise le style de fonction chaîné .

Il existe différentes réponses alternatives à cette question précédente - qui visait certes un tableau entier comme source, mais a reçu des réponses généralisées.

Ici, il utilise LINQ pur comme une seule expression:

static string StringJoin(string sep, IEnumerable<string> strings) {
  return strings
    .Skip(1)
    .Aggregate(
       new StringBuilder().Append(strings.FirstOrDefault() ?? ""), 
       (sb, x) => sb.Append(sep).Append(x));
}

Et c'est sacrément rapide!

Je vais tricher un peu et lancer une nouvelle réponse à cela qui semble résumer le meilleur de tout ici au lieu de la coller dans un commentaire.

Vous pouvez donc une ligne:

List<string> strings = new List<string>() { "one", "two", "three" };

string concat = strings        
    .Aggregate(new StringBuilder("\a"), 
                    (current, next) => current.Append(", ").Append(next))
    .ToString()
    .Replace("\a, ",string.Empty); 

Modifier: vous souhaiterez d'abord vérifier un énumérable vide ou ajouter un.Replace("\a",string.Empty); à la fin de l'expression. Je suppose que j'aurais pu essayer d'être un peu trop intelligent.

La réponse de @ a.friend pourrait être légèrement plus performante, je ne sais pas ce que remplace Replace sous le capot par rapport à Remove. La seule autre mise en garde si une raison pour laquelle vous vouliez concaténer des chaînes qui se terminaient par \ a, vous perdriez vos séparateurs ... Je trouve cela peu probable. Si tel est le cas, vous avez le choix entre d' autres personnages fantaisistes .

Vous pouvez combiner LINQ et string.join()assez efficacement. Ici, je supprime un élément d'une chaîne. Il existe de meilleures façons de le faire aussi, mais voici:

filterset = String.Join(",",
                        filterset.Split(',')
                                 .Where(f => mycomplicatedMatch(f,paramToMatch))
                       );

Beaucoup de choix ici. Vous pouvez utiliser LINQ et un StringBuilder pour obtenir les performances aussi comme ceci:

StringBuilder builder = new StringBuilder();
List<string> MyList = new List<string>() {"one","two","three"};

MyList.ForEach(w => builder.Append(builder.Length > 0 ? ", " + w : w));
return builder.ToString();

J'ai fait ce qui suit rapidement et sale lors de l'analyse d'un fichier journal IIS à l'aide de linq, cela a fonctionné assez bien @ 1 million de lignes (15 secondes), bien que j'ai obtenu une erreur de mémoire insuffisante lors de l'essai de 2 millions de lignes.

    static void Main(string[] args)
    {

        Debug.WriteLine(DateTime.Now.ToString() + " entering main");

        // USED THIS DOS COMMAND TO GET ALL THE DAILY FILES INTO A SINGLE FILE: copy *.log target.log 
        string[] lines = File.ReadAllLines(@"C:\Log File Analysis\12-8 E5.log");

        Debug.WriteLine(lines.Count().ToString());

        string[] a = lines.Where(x => !x.StartsWith("#Software:") &&
                                      !x.StartsWith("#Version:") &&
                                      !x.StartsWith("#Date:") &&
                                      !x.StartsWith("#Fields:") &&
                                      !x.Contains("_vti_") &&
                                      !x.Contains("/c$") &&
                                      !x.Contains("/favicon.ico") &&
                                      !x.Contains("/ - 80")
                                 ).ToArray();

        Debug.WriteLine(a.Count().ToString());

        string[] b = a
                    .Select(l => l.Split(' '))
                    .Select(words => string.Join(",", words))
                    .ToArray()
                    ;

        System.IO.File.WriteAllLines(@"C:\Log File Analysis\12-8 E5.csv", b);

        Debug.WriteLine(DateTime.Now.ToString() + " leaving main");

    }

La vraie raison pour laquelle j'ai utilisé linq était pour un Distinct () dont j'avais besoin auparavant:

string[] b = a
    .Select(l => l.Split(' '))
    .Where(l => l.Length > 11)
    .Select(words => string.Format("{0},{1}",
        words[6].ToUpper(), // virtual dir / service
        words[10]) // client ip
    ).Distinct().ToArray()
    ;

J'ai blogué à ce sujet il y a quelque temps, ce que j'ai fait semble être exactement ce que vous recherchez:

http://ondevelopment.blogspot.com/2009/02/string-concatenation-made-easy.html

Dans le billet de blog, décrivez comment implémenter des méthodes d'extension qui fonctionnent sur IEnumerable et sont nommées Concatenate, cela vous permettra d'écrire des choses comme:

var sequence = new string[] { "foo", "bar" };
string result = sequence.Concatenate();

Ou des choses plus élaborées comme:

var methodNames = typeof(IFoo).GetMethods().Select(x => x.Name);
string result = methodNames.Concatenate(", ");