Create a Comma-Separated String from IEnumerable<string> in C#

By the end of this page, you will understand how to turn an IEnumerable<string> or IList<string> into a comma-separated string in C#. You will learn the idiomatic use of string.Join, how it works with collections, when conversion is unnecessary, and how to avoid common mistakes such as handling null values or adding separators manually.

In C#, a very common task is combining many string values into one string with a separator such as a comma, space, or pipe character.

The core concept here is joining a sequence of values into a single string.

If you have values like this:

var names = new List<string> { "Alice", "Bob", "Charlie" };

You often want this result:

"Alice,Bob,Charlie"

or this:

"Alice, Bob, Charlie"

In C#, the standard tool for this is string.Join.

A common beginner concern is that string.Join is only for arrays like string[]. That was a limitation in older usage patterns, but modern C# and .NET provide overloads that work directly with IEnumerable<string>.

That matters because many APIs return sequences such as:

• List<string>
• IList<string>
• IEnumerable<string>

Think of string.Join like a machine that places glue between items in a line.

If your items are:

Alice   Bob   Charlie

and your glue is ", ", the machine produces:

Alice, Bob, Charlie

Important detail: the separator goes between items, not before the first one and not after the last one.

That is why string.Join is usually better than manually looping and appending commas yourself. It handles the separator placement for you.

The basic syntax is:

string result = string.Join(separator, values);

Where:

• separator is a string such as ", "
• values is a sequence of strings

Example with List<string>

using System;
using System.Collections.Generic;

var fruits = new List<string> { "Apple", "Banana", "Orange" };
string result = string.Join(", ", fruits);

Console.WriteLine(result);

Output:

Apple, Banana, Orange

Example with IEnumerable<string>

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

IEnumerable<> shortWords = [] { , , ,  }
    .Where(word => word.Length <= );

 result = .Join(, shortWords);
Console.WriteLine(result);

Consider this code:

using System;
using System.Collections.Generic;

IEnumerable<string> names = new List<string> { "Ana", "Ben", "Cara" };
string result = string.Join(", ", names);
Console.WriteLine(result);

Here is what happens step by step:

1. names is created as a sequence containing three strings:

   • "Ana"
   • "Ben"
   • "Cara"

2. string.Join(", ", names) is called.

   • The separator is ", "
   • The values come from the IEnumerable<string> sequence

3. string.Join reads the sequence items in order.

4. It builds one final string by putting the separator between each item:

   • Start with "Ana"

This pattern appears in many practical situations.

Displaying tags or labels

var tags = new List<string> { "csharp", "linq", "strings" };
string display = string.Join(", ", tags);

Useful for UI display such as:

csharp, linq, strings

Logging selected items

var selectedIds = new List<string> { "A12", "B34", "C56" };
logger.LogInformation("Selected items: {Items}", string.Join(", ", selectedIds));

Building query parameters or route pieces

var ids = new List<string> { "10", "20", "30" };
string csv = string.Join(",", ids);

That may be sent to an API as:

In real codebases, developers often use string.Join together with LINQ and validation.

Pattern: joining projected values

Sometimes the original collection contains objects, not strings.

var users = new[]
{
    new { Name = "Ava" },
    new { Name = "Noah" },
    new { Name = "Liam" }
};

string names = string.Join(", ", users.Select(u => u.Name));

This is very common when formatting lists from domain objects.

Pattern: guard clause before joining

if (items == null)
{
    return string.Empty;
}

return string.Join(", ", items);

This protects your code from a null collection reference.

Pattern: filtering empty values

var cleaned = values.Where(v => !string.IsNullOrWhiteSpace(v));
string result = string.Join(, cleaned);

1. Manually adding commas in a loop

Broken or awkward approach:

var result = "";
foreach (var item in items)
{
    result += item + ",";
}

Problems:

• leaves a trailing comma
• less readable
• repeated string concatenation can be inefficient

Better:

string result = string.Join(",", items);

2. Assuming ToArray() is always required

Unnecessary code:

string result = string.Join(", ", items.ToArray());

If items is already an IEnumerable<string> and your framework supports the overload, this is usually unnecessary.

Better:

string result = string.Join(", ", items);

3. Forgetting to handle collections

// Best common solution
string result = string.Join(", ", values);

Common separators

string.Join(",", values);    // A,B,C
string.Join(", ", values);   // A, B, C
string.Join(" | ", values);  // A | B | C
string.Join(Environment.NewLine, values); // one per line

With LINQ projection

string result = string.Join(", ", users.Select(u => u.Name));

Safe null handling

string result = string.Join(", ", values ?? Enumerable.Empty<string>());

Filter blanks first

string result = string.Join(", ", values.Where(v => !string.IsNullOrWhiteSpace(v)));

Can string.Join work with IEnumerable<string> in C#?

Yes. In modern .NET, string.Join has overloads that work directly with IEnumerable<string>.

Do I need to convert a List<string> to an array before calling string.Join?

No, not usually. A List<string> can be passed directly to the appropriate overload.

What happens if one item in the collection is null?

That item is treated like an empty string in the output.

What happens if the whole collection is null?

You should guard against that case, for example with values ?? Enumerable.Empty<string>().

Is string.Join better than using a loop?

Yes for this task. It is shorter, clearer, and avoids separator-placement bugs.

Can I join values from objects instead of strings?

Yes. Use Select to project the property you want, then pass that sequence to string.Join.

Should I use instead of ?

• IEnumerable<T> - The base sequence interface used throughout LINQ and collection processing.
• IList<T> - A list interface that supports indexing and is often passed into string.Join.
• string - Understanding immutability helps explain why repeated concatenation is often less ideal.
• LINQ Select - Useful for converting objects into strings before joining.
• LINQ Where - Useful for filtering out empty or unwanted values before joining.
• StringBuilder - Helpful when constructing more complex strings manually.
• null handling - Important when collections or items may be missing.
• collection interfaces in C# - Helps clarify the difference between arrays, lists, and enumerable sequences.