C# String Copy() Method

What You’ll Learn

The static method string.Copy() creates a new string object with the same characters as an existing string. It copies the entire string—not a portion. For everyday C# code, simple assignment often suffices because strings are immutable, but Copy() is useful when you explicitly need a separate instance.

Definition and Usage

In C#, string.Copy() duplicates the full character sequence of a string into a newly allocated string object. It is declared as a static method: string.Copy(original).

Because C# strings are immutable, you cannot modify characters in place anyway—so many programs never call Copy() and simply write string copy = original. Use Copy() when you deliberately want a new object reference with identical text, or when mirroring API patterns from other .NET types.

📝 Syntax

The single overload on System.String:

public static string Copy(string str);

Parameters

• str — the source string whose characters are copied. Must not be null.

Return Value

A new string containing the same characters as str. The original string is unchanged.

Examples Gallery

Run with dotnet run. Each example shows how Copy() works and how it differs from assignment, Clone(), and Substring().

using System;

class Program {
    static void Main() {
        string original = "Hello ";
        string duplicate = string.Copy(original);

        Console.WriteLine($"Original:  '{original}'");
        Console.WriteLine($"Duplicate: '{duplicate}'");
        Console.WriteLine($"Same text: {original == duplicate}");
    }
}

Original:  'Hello '
Duplicate: 'Hello '
Same text: True

using System;

class Program {
    static void Main() {
        string original = new string(new char[] { 'H', 'i' });
        string copied   = string.Copy(original);

        Console.WriteLine($"ReferenceEquals: {ReferenceEquals(original, copied)}");
        Console.WriteLine($"Content equal:   {original == copied}");
    }
}

ReferenceEquals: False
Content equal:   True

using System;

class Program {
    static void Main() {
        string message = "Welcome to C#";

        string viaAssign = message;
        string viaCopy   = string.Copy(message);

        Console.WriteLine($"Assign — same ref: {ReferenceEquals(message, viaAssign)}");
        Console.WriteLine($"Copy   — same ref: {ReferenceEquals(message, viaCopy)}");
        Console.WriteLine($"Both readable: {viaAssign} | {viaCopy}");
    }
}

Assign — same ref: True
Copy   — same ref: False
Both readable: Welcome to C# | Welcome to C#

using System;

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

        string fullCopy = string.Copy(text);
        string partial  = text.Substring(3, 11);  // "Programming"

        Console.WriteLine($"Copy:      '{fullCopy}'");
        Console.WriteLine($"Substring: '{partial}'");
    }
}

Copy:      'C# Programming'
Substring: 'Programming'

using System;

class Program {
    static void Main() {
        string original = "Hello, C#!";

        object clonedObj = original.Clone();
        string copied    = string.Copy(original);

        Console.WriteLine($"Clone same ref: {ReferenceEquals(original, clonedObj)}");
        Console.WriteLine($"Copy same ref:  {ReferenceEquals(original, copied)}");
        Console.WriteLine($"Clone text: {(string)clonedObj}");
        Console.WriteLine($"Copy text:  {copied}");
    }
}

Clone same ref: True
Copy same ref:  False
Clone text: Hello, C#!
Copy text:  Hello, C#!

🚀 Common Use Cases

• Explicit duplication — when API design or tests require a distinct string instance.
• Legacy .NET code — older libraries may call String.Copy by convention.
• Defensive copies — rare for strings (immutable), but mirrors patterns used with mutable types.
• Learning object references — comparing Copy() with assignment in tutorials.
• Contrasting with CopyTo() — Copy() returns a string; CopyTo() writes into a char[].

📝 Notes

• Copy() duplicates the entire string—not a range. Use Substring() for portions.
• Passing null throws ArgumentNullException.
• For most apps, string b = a is sufficient because strings are immutable.
• Clone() on strings returns the same instance; Copy() creates a new one.
• Do not confuse Copy() with CopyTo(), which copies characters into a character array.
• String interning may cause literal assignments to share references—Copy() from a non-interned string avoids that sharing.

⚡ Optimization

Copy() allocates memory proportional to string length. Avoid calling it unnecessarily when assignment gives the same practical result. In tight loops over large collections, prefer passing strings by reference rather than copying each one with Copy(). For partial text, Substring() or spans may be more appropriate than copying the whole string first.

💡 Best Practices