Verwenden von LINQ zum Verketten von Zeichenfolgen

Was ist der effizienteste Weg, um die alte Schule zu schreiben:

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

... in LINQ?

Diese Antwort zeigt die Verwendung von LINQ ( Aggregate) wie in der Frage angefordert und ist nicht für den täglichen Gebrauch vorgesehen. Da dies kein verwendet StringBuilder, wird es für sehr lange Sequenzen eine schreckliche Leistung haben. Für den regulären Code verwenden Sie String.Joinwie in der anderen Antwort gezeigt

Verwenden Sie aggregierte Abfragen wie folgt:

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

Dies gibt aus:

, eins zwei drei

Ein Aggregat ist eine Funktion, die eine Sammlung von Werten verwendet und einen Skalarwert zurückgibt. Beispiele aus T-SQL sind min, max und sum. Sowohl VB als auch C # unterstützen Aggregate. Sowohl VB als auch C # unterstützen Aggregate als Erweiterungsmethoden. Mit der Punktnotation ruft man einfach eine Methode auf einem IEnumerable auf Objekt auf.

Denken Sie daran, dass aggregierte Abfragen sofort ausgeführt werden.

Weitere Informationen - MSDN: Aggregierte Abfragen

Wenn Sie wirklich Aggregateeine Variante verwenden möchten, verwenden Sie StringBuilderdie im CodeMonkeyKing- Vorschlag vorgeschlagene Variante, die ungefähr dem gleichen Code wie normal entspricht, String.Joineinschließlich einer guten Leistung für eine große Anzahl von Objekten:

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

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

In .Net 4, gibt es eine neue Überlast für string.Joindas akzeptiert IEnumerable<string>. Der Code würde dann so aussehen:

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

Warum Linq verwenden?

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

Das funktioniert perfekt und akzeptiert, IEnumerable<string>soweit ich mich erinnere. Hier brauchen Sie Aggregatenichts, was viel langsamer ist.

Haben Sie sich die Aggregate-Erweiterungsmethode angesehen?

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

Echtes Beispiel aus meinem Code:

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

Eine Abfrage ist ein Objekt mit einer Name-Eigenschaft, bei der es sich um eine Zeichenfolge handelt. Ich möchte, dass die Namen aller Abfragen in der ausgewählten Liste durch Kommas getrennt werden.

Hier ist der kombinierte Join / Linq-Ansatz, für den ich mich entschieden habe, nachdem ich mir die anderen Antworten und die in einer ähnlichen Frage behandelten Probleme angesehen habe (nämlich, dass Aggregate und Concatenate mit 0 Elementen fehlschlagen).

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

oder (wenn ses sich nicht um eine Zeichenfolge handelt)

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

• Einfach
• leicht zu lesen und zu verstehen
• funktioniert für generische Elemente
• ermöglicht die Verwendung von Objekten oder Objekteigenschaften
• behandelt den Fall von Elementen der Länge 0
• könnte mit zusätzlicher Linq-Filterung verwendet werden
• funktioniert gut (zumindest nach meiner Erfahrung)
• erfordert keine (manuelle) Erstellung eines zusätzlichen Objekts (z. B. StringBuilder) zur Implementierung

Und natürlich kümmert sich Join um das lästige letzte Komma, das sich manchmal in andere Ansätze einschleicht ( for, foreach), weshalb ich überhaupt nach einer Linq-Lösung gesucht habe.

Sie können verwenden StringBuilderin 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());

(Das Selectist nur da, um zu zeigen, dass Sie mehr LINQ-Sachen machen können.)

Schnelle Leistungsdaten für den Fall StringBuilder vs Select & Aggregate über 3000 Elemente:

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

Ich benutze immer die Erweiterungsmethode:

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

Mit " supercooler LINQ-Methode " könnten Sie darüber sprechen, wie LINQ die funktionale Programmierung durch die Verwendung von Erweiterungsmethoden viel angenehmer macht. Ich meine, der syntaktische Zucker, mit dem Funktionen visuell linear (nacheinander) verkettet werden können, anstatt (ineinander) zu verschachteln. Zum Beispiel:

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

