C# String CopyTo() Method

What You’ll Learn

The instance method CopyTo() copies characters from a string into a char[] array. Unlike Copy(), which returns a new string, CopyTo() writes into a buffer you provide—useful when you need to work with individual characters, copy only part of a string, or fill a specific slot in a larger array.

Definition and Usage

In C#, CopyTo() transfers characters from a string into a char[] destination. You choose where reading starts in the string (sourceIndex), where writing starts in the array (destinationIndex), and how many characters to copy (count).

Because C# strings are immutable, CopyTo() does not change the original string—it only reads from it. The destination array is mutable, so you can modify copied characters afterward (for example, encrypting or normalizing them) before building a new string with new string(buffer).

📝 Syntax

The single overload on System.String:

public void CopyTo(int sourceIndex, char[] destination, int destinationIndex, int count);

Parameters

• sourceIndex — zero-based index in the string where copying begins.
• destination — the char[] that receives characters. Must not be null.
• destinationIndex — zero-based index in the array where writing begins.
• count — number of characters to copy.

Return Value

void — no return value. Results appear in the destination array.

Examples Gallery

Run with dotnet run. Each example shows a practical use of CopyTo()—from copying an entire string to partial ranges, buffer offsets, and comparison with ToCharArray().

using System;

class Program {
    static void Main() {
        string sampleString = "C# is powerful!";

        char[] charArray = new char[sampleString.Length];

        sampleString.CopyTo(0, charArray, 0, sampleString.Length);

        Console.WriteLine("Copied characters:");
        Console.WriteLine(charArray);
    }
}

Copied characters:
C# is powerful!

using System;

class Program {
    static void Main() {
        string text = "C# Programming";

        // Copy "Program" — starts at index 3, length 7
        char[] slice = new char[7];
        text.CopyTo(3, slice, 0, 7);

        Console.WriteLine(new string(slice));
    }
}

Program

using System;

class Program {
    static void Main() {
        string first  = "Hello";
        string second = "C#";

        char[] buffer = new char[20];
        buffer[5] = '-';  // separator at index 5

        first.CopyTo(0, buffer, 0, first.Length);
        second.CopyTo(0, buffer, 6, second.Length);

        Console.WriteLine(new string(buffer).TrimEnd('\0'));
    }
}

Hello-C#

using System;

class Program {
    static void Main() {
        string word = "Copy";

        // Simple — entire string to new array
        char[] viaToCharArray = word.ToCharArray();

        // Explicit — same result for full copy
        char[] viaCopyTo = new char[word.Length];
        word.CopyTo(0, viaCopyTo, 0, word.Length);

        Console.WriteLine($"ToCharArray: {new string(viaToCharArray)}");
        Console.WriteLine($"CopyTo:      {new string(viaCopyTo)}");
    }
}

ToCharArray: Copy
CopyTo:      Copy

using System;

class Program {
    static void Main() {
        string original = "secret";

        char[] buffer = new char[original.Length];
        original.CopyTo(0, buffer, 0, original.Length);

        // Mask every character (arrays are mutable)
        for (int i = 0; i < buffer.Length; i++) {
            buffer[i] = '*';
        }

        string masked = new string(buffer);
        Console.WriteLine($"Original: {original}");
        Console.WriteLine($"Masked:   {masked}");
    }
}

Original: secret
Masked:   ******

🚀 Common Use Cases

• Character-level processing — analyze or transform text one character at a time in an array.
• Partial extraction — copy a slice without calling Substring() first.
• Shared buffers — fill a pre-allocated array used by APIs expecting char[].
• Combining segments — write multiple strings into one buffer at different offsets.
• Interop scenarios — legacy code or libraries that read/write character arrays directly.

📝 Notes

• CopyTo() returns void—results appear in the destination array.
• destination must not be null (ArgumentNullException).
• Ensure destinationIndex + count <= destination.Length and sourceIndex + count <= string.Length.
• Negative indices or negative count throw ArgumentOutOfRangeException.
• The original string is never modified—only read from.
• For a full copy with no offset needs, ToCharArray() is often simpler.

⚡ Optimization

CopyTo() is efficient for bulk character transfer. When copying repeatedly into the same buffer, reuse the char[] instead of allocating a new array each time. For modern .NET code that only reads characters, consider ReadOnlySpan<char> as an alternative that avoids heap allocation. For beginners and typical apps, CopyTo() and ToCharArray() are both fine choices.

💡 Best Practices