Créer une liste séparée par des virgules en C#
-
Utilisation de la méthode
String.Join()pour créer une liste séparée par des virgules enC# -
Utilisation de la méthode d’agrégation LINQ pour créer une liste séparée par des virgules en
C# -
Utilisation de la méthode StringBuilder pour créer une liste séparée par des virgules en
C#
Ce didacticiel montrera comment créer une liste séparée par des virgules à partir de conteneurs tels qu’un IList<string ou un IEnumerable<string> en utilisant string.Join(), LINQ Aggregate, ou StringBuilder.
Utilisation de la méthode String.Join() pour créer une liste séparée par des virgules en C#
Le moyen le plus simple de joindre les valeurs d’un conteneur serait le string.Join(). La fonction string.Join() prend toutes les valeurs d’une collection et les concatène avec n’importe quel séparateur défini. En utilisant cette méthode, vous pouvez non seulement créer des listes séparées par des virgules, mais également tout autre délimiteur.
string joined_str = string.Join(separator, source);
Le paramètre séparateur doit être une chaîne tandis que la source peut être une collection de n’importe quel type de données.
Exemple:
using System;
using System.Collections.Generic;
namespace StringJoin_Example {
class Program {
static void Main(string[] args) {
// Initialize the IList
IList<Int32> list_strings = new List<Int32> { 1, 2, 3 };
// Join the IList with a comma
string joined_list = string.Join(", ", list_strings);
// Print the results
Console.WriteLine("From List: " + joined_list);
// Initialize the IEnumerable
IEnumerable<string> enum_strings =
new List<string>() { "Enum Sample 1", "Enum Sample 2", "Enum Sample 3" };
// Join the IEnumerable with a semi colon
string joined_enum = string.Join("; ", enum_strings);
// Print the results
Console.WriteLine("From Enumerable: " + joined_enum);
Console.ReadLine();
}
}
}
Dans l’exemple ci-dessus, nous avons créé deux sources différentes : une liste d’entiers et une liste énumérable de chaînes. Nous les avons ensuite joints en utilisant la même méthode string.Join() avec deux séparateurs différents, puis nous avons imprimé les chaînes résultantes sur la console.
Production:
From List : 1, 2, 3 From Enumerable : Enum Sample 1;
Enum Sample 2;
Enum Sample 3
Utilisation de la méthode d’agrégation LINQ pour créer une liste séparée par des virgules en C#
Une autre option pour joindre les valeurs d’une collection serait d’utiliser la méthode LINQ Aggregate. Bien que pratique à coder, cela est considéré comme inefficace, en particulier plus l’entrée est grande. Cette méthode générera également une erreur si le nombre d’entrées est inférieur à un, donc une gestion des erreurs plus importante peut être nécessaire pour s’assurer que cela fonctionne à chaque fois sans heurts.
string joined_str = input.Aggregate((x, y) => x + ", " + y);
Comme la première méthode, vous pouvez utiliser n’importe quelle entrée de chaîne comme séparateur, mais cette méthode s’attendra à ce que la valeur du résultat soit la même que son entrée. Par exemple, si la collection d’entrée était une liste d’entiers, cette fonction ne fonctionnerait pas.
Exemple:
using System;
using System.Collections.Generic;
using System.Linq;
namespace LinqAggregate_Example {
class Program {
static void Main(string[] args) {
// Initialize the IList
IList<string> list_strings =
new List<string> { "List Sample 1", "List Sample 2", "List Sample 3" };
// Join the IList with a comma using LINQ Aggregate
string joined_list = list_strings.Aggregate((x, y) => x + ", " + y);
// Print the results
Console.WriteLine("From List: " + joined_list);
// Initialize the IEnumerable
IEnumerable<string> enum_strings =
new List<string>() { "Enum Sample 1", "Enum Sample 2", "Enum Sample 3" };
// Join the IEnumerable with a semi colon using LINQ Aggregate
string joined_enum = enum_strings.Aggregate((x, y) => x + "; " + y);
// Print the results
Console.WriteLine("From Enumerable: " + joined_enum);
Console.ReadLine();
}
}
}
Dans l’exemple ci-dessus, nous avons joint les deux collections en utilisant la méthode LINQ Aggregate. Les variables x et y peuvent être remplacées par le nom de variable de votre choix. L’idée derrière cette méthode est qu’elle concatène la chaîne précédente à la chaîne suivante s’il y a encore des valeurs à joindre.
Production:
From List: List Sample 1, List Sample 2, List Sample 3
From Enumerable: Enum Sample 1; Enum Sample 2; Enum Sample 3
Utilisation de la méthode StringBuilder pour créer une liste séparée par des virgules en C#
La dernière option dont nous parlerons est la méthode StringBuilder. Par rapport aux deux autres méthodes, celle-ci nécessite un peu plus de code à écrire mais permet beaucoup plus de personnalisation. Dans la fonction, vous pouvez ajouter d’autres étapes pour modifier les valeurs si vous le souhaitez. Par exemple, si vous transmettez une liste de datetimes, vous pouvez combiner les valeurs tout en utilisant un format DateTime spécifié.
Exemple:
using System;
using System.Collections.Generic;
using System.Text;
namespace StringBuilder_Example {
class Program {
static void Main(string[] args) {
// Initialize the IList
IList<string> list_strings =
new List<string> { "List Sample 1", "List Sample 2", "List Sample 3" };
// Join the IList with a comma using the StringBuilder method
string joined_list = join_collection(", ", list_strings);
// Print the results
Console.WriteLine("From List: " + joined_list);
// Initialize the IEnumerable
IEnumerable<string> enum_strings =
new List<string>() { "Enum Sample 1", "Enum Sample 2", "Enum Sample 3" };
// Join the IEnumerable with a semi colon using the StringBuilder method
string joined_enum = join_collection("; ", enum_strings);
// Print the results
Console.WriteLine("From Enumerable: " + joined_enum);
Console.ReadLine();
}
static string join_collection<T>(string separator, IEnumerable<T> values) {
// Initialize StringBuilder
StringBuilder sb = new StringBuilder();
// Intialize the item counter
int ctr = 0;
foreach (T item in values) {
string sep = "";
if (ctr > 0) {
// If the first item from the value collection has already been added, use the specified
// separator This is to avoid printing the separator as the first value of the string
sep = separator;
}
// Append the separator and the value as a string
sb.Append(sep);
sb.Append(item.ToString());
ctr++;
}
// Return the built string
return sb.ToString();
}
}
}
Dans l’exemple ci-dessus, nous avons joint les collections à l’aide de notre fonction personnalisée join_collection, qui accepte un séparateur de chaîne et une collection énumérable. Les valeurs sont ensuite réunies à l’aide d’un StringBuilder et en ajoutant les valeurs de séparateur et de collection.
Production:
From List: List Sample 1, List Sample 2, List Sample 3
From Enumerable: Enum Sample 1; Enum Sample 2; Enum Sample 3