String.Join Method

Overloads

Join(String, String[], Int32, Int32)	Concatenates the specified elements of a string array, using the specified separator between each element.
Join(String, String[])	Concatenates all the elements of a string array, using the specified separator between each element.
Join(String, Object[])	Concatenates the elements of an object array, using the specified separator between each element.
Join(String, IEnumerable<String>)	Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.
Join<T>(String, IEnumerable<T>)	Concatenates the members of a collection, using the specified separator between each member.

Join(String, String[], Int32, Int32)

Concatenates the specified elements of a string array, using the specified separator between each element.

C#Copy

public static string Join (string separator, string[] value, int startIndex, int count);

Parameters

separator

String

The string to use as a separator. separator is included in the returned string only if value has more than one element.

value

String[]

An array that contains the elements to concatenate.

startIndex

Int32

The first element in value to use.

count

Int32

The number of elements of value to use.

Returns

String

A string that consists of the strings in value delimited by the separator string.

-or-

Empty if count is zero, value has no elements, or separator and all the elements of value are Empty.

Exceptions

ArgumentNullException

value is null.

ArgumentOutOfRangeException

startIndex or count is less than 0.

-or-

startIndex plus count is greater than the number of elements in value.

OutOfMemoryException

Out of memory.

Examples

The following example concatenates two elements from an array of names of fruit.

C#Copy

// Sample for String.Join(String, String[], int int)
using System;

class Sample {
    public static void Main() {
    String[] val = {"apple", "orange", "grape", "pear"};
    String sep   = ", ";
    String result;

    Console.WriteLine("sep = '{0}'", sep);
    Console.WriteLine("val[] = {{'{0}' '{1}' '{2}' '{3}'}}", val[0], val[1], val[2], val[3]);
    result = String.Join(sep, val, 1, 2);
    Console.WriteLine("String.Join(sep, val, 1, 2) = '{0}'", result);
    }
}
/*
This example produces the following results:
sep = ', '
val[] = {'apple' 'orange' 'grape' 'pear'}
String.Join(sep, val, 1, 2) = 'orange, grape'
*/

Remarks

For example, if separator is ", " and the elements of value are "apple", "orange", "grape", and "pear", Join(separator, value, 1, 2) returns "orange, grape".

If separator is null, an empty string (String.Empty) is used instead. If any element in value is null, an empty string is used instead.

See also

Split(Char[])

Join(String, String[])

Concatenates all the elements of a string array, using the specified separator between each element.

C#Copy

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

Parameters

separator

String

The string to use as a separator. separator is included in the returned string only if value has more than one element.

value

String[]

An array that contains the elements to concatenate.

Returns

String

A string that consists of the elements in value delimited by the separator string. If value is an empty array, the method returns Empty.

Exceptions

ArgumentNullException

value is null.

Examples

The following example demonstrates the Join method.

C#Copy

using System;

public class JoinTest {
    public static void Main() {

        Console.WriteLine(MakeLine(0, 5, ", "));
        Console.WriteLine(MakeLine(1, 6, "  "));
        Console.WriteLine(MakeLine(9, 9, ": "));
        Console.WriteLine(MakeLine(4, 7, "< "));
    }

    private static string MakeLine(int initVal, int multVal, string sep) {

        string [] sArr = new string [10];

        for (int i = initVal; i < initVal + 10; i++)
            sArr[i - initVal] = String.Format("{0,-3}", i * multVal);

        return String.Join(sep, sArr);
    }
}
// The example displays the following output:
//       0  , 5  , 10 , 15 , 20 , 25 , 30 , 35 , 40 , 45
//       6    12   18   24   30   36   42   48   54   60
//       81 : 90 : 99 : 108: 117: 126: 135: 144: 153: 162
//       28 < 35 < 42 < 49 < 56 < 63 < 70 < 77 < 84 < 91

Remarks

For example, if separator is ", " and the elements of value are "apple", "orange", "grape", and "pear", Join(separator, value)returns "apple, orange, grape, pear".

If separator is null, an empty string (String.Empty) is used instead. If any element in value is null, an empty string is used instead.

See also

Concat(Object)

Join(String, Object[])

Concatenates the elements of an object array, using the specified separator between each element.

C#Copy

[System.Runtime.InteropServices.ComVisible(false)]
public static string Join (string separator, params object[] values);

Parameters

separator

String

The string to use as a separator. separator is included in the returned string only if values has more than one element.

values

Object[]

An array that contains the elements to concatenate.

Returns

String

A string that consists of the elements of values delimited by the separator string. If values is an empty array, the method returns Empty.

Exceptions

ArgumentNullException

values is null.

Examples

The following example uses the Sieve of Eratosthenes algorithm to calculate the prime numbers that are less than or equal to 100. It assigns the result to a integer array, which it then passes to the Join(String, Object[]) method.

