Le plus efficace moyen de joindre des chaînes

J'ai besoin de concaténer beaucoup de cordes ensemble et mettre une virgule entre l'un d'eux.
J'ai une liste de chaînes de caractères

"123123123213"
"1232113213213"
"123213123"

et je veux obtenir

"123123123213,1232113213213,123213123"

Je me demandais quelle est la meilleure façon d'y parvenir.

Je pouvais le faire comme ceci:

private List<string> stringList = new List<string> { 
    //a lot of strings in here
    "1234567890", "34343434", "4343434" }; 

string outcome = string.Join(",", stringList.ToArray());

Ou peut-être:

StringBuilder builder = new StringBuilder();
stringList.ForEach(val => {
    builder.Append(val);
    builder.Append(",");
});

string outcome = builder.ToString();

Ce qui est mieux? Savez-vous de meilleures façons de concaténer des chaînes de caractères?

Liés à ou peut-être dupliqué: stackoverflow.com/q/3102806/340760
Pourquoi ne pas tester les performances de vous-même?
Vous n'avez pas spécifié quels moyens les mieux. J'ai ajouté performance la balise à votre question.

OriginalL'auteur image | 2011-05-01

c#performance string

6

Comme @Ekkehard dit, l'utilisation de la chaîne de caractères.Rejoindre.

Cependant, vous n'avez pas besoin de la ToArray() parce que string.Join a une surcharge pour IEnumerable<string>.
```
List<string> stringList = new List<string> 
    { "1234567890", "34343434", "4343434" }; 

string outcome = string.Join(",", stringList);
```
MODIFIER

Comme @Kobi dit, cela fonctionnera seulement C# 4.0. En 3.5, je le ferais.
```
var s = new StringBuilder(stringList.Count * 8);
foreach (var item in stringList)
{
   s.Append(item);
   s.Append(',');
}
s.Length -= 1;
string outcome = stringList.ToList();
```
Notez que ce qui est nouveau dans .Net 4, 3.5 a encore besoin d'un tableau.

OriginalL'auteur Richard Schneider
5

Vous devez utiliser string.Join() parce que:

un) c'est beaucoup plus lisible, plus facile à gérer et facile sur les yeux.

b) il utilise un StringBuilder en interne déjà, donc c'est très efficace ( vous pouvez vérifier vous-même en utilisant le Réflecteur).

Edit:

string.Join() utilise un StringBuilder pour le cas général d'un IEnumerable<T> d'entrée. Si vous disposez déjà d'un tableau sur l'autre main, elle utilise de la magie vaudou (y compris FastAllocateString() et UnSafeCharBuffer) pour être encore plus rapide.

Pour info, string.Join(string, string[]) ne pas utiliser StringBuilder, mais UnSafeCharBuffer.
Oui, tout était dans le processus d'édition qu'après cette observation ainsi - c'est vodoo magique, effectivement 😉

OriginalL'auteur BrokenGlass
1

Utilisation de la Rejoindre, car elle permet de ne pas ajouter un point ",".

OriginalL'auteur Ekkehard.Horner
1

Il y a une référence sur la cette page qui semble montrer que string.Join fonctionne mieux que StringBuilder sur un petit tableau dans un grand nombre d'itérations. vous devriez probablement de référence pour des matrices plus grandes aussi. Comme je vais poster ce que je vois que BrokenGlass répondu que StringBuilder est utilisé en interne dans string.Join de sorte que vous pouvez vous attendre à être plus rapide je pense.

OriginalL'auteur Jan
1

Votre deuxième solution consiste à ajouter un supplément de , à la fin. Jetez un oeil à Eric Lippert entrée de blog de

Je recommande la fixation de votre deuxième solution. Un StringBuilder serait certainement plus rapide, que vous évitez d'adaptation du contenu de la liste d'un nouveau tableau.
```
StringBuilder builder = new StringBuilder();
string separator = "";
stringList.ForEach(
    val =>
    {
        builder.Append(separator).Append(val);
        separator = ",";
    });
string outcome = builder.ToString();
```
OriginalL'auteur Fede
0

StringBuilder est un moyen très efficace et serait recommandé ici.