kann so geschrieben werden:

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

Sie können sehen, wie das zweite Beispiel leichter zu lesen ist. Sie können auch sehen, wie mehr Funktionen mit weniger Einrückungsproblemen oder dem Lispy hinzugefügt werden können Abschlussparens am Ende des Ausdrucks erscheinen.

Viele der anderen Antworten besagen, dass dies der String.Joinrichtige Weg ist, da es am schnellsten oder am einfachsten zu lesen ist. Wenn Sie jedoch meine Interpretation von " supercooler LINQ-Methode " verwenden, lautet die Antwort, sie zu verwenden String.Join, sie jedoch in eine Erweiterungsmethode im LINQ-Stil einzuschließen, mit der Sie Ihre Funktionen auf visuell ansprechende Weise verketten können. Wenn Sie also schreiben möchten, müssen sa.Concatenate(", ")Sie nur Folgendes erstellen:

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

Dies liefert Code, der genauso performant ist wie der direkte Aufruf (zumindest in Bezug auf die Komplexität des Algorithmus) und in einigen Fällen den Code (je nach Kontext) besser lesbar macht, insbesondere wenn anderer Code im Block den verketteten Funktionsstil verwendet .

Bei dieser vorherigen Frage gibt es verschiedene alternative Antworten - die zwar auf ein ganzzahliges Array als Quelle abzielten, aber allgemeine Antworten erhielten.

Hier wird reines LINQ als einzelner Ausdruck verwendet:

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

Und es ist verdammt schnell!

Ich werde ein wenig schummeln und eine neue Antwort darauf herauswerfen, die das Beste von allem hier zusammenzufassen scheint, anstatt es in einen Kommentar zu stecken.

Sie können dies also in einer Zeile festhalten:

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

Bearbeiten: Sie möchten entweder zuerst nach einer leeren Aufzählung suchen oder eine hinzufügen.Replace("\a",string.Empty); am Ende des Ausdrucks . Ich schätze, ich habe versucht, ein bisschen zu schlau zu werden.

Die Antwort von @ a.friend ist möglicherweise etwas performanter. Ich bin mir nicht sicher, was Replace unter der Haube im Vergleich zu Remove tut. Die einzige andere Einschränkung, wenn Sie aus irgendeinem Grund Zeichenfolgen zusammenfassen wollten, die mit \ a endeten, würden Sie Ihre Trennzeichen verlieren ... Ich finde das unwahrscheinlich. In diesem Fall haben Sie andere ausgefallene Charaktere zur Auswahl.

Sie können LINQ string.join()sehr effektiv kombinieren . Hier entferne ich ein Element aus einer Zeichenfolge. Es gibt auch bessere Möglichkeiten, dies zu tun, aber hier ist es:

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

Viele Möglichkeiten hier. Sie können LINQ und einen StringBuilder verwenden, damit Sie die Leistung auch so erhalten:

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

Ich habe Folgendes schnell und schmutzig gemacht, als ich eine IIS-Protokolldatei mit linq analysiert habe. Es hat bei 1 Million Zeilen ziemlich gut funktioniert (15 Sekunden), obwohl beim Versuch, 2 Millionen Zeilen zu speichern, ein Speicherfehler aufgetreten ist.

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

    }

Der wahre Grund, warum ich linq verwendet habe, war für ein Distinct (), das ich zuvor brauchte:

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

Ich habe vor einiger Zeit darüber gebloggt, was ich getan habe, um genau das zu sein, wonach Sie suchen:

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

In diesem Blogbeitrag wird beschrieben, wie Sie Erweiterungsmethoden implementieren, die unter IEnumerable funktionieren und den Namen "Verketten" tragen. Auf diese Weise können Sie Folgendes schreiben:

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

Oder ausgefeiltere Dinge wie:

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