Jak dołączyć int [] do oddzielonego znakiem łańcucha in.NET?

Chociaż OP określa. NET 3.5, ludzie chcący to zrobić w. NET 2.0 z C#2 mogą to zrobić:

string.Join(",", Array.ConvertAll<int, String>(ints, Convert.ToString));

Uważam, że istnieje wiele innych przypadków, w których użycie konwertera.xxx functions jest lepszą alternatywą dla lambda, chociaż w C#3 lambda może pomóc w wnioskowaniu typu.

Dość kompaktowa wersja C # 3, która współpracuje z. NET 2.0 to:

string.Join(",", Array.ConvertAll(ints, item => item.ToString()))

Jedną z kombinacji tych dwóch metod byłoby napisanie metody rozszerzenia na IEnumerable, która używała Stringbuildera. Oto przykład, z różnymi przeciążeniami w zależności od tego, czy chcesz określić transformację, czy po prostu polegać na zwykłym ToString. Nazwałem metodę "JoinStrings" zamiast "Join", aby uniknąć pomyłki z innym typem łączenia. Może ktoś wymyśli lepszą nazwę:)

using System;
using System.Collections.Generic;
using System.Text;

public static class Extensions
{
    public static string JoinStrings<T>(this IEnumerable<T> source, 
                                        Func<T, string> projection, string separator)
    {
        StringBuilder builder = new StringBuilder();
        bool first = true;
        foreach (T element in source)
        {
            if (first)
            {
                first = false;
            }
            else
            {
                builder.Append(separator);
            }
            builder.Append(projection(element));
        }
        return builder.ToString();
    }

    public static string JoinStrings<T>(this IEnumerable<T> source, string separator)
    {
        return JoinStrings(source, t => t.ToString(), separator);
    }
}

class Test
{

    public static void Main()
    {
        int[] x = {1, 2, 3, 4, 5, 10, 11};

        Console.WriteLine(x.JoinStrings(";"));
        Console.WriteLine(x.JoinStrings(i => i.ToString("X"), ","));
    }
}

String.Join(";", number.Select(item => item.ToString()).ToArray());

Musimy przekonwertować każdy z elementów na String, zanim będziemy mogli je połączyć, więc sensowne jest użycie Select i wyrażenia lambda. Jest to odpowiednik map w niektórych innych językach. Następnie musimy przekonwertować wynikową kolekcję łańcuchów z powrotem na tablicę, ponieważ String.Join akceptuje tylko tablicę łańcuchów.

ToArray() jest chyba trochę brzydki. String.Join powinien naprawdę zaakceptować IEnumerable<String>, nie ma powodu, aby ograniczać go tylko do tablic. To pewnie dlatego, że {[8] } jest z przed generics, kiedy tablice były jedynym rodzajem typed zbiór dostępny.

Jeśli Twoja tablica liczb całkowitych może być duża, uzyskasz lepszą wydajność za pomocą Stringbuildera. Np.:

StringBuilder builder = new StringBuilder();
char separator = ',';
foreach(int value in integerArray)
{
    if (builder.Length > 0) builder.Append(separator);
    builder.Append(value);
}
string result = builder.ToString();

Edit: kiedy to zamieściłem, miałem błędne wrażenie, że " StringBuilder.Append (int value) " wewnętrznie udało się dopisać reprezentację string wartości całkowitej bez tworzenia obiektu string. Jest to błędne: sprawdzenie metody za pomocą reflektora pokazuje, że po prostu dodaje wartość.ToString().

Dlatego jedyna potencjalna różnica w wydajności jest to, że ta technika pozwala uniknąć tworzenia jednej tablicy i zwalnia łańcuchy do zbierania śmieci nieco wcześniej. W praktyce nie będzie to miało żadnej wymiernej różnicy, więc podałem to lepsze rozwiązanie .

Pytanie dotyczy "najprostszego sposobu konwersji ich na pojedynczy ciąg znaków, w którym liczba jest oddzielona znakiem".

Najprostszym sposobem jest:

