Bir dizi veya giriş listesini aşağıdaki gibi virgülle ayrılmış bir dizeye dönüştürmek istiyorum:

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

Ancak string.Join yalnızca List<string>ikinci parametre olarak alır . Bunu yapmanın en iyi yolu nedir?

En iyi yol, istediğinizi yapan bir aşırı yükün olduğu .NET 4.0'a yükseltmektir:

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

Yükseltemezseniz, aynı efekti Select ve ToArray kullanarak elde edebilirsiniz.

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

Bir ölçeklenebilir ve güvenli bir jenerik enumerable dize uygulanması .NET 3.5 için katılın. Yineleyicilerin kullanımı, birleştirme dizesi değerinin dizenin sonunda sıkışmaması içindir. 0, 1 ve daha fazla elemanla doğru çalışır:

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

Kullanım:

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

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

Zevk almak!

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

Buna değiştirdiğim benzer bir Uzatma Yöntemi vardı

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

ve bunu böyle kullanıyorsun

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

.NET 3.5

Henüz .NET 4.0'ın derinliklerine dalmak istemiyorsanız, bu cevap tam size göre.

String.Join (), her öğe arasında belirtilen ayırıcıyı kullanarak bir dize dizisinin tüm öğelerini birleştirir.

Sözdizimi

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

Girişler Listenizi Join yöntemine geçirmek yerine, önce bir dizi dizesi oluşturmanızı öneririm.

İşte önerdiğim şey:

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

.NET 4.0 kullanma

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

.NET'te liste sınıfının bir .ToArray()yöntemi vardır. Bunun gibi bir şey işe yarayabilir:

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

Başvuru: <T> Yöntemleri Listesi (MSDN)