Gibt es eine LINQ-Entsprechung von string.Join(string, string[])

Question

Gibt es eine Möglichkeit, eine Sammlung von Objekten in ein einzelnes neues Objekt mit LINQ zu konvertieren?

Ich möchte dies in einem anderen LINQ to SQL-Ausdruck verwenden.

Answer 1

Warum benutzen Sie nicht die string.Join selbst?

string.Join("<br/>", collection.Select(e => e.TextProp).ToArray());

Answer 2

Sie können die Aggregatmethode verwenden...

var myResults = (from myString in MyStrings
                 select myString)
                .Aggregate(string.Empty, (results, nextString) 
                   => string.Format("{0}<br />{1}", results, nextString));

o

var myResults = MyStrings.Aggregate(string.Empty, (results, nextString) 
                   => string.Format("{0}<br />{1}", results, nextString));

Answer 3

Der normale Weg wäre die Verwendung eines der Aggregationsoperatoren ( Aggregate , Sum , Average usw.), aber es kommt ganz auf den Typ an und darauf, was Sie tun wollen. Für welchen Typ interessieren Sie sich?

EDIT: Okay, Sie wollen also Zeichenketten verketten... Ich will nicht penser gibt es etwas, das das in LINQ to SQL selbst tun wird. Optionen:

• Schreiben Sie eine gespeicherte Prozedur oder TVF, um dies in SQL zu tun
• Abrufen der einzelnen Strings in LINQ to SQL und Verkettung auf der Client-Seite

Answer 4

Die meisten der hier vorgestellten Lösungen sind ziemlich ineffizient, wenn Sie eine große Anzahl von Werten miteinander verknüpfen möchten. Außerdem sind sie nicht sonderlich lesbar. Wenn Sie diese Art von Aufgaben häufig erledigen müssen, lohnt es sich, eine eigene Erweiterungsmethode dafür zu entwickeln. Die unten stehende Implementierung ermöglicht es Ihnen, das Äquivalent von string.Join(", ", arrayOfStrings) wobei das ArrayOfStrings ein IEnumerable<T> und Trennzeichen kann jedes beliebige Objekt sein. Damit können Sie so etwas wie dies tun:

var names = new [] { "Fred", "Barney", "Wilma", "Betty" };
var list = names
    .Where(n => n.Contains("e"))
    .Join(", ");

Zwei Dinge, die mir daran gefallen, sind:

1. In einem LINQ-Kontext ist es sehr gut lesbar.

2. Es ist ziemlich effizient, weil es StringBuilder verwendet und vermeidet die Auswertung der Aufzählung zweimal, die in einer Datenbank-Szenario (L2S, L2E oder L2Nh) wichtig ist.

   public static string Join<TItem,TSep>( this IEnumerable<TItem> enuml, TSep separator) { if (null == enuml) return string.Empty;

   var sb = new StringBuilder(); 
   
   using (var enumr = enuml.GetEnumerator()) 
   { 
       if (null != enumr && enumr.MoveNext()) 
       { 
           sb.Append(enumr.Current); 
           while (enumr.MoveNext()) 
           { 
               sb.Append(separator).Append(enumr.Current); 
           } 
       } 
   } 
   
   return sb.ToString(); 

   }