Ich möchte ein Array oder eine Liste von Ints in eine durch Kommas getrennte Zeichenfolge umwandeln, wie folgt:

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

String.Join ist jedoch nur List<string>der zweite Parameter. Was ist der beste Weg, dies zu tun?

Der beste Weg ist ein Upgrade auf .NET 4.0, bei dem eine Überlastung vorliegt, die genau das tut, was Sie möchten:

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

Wenn Sie kein Upgrade durchführen können, können Sie mit Select und ToArray denselben Effekt erzielen.

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

Eine skalierbare und sichere Implementierung eines generischen Enumerable-String-Joins für .NET 3.5. Die Verwendung von Iteratoren ist so, dass der Wert der Verknüpfungszeichenfolge nicht am Ende der Zeichenfolge hängen bleibt. Es funktioniert korrekt mit 0, 1 und mehr Elementen:

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

Verwendung:

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

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

Genießen!

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

Diese Antwort ist für Sie, wenn Sie sich noch nicht in die Tiefen von .NET 4.0 wagen möchten.

String.Join () verkettet alle Elemente eines String-Arrays unter Verwendung des angegebenen Trennzeichens zwischen den einzelnen Elementen.

Die Syntax lautet

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

Anstatt Ihre Liste der Ints an die Join-Methode zu übergeben, empfehle ich, zuerst ein Array von Zeichenfolgen aufzubauen.

Folgendes schlage ich vor:

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

Hatte eine ähnliche Erweiterungsmethode, die ich daran geändert habe

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

und du benutzt es so

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

.NET 3.5

Verwenden von .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 verfügt die Listenklasse über eine .ToArray()Methode. So etwas könnte funktionieren:

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

Ref: List <T> Methods (MSDN)