Every application works with text — and strings are how .NET represents it.

Imagine you're building a login form. The user types a username, an email address, maybe a password. Behind every input box is a string — a sequence of characters that travels from the screen into your application, gets validated, stored, searched, and displayed back.

In C#, string is one of the most used types. It looks simple, but it hides a lot of important behaviour. Understanding how strings work — and how to avoid the most common performance traps — is one of the most useful skills you can develop early.

In this lesson, you'll learn what strings really are, why they're immutable, how to manipulate them safely, and when to use StringBuilder or modern span-based APIs.

What Is It?

The Simple Explanation

A string is a sequence of characters. It can be a single word, a sentence, a JSON payload, a file path — anything made of text.

The Technical Definition

string in C# is an alias for System.String, a reference type that represents a sequence of UTF-16 code units. It is immutable, which means once a string is created, its contents can never change.

Some important facts:

• Index-based — you access individual characters with [index], starting at 0.
• Length property — string.Length gives the number of characters.
• Can be empty — string.Empty or "".
• Can be null — null means no string object exists.
• Unicode-aware — strings can hold letters, symbols, emoji, and characters from any language.

Why Does It Exist?

The Problem

Computers fundamentally work with numbers. But users, files, networks, and APIs work with text. Somewhere there must be a bridge between raw numeric data and meaningful human-readable information.

Text is also tricky:

• It can be variable-length — from one character to millions.
• It has encoding concerns — different systems use different character encodings.
• It needs culture-aware operations — sorting, casing, and comparison depend on language.
• It needs to be safe and efficient — text processing is common, and naive implementations can be very slow.

The Solution

The .NET framework provides a rich string type, a mutable builder (StringBuilder), and modern low-allocation APIs (ReadOnlySpan<char>, SearchValues<char>) to handle all of these concerns.

The most important design decision is immutability — strings cannot change after creation. This gives us thread safety, simpler reasoning, and the ability to share string data without fear of accidental mutation.

Big Picture

Here's how text flows through a typical .NET application:

At the center of all this is the string object. Understanding its behaviour is essential to writing correct and performant text-processing code.

How It Works

Let's trace what happens when you create and modify strings.

Step 1 — A string is created

string greeting = "Hello";

The runtime allocates a block of memory on the managed heap to hold the characters H, e, l, l, o. The variable greeting holds a reference to that object.

Step 2 — Modifying creates a new string

string name = greeting + " Buddy";

Because strings are immutable, this does not change the original "Hello". Instead, the compiler calls String.Concat, which allocates a new string that contains "Hello Buddy". The original string remains unchanged in memory.

Step 3 — Assignment updates the reference

greeting = greeting + " Buddy";

Now the variable greeting points to the new string. The old "Hello" string may become garbage and eventually be collected by the Garbage Collector.

Step 4 — Many edits need a mutable builder

var builder = new StringBuilder();
for (int i = 0; i < 10; i++)
{
    builder.Append(i);
}
string result = builder.ToString();

StringBuilder maintains an internal mutable buffer. Each Append writes into that buffer without creating a new string until you call ToString(). This is dramatically more efficient for loops.

Step 5 — Encoding bridges memory and I/O

In memory, a string is stored as UTF-16 code units. When writing to a file or sending over the network, you usually convert to UTF-8 using Encoding.UTF8.GetBytes(...). The reverse process uses Encoding.UTF8.GetString(...). This encoding step is where many real-world text bugs appear.

Simple Example

using System.Text;

string firstName = "Ada";
string lastName = "Lovelace";

// String interpolation (modern C#)
string fullName = $"{firstName} {lastName}";
Console.WriteLine(fullName);          // Ada Lovelace

Console.WriteLine(fullName.Length);   // 12
Console.WriteLine(fullName.ToUpperInvariant()); // ADA LOVELACE

// Mutable building with StringBuilder
var builder = new StringBuilder();
for (int i = 0; i < 5; i++)
{
    builder.Append(i);
}
string result = builder.ToString();
Console.WriteLine(result);            // 01234

Code → Meaning → Result

• $"{firstName} {lastName}" — creates a new string using interpolation.
• Length — returns the number of characters.
• ToUpperInvariant() — returns an uppercase copy; the original is unchanged.
• StringBuilder.Append — mutates internal buffer, then ToString() creates one final string.

Real-World Example

Imagine an e-commerce system generating an order confirmation message. You need to combine a customer name, order ID, and total into a human-readable email:

string customer = "Grace";
int orderId = 1024;
decimal total = 249.99m;

string message = $"""
    Dear {customer},

    Your order {orderId} has been confirmed.
    Total: {total:C}
    """;

Console.WriteLine(message);

