Stringerweiterungsmethode eine Sammlung in C#

Question

In C# zum Anhang, ich versuche, eine Erweiterungsmethode für Stringbuilder zu bauen genannt AppendCollection(), die ich das machen lassen würde:

var sb1 = new StringBuilder(); 
var sb2 = new StringBuilder(); 
var people = new List<Person>() { ...init people here... }; 
var orders = new List<Orders>() { ...init orders here... }; 

sb1.AppendCollection(people, p => p.ToString()); 
sb2.AppendCollection(orders, o => o.ToString()); 

string stringPeople = sb1.ToString(); 
string stringOrders = sb2.ToString(); 

stringPeople mit einem enden würde Linie für jede Person in der Liste. Jede Zeile wäre das Ergebnis von p.ToString(). Gleiches gilt für StringOrders. Ich bin mir nicht ganz sicher, wie ich den Code schreiben soll, damit die Lambdas mit Generika funktionieren.

Answer 1

Verwenden Sie den Func<T,string> Delegierten.

public static void AppendCollection<T>(this StringBuilder sb, 
             IEnumerable<T> collection, Func<T, string> method) { 
    foreach(T x in collection) 
     sb.AppendLine(method(x)); 
} 

Answer 2

Was soll diese Methode zurückgeben? Ich kann eine Zeichenfolge sehen, aber warum, wenn Sie an einen StringBuilder anhängen?

Was Sie versuchen, ist ziemlich einfach, aber Sie müssen genau erklären, was Sie wollen.

Update:

Hier ist mein nehmen. Die Verwendung einer Erweiterungsmethode ist dumm und sinnlos, wenn Sie einfach einen neuen StringBuilder übergeben und eine Zeichenfolge zurückgeben.

Update 2:

Nun, da ich sehe, dass die Nutzung, was Sie tun, schlechte Praxis. Was Sie sollten im Idealfall tun ist so etwas wie:

public static string Print<T>(this IEnumerable<T> col, Func<T,string> printer) 
{ 
    var sb = new StringBuilder(); 
    foreach (T t in col) 
    { 
    sb.AppendLine(printer(t)); 
    } 
    return sb.ToString(); 
} 

string[] col = { "Foo" , "Bar" }; 
string lines = col.Print(s => s); 

Update 3:

Nach mehr Klarstellung:

public static void AppendCollection<T>(this StringBuilder sb, 
    List<T> col, Func<T,string> printer) 
{ 
    col.ForEach(o => sb.AppendLine(printer(o))); 
} 

(was dasselbe ist wie bruno conde sagte)

Und jetzt brauchst du es nicht mehr :)

Answer 3

Ich bin nicht sicher, was Sie brauchen, dass hart arbeiten:

public static void AppendCollection(this StringBuilder builder, 
             ICollection collection) 
{ 
    foreach (var item in collection) 
    { 
     builder.AppendLine(Convert.ToString(item)); 
    } 
} 

Eingesetzt als

List<Person> people = ... 

StringBuilder builder = new StringBuilder(); 
builder.AppendCollection(people); 
var s = builder.ToString(); 

Natürlich Person muss ToString() zu überschreiben die korrekte Ausgabe zu erzeugen für ein Person-Objekt.

Answer 4

Etwas wie:

public static void AppendCollection<TItem>(this StringBuilder builder, IEnumerable<TItem> items, Func<TItem, string> valueSelector) 
    { 
     foreach(TItem item in items) 
     { 
      builder.Append(valueSelector(item)); 
     } 
    } 

ich in einem nützlichen Standard hinzufügen würde Einzelheiten enthalten das Lambda in 90% der Fälle zu retten ...

public static void AppendCollection<TItem>(this StringBuilder builder, IEnumerable<TItem> items) 
    { 
     AppendCollection(builder, items, x=>x.ToString()); 
    } 

Answer 5

static class SBExtention 
{ 
    static string AppendCollection<T>(this StringBuilder sb, 
            IEnumerable<T> coll, 
            Func<T,string> action) 
    { 
     foreach(T t in coll) 
     { 
      sb.Append(action(t)); 
      sb.Append("\n"); 
     } 
     return sb.ToString(); 

    } 
} 

Aber ich denke, Ihnen‘ Es wäre besser, wenn Sie den StringBuilder zurückgeben. Auf diese Weise konnte man die Kette es:

static StringBuilder AppendCollection<T>(this StringBuilder sb, 
            IEnumerable<T> coll, 
            Func<T,string> action) 
    { 
     // same 
     return sb; 

    } 

String peopleAndOrders = sb.AppendCollection (Menschen, p => p.ToString()) .AppendCollection (Befehle, o => o.ToString()). ToString();

Und ich stimme mit Jennifer über Standardfall:

public static StringBuilder AppendCollection<TItem>(
        this StringBuilder builder, 
        IEnumerable<TItem> items) 
    { 
     return AppendCollection(builder, items, x=>x.ToString()); 
    } 

String peopleAndOrders = sb.AppendCollection (Personen) .AppendCollection (Aufträge) .ToString();

Answer 6

public static void AppendCollection<T>(this StringBuilder builder, IEnumerable<T> list, Func<T,string> func) 
     { 
      foreach (var item in list) 
      { 
       builder.AppendLine(func(item)); 
      } 
     } 

würde ich nicht einen String zurückgeben, würde ich hängen Sie ihn nur auf den ursprünglichen String, die übergeben wurde

Answer 7

Meine Version.

public static string AppendCollection<T>(this StringBuilder sb, IEnumerable<T> enumerable, Func<T, string> method) 
    { 
     List<T> l = new List<T>(enumerable); 
     l.ForEach(item => sb.AppendLine(method(item))); 
     return sb.ToString(); 
    } 

aber Sie sollten eine nicht zurück String in diesem Fall. Ich würde es vorziehen, die folgenden:

public static void AppendCollection<T>(this StringBuilder sb, IEnumerable<T> enumerable, Func<T, string> method) 
    { 
     List<T> l = new List<T>(enumerable); 
     l.ForEach(item => sb.AppendLine(method(item))); 
    } 

wie verwendet werden:

 sb.AppendCollection(people, p => p.ToString()); 
     sb.AppendCollection(orders, o => o.ToString()); 
     Console.WriteLine(sb.ToString());