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>
• LINQ query results
• filtered or projected collections

Instead of building the string manually with loops, string.Join gives you a cleaner, safer, and more readable solution.

Why this matters in real programming:

• formatting user-visible text
• generating CSV-like output
• logging collections
• building query parameters
• combining tags, labels, or roles

Using the right built-in method reduces bugs like extra commas at the end and makes the code easier to read.

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<string> shortWords = new[] { "cat", "elephant", "dog", "tiger" }
    .Where(word => word.Length <= 5);

string result = string.Join(" | ", shortWords);
Console.WriteLine(result);

Output:

cat | dog | tiger

Example with IList<string>

using System;
using System.Collections.Generic;

IList<string> colors = new List<string> { "Red", "Green", "Blue" };
string result = string.Join(",", colors);

Console.WriteLine(result);

Output:

Red,Green,Blue

When values are not strings

If your collection contains another type, convert each item first:

using System;
using System.Linq;

var numbers = new[] { 10, 20, 30 };
string result = string.Join(", ", numbers.Select(n => n.ToString()));

Console.WriteLine(result);

Output:

10, 20, 30

In many real cases, if the values are already strings, you do not need to call ToArray() first.

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"
   • Add ", " and "Ben"
   • Add ", " and "Cara"

5. The final result becomes:

Ana, Ben, Cara

1. Console.WriteLine(result) prints that final string.

Trace example with filtering

using System;
using System.Linq;

var words = new[] { "sun", "moon", "star", "sky" };
var filtered = words.Where(w => w.Length <= 4);
string result = string.Join("; ", filtered);

Console.WriteLine(result);

Step-by-step:

1. words contains sun, moon, star, sky
2. Where(w => w.Length <= 4) keeps all of them in this case
3. string.Join("; ", filtered) combines them with ;
4. Output is:

sun; moon; star; sky

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:

ids=10,20,30

Exporting data

var columns = new[] { "Name", "Email", "Country" };
string header = string.Join(",", columns);

Result:

Name,Email,Country

Formatting validation messages

var missingFields = new List<string> { "Email", "Password" };
string message = "Missing required fields: " + string.Join(", ", missingFields);

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

This avoids output like:

Alice, , Bob, 

Pattern: configuration or serialization helpers

Developers often join string collections when producing:

• configuration values
• cache keys
• display summaries
• SQL parameter logs
• audit messages

Pattern: early return for empty data

if (!values.Any())
{
    return "No items";
}

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

This makes output more meaningful when the sequence is empty.

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 null collections

Broken code:

IEnumerable<string> items = null;
string result = string.Join(", ", items);

Depending on context, this can fail because items itself is null.

Safer:

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

4. Confusing null items with a null collection

var items = new List<string> { "A", null, "C" };
string result = string.Join(", ", items);

This is valid. A null element is treated like an empty string in the joined output.

Possible result:

A, , C

If you do not want that, filter values first:

string result = string.Join(", ", items.Where(x => !string.IsNullOrEmpty(x)));

5. Using the wrong separator

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

This gives:

A,B,C

If you want spaces after commas, use:

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

string.Join vs Aggregate

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

vs.

string result = items.Aggregate((a, b) => a + ", " + b);

string.Join is usually better because:

• it is clearer
• it handles empty sequences more safely
• it directly expresses your intent

IList<string> vs IEnumerable<string>

For string.Join, both are commonly fine because an IList<string> is also an IEnumerable<string> in practice for standard collection types.

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

Key points

• Use string.Join for separator-based string building.
• Prefer it over manual loops for readability.
• You usually do not need ToArray() for IEnumerable<string>.
• A null element becomes an empty part in the output.
• A null collection should be handled before joining.

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 Aggregate instead of string.Join?

Usually no. string.Join is the clearer and more idiomatic choice for combining strings with separators.

• 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.