This uses a raw string literal (C# 11+), which lets you write multi-line text without escaping quotes or newline characters. Interpolation with {total:C} formats the decimal as currency using the current culture.

If this message were built by concatenating many pieces inside a loop, using string += would allocate a new string on every iteration. Instead, a production system would likely use StringBuilder for the loop, then interpolation for the final template.

Analogy

Under the Hood

What actually happens inside the .NET runtime when you work with strings?

C# 14 and .NET 10 do not change the fundamental string model. The underlying object is still an immutable UTF-16 sequence. However, modern C# (11+) introduced raw string literals, UTF-8 string literals, and performance-oriented APIs like spans continue to be the recommended way to handle high-performance text processing.

Common Confusion

1. string vs StringBuilder

Many beginners assume string can be modified because code like name += "!" appears to change the variable. It doesn't — it creates a new string and reassigns the reference.

2. == vs .Equals()

For most reference types, == compares references. But string overloads == to compare values. So both a == b and a.Equals(b) return true if the content is identical, even if the objects are different references.

string a = "test";
string b = "te" + "st";
Console.WriteLine(a == b);       // True
Console.WriteLine(a.Equals(b));   // True

3. null vs empty vs whitespace

These are different states:

• null — no string object exists at all.
• "" or string.Empty — a valid string with zero characters.
• " " — a string that contains whitespace characters.

string? nullable = null;
string empty = "";
string whitespace = "   ";

Console.WriteLine(string.IsNullOrEmpty(nullable));        // True
Console.WriteLine(string.IsNullOrEmpty(empty));           // True
Console.WriteLine(string.IsNullOrWhiteSpace(whitespace)); // True
Console.WriteLine(string.IsNullOrEmpty(whitespace));      // False

4. char vs string

A char uses single quotes and represents one UTF-16 code unit. A string uses double quotes and represents a sequence.

char letter = 'A';      // one character
string text = "A";      // a sequence of one character

Common Mistakes

Mistake 1 — Using += inside a loop

Wrong:

string result = "";
for (int i = 0; i < 10000; i++)
{
    result += i.ToString();   // new string allocated every iteration!
}

Correct:

var builder = new StringBuilder();
for (int i = 0; i < 10000; i++)
{
    builder.Append(i);
}
string result = builder.ToString();

This can be orders of magnitude faster.

Mistake 2 — Forgetting culture when casing/comparing

Using ToLower() or ToUpper() for internal identifiers can create culture-specific surprises (e.g., Turkish İ problem).

Use ToLowerInvariant(), ToUpperInvariant(), or specify StringComparison.Ordinal for identifiers and keys. Use culture-aware methods only for user-facing text.

Mistake 3 — Not handling null before calling methods

Calling .Length or .ToUpper() on a null string throws NullReferenceException.

Check with string.IsNullOrEmpty or string.IsNullOrWhiteSpace first, or use null-conditional access name?.Length.

Mistake 4 — Using string methods for high-performance scanning

Calling string.Contains, Split, or repeated IndexOf in a hot loop can allocate unnecessarily.

In .NET 8+, use SearchValues<char> and ReadOnlySpan<char> for zero-allocation parsing and scanning.

using System.Buffers;

ReadOnlySpan<char> text = "Hello, World!".AsSpan();
SearchValues<char> vowels = SearchValues.Create("aeiouAEIOU");
int count = 0;
foreach (var ch in text)
{
    if (vowels.Contains(ch)) count++;
}
Console.WriteLine(count); // 3

When Should I Use It?

Use plain string when:

• Working with user input, API responses, or simple display text
• Performing one-off concatenation or formatting
• You need thread safety without extra locks
• The text is short or modifications are few

Use StringBuilder when:

• Building a large string inside a loop
• Constructing text dynamically with many pieces
• Performance matters in a text-heavy operation (e.g., log generation, CSV export)

Use ReadOnlySpan<char> / SearchValues when:

• Parsing or scanning large strings in performance-critical code
• You want to avoid heap allocations
• Working with substrings without copying

When string handling might be overkill:

• If you're processing raw binary data, consider byte[] or Stream first
• If you need mutable character buffers with fixed size, char[] may be simpler
• For extremely high-performance text processing, consider specialized libraries or direct native interop

Mental Model

Key Takeaway

Check Your Understanding

You've seen how strings work, why immutability matters, and how to choose the right text tool for the job. Let's see if you can apply this knowledge.

string a = "hello";
string b = a;
b = b + " world";
Console.WriteLine(a);

You now have a clear mental model of strings and text in .NET — from immutable strings to high-performance span-based scanning!

dotnetmadeeasy.com — Learn C# and .NET, the right way.