Voglio trasformare un array o un elenco di int in una stringa delimitata da virgole, come questa:

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

Ma string.Join accetta solo List<string>come secondo parametro. Qual è il modo migliore per farlo?

Il modo migliore è aggiornare a .NET 4.0 dove c'è un sovraccarico che fa quello che vuoi:

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

Se non puoi eseguire l'aggiornamento, puoi ottenere lo stesso effetto usando Select e ToArray.

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

Un scalabile e sicura implementazione di una stringa enumerabile generica unirsi per .NET 3.5. L'utilizzo degli iteratori è in modo che il valore della stringa di join non sia bloccato alla fine della stringa. Funziona correttamente con 0, 1 e più elementi:

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

Utilizzo:

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

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

Godere!

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

Avevo un metodo di estensione simile che ho modificato a questo

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

e lo usi in questo modo

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

.NET 3.5

Questa risposta è per te se non vuoi ancora avventurarti nelle profondità di .NET 4.0.

String.Join () concatena tutti gli elementi di un array di stringhe, utilizzando il separatore specificato tra ogni elemento.

La sintassi è

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

Piuttosto che passare la tua lista di int al metodo Join, suggerisco di creare prima un array di stringhe.

Ecco cosa propongo:

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

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

In .NET la classe list ha un .ToArray()metodo. Qualcosa del genere potrebbe funzionare:

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

Rif: List <T> Metodi (MSDN)