Un analogue de String.Join (string, string []) pour IEnumerable <T>

Question

La classe String contient une méthode très utile - String.Join(string, string[]).

Il crée une chaîne à partir d'un tableau, en séparant chaque élément de tableau par un symbole donné. Mais général - il n'ajoute pas de séparateur après le dernier élément! Je l'utilise pour le codage ASP.NET pour séparer avec "<br />" ou Environment.NewLine. Donc je veux ajouter une ligne vide après chaque ligne dans asp:Table. Quelle méthode de puis-je utiliser pour la même fonctionnalité?

Answer 1

j'ai écrit une méthode d'extension:

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

Vous pouvez l'utiliser comme suit:

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

Answer 2

Il n'y a pas de méthode intégrée pour cela, vous devriez rouler les vôtres.

Answer 3

Si je ne trouvais pas une méthode qui répond à mes besoins, je créerais simplement la mienne. Et les méthodes d'extension sont très sympas, puisqu'elles vous permettent d'étendre les choses comme ça. Je ne sais pas beaucoup sur asp: table, mais voici une méthode d'extension au moins que vous pouvez modifier à tout: p

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

Answer 4

Si vous allez faire ce genre de chose souvent, il vaut la peine de construire votre propre méthode d'extension pour le faire. L'implémentation ci-dessous vous permet de faire l'équivalent de string.Join(", ", arrayOfStrings) où arrayOfStrings peut être un IEnumerable<T>, et le séparateur peut être n'importe quel objet du tout. Il vous permet de faire quelque chose comme ceci:

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

Deux choses que j'aime ce sont:

1. Il est très lisible dans un contexte LINQ.
2. C'est assez efficace car il utilise StringBuilder et évite d'évaluer l'énumération deux fois.

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

Dans .NET 3.5, vous pouvez utiliser cette méthode d'extension:

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

ou .NET 4

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

mais la question voulait un séparateur après chaque élément, y compris la dernier pour lequel cette (version 3.5) fonctionnerait: -

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

Vous pouvez également utiliser .Aggregate pour ce faire sans méthode d'extension.

Answer 6

L'équivalent de Linq String.Join est Aggregate

Par exemple:

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

Si on leur donne un IE de tablerows, le code sera similaire.

Answer 7

Ce que vous cherchez est une Intersperse fonction. Pour les implémentations LINQ d'une telle fonction, voir this question.

---

Soit dit en passant, un autre analogue possible de String.Join est la fonction Intercalate, qui est en fait ce que je cherchais:

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