StringBuilder para anexar una colección en C#

Question

En C#, yo estoy tratando de construir un método de extensión de StringBuilder llama AppendCollection() que dejarme hacer esto:

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 terminaría con una línea para cada persona en la lista. Cada línea sería el resultado de p.ToString(). Del mismo modo para stringOrders. No estoy seguro de cómo escribir el código para que las lambdas funcionen con genéricos.

Answer 1

Utilice el delegado Func<T,string>.

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

¿Qué se supone que debe devolver este método? Puedo ver una cadena, pero ¿por qué, si agregas un StringBuilder?

Lo que intenta hacer es bastante fácil, pero necesita explicar exactamente lo que desea.

Actualización:

Esta es mi opinión. Usar un método de extensión para esto es estúpido e inútil si solo vas a pasar un nuevo StringBuilder y devolver una cadena.

Actualización 2:

Ahora que veo que el uso, lo que está haciendo es una mala práctica. Lo que idealmente debería estar haciendo es algo así como:

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

Actualización 3:

Después de más aclaraciones:

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

(que es el mismo que dicho Bruno Conde)

Y ahora ya no lo necesitas :)

Answer 3

No estoy seguro de que necesita trabajar tan duro:

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

Utilizado como

List<Person> people = ... 

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

Por supuesto, la persona tiene que anular ToString() para producir la salida correcta para un objeto Persona.

Answer 4

Algo así como:

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

Yo añadiría en una forma predeterminada útil para ahorrar especificando la lambda en el 90% de los casos ...

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

    } 
} 

Sin embargo, creo que' Será mejor que lo devuelva StringBuilder. De esa manera usted podría encadenarse que:

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

    } 

peopleAndOrders cadena = sb.AppendCollection (gente, p => p.ToString()) .AppendCollection (orders, o => o.ToString()). ToString();

Y estoy de acuerdo con Jennifer sobre el caso por defecto:

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

peopleAndOrders cadena = sb.AppendCollection (personas) .AppendCollection (órdenes) .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)); 
      } 
     } 

no volvería una cadena, me acaba de añadirlo al StringBuilder original que fue aprobada en

Answer 7

Mi versión:.

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

pero no debería devolver una cadena en este caso. Yo preferiría el siguiente:

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

para ser utilizado como:

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