C# String Concat() Method

What You’ll Learn

The static String.Concat() method joins two or more strings into a single new string. Because C# strings are immutable, the originals stay unchanged—you always assign or use the returned result. It is one of the core tools for building messages, labels, and formatted output.

Definition and Usage

In C#, string.Concat() combines string arguments in order and returns one new string. It is declared as a static method on the String class, so you call it as string.Concat(a, b) rather than on an instance.

Overloads accept two, three, or four strings directly; a params string[] for any number of arguments; and IEnumerable<T> for collections where each element is converted with ToString(). This flexibility makes Concat() handy when the number of pieces is not fixed at compile time.

📝 Syntax

Common overloads on System.String:

public static string Concat(string str0, string str1);
public static string Concat(string str0, string str1, string str2);
public static string Concat(params string[] values);
public static string Concat<T>(IEnumerable<T> values);

Parameters

• String arguments — text pieces to join in order. null is treated as String.Empty.
• params string[] values — variable number of strings: Concat("a", "b", "c").
• IEnumerable<T> values — each item converted via ToString() before joining.

Return Value

A new string containing all parts concatenated. Original strings are not modified.

Examples Gallery

Run with dotnet run. Each example shows a practical way to join strings—from simple names to arrays, alternatives, and performance-conscious patterns.

using System;

class Program {
    static void Main() {
        string firstName = "John";
        string lastName  = "Doe";

        string fullName = string.Concat(firstName, " ", lastName);

        Console.WriteLine($"Full Name: {fullName}");
    }
}

Full Name: John Doe

using System;

class Program {
    static void Main() {
        string greeting = string.Concat(
            "Hello", ", ", "C#", " ", "World", "!");

        Console.WriteLine(greeting);
    }
}

Hello, C# World!

using System;

class Program {
    static void Main() {
        string[] words = { "Learn", "C#", "Strings" };

        string sentence = string.Concat(words);
        string spaced = string.Join(" ", words);

        Console.WriteLine($"Concat: {sentence}");
        Console.WriteLine($"Join:   {spaced}");
    }
}

Concat: LearnC#Strings
Join:   Learn C# Strings

using System;

class Program {
    static void Main() {
        string lang = "C#";
        int version = 12;

        string viaConcat  = string.Concat("Language: ", lang, ", Version: ", version.ToString());
        string viaPlus    = "Language: " + lang + ", Version: " + version;
        string viaInterp  = $"Language: {lang}, Version: {version}";

        Console.WriteLine(viaConcat);
        Console.WriteLine(viaPlus);
        Console.WriteLine(viaInterp);
    }
}

Language: C#, Version: 12
Language: C#, Version: 12
Language: C#, Version: 12

using System;
using System.Text;

class Program {
    static void Main() {
        StringBuilder builder = new StringBuilder();

        for (int i = 1; i <= 5; i++) {
            builder.Append("Item ");
            builder.Append(i);
            builder.Append(", ");
        }

        string result = builder.ToString().TrimEnd(',', ' ');
        Console.WriteLine(result);
    }
}

Item 1, Item 2, Item 3, Item 4, Item 5

🚀 Common Use Cases

• Full names and labels — join first name, space, and last name.
• Building file paths — combine folder and file name segments (consider Path.Combine for paths).
• Log messages — merge timestamp, level, and message text.
• Joining array elements — flatten a string[] without separators.
• CSV-like output — use Join when you need delimiters; Concat when you do not.

📝 Notes

• Concat() returns a new string—original arguments are never modified.
• null arguments become empty strings; they do not produce the text "null".
• Concat on a string[] joins with no separator—use Join for delimiters.
• For paths, prefer Path.Combine() over manual concatenation.
• In loops with many appends, use StringBuilder instead of repeated Concat.
• The + operator internally uses similar concatenation logic for strings.

⚡ Optimization

Concat() is efficient for a small, fixed number of strings because the runtime can compute the final size once and allocate a single result. Avoid calling Concat() or + on every iteration of a large loop—each call creates a new string and copies prior content. For that pattern, accumulate with StringBuilder or collect pieces in a List<string> and join once at the end with string.Join.

💡 Best Practices