Join

The C# string.Join method combines many strings into one. It receives 2 arguments: an array (or IEnumerable) and a separator string.

This method places the separator between every element of the collection in the returned string. The separator is not added to the start or end of the result.

First example

We combine string elements from an array into a new, single string with dividing characters. This example will produce the output with separating commas.

using System;

string[] words = { "one", "two", "three" };

// Call the Join method and print the resulting string.
var result = string.Join(",", words);
Console.WriteLine(result);
one,two,three

HTML

We can use string.Join to generate HTML. Often with HTML we need a separating tag or element. Join helps because it does not insert the separating tag at the end.

using System;
using System.IO;

var items = new string[] { "Line 1", "Line 2", "Final line" };

// Step 1: join with break element in HTML.
string html = string.Join("<br/>\r\n", items);

// Step 2: write to text file.
File.WriteAllText("test.html", html);
Console.WriteLine("DONE");
DONE

StringBuilder

We can replace code that appends strings in loops with a single call to string.Join. The string.Join method is often faster in addition to being simpler.

using System;
using System.Text;

class Program
{
    static void Main()
    {
        string[] animals = { "bird", "cat", "dog", "frog" };

        // Part 1: use method that calls string.Join.
        Console.WriteLine(CombineA(animals));

        // Part 2: use StringBuilder method.
        Console.WriteLine(CombineB(animals));
    }

    static string CombineA(string[] arr)
    {
        return string.Join(",", arr);
    }

    static string CombineB(string[] arr)
    {
        StringBuilder builder = new StringBuilder();
        foreach (string s in arr)
        {
            builder.Append(s).Append(",");
        }
        return builder.ToString().TrimEnd(new char[] { ',' });
    }
}
bird,cat,dog,frog
bird,cat,dog,frog

List

We can use string.Join with a List. This example includes the System.Collections.Generic namespace. Here a List is instantiated with 3 string literals in it.

using System;
using System.Collections.Generic;

// Create a List of 3 strings.
var list = new List<string>() { "cat", "dog", "rat" };
// Join the strings from the List.
string joined = string.Join<string>("*", list);
// Display.
Console.WriteLine(joined);
cat*dog*rat

Exceptions

String.Join can throw 3 different exceptions. The first 2 exceptions (ArgumentNullException, ArgumentOutOfRangeException) are often possible.

using System;

class Program
{
    static void Main()
    {
        try
        {
            string bug = string.Join(null, null); // Null arguments are bad
        }
        catch (Exception ex)
        {
            Console.WriteLine(ex);
        }
    }
}
System.ArgumentNullException: Value cannot be null.
Parameter name: value

A benchmark

We test the general performance of string.Join. This method appears to have excellent performance. We see that string.Join performs well—often better than loops.

using System;
using System.Diagnostics;

class Program
{
    static string CombineA(string[] arr)
    {
        return string.Join(",", arr);
    }

    static string CombineB(string[] arr)
    {
        var builder = new System.Text.StringBuilder();
        foreach (string s in arr)
        {
            builder.Append(s).Append(",");
        }
        return builder.ToString(); // Has ending comma.
    }

    const int _max = 1000000;
    static void Main()
    {
        string[] arr = { "one", "two", "three", "four", "five" };

        var s1 = Stopwatch.StartNew();
        // Version 1: use string.Join.
        for (int i = 0; i < _max; i++)
        {
            if (CombineA(arr).Length == 0)
            {
                return;
            }
        }
        s1.Stop();
        var s2 = Stopwatch.StartNew();
        // Version 2: use StringBuilder.
        for (int i = 0; i < _max; i++)
        {
            if (CombineB(arr).Length == 0)
            {
                return;
            }
        }
        s2.Stop();
        Console.WriteLine(((double)(s1.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns"));
        Console.WriteLine(((double)(s2.Elapsed.TotalMilliseconds * 1000000) / _max).ToString("0.00 ns"));
    }
}
58.42 ns     string.Join
122.52 ns    StringBuilder, Append, ToString

Result note

When we call Join, we do not get an ending delimiter on the result. The separator only is placed between elements—this is desired in some programs, but not in others.

Summary

Join is an important operation on the string type—it simplifies certain common operations on string arrays. It is helpful when StringBuilder is not needed.