Concat toutes les chaînes à l'intérieur d'une liste <string> en utilisant LINQ

Question

Existe-t-il une expression LINQ facile pour concaténer tous mes éléments de collection List<string> en un seul string avec un caractère délimiteur?

Que faire si la collection est d'objets personnalisés au lieu de string? Imaginez que je dois concaténer sur object.Name.

Answer 1

En utilisant LINQ, cela devrait fonctionner;

string delimiter = ","; 
List<string> items = new List<string>() { "foo", "boo", "john", "doe" }; 
Console.WriteLine(items.Aggregate((i, j) => i + delimiter + j)); 

Description de la classe:

public class Foo 
{ 
    public string Boo { get; set; } 
} 

Utilisation:

class Program 
{ 
    static void Main(string[] args) 
    { 
     string delimiter = ","; 
     List<Foo> items = new List<Foo>() { new Foo { Boo = "ABC" }, new Foo { Boo = "DEF" }, 
      new Foo { Boo = "GHI" }, new Foo { Boo = "JKL" } }; 

     Console.WriteLine(items.Aggregate((i, j) => new Foo{Boo = (i.Boo + delimiter + j.Boo)}).Boo); 
     Console.ReadKey(); 

    } 
} 

Et voici mon meilleur :)

items.Select(i => i.Boo).Aggregate((i, j) => i + delimiter + j) 

Answer 2

Dans .NET 4.0 et versions ultérieures:

String.Join(delimiter, list); 

est suffisante. Pour les anciennes versions, vous devez:

String.Join(delimiter, list.ToArray()); 

Answer 3

Bonne question. J'ai utilisé

List<string> myStrings = new List<string>{ "ours", "mine", "yours"}; 
string joinedString = string.Join(", ", myStrings.ToArray()); 

Ce n'est pas LINQ, mais cela fonctionne.

Answer 4

List<string> strings = new List<string>() { "ABC", "DEF", "GHI" }; 
string s = strings.Aggregate((a, b) => a + ',' + b); 

Answer 5

Ceci est un tableau de chaînes:

string.Join(delimiter, array); 

Ceci est pour une liste < chaîne >:

string.Join(delimiter, list.ToArray()); 

Et ceci est une liste des objets personnalisés:

string.Join(delimiter, list.Select(i => i.Boo).ToArray()); 

Answer 6

using System.Linq; 

public class Person 
{ 
    string FirstName { get; set; } 
    string LastName { get; set; } 
} 

List<Person> persons = new List<Person>(); 

string listOfPersons = string.Join(",", persons.Select(p => p.FirstName)); 

Answer 7

Je pense que si vous définissez la logique une méthode d'extension le code sera beaucoup plus lisible:

public static class EnumerableExtensions { 
    public static string Join<T>(this IEnumerable<T> self, string separator) { 
    return String.Join(separator, self.Select(e => e.ToString()).ToArray()); 
    } 
} 

public class Person { 
    public string FirstName { get; set; } 
    public string LastName { get; set; } 
    public override string ToString() { 
    return string.Format("{0} {1}", FirstName, LastName); 
    } 
} 

// ... 

List<Person> people = new List<Person>(); 
// ... 
string fullNames = people.Join(", "); 
string lastNames = people.Select(p => p.LastName).Join(", ");