Pages

Topics

Tools

↑↓navigate↵openescclose
All guides

Converting a Char Array to a String in C#

Learn the practical ways to convert a char array to a string in C#, including new string(), String.Concat, and StringBuilder, with performance and edge cases.

~4 min readC#
#C##char array#string conversion#String.Concat
Illustration of a C# char array being converted into a string, showing the transformation from individual characters to a single string object.

Converting a char[] to a string is a common operation in C#. The most direct way is to use the string constructor that accepts a char[], but other approaches exist and each has its own tradeoffs. This article covers the main conversion methods, their runtime behavior, and the conditions that should guide your choice.

The Direct Conversion with new string(char[])

The string class provides a constructor that takes a char[] and creates a new string from its contents. This is the simplest and most efficient way to perform the conversion when you already have the complete array.

csharp
char[] chars = { 'H', 'e', 'l', 'l', 'o' }; string result = new string(chars); Console.WriteLine(result); // Output: Hello

The constructor copies the characters into the internal string buffer. Because strings are immutable, the resulting string is independent of the original array. If you modify chars after creating the string, the string remains unchanged. This behavior is important when the array is reused later.

This approach works in all .NET versions and is the idiomatic way to perform a one-time conversion. It also handles an empty array correctly, producing string.Empty.

Using string.Concat and string.Join

The static string.Concat method has an overload that accepts a char[] and returns a string. In current .NET implementations, it performs the same kind of copy as the constructor, so the result is identical for a complete array.

csharp
char[] chars = { 'W', 'o', 'r', 'l', 'd' }; string result = string.Concat(chars);

string.Join can also convert a char[] if you provide a separator, but that adds the separator between each character, which is rarely what you want for a direct conversion. For example, string.Join("", chars) works but is less efficient because it goes through a join routine. Prefer new string(chars) or string.Concat(chars) when no separator is needed.

When to Use StringBuilder

If you are building a string incrementally from characters, StringBuilder is the appropriate tool. It is not designed for a one-time conversion from an existing array, but it becomes relevant when you append characters in a loop and then convert the result.

csharp
char[] chars = { 'a', 'b', 'c' }; var builder = new StringBuilder(); foreach (char c in chars) { builder.Append(c); } string result = builder.ToString();

This is more verbose and slower than the direct constructor for a complete array. Use StringBuilder only when you are assembling a string over multiple steps, such as parsing a stream or building a message piece by piece. For a simple array-to-string conversion, it adds unnecessary overhead.

Performance and Memory Behavior

The new string(char[]) constructor performs a single allocation for the string and copies the characters. The time is proportional to the array length. string.Concat(char[]) does the same kind of work, so there is no practical performance difference between the two for a complete array.

string.Join with an empty separator goes through extra steps to handle separators and enumeration, even though the result is identical. If you are converting a large array frequently, new string(char[]) is the most direct path and avoids the overhead of a join operation.

StringBuilder allocates internal buffers that grow as you append. For a one-time conversion, that means additional allocations and copying compared to the direct constructor. If you already have the full array, there is no reason to use StringBuilder for the conversion itself.

One subtle point: the string constructor copies the array contents into the new string. On runtimes that expose the string(ReadOnlySpan<char>) constructor, you can avoid an intermediate char[] if you already have a span, but the resulting string is still a copy. For most scenarios, the standard constructor is sufficient.

Handling Null, Empty, and Large Arrays

Passing a null array to new string(char[]) throws ArgumentNullException. If you have a method that may receive null, check for it explicitly or use the null-coalescing operator to provide a default.

csharp
char[]? chars = GetChars(); string result = chars == null ? string.Empty : new string(chars);

An empty array produces string.Empty, which is a cached instance, so no new allocation occurs. This is a convenient property when you often deal with empty inputs.

For very large arrays, the conversion allocates a string of the same length, so memory usage doubles temporarily. If the array is no longer needed after conversion, you can let it go out of scope to allow garbage collection. If you are converting many large arrays in a loop, consider reusing buffers or using Span<char> to reduce allocations, but only if profiling shows a real problem.

Choosing the Right Approach for Your Scenario

The decision depends on whether you already have the complete array and whether you need to build the string incrementally.

  • Use new string(char[]) when you have a complete char[] and want a one-time conversion. It is the clearest and most efficient option.
  • Use string.Concat(char[]) if you prefer a static method call, but the result is identical to the constructor.
  • Use StringBuilder when you are appending characters over time and only need the final string at the end.
  • Avoid string.Join for this purpose unless you actually need a separator between characters.

A practical scenario where this matters is reading a character buffer from a stream or a network socket. If the buffer is already filled, new string(buffer, startIndex, count) lets you convert a portion of the array without copying the whole thing. This overload is useful when the array is larger than the actual data.

csharp
char[] buffer = new char[1024]; int read = ReadFromStream(buffer); string content = new string(buffer, 0, read);

This avoids allocating a temporary array for the exact length and is the preferred way to handle partial buffers. Unlike string.Concat, the string constructor has a range overload, so the constructor is the right choice here.

Understanding these conversion paths helps you write code that is both clear and efficient, especially when working with character data at the boundaries of your application.

Try matching browser tools

All tools

Small utilities that fit C# work — they run entirely in this browser tab, so nothing you paste leaves your device.

All C# guides

More in C#

All C# guides

The guides filed next to this one in C#, in library order.