Iterieren über IEnumerable, spezielles Gehäuse letztes Element

Question

ich ein String Aufbau basiert auf einer IEnumerable, und so etwas wie dies zu tun:

public string BuildString() 
{ 
    var enumerable = GetEnumerableFromSomewhere(); // actually an in parameter, 
                // but this way you don't have to care 
                // about the type :) 

    var interestingParts = enumerable.Select(v => v.TheInterestingStuff).ToArray(); 

    stringBuilder.Append("This is it: "); 

    foreach(var part in interestingParts) 
    { 
     stringBuilder.AppendPart(part); 

     if (part != interestingParts.Last()) 
     { 
      stringBuilder.Append(", "); 
     } 
    } 
} 

private static void AppendPart(this StringBuilder stringBuilder, InterestingPart part) 
{ 
    stringBuilder.Append("["); 
    stringBuilder.Append(part.Something"); 
    stringBuilder.Append("]"); 

    if (someCondition(part)) 
    { 
     // this is in reality done in another extension method, 
     // similar to the else clause 
     stringBuilder.Append(" = @"); 
     stringBuilder.Append(part.SomethingElse"); 
    } 
    else 
    { 
     // this is also an extension method, similar to this one 
     // it casts the part to an IEnumerable, and iterates over 
     // it in much the same way as the outer method. 
     stringBuilder.AppendInFilter(part); 
    } 
} 

ich mit diesem Idiom nicht ganz zufrieden bin, aber ich bin zu kämpfen etwas prägnanter formulieren.

Dies ist natürlich ein Teil eines größeren String Gebäudebetrieb (wo es mehrere Blöcke ähnlich wie diese, sowie andere Sachen dazwischen) - sonst würde ich wahrscheinlich die StringBuilder fallen und string.Join(", ", ...) direkt verwenden.

Meine engsten Versuch, die oben zu vereinfachen, obwohl, wie dies Konstrukte für jede Iterator:

stringBuilder.Append(string.Join(", ", propertyNames.Select(prop => "[" + prop + "]"))); 

aber hier bin ich noch Saiten mit + verketten, die es der StringBuilder nicht tut das Gefühl, macht wirklich viel beitragen.

Wie kann ich diesen Code vereinfachen und gleichzeitig effizient halten?

Answer 1

Sie können diese ersetzen:

string.Join(", ", propertyNames.Select(prop => "[" + prop + "]")) 

Mit C# 6 String-Interpolation:

string.Join(", ", propertyNames.Select(prop => $"[{prop}]")) 

In beiden Fällen ist der Unterschied semantische nur und es ist nicht wirklich wichtig. String Verkettung wie in Ihrem Fall in der Auswahl ist kein Problem. Der Compiler erstellt immer noch nur eine neue Zeichenfolge (und nicht 4, eine für jedes Segment und eine vierte für die gemeinsame Zeichenfolge).

es Putting alles zusammen:

var result = string.Join(", ", enumerable.Select(v => $"[{v.TheInterestingStuff}]")); 

---

Weil Körper foreach komplexer ist, dass Sie in einem String-Interpolation Rahmen passen können nur die letzten N Zeichen der Zeichenfolge entfernen, sobald berechnet, wie KooKiz empfohlen.

string separator = ", "; 
foreach(var part in interestingParts) 
{ 
    stringBuilder.Append("["); 
    stringBuilder.Append(part); 
    stringBuilder.Append("]"); 

    if (someCondition(part)) 
    { 
     // Append more stuff 
    } 
    else 
    { 
     // Append other thingd 
    } 
    stringBuilder.Append(separator); 
} 
stringBuilder.Length = stringBuilder.Lenth - separator; 

Auf jeden Fall denke ich, für eine bessere Kapselung, dass der Inhalt des Anwendungsbereichs der Schleife in einer separaten Funktion sitzen sollte, die eine part und die separator erhalten und wird die Ausgabe-String zurück. Es kann auch eine Erweiterungsmethode für StringBuilder sein, wie durch user734028

Answer 2

Aggregate Lösung vorgeschlagen:

var answer = interestingParts.Select(v => "[" + v + "]").Aggregate((a, b) => a + ", " + b); 

Serialisierung Lösung:

var temp = JsonConvert.SerializeObject(interestingParts.Select(x => new[] { x })); 
var answer = temp.Substring(1, temp.Length - 2).Replace(",", ", "); 

Answer 3

Verwenden Aggregate Erweiterungsmethode mit StringBuilder.
Wird mehr effizient dann Strings verketten, wenn Sie Ihre Sammlung

 var builder = new StringBuilder(); 
     list.Aggregate(builder, (sb, person) => 
     { 
      sb.Append(","); 
      sb.Append("["); 
      sb.Append(person.Name); 
      sb.Append("]"); 
      return sb; 
     }); 
     builder.Remove(0, 1); // Remove first comma 

Als reine foreach immer effizienter groß sind, ist dann LINQ dann nur Logik ändern delimeter Komma

var builder = new StringBuilder(); 
foreach(var part in enumerable.Select(v => v.TheInterestingStuff)) 
{ 
    builder.Append(", "); 
    builder.Append("["); 
    builder.Append(part); 
    builder.Append("]"); 
} 

builder.Remove(0, 2); //Remove first comma and space 

Answer 4

der Code:

public string BuildString() 
{ 
    var enumerable = GetEnumerableFromSomewhere(); 
    var interestingParts = enumerable.Select(v => v.TheInterestingStuff).ToArray(); 

    stringBuilder.Append("This is it: "); 

    foreach(var part in interestingParts) 
    { 
     stringBuilder.AppendPart(part) 

    } 
    if (stringBuilder.Length>0) 
     stringBuilder.Length--; 
} 

private static void AppendPart(this StringBuilder stringBuilder, InterestingPart part) 
{ 
    if (someCondition(part)) 
    { 
     stringBuilder.Append(string.Format("[{0}] = @{0}", part.Something));   

    } 
    else 
    { 
     stringBuilder.Append(string.Format("[{0}]", part.Something)); 
     stringBuilder.AppendInFilter(part); // 
    } 
} 

viel besser jetzt IMO.

Jetzt ein wenig Diskussion darüber, es sehr schnell zu machen. Wir können Parallel.For verwenden. Aber du würdest denken (wenn du denkst), dass die Anhänge alle mit einer einzigen gemeinsam nutzbaren Ressource, dem StringBuilder, passieren, und dann musst du sie anhängen, um sie anzuhängen, nicht so effizient! Nun, wenn wir sagen können, dass jede Iteration der for-Schleife in der äußeren Funktion ein einzelnes String-Artefakt erzeugt, dann können wir ein einzelnes Array von Strings haben, das der Anzahl interessanter parts vor dem Parallelen für Starts und jedem Index des Parallel for würde seinen String in seinem jeweiligen Index speichern.

Etwas wie:

string[] iteration_buckets = new string[interestingParts.Length]; 
System.Threading.Tasks.Parallel.For(0, interestingParts.Length, 
    (index) => 
    { 
     iteration_buckets[index] = AppendPart(interestingParts[index]); 
    }); 

Ihre Funktion AppendPart müssen eingestellt werden, es sich um eine nicht-Erweiterung machen nur einen String zu nehmen und einen String zurück. Nachdem die Schleife beendet ist, können Sie eine Zeichenkette machen. Verbinden Sie sich, um eine Zeichenkette zu erhalten, was Sie möglicherweise auch mit stringBuilder.ToString() machen.