C#Copy

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      int maxPrime = 100;
      int[] primes = GetPrimes(maxPrime);
      Console.WriteLine("Primes less than {0}:", maxPrime);
      Console.WriteLine("   {0}", String.Join(" ", primes));
   }

   private static int[] GetPrimes(int maxPrime)
   {
      Array values = Array.CreateInstance(typeof(int),
                              new int[] { maxPrime - 1}, new int[] { 2 });
      // Use Sieve of Eratosthenes to determine prime numbers.
      for (int ctr = values.GetLowerBound(0); ctr <= (int) Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))); ctr++)
      {

         if ((int) values.GetValue(ctr) == 1) continue;

         for (int multiplier = ctr; multiplier <=  maxPrime / 2; multiplier++)
            if (ctr * multiplier <= maxPrime)
               values.SetValue(1, ctr * multiplier);
      }      

      List<int> primes = new List<int>();
      for (int ctr = values.GetLowerBound(0); ctr <= values.GetUpperBound(0); ctr++)
         if ((int) values.GetValue(ctr) == 0)
            primes.Add(ctr);
      return primes.ToArray();
   }
}
// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Remarks

If separator is null or if any element of values other than the first element is null, an empty string (String.Empty) is used instead. See the Notes for Callers section if the first element of values is null.

Join(String, Object[]) is a convenience method that lets you concatenate each element in an object array without explicitly converting its elements to strings. The string representation of each object in the array is derived by calling that object's ToString method.

Notes to Callers

If the first element of values is null, the Join(String, Object[]) method does not concatenate the elements in values but instead returns Empty. A number of workarounds for this issue are available. The easiest is to assign a value of Empty to the first element of the array, as the following example shows.

C#Copy

object[] values = { null, "Cobb", 4189, 11434, .366 };
if (values[0] == null) values[0] = String.Empty;
Console.WriteLine(String.Join("|", values));
// The example displays the following output:
//      |Cobb|4189|11434|0.366

See also

Split(Char[])

Join(String, IEnumerable<String>)

Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.

C#Copy

[System.Runtime.InteropServices.ComVisible(false)]
public static string Join (string separator, System.Collections.Generic.IEnumerable<string> values);

Parameters

separator

String

The string to use as a separator.separator is included in the returned string only if values has more than one element.

values

IEnumerable<String>

A collection that contains the strings to concatenate.

Returns

String

A string that consists of the members of values delimited by the separator string. If values has no members, the method returns Empty.

Exceptions

ArgumentNullException

values is null.

Examples

The following example uses the Sieve of Eratosthenes algorithm to calculate the prime numbers that are less than or equal to 100. It assigns the result to a List<T> object of type String, which it then passes to the Join(String, IEnumerable<String>) method.

C#Copy

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      int maxPrime = 100;
      List<int> primes = GetPrimes(maxPrime);
      Console.WriteLine("Primes less than {0}:", maxPrime);
      Console.WriteLine("   {0}", String.Join(" ", primes));
   }

   private static List<int> GetPrimes(int maxPrime)
   {
      Array values = Array.CreateInstance(typeof(int),
                              new int[] { maxPrime - 1}, new int[] { 2 });
      // Use Sieve of Eratosthenes to determine prime numbers.
      for (int ctr = values.GetLowerBound(0); ctr <= (int) Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))); ctr++)
      {

         if ((int) values.GetValue(ctr) == 1) continue;

         for (int multiplier = ctr; multiplier <=  maxPrime / 2; multiplier++)
            if (ctr * multiplier <= maxPrime)
               values.SetValue(1, ctr * multiplier);
      }      

      List<int> primes = new List<int>();
      for (int ctr = values.GetLowerBound(0); ctr <= values.GetUpperBound(0); ctr++)
         if ((int) values.GetValue(ctr) == 0)
            primes.Add(ctr);
      return primes;
   }
}
// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Remarks

If separator is null, an empty string (String.Empty) is used instead. If any member of values is null, an empty string is used instead.

Join(String, IEnumerable<String>) is a convenience method that lets you concatenate each element in an IEnumerable(Of String)collection without first converting the elements to a string array. It is particularly useful with Language-Integrated Query (LINQ) query expressions. The following example passes a List(Of String) object that contains either the uppercase or lowercase letters of the alphabet to a lambda expression that selects letters that are equal to or greater than a particular letter (which, in the example, is "M"). The IEnumerable(Of String) collection returned by the Enumerable.Where method is passed to the Join(String, IEnumerable<String>) method to display the result as a single string.

C#Copy

using System;
using System.Collections.Generic;
using System.Linq;

