Un análogo de String.Join (cadena, cadena []) para IEnumerable <T>

Question

clase String contiene un método muy útil - String.Join(string, string[]).

Crea una cadena a partir de una matriz, separando cada elemento de la matriz con un símbolo dado. Pero, en general, ¡no agrega un separador después del último elemento! Lo uso para la codificación ASP.NET para separar con "<br />" o Environment.NewLine.

Por lo tanto, quiero agregar una fila vacía después de cada fila en asp:Table. ¿Qué método de puedo usar para la misma funcionalidad?

Answer 1

escribí un método de extensión:

public static IEnumerable<T> 
     Join<T>(this IEnumerable<T> src, Func<T> separatorFactory) 
    { 
     var srcArr = src.ToArray(); 
     for (int i = 0; i < srcArr.Length; i++) 
     { 
      yield return srcArr[i]; 
      if(i<srcArr.Length-1) 
      { 
       yield return separatorFactory(); 
      } 
     } 
    } 

Usted puede usarlo de la siguiente manera:

tableRowList.Join(()=>new TableRow()) 

Answer 2

No hay un método integrado para hacerlo, debe hacer las suyas.

Answer 3

Si no puedo encontrar un método que se adapte a mis necesidades, solo crearía el mío. Y los métodos de extensión son muy buenos de esa manera, ya que te permiten extender cosas así. No sé mucho acerca de ASP: mesa, pero aquí es un método de extensión al menos que se puede ajustar a cualquier cosa: p

public static class TableRowExtensions 
{ 
    public string JoinRows(this IEnumerable<TableRow> rows, string separator) 
    { 
     // do what you gotta do 
    } 
} 

Answer 4

Si va a hacer este tipo de cosas con frecuencia, entonces vale la pena construir su propio método de extensión para hacerlo. La implementación a continuación le permite hacer el equivalente a string.Join(", ", arrayOfStrings) donde arrayOfStrings puede ser IEnumerable<T>, y el separador puede ser cualquier objeto. Se le permite hacer algo como esto:

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

Dos cosas que me gusta de esto son:

1. Es muy fácil de leer en un contexto de LINQ.
2. Es bastante eficiente porque usa StringBuilder y evita evaluar la enumeración dos veces.

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

Answer 5

En .NET 3.5 se puede utilizar este método de extensión:

public static string Join<TItem>(this IEnumerable<TItem> enumerable, string separator) 
{ 
    return string.Join(separator, enumerable.Select(x => x.ToString()).ToArray()); 
} 

o en .NET 4

public static string Join<TItem>(this IEnumerable<TItem> enumerable, string separator) 
{ 
    return string.Join(separator, enumerable); 
} 

pero la pregunta quería un separador después de cada elemento incluyendo el último para el cual esto (versión 3.5) funcionaría: -

public static string AddDelimiterAfter<TItem>(this IEnumerable<TItem> enumerable, string delimiter) 
{ 
    return string.Join("", enumerable.Select(x => x.ToString() + separator).ToArray()); 
} 

También puede usar .Agregar para hacer esto sin un método de extensión.

Answer 6

El equivalente Linq de String.Join es Aggregate

Por ejemplo:

IEnumerable<string> strings; 
string joinedString = strings.Aggregate((total,next) => total + ", " + next); 

Si se les da un IE de TableRows, el código será similar.

Answer 7

Lo que estás buscando es una función de Intersperse. Para implementaciones de LINQ de dicha función, consulte this question.

---

Por cierto, otra posible analógica de String.Join es la función Intercalate, que es en realidad lo que estaba buscando:

public static IEnumerable<T> Intercalate<T>(this IEnumerable<IEnumerable<T>> source, 
              IEnumerable<T> separator) { 
    if (source == null) throw new ArgumentNullException("source"); 
    if (separator == null) throw new ArgumentNullException("separator"); 
    return source.Intersperse(separator) 
     .Aggregate(Enumerable.Empty<T>(), Enumerable.Concat); 
}