Sauf string.Join() peut être encore plus efficace (au moins dans le cas, lorsque vous lui donner string[], sinon utilise StringBuilder lui-même).
svick vous avez donné un -1 pour quelqu'un qui dit quelque chose de plus intelligent que vous. Et cependant, le demandeur a besoin d'elle pour une liste de chaînes, pas pour un tableau.
comment est l'utilisation de StringBuilder de plus intelligent que de l'aide string.Join()? Le dernier est beaucoup plus claire, moins enclins à faire des erreurs (vous n'avez pas à écrire votre propre code) et peut-être plus rapidement.
Mince, c'est juste une solution de rechange.
Pour utiliser des chaînes de caractères.rejoindre vous avez à prendre la liste et d'abord faire un tableau. Qui peut ne pas être le moyen le plus efficace, surtout si vous avez beaucoup de petites chaînes.

OriginalL'auteur Kevin Hsu

Selon le test que j'ai fait, Rejoindre est 3x plus rapide plus rapide sur de grands tableaux:

La Text.txt fichier contient la valeur "aaaaaaaaaaaaaaaaaaa" sur 38400 lignes:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Diagnostics;

namespace ConsoleApplication1
{
  class Program
  {
    static void Main(string[] args)
    {
      var strings = File.ReadAllLines("Text.txt");

      Stopwatch sw;

      StringBuilder sb = new StringBuilder();

      sw = Stopwatch.StartNew();
      for (int i = 0; i < strings.Length; i++)
      {
        sb.AppendLine(strings[i]);
      }
      sw.Stop();
      TimeSpan sbTime = sw.Elapsed;

      sw = Stopwatch.StartNew();
     var output = string.Join(",", strings);
     sw.Stop();

     TimeSpan joinTime = sw.Elapsed;   

    }
  }
}

De sortie:

00:00:00.0098754
00:00:00.0032922

OriginalL'auteur Shimmy

0

Chaîne de caractères.Rejoindre est la manière la plus rapide si vous avez un nombre fixe de chaînes à la rejoindre. La raison plus profonde est que la Chaîne de caractères.Jointure ne boucle sur le tableau et alloue de la finale de la mémoire tampon de chaîne avec la bonne taille, car il a la première passe, ajouter la longueur de la chaîne de toutes les cordes en même temps. Vous pouvez obtenir des résultats similaires lorsque vous jouez avec des StringBuilder et de sa capacité. La règle d'or est d'éviter les allocations de mémoire au prix de boucler sur le tableau à deux reprises. L'approche la plus rapide dépend du nombre d'articles que vous avez dans votre liste et comment big le resultint chaîne obtiendrez.

Vôtre,
Alois Kraus

OriginalL'auteur Alois Kraus

Code de Test:

public static void Performance(Action fn)
{
    var timer = new Stopwatch();
    timer.Start();

    for (var i = 0; i < 10000000; ++i)
    {
        fn();
    }

    timer.Stop();

    Console.WriteLine("{0} Time: {1}ms ({2})", fn.ToString(), timer.ElapsedMilliseconds, timer.ElapsedTicks);
}

static void Main(string[] args)
{
    var stringList = new List<string>() {
        "123123123213",
        "1232113213213",
        "123213123"
    };

    string outcome = String.Empty;
    Performance(() =>
    {
        outcome = string.Join(",", stringList);
    });

    Console.WriteLine(outcome);

    Performance(() =>
    {
        StringBuilder builder = new StringBuilder();
        stringList.ForEach
            (
                val =>
                {
                    builder.Append(val);
                    builder.Append(",");
                }
            );
        outcome = builder.ToString();
        outcome = outcome.Substring(0, outcome.Length - 1);
    });

    Console.WriteLine(outcome);

    Console.ReadKey();

}

Résultat 1. String.Join - 2. StringBuilder + SubString. ####ms (ticks)

Le plus efficace moyen de joindre des chaînes

Dans ce cas String.Join est plus rapide, mais si vous êtes ok avec un trailing , puis

Le plus efficace moyen de joindre des chaînes

StringBuilder est légèrement plus rapide (avec un trailing ,).

OriginalL'auteur BrunoLM

Cette ad hoc de la mise en œuvre, j'ai essayé avec le StrignBuilder est plus rapide que la Chaîne.Rejoignez.
Plus de cette Chaîne.Jointure est un dévoreur de MÉMOIRE.
J'ai essayé avec 20000000 des chaînes et des Cordes.Rejoignez donne toujours OutOfMemory, lors de ma mise en œuvre de finitions.
Sur votre machine, Il peut être encore moins de chaînes si vous avez moins de 8 go de mémoire.
Commentaire de l'une des implémentations de test.
Cela est vrai, sauf si vous utilisez une chaîne de caractères fixe tableau []. Chaîne de caractères.Rejoindre est bien.

   public static void Main(string[] Args)
{
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
List<string> strings = new List<string>() {};
for (double d = 0; d < 8000000; d++) {
strings.Add(d.ToString());
}
TimeSpan upTime;
TimeSpan newupTime;
using (var pc = new PerformanceCounter("System", "System Up Time"))
{
StringBuilder sb = new StringBuilder(strings.Count);
int i;
pc.NextValue();    //The first call returns 0, so call this twice
upTime = TimeSpan.FromSeconds(pc.NextValue());
for (i = 0; i < strings.Count - 1; i++)
{
sb.Append(strings[i]);
sb.Append(",");
}
sb.Append(strings[i]);
newupTime = TimeSpan.FromSeconds(pc.NextValue());
sb = null;
Console.WriteLine("SB " + (newupTime - upTime).TotalMilliseconds);
}
using (var pc = new PerformanceCounter("System", "System Up Time"))
{
pc.NextValue();
upTime = TimeSpan.FromSeconds(pc.NextValue());
string s = string.Join(",", strings);
newupTime = TimeSpan.FromSeconds(pc.NextValue());
Console.WriteLine("JOIN " + (newupTime - upTime).TotalMilliseconds);
}
}
SB 406
JOIN 484

OriginalL'auteur Marino Šimić

Si l'on veut être cool et exécuter sur de Fuel Lourd utiliser l'ensemble des

List<string> stringList = new List<string> { "1234567890", "34343434", "4343434" };
Console.WriteLine( stringList.Aggregate( ( current, next ) => string.Format( "{0}, {1}", current, next ) ) );
//Outputs:   1234567890, 34343434, 4343434

OriginalL'auteur ΩmegaMan

Vous devez vous connecter pour publier un commentaire.