Effizienteste Weg von verbinden von strings

Brauche ich zum verketten einer Menge von Zeichenketten insgesamt und setzen Sie ein Komma zwischen jedem von Ihnen.
Ich habe eine Liste von strings

"123123123213"
"1232113213213"
"123213123"

und ich will mich

"123123123213,1232113213213,123213123"

Ich Frage mich, was ist der beste Weg, das zu erreichen.

Könnte ich das in etwa so machen:

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

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

Oder vielleicht:

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

string outcome = builder.ToString();

Welcher Weg ist besser? Kennen Sie bessere Möglichkeiten zum verketten von strings?

Verwandte oder vielleicht dupliziert: stackoverflow.com/q/3102806/340760
Warum nicht, testen Sie die Leistung selbst?
Sie nicht angeben, welche Mittel am besten. Ich habe die Leistung - tag zu Ihrer Frage.

InformationsquelleAutor image | 2011-05-01

c#performance string

Als @Ekkehard sagte, verwenden Sie die string.Beitreten.

Jedoch, Sie brauchen nicht die ToArray() weil string.Join hat eine überlastung für IEnumerable<string>.

List<string> stringList = new List<string> 
    { "1234567890", "34343434", "4343434" }; 

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

BEARBEITEN

Als @Kobi gesagt, dies funktioniert nur, C# 4.0. Bei 3.5 würde ich das tun.

var s = new StringBuilder(stringList.Count * 8);
foreach (var item in stringList)
{
   s.Append(item);
   s.Append(',');
}
s.Length -= 1;
string outcome = stringList.ToList();

Beachten Sie, dass diese neu ist .Net 4, 3.5 muss noch ein array.

InformationsquelleAutor Richard Schneider

5

Sollten Sie verwenden string.Join() weil:

a) es ist sehr viel besser lesbar, wartbar und einfach auf die Augen.

b) er verwendet ein StringBuilder intern bereits, so dass es sehr effizient ist ( Sie kann bestätigen, sich mit dem Reflektor).

Edit:

string.Join() verwendet eine StringBuilder für den Allgemeinen Fall eines IEnumerable<T> Eingang. Wenn Sie bereits über ein array auf der anderen Seite verwendet er eine Art voodoo-Zauber (einschließlich FastAllocateString() und UnSafeCharBuffer) noch schneller.
- FYI, string.Join(string, string[]) nicht verwenden StringBuilder, aber UnSafeCharBuffer.
- Ja nur war in den Prozess der Bearbeitung, die in nach dieser Beobachtung, wie gut es ist vodoo magic in der Tat 😉
InformationsquelleAutor BrokenGlass
1

Join, weil es doesn ' T fügen Sie einen trailing ",".

InformationsquelleAutor Ekkehard.Horner
1

Gibt es einen benchmark auf auf dieser Seite, die scheint zu zeigen, dass string.Join besser abschneidet als der StringBuilder auf einem kleinen array in eine Menge von Iterationen. Sie sollte wohl benchmark für größere arrays auch. Als ich dieses posting sehe ich, dass BrokenGlass antwortete, dass StringBuilder wird intern verwendet, in string.Join so können Sie erwarten, dass es schneller sein, denke ich.

InformationsquelleAutor Jan
1

Deine zweite Lösung fügt eine zusätzliche , am Ende. Werfen Sie einen Blick auf Eric Lippert ' s blog Eintrag

Ich würde empfehlen, die Befestigung der zweiten Lösung. Ein StringBuilder-Objekt wäre auf jeden Fall schneller, als Sie vermeiden coping-die Inhalte der Liste in einem neuen array.
```
StringBuilder builder = new StringBuilder();
string separator = "";
stringList.ForEach(
    val =>
    {
        builder.Append(separator).Append(val);
        separator = ",";
    });
string outcome = builder.ToString();
```
InformationsquelleAutor Fede
0

StringBuilder ist eine sehr effiziente Art und Weise und zu empfehlen wäre hier.
- Außer string.Join() noch effektiver (zumindest in dem Fall, geben, wenn Sie es string[] sein, sonst ist verwendet StringBuilder selbst).
- svick Sie haben eine -1 bis jemand sagte, dass etwas cleverer als Sie. Und wie der Fragesteller braucht es für eine Liste von Zeichenfolgen, die nicht für ein array.
- wie ist mit StringBuilder cleverer als die mit string.Join()? Die letztere ist viel übersichtlicher, weniger fehleranfällig (Sie müssen nicht Ihren eigenen code schreiben) und möglicherweise schneller.
- Gosh, es ist nur eine alternative.
- Die Verwendung von string.beitreten, müssen Sie nehmen Sie die Liste und machen Sie zuerst ein array. Das mag nicht der effizienteste Weg sein, vor allem, wenn Sie haben eine Menge von kleinen strings.
InformationsquelleAutor Kevin Hsu

Gemäß dem folgenden test, den ich gemacht habe, Join ist 3x schneller auf große arrays:

Den Text.txt - Datei enthält den Wert "aaaaaaaaaaaaaaaaaaa" auf 38400 Linien:

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;   

    }
  }
}

Ausgabe:

00:00:00.0098754
00:00:00.0032922

InformationsquelleAutor Shimmy

0

String.Beitreten ist das am schnellsten, wenn Sie haben eine Feste Anzahl von strings zu verbinden. Der tiefere Grund ist, dass String.Verknüpfung wird-Schleife über das array und ordnet die final string Puffer mit der richtigen Größe, weil es im ersten Durchgang fügen Sie die Zeichenfolge der Länge aller strings zusammen. Sie können ähnliche Ergebnisse erhalten, wenn Sie spielen, um mit StringBuilder und seine Kapazität. Die goldene Regel ist, spare-Speicher Zuweisungen an den Kosten der Schleife über das array zwei mal. Welcher Ansatz schneller ist, hängt davon ab, wie viele Elemente, die Sie in Ihrer Liste haben und wie groß die resultint string erhalten.

Yours,
Alois Kraus

InformationsquelleAutor Alois Kraus

Test-code:

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

}

Ergebnis 1. String.Join - 2. StringBuilder + SubString. ####ms (ticks)

Effizienteste Weg von verbinden von strings

In diesem Fall String.Join ist schneller, aber wenn Sie sind ok mit einem nachgestellten , dann

Effizienteste Weg von verbinden von strings

StringBuilder ist etwas schneller (mit einem nachgestellten ,).

InformationsquelleAutor BrunoLM

Dieser ad-hoc-Implementierung habe ich versucht mit dem StrignBuilder ist schneller als String.Join.
Mehr als die Zeichenkette.Join ist ein Speicherfresser.
Ich habe versucht, mit 20000000 strings und String.Join gibt immer OutOfMemory, wenn meine Anwendung beendet.
Auf Ihrem Rechner kann Es auch auf weniger Saiten, wenn Sie weniger als 8 GB Arbeitsspeicher.
Kommentar einer der Implementierungen zu testen.
Dies gilt, es sei denn, Sie verwenden einen festen string [] - array. String.Beitreten ist gut.

   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

InformationsquelleAutor Marino Šimić

Wenn man will cool sein und laufen auf Schweröl Verwendung Aggregierter

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

InformationsquelleAutor ΩmegaMan

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.