public class Example
{
   public static void Main()
   {
      string output = String.Join(" ", GetAlphabet(true).Where( letter =>
                      letter.CompareTo("M") >= 0));
      Console.WriteLine(output);
   }

   private static List<string> GetAlphabet(bool upper)
   {
      List<string> alphabet = new List<string>();
      int charValue = upper ? 65 : 97;
      for (int ctr = 0; ctr <= 25; ctr++)
         alphabet.Add(Convert.ToChar(charValue + ctr).ToString());
      return alphabet;
   }
}
// The example displays the following output:
//      M N O P Q R S T U V W X Y Z

See also

Split(Char[])

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

Concatenates the members of a collection, using the specified separator between each member.

C#Copy

[System.Runtime.InteropServices.ComVisible(false)]
public static string Join<T> (string separator, System.Collections.Generic.IEnumerable<T> values);

Type Parameters

T

The type of the members of values.

Parameters

separator

String

The string to use as a separator.separator is included in the returned string only if values has more than one element.

values

IEnumerable<T>

A collection that contains the objects to concatenate.

Returns

String

A string that consists of the members of values delimited by the separator string. If values has no members, the method returns Empty.

Exceptions

ArgumentNullException

values is null.

Examples

The following example uses the Sieve of Eratosthenes algorithm to calculate the prime numbers that are less than or equal to 100. It assigns the result to a List<T> object of type integer, which it then passes to the Join<T>(String, IEnumerable<T>) method.

C#Copy

using System;
using System.Collections.Generic;

public class Example
{
   public static void Main()
   {
      int maxPrime = 100;
      List<int> primes = GetPrimes(maxPrime);
      Console.WriteLine("Primes less than {0}:", maxPrime);
      Console.WriteLine("   {0}", String.Join(" ", primes));
   }

   private static List<int> GetPrimes(int maxPrime)
   {
      Array values = Array.CreateInstance(typeof(int),
                              new int[] { maxPrime - 1}, new int[] { 2 });
      // Use Sieve of Eratosthenes to determine prime numbers.
      for (int ctr = values.GetLowerBound(0); ctr <= (int) Math.Ceiling(Math.Sqrt(values.GetUpperBound(0))); ctr++)
      {

         if ((int) values.GetValue(ctr) == 1) continue;

         for (int multiplier = ctr; multiplier <=  maxPrime / 2; multiplier++)
            if (ctr * multiplier <= maxPrime)
               values.SetValue(1, ctr * multiplier);
      }      

      List<int> primes = new List<int>();
      for (int ctr = values.GetLowerBound(0); ctr <= values.GetUpperBound(0); ctr++)
         if ((int) values.GetValue(ctr) == 0)
            primes.Add(ctr);
      return primes;
   }
}
// The example displays the following output:
//    Primes less than 100:
//       2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97

Remarks

If separator is null, an empty string (String.Empty) is used instead. If any member of values is null, an empty string is used instead.

Join<T>(String, IEnumerable<T>) is a convenience method that lets you concatenate each member of an IEnumerable<T>collection without first converting them to strings. The string representation of each object in the IEnumerable<T> collection is derived by calling that object's ToString method.

This method is particular useful with Language-Integrated Query (LINQ) query expressions. For example, the following code defines a very simple Animal class that contains the name of an animal and the order to which it belongs. It then defines a List<T> object that contains a number of Animal objects. The Enumerable.Where extension method is called to extract the Animal objects whose Order property equals "Rodent". The result is passed to the Join<T>(String, IEnumerable<T>) method.

C#Copy

using System;
using System.Collections.Generic;
using System.Linq;

public class Animal
{
   public string Kind;
   public string Order;

   public Animal(string kind, string order)
   {
      this.Kind = kind;
      this.Order = order;
   }

   public override string ToString()
   {
      return this.Kind;
   }
}

public class Example
{
   public static void Main()
   {
      List<Animal> animals = new List<Animal>();
      animals.Add(new Animal("Squirrel", "Rodent"));
      animals.Add(new Animal("Gray Wolf", "Carnivora"));
      animals.Add(new Animal("Capybara", "Rodent"));
      string output = String.Join(" ", animals.Where( animal =>
                      (animal.Order == "Rodent")));
      Console.WriteLine(output);
   }
}
// The example displays the following output:
//      Squirrel Capybara

See also

Split(Char[])

Applies to

.NET Core

2.2 2.1 2.0 1.1 1.0

.NET Framework

4.8 4.7.2 4.7.1 4.7 4.6.2 4.6.1 4.6 4.5.2 4.5.1 4.5 4.0 3.5 3.0 2.0 1.1

.NET Standard

2.0 1.6 1.5 1.4 1.3 1.2 1.1 1.0

Xamarin.Android

7.1

Xamarin.iOS

10.8

Xamarin.Mac

3.0