Come unire int [] a una stringa separata da caratteri in .NET?

Ho un array di numeri interi:

int[] number = new int[] { 2,3,6,7 };

Qual è il modo più semplice per convertirli in un'unica stringa in cui i numeri sono separati da un carattere (come:) "2,3,6,7"?

Sono in C # e .NET 3.5.

var ints = new int[] {1, 2, 3, 4, 5};
var result = string.Join(",", ints.Select(x => x.ToString()).ToArray());
Console.WriteLine(result); // prints "1,2,3,4,5"

EDIT : a partire da (almeno) .NET 4.5,

var result = string.Join(",", ints.Select(x => x.ToString()).ToArray());

è equivalente a:

var result = string.Join(",", ints);

MODIFICA :

Vedo diverse soluzioni che pubblicizzano l'utilizzo di StringBuilder. Qualcuno si lamenta che il metodo Join dovrebbe accettare un argomento IEnumerable.

Ti deluderò :) String.Join richiede array per un unico motivo: le prestazioni. Il metodo Join deve conoscere la dimensione dei dati per preallocare efficacemente la quantità di memoria necessaria.

Ecco una parte dell'implementazione interna del metodo String.Join:

// length computed from length of items in input array and length of separator
string str = FastAllocateString(length);
fixed (char* chRef = &str.m_firstChar) // note than we use direct memory access here
{
    UnSafeCharBuffer buffer = new UnSafeCharBuffer(chRef, length);
    buffer.AppendString(value[startIndex]);
    for (int j = startIndex + 1; j <= num2; j++)
    {
        buffer.AppendString(separator);
        buffer.AppendString(value[j]);
    }
}

Sono troppo pigro per confrontare le prestazioni dei metodi suggeriti. Ma qualcosa mi dice che Join vincerà :)

Sebbene l'OP abbia specificato .NET 3.5, le persone che desiderano farlo in .NET 2.0 con C # 2 possono farlo:

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

Trovo che ci siano una serie di altri casi in cui l'uso delle funzioni Convert.xxx è un'alternativa più ordinata a un lambda, sebbene in C # 3 il lambda potrebbe aiutare l'inferenza del tipo.

Una versione C # 3 abbastanza compatta che funziona con .NET 2.0 è questa:

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

Una combinazione dei due approcci sarebbe scrivere un metodo di estensione su IEnumerable <T> che utilizza StringBuilder. Ecco un esempio, con sovraccarichi diversi a seconda che si desideri specificare la trasformazione o semplicemente fare affidamento su ToString semplice. Ho chiamato il metodo "JoinStrings" invece di "Join" per evitare confusione con l'altro tipo di Join. Forse qualcuno può inventare un nome migliore :)

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

Dobbiamo convertire ciascuno degli elementi in a Stringprima di poterli unire, quindi ha senso usare Selecte un'espressione lambda. Questo è equivalente a mapin alcune altre lingue. Quindi dobbiamo riconvertire la raccolta di stringhe risultante in un array, perché String.Joinaccetta solo un array di stringhe.

Il ToArray()è un po 'brutto credo. String.Joindovrebbe davvero accettare IEnumerable<String>, non c'è motivo di restringerlo solo agli array. Questo probabilmente è solo perché Joinrisale a prima dei generici, quando gli array erano l'unico tipo di raccolta digitata disponibile.

Se il tuo array di numeri interi può essere grande, otterrai prestazioni migliori usando StringBuilder. Per esempio:

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

Modifica: quando ho pubblicato questo, avevo l'impressione errata che "StringBuilder.Append (int value)" fosse riuscito internamente ad aggiungere la rappresentazione di stringa del valore intero senza creare un oggetto stringa. Questo è sbagliato: l'ispezione del metodo con Reflector mostra che aggiunge semplicemente value.ToString ().

Pertanto l'unica potenziale differenza di prestazioni è che questa tecnica evita la creazione di un array e libera le stringhe per la garbage collection leggermente prima. In pratica questo non farà alcuna differenza misurabile, quindi ho votato positivamente questa soluzione migliore .

La domanda è "il modo più semplice per convertirli in un'unica stringa in cui il numero è separato da un carattere".

Il modo più semplice è:

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: funziona solo in .NET 4.0+, ho perso il requisito .NET 3.5 la prima volta che ho letto la domanda.

Sono d'accordo con l'espressione lambda per leggibilità e manutenibilità, ma non sarà sempre l'opzione migliore. Lo svantaggio dell'utilizzo di entrambi gli approcci IEnumerable / ToArray e StringBuilder è che devono far crescere dinamicamente un elenco, di elementi o caratteri, poiché non sanno quanto spazio sarà necessario per la stringa finale.

Se il raro caso in cui la velocità è più importante della concisione, quanto segue è più efficiente.

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

Ho anche pensato che ci fosse un modo più semplice. Non conosco la performance, qualcuno ha qualche idea (teorica)?

In .NET 4.0, il join di stringa ha un overload per params object[], quindi è semplice come:

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

esempio

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

In .NET 2.0, è un po 'più difficile, poiché non c'è un tale sovraccarico. Quindi hai bisogno del tuo metodo generico:

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

In .NET 3.5 è possibile utilizzare metodi di estensione:

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

}

Quindi puoi usare il metodo di estensione JoinArray.

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

Puoi anche usare quel metodo di estensione in .NET 2.0, se aggiungi ExtensionAttribute al tuo codice:

// 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 {}
}

Tu puoi fare

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

Check-out

ToString delimitato da separatore per array, elenco, dizionario, IEnumerable generico