Je veux transformer un tableau ou une liste d'entiers en une chaîne délimitée par des virgules, comme ceci:

string myFunction(List<int> a) {
    return string.Join(",", a);
}

Mais string.Join ne prend List<string>que le deuxième paramètre. Quelle est la meilleure façon de procéder?

Le meilleur moyen est de passer à .NET 4.0 là où il y a une surcharge qui fait ce que vous voulez:

• String.Join<T>(String, IEnumerable<T>)

Si vous ne pouvez pas mettre à niveau, vous pouvez obtenir le même effet en utilisant Select et ToArray.

    return string.Join(",", a.Select(x => x.ToString()).ToArray());

Une implémentation évolutive et sûre d'une jointure de chaîne énumérable générique pour .NET 3.5. L'utilisation des itérateurs est telle que la valeur de la chaîne de jointure ne soit pas bloquée à la fin de la chaîne. Cela fonctionne correctement avec 0, 1 et plus d'éléments:

public static class StringExtensions
{
    public static string Join<T>(this string joinWith, IEnumerable<T> list)
    {
        if (list == null)
            throw new ArgumentNullException("list");
        if (joinWith == null)
            throw new ArgumentNullException("joinWith");

        var stringBuilder = new StringBuilder();
        var enumerator = list.GetEnumerator();

        if (!enumerator.MoveNext())
            return string.Empty;

        while (true)
        {
            stringBuilder.Append(enumerator.Current);
            if (!enumerator.MoveNext())
                break;

            stringBuilder.Append(joinWith);
        }

        return stringBuilder.ToString();
    }
}

Usage:

var arrayOfInts = new[] { 1, 2, 3, 4 };
Console.WriteLine(",".Join(arrayOfInts));

var listOfInts = new List<int> { 1, 2, 3, 4 };
Console.WriteLine(",".Join(listOfInts));

Prendre plaisir!

.NET 2.0:

static string IntListToDelimitedString(List<int> intList, char Delimiter)
{
    StringBuilder builder = new StringBuilder();

    for (int i = 0; i < intList.Count; i++)
    {
        builder.Append(intList[i].ToString());

        if (i != intList.Count - 1)
            builder.Append(Delimiter);
    }

    return builder.ToString();
}

J'avais une méthode d'extension similaire que j'ai modifiée pour cela

public static class MyExtensions
{
    public static string Join(this List<int> a, string splitChar)
    {
        return string.Join(splitChar, a.Select(n => n.ToString()).ToArray());
    }
}

et vous l'utilisez comme ça

var test = new List<int>() { 1, 2, 3, 4, 5 };
string s = test.Join(",");

.NET 3.5

Cette réponse est faite pour vous si vous ne voulez pas encore vous aventurer dans les profondeurs de .NET 4.0.

String.Join () concatène tous les éléments d'un tableau de chaînes, en utilisant le séparateur spécifié entre chaque élément.

La syntaxe est

public static string Join(
    string separator,
    params string[] value
)

Plutôt que de passer votre liste d'entiers à la méthode Join, je suggère de créer d'abord un tableau de chaînes.

Voici ce que je propose:

static string myFunction(List<int> a) {
    int[] intArray = a.ToArray();
    string[] stringArray = new string[intArray.Length];

    for (int i = 0; i < intArray.Length; i++)
    {
        stringArray[i] = intArray[i].ToString();
    }

    return string.Join(",", stringArray);
}

Utilisation de .NET 4.0

public partial class _Default : System.Web.UI.Page
{
    protected void Page_Load(object sender, EventArgs e)
    {
        string s = myFunction(PopulateTestList());
        this.TextBox1.Text = s;
    }

    protected List<int> PopulateTestList()
    {
        List<int> thisList = new List<int>();
        thisList.Add(22);
        thisList.Add(33);
        thisList.Add(44);

        return thisList;
    }

    protected string myFunction(List<int> a)
    {
        return string.Join(",", a);
    }
}

Dans .NET, la classe de liste a une .ToArray()méthode. Quelque chose comme ça pourrait fonctionner:

string myFunction(List<int> a)
{
    return string.Join(",", a.ToArray());
}

Réf: méthodes List <T> (MSDN)