How can I join int[] to a character-separated string in .NET?

Question

I have an array of integers:

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

What is the easiest way of converting these into a single string where the numbers are separated by a character (like: "2,3,6,7")?

I'm using C# and .NET 3.5.

Grandsire

SO rocks! I got these 3 excellent answers within 10 minutes on a Sunday! – Grandsire

As of .NET 4.0 there are methods that take an array of objects and an IEnumerable so you can just do string.join(",", number). I know the question specifies .NET 3.5 so I didn't make this an answer, but it comes up in searches that don't specify a version and knowing it's possible in 4.0 could help someone. – Llanes

Answer 1

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"

As of (at least) .NET 4.5,

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

is equivalent to:

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

I see several solutions advertise usage of StringBuilder. Someone complains that the Join method should take an IEnumerable argument.

I'm going to disappoint you :) String.Join requires an array for a single reason - performance. The Join method needs to know the size of the data to effectively preallocate the necessary amount of memory.

Here is a part of the internal implementation of String.Join method:

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

Igbo

This is probably the best bet using core .NET extension methods, but I really wished string.Join() would accept an IEnumerable<string> to avoid the ToArray() conversion. – Pleasurable

Nothing prevent someone from overloading string.Join to take an IEnumerable, as well. ;) – Hemianopsia

This is probably also the easiest solution, and not just the fastest. – Raddy

.NET 4 provides a String.Join overload that accepts IEnumerable as a parameter. msdn.microsoft.com/en-us/library/dd783876.aspx – Ankh

using System.Linq; is required. – Neu

Answer 2

Although the OP specified .NET 3.5, people wanting to do this in .NET 2.0 with C# 2.0 can do this:

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

I find there are a number of other cases where the use of the Convert.xxx functions is a neater alternative to a lambda, although in C# 3.0 the lambda might help the type-inferencing.

A fairly compact C# 3.0 version which works with .NET 2.0 is this:

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

Indictment

Answer 3

One mixture of the two approaches would be to write an extension method on IEnumerable<T> which used a StringBuilder. Here's an example, with different overloads depending on whether you want to specify the transformation or just rely on plain ToString. I've named the method "JoinStrings" instead of "Join" to avoid confusion with the other type of Join. Perhaps someone can come up with a better name :)

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

Alfilaria

Nice solution! You dont need the projection parameter though, you can just write x.Select(i => i.ToString("X")).JoinStrings(";") which is more idiomatic. – Ana

Yes, I thought about that afterwards. Occasionally it's nice to be able to specify it all in one go, but it's definitely more elegant to split the operations :) – Alfilaria

Answer 4

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

We have to convert each of the items to a String before we can join them, so it makes sense to use Select and a lambda expression. This is equivalent to map in some other languages. Then we have to convert the resulting collection of string back to an array, because String.Join only accepts a string array.

The ToArray() is slightly ugly I think. String.Join should really accept IEnumerable<String>, there is no reason to restrict it to only arrays. This is probably just because Join is from before generics, when arrays were the only kind of typed collection available.

Ana

Answer 5

If your array of integers may be large, you'll get better performance using a StringBuilder. E.g.:

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: When I posted this I was under the mistaken impression that "StringBuilder.Append(int value)" internally managed to append the string representation of the integer value without creating a string object. This is wrong: inspecting the method with Reflector shows that it simply appends value.ToString().

Therefore the only potential performance difference is that this technique avoids one array creation, and frees the strings for garbage collection slightly sooner. In practice this won't make any measurable difference, so I've upvoted this better solution.

Elutriate

Have you measured it to be faster? String.Join uses a StringBuilder also. – Ana

Yes, but you first need to convert the whole thing to an array, which is far from ideal. In particular, it means that you need to have all the converted strings in memory at the same time, before you start building the resulting string. – Alfilaria

OTOH String.Join precalculates the size of the StringBuilder buffer so it avoids resizing. So it might be faster even if it requires more memory. – Ana

Answer 6

The question is for "easiest way of converting these in to a single string where the number are separated by a character".

The easiest way is:

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

This only works in .NET 4.0+.

Hubie

This is not valid as string.Join method takes only an array of strings. Have a look here msdn.microsoft.com/en-us/library/tk0xe5h0.aspx – Tobacconist

It is an overloaded method: msdn.microsoft.com/en-us/library/dd988350 I just copied the code I wrote into a new console app, added a Console.WriteLine and this is the output: 2,3,6,7 – Hubie

I think this is available in only .net 4 – Lend

Requires an object array (or string array), not an int array. Will give a "call is ambiguous" error. – Emptyhanded

Answer 7

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

I also thought there was a simpler way.

Kienan

This solution would give you ",1,2,3,4,5". – Soapy

Thanks, I've added Substring(1) to fix that (it was from memory). – Kienan

Answer 8

In .NET 4.0, string join has an overload for params object[], so it's as simple as:

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

Example

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, it's a tiny little bit more difficult, since there's no such overload. So you need your own generic method:

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, you can use extension methods:

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

}

So you can use the JoinArray extension method.

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

You can also use that extension method in .NET 2.0, if you add the ExtensionAttribute to your code:

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

Imperfect

Answer 9

I agree with the lambda expression for readability and maintainability, but it will not always be the best option. The downside to using both the IEnumerable/ToArray and StringBuilder approaches is that they have to dynamically grow a list, either of items or characters, since they do not know how much space will be needed for the final string.

If the rare case where speed is more important than conciseness, the following is more efficient.

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

Prostrate

Answer 10

You can do

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

Check out

Separator Delimited ToString for Array, List, Dictionary, Generic IEnumerable

Bulldog

This requires the extension method defined on the linked page, this could be clearer – Parbuckle

Answer 11

Forget about .NET 3.5 and use the following code in .NET Core:

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

Gussiegussman