int[] numbers = new int[] { 2,3,6,7 };
string number_string = string.Join(",", numbers);
// do whatever you want with your exciting new number string

EDIT: to działa tylko w. NET 4.0+, przegapiłem wymóg. NET 3.5 za pierwszym razem, gdy przeczytałem pytanie.

Zgadzam się z wyrażeniem lambda pod względem czytelności i konserwacji, ale nie zawsze będzie to najlepsza opcja. Minusem korzystania z metod IEnumerable / ToArray i StringBuilder jest to, że muszą dynamicznie rozwijać listę, zarówno elementów, jak i znaków, ponieważ nie wiedzą, ile miejsca będzie potrzebne na końcowy ciąg.

Jeśli rzadki przypadek, w którym szybkość jest ważniejsza niż zwięzłość, poniżej jest bardziej efektywna.

int[] number = new int[] { 1, 2, 3, 4, 5 };
string[] strings = new string[number.Length];
for (int i = 0; i < number.Length; i++)
  strings[i] = number[i].ToString();
string result = string.Join(",", strings);

ints.Aggregate("", ( str, n ) => str +","+ n ).Substring(1);

W. NET 4.0, string join ma przeciążenie dla params object[], więc jest to tak proste, jak:

int[] ids = new int[] { 1, 2, 3 };
string.Join(",", ids);

Przykład

int[] ids = new int[] { 1, 2, 3 };
System.Data.Common.DbCommand cmd = new System.Data.SqlClient.SqlCommand("SELECT * FROM some_table WHERE id_column IN (@bla)");
cmd.CommandText = cmd.CommandText.Replace("@bla",  string.Join(",", ids));

public static string JoinArray<T>(string separator, T[] inputTypeArray)
{
    string strRetValue = null;
    System.Collections.Generic.List<string> ls = new System.Collections.Generic.List<string>();

    for (int i = 0; i < inputTypeArray.Length; ++i)
    {
        string str = System.Convert.ToString(inputTypeArray[i], System.Globalization.CultureInfo.InvariantCulture);

        if (!string.IsNullOrEmpty(str))
        { 
            // SQL-Escape
            // if (typeof(T) == typeof(string))
            //    str = str.Replace("'", "''");

            ls.Add(str);
        } // End if (!string.IsNullOrEmpty(str))

    } // Next i 

    strRetValue= string.Join(separator, ls.ToArray());
    ls.Clear();
    ls = null;

    return strRetValue;
}

W. NET 3.5 możesz użyć metod rozszerzeń:

public static class ArrayEx
{

    public static string JoinArray<T>(this T[] inputTypeArray, string separator)
    {
        string strRetValue = null;
        System.Collections.Generic.List<string> ls = new System.Collections.Generic.List<string>();

        for (int i = 0; i < inputTypeArray.Length; ++i)
        {
            string str = System.Convert.ToString(inputTypeArray[i], System.Globalization.CultureInfo.InvariantCulture);

            if (!string.IsNullOrEmpty(str))
            { 
                // SQL-Escape
                // if (typeof(T) == typeof(string))
                //    str = str.Replace("'", "''");

                ls.Add(str);
            } // End if (!string.IsNullOrEmpty(str))

        } // Next i 

        strRetValue= string.Join(separator, ls.ToArray());
        ls.Clear();
        ls = null;

        return strRetValue;
    }

}

Więc możesz użyć joinarray extension-method.

int[] ids = new int[] { 1, 2, 3 };
string strIdList = ids.JoinArray(",");

Możesz również użyć tej metody rozszerzenia w. NET 2.0, jeśli dodasz ExtensionAttribute do swojego kod:

// you need this once (only), and it must be in this namespace
namespace System.Runtime.CompilerServices
{
    [AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Class | AttributeTargets.Method)]
    public sealed class ExtensionAttribute : Attribute {}
}

You can do

ints.ToString(",")
ints.ToString("|")
ints.ToString(":")

Sprawdź

Separator rozdzielany ToString dla Array, List, Dictionary, Generic IEnumerable