Convert List<string> to a Delimited String in C#

By the end of this page, you will understand how to combine a List<string> or other collections into one string in C#. You will learn the standard method, string.Join, how it works, when to use it, and common mistakes to avoid.

In C#, the standard way to combine many string values into one string with a separator is string.Join.

When you have a collection such as:

List<string> names = new List<string> { "John", "Anna", "Monica" };

and want this result:

"John, Anna, Monica"

string.Join is the built-in tool designed for exactly that job.

Example:

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

This produces:

John, Anna, Monica

Why this matters:

• You often need to display lists of values to users.
• You may need to create CSV-like text output.
• You may need to build log messages, API parameters, or configuration values.
• It is cleaner and safer than manually looping and adding separators yourself.

Instead of writing custom code to add commas between items and avoid an extra comma at the end, string.Join handles that for you.

Think of string.Join like a machine that takes:

• a separator such as ", "
• a list of items

and places the separator between each item.

If the items are:

• John
• Anna
• Monica

and the separator is ,

the machine builds:

John, Anna, Monica

A helpful detail: the separator goes between items, not before the first one or after the last one. That is why string.Join is so useful.

The basic syntax is:

string.Join(separator, collection)

Example with List<string>

List<string> names = new List<string> { "John", "Anna", "Monica" };
string namesTogether = string.Join(", ", names);

Console.WriteLine(namesTogether);

Output:

John, Anna, Monica

Explanation:

• ", " is the delimiter.
• names is the collection.
• string.Join returns one combined string.

Example with an array

string[] colors = { "Red", "Green", "Blue" };
string result = string.Join(" | ", colors);

Console.WriteLine(result);

Output:

Consider this code:

List<string> names = new List<string> { "John", "Anna", "Monica" };
string result = string.Join(", ", names);
Console.WriteLine(result);

Step by step:

1. A List<string> is created with three values:

   • John
   • Anna
   • Monica

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

3. C# starts with the first item:

   • current result: John

4. It sees another item exists, so it inserts the separator , :

   • current result: John,

5. It adds the next item Anna:

   • current result:

Here are common places where this concept is used:

Displaying names or tags in a UI

List<string> tags = new List<string> { "csharp", "dotnet", "backend" };
string display = string.Join(", ", tags);

Result:

csharp, dotnet, backend

Writing log messages

List<string> errors = new List<string> { "Missing email", "Invalid password" };
string message = "Validation failed: " + string.Join("; ", errors);

Building CSV-like lines

string[] fields = { "John", "Developer", "London" };
string csvLine = string.Join(",", fields);

Creating query parameter values

In real projects, developers often use string.Join together with filtering, mapping, and validation.

Pattern: filter before join

var parts = new List<string> { firstName, middleName, lastName };
string fullName = string.Join(" ", parts.Where(p => !string.IsNullOrWhiteSpace(p)));

This avoids extra spaces when one part is missing.

Pattern: map values before join

var users = new List<string> { "john", "anna", "monica" };
string result = string.Join(", ", users.Select(u => u.ToUpper()));

This transforms each item before combining it.

Pattern: join validation errors

var errors = new List<string>();

if (string.IsNullOrWhiteSpace(email))
    errors.Add("Email is required");

if (password.Length < 8)
    errors.Add("Password must be at least 8 characters");

 errorMessage = .Join(, errors);

1. Building the string manually in a loop

Beginners often do this:

string result = "";
foreach (string name in names)
{
    result += name + ", ";
}

Problem:

• It adds an extra delimiter at the end.
• Repeated string concatenation is less clean.

Better:

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

2. Forgetting that null items may exist

List<string> names = new List<string> { "John", null, "Anna" };
string result = string.Join(", ", names);

This may produce an empty spot in the output, such as:

John, , Anna

If that is not what you want, filter first:

string result = string.Join(, names.Where(n => !.IsNullOrWhiteSpace(n)));

vs

// Basic usage
string result = string.Join(", ", names);

// With array
string result2 = string.Join(" | ", colors);

// With numbers
string result3 = string.Join("-", numbers);

// Skip null or empty values
string result4 = string.Join(", ", names.Where(n => !string.IsNullOrWhiteSpace(n)));

// Safe when collection may be null
string result5 = string.Join(", ", names ?? new List<string>());

Quick rules:

• Use string.Join(separator, collection) to combine values.
• The separator goes between items.
• No extra separator is added at the end.
• string.Concat does not add separators.
• Filter values first if you want to remove empty or null items.
• Use ?? if the collection might be null.

What is the easiest way to convert a list of strings to one string in C#?

Use:

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

Does string.Join work with lists and arrays?

Yes. It works with arrays, lists, and other collections.

Can I use string.Join with integers or other types?

Yes. Values can be converted to strings automatically.

How do I remove empty items before joining?

Use LINQ:

string result = string.Join(", ", names.Where(n => !string.IsNullOrWhiteSpace(n)));

What is the difference between string.Join and string.Concat?

string.Join adds a separator between items. string.Concat does not.

Does string.Join add a comma at the end?

No. It only inserts the separator between elements.

What if my list is null?

• List<T> — the generic collection type commonly used to store strings before joining them.
• arrays — another common collection type that works with string.Join.
• string.Concat — similar string-combining method, but without a delimiter.
• LINQ Where — useful for filtering out null or empty values before joining.
• LINQ Select — useful for transforming items before joining.
• null handling — important when the collection or its items may be missing.
• StringBuilder — useful when building more complex strings manually.
• string formatting — related because joined strings are often part of formatted output.