C# String: Length, Compare, Escape Characters, Verbatim and Multiline Strings

A string in C# is a sequence of UTF-16 characters (char values). It is a reference type, but it behaves like a value in the ways that matter: it is immutable, and == compares the text rather than the object identity. string is the C# keyword for the .NET type System.String; the two are interchangeable.

using System;

class Program
{
    static void Main()
    {
        string city = "Porto";
        string empty = "";
        string repeated = new string('*', 5);
        char[] letters = { 'h', 'i' };
        string fromChars = new string(letters);

        Console.WriteLine(city);
        Console.WriteLine(city.Length);
        Console.WriteLine(empty.Length);
        Console.WriteLine(repeated);
        Console.WriteLine(fromChars);
        Console.WriteLine(city + " has " + city.Length + " letters");
    }
}

Output:

Porto
5
0
*****
hi
Porto has 5 letters

Strings are immutable

No method changes a string in place. ToUpper, Replace, Trim and every other method return a new string and leave the original untouched. Forgetting to use the return value is a very common string bug:

using System;

class Program
{
    static void Main()
    {
        string name = "  maya  ";

        name.Trim();          // result discarded: name is unchanged
        name.ToUpper();       // same
        Console.WriteLine($"[{name}]");

        name = name.Trim().ToUpper();   // assign the new string
        Console.WriteLine($"[{name}]");

        string original = "tea";
        string copy = original;
        copy += " and cake";   // creates a new string; original is not affected
        Console.WriteLine(original);
        Console.WriteLine(copy);
    }
}

Output:

[  maya  ]
[MAYA]
tea
tea and cake

Immutability makes strings safe to share between threads and to use as dictionary keys. The cost is that building a string piece by piece in a loop creates a new string at every step; for that, use StringBuilder.

Length and indexing

Length is a property (no parentheses). The indexer s[i] returns the char at position i, counting from 0, and is read-only:

using System;

class Program
{
    static void Main()
    {
        string code = "AB-2931";

        Console.WriteLine(code.Length);          // 7
        Console.WriteLine(code[0]);              // A
        Console.WriteLine(code[code.Length - 1]); // last character: 1

        // code[0] = 'X';   // error CS0200: the indexer is read-only

        try
        {
            char c = code[7];                    // valid indexes are 0..6
        }
        catch (IndexOutOfRangeException)
        {
            Console.WriteLine("IndexOutOfRangeException");
        }

        char[] chars = code.ToCharArray();       // to modify, copy into an array
        chars[0] = 'X';
        Console.WriteLine(new string(chars));
    }
}

Output:

7
A
1
IndexOutOfRangeException
XB-2931

C# 8 and later also accept an index from the end: code[^1] is the last character, the same as code[code.Length - 1]. To take several characters at once, see substring.

Length counts UTF-16 code units, not what a reader sees as characters. Most letters in most languages are one unit, but emoji and some rare scripts use two (a surrogate pair), so "👍".Length is 2.

Comparing strings

== and != compare the characters, case-sensitively. For anything else, pass a StringComparison value that says how to compare:

using System;

class Program
{
    static void Main()
    {
        string a = "Report.PDF";
        string b = "report.pdf";

        Console.WriteLine(a == b);                                   // False
        Console.WriteLine(a.Equals(b));                              // False
        Console.WriteLine(string.Equals(a, b, StringComparison.OrdinalIgnoreCase)); // True
        Console.WriteLine(a.Equals(b, StringComparison.OrdinalIgnoreCase));         // True

        // Ordering: negative, zero or positive
        int order = string.Compare("apple", "banana", StringComparison.Ordinal);
        Console.WriteLine(order < 0 ? "apple first" : "banana first");

        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.Ordinal) < 0);           // uppercase sorts first
        Console.WriteLine(string.Compare("Zoe", "adam", StringComparison.OrdinalIgnoreCase) < 0); // False

        string missing = null;
        Console.WriteLine(missing == "x");                           // False, no exception
        Console.WriteLine(string.Equals(missing, null));             // True
    }
}

Output:

False
False
True
True
apple first
True
False
False
True

Which comparison to use:

• Ordinal compares the numeric character codes. It is fast, predictable and the same on every machine. Use it for identifiers, file names, keys, protocol values and anything not shown to a person.
• OrdinalIgnoreCase is the same, ignoring case. The right choice for case-insensitive checks such as file extensions or HTTP headers.
• CurrentCulture (and CurrentCultureIgnoreCase) follows the rules of the user's language, so it sorts words the way a dictionary in that language would. Use it for sorting lists shown to users.
• InvariantCulture uses culture-aware rules that do not depend on the user's language settings. It still depends on the globalization library: modern .NET uses ICU, .NET Framework uses Windows' NLS, and the two can order some strings differently.

string.Compare(a, b) and a.CompareTo(b) without a StringComparison use the current culture, which makes their results vary between machines. Avoid comparing with a.ToLower() == b.ToLower(): it allocates two new strings, and it gives wrong answers in some cultures (the Turkish dotted and dotless i is the classic case).

Calling a.Equals(b) when a is null throws a NullReferenceException, while a == b and the static string.Equals(a, b) handle null safely.

Escape characters

Inside a regular string literal, a backslash starts an escape sequence:

using System;

class Program
{
    static void Main()
    {
        Console.WriteLine("Name:\tAna\nCity:\tPorto");
        Console.WriteLine("She said \"hi\"");
        Console.WriteLine("C:\\temp\\report.txt");
        Console.WriteLine("caf\u0065 = cafe");
        Console.WriteLine('\'' + " is a quote char");
    }
}

Output:

Name:	Ana
City:	Porto
She said "hi"
C:\temp\report.txt
cafe = cafe
' is a quote char

An unrecognized sequence such as "\d" is a compile error (CS1009, unrecognized escape sequence), which is what happens when a Windows path or a regular expression is written as a regular string.

Verbatim strings and multiline strings

Prefixing a literal with @ makes it verbatim: backslashes are literal characters, and the string may span several lines. The only escape left is "", which produces one double quote.

using System;

class Program
{
    static void Main()
    {
        string path = @"C:\Users\ana\Documents\notes.txt";
        string pattern = @"\d{3}-\d{4}";
        string quote = @"He said ""ready"" and left.";

        string address = @"Rua das Flores 12
4050-262 Porto
Portugal";

        Console.WriteLine(path);
        Console.WriteLine(pattern);
        Console.WriteLine(quote);
        Console.WriteLine(address);

        string lines = "first line" + Environment.NewLine + "second line";
        Console.WriteLine(lines);
    }
}

Output:

C:\Users\ana\Documents\notes.txt
\d{3}-\d{4}
He said "ready" and left.
Rua das Flores 12
4050-262 Porto
Portugal
first line
second line

A verbatim multiline string includes everything between the quotes, including the indentation of the continuation lines, which is why they are usually written flush against the margin as above. The line breaks it contains are the ones in the source file, so a file saved with Windows line endings produces \r\n.

C# 11 added raw string literals, which solve both problems. They start and end with three or more double quotes, need no escaping at all, and remove the indentation that the closing quotes are indented by:

// C# 11 and later
string json = """
    {
      "name": "Ana",
      "path": "C:\temp"
    }
    """;
// The 4 spaces before the closing """ are removed from every line.

If the content itself contains """, start and end with four quotes instead. Raw literals combine with interpolation too ($"""..."""); see string interpolation.

Null, empty and whitespace

A string variable can be null (no string at all), empty ("", length 0), or contain only whitespace. Two static helpers check these cases without risking a NullReferenceException:

using System;

class Program
{
    static void Main()
    {
        string[] inputs = { null, "", "   ", "Ana" };

        foreach (string s in inputs)
        {
            string shown = s == null ? "null" : $"\"{s}\"";
            Console.WriteLine($"{shown,-7} empty: {string.IsNullOrEmpty(s),-5}  blank: {string.IsNullOrWhiteSpace(s)}");
        }

        Console.WriteLine(string.Empty == "");
    }
}

Output:

null    empty: True   blank: True
""      empty: True   blank: True
"   "   empty: False  blank: True
"Ana"   empty: False  blank: False
True

For validating user input, string.IsNullOrWhiteSpace is almost always the one you want. string.Empty and "" are the same value; which one to write is style.

Looping over characters

A string is enumerable, so foreach visits each char. The char type has static methods to classify characters:

using System;

class Program
{
    static void Main()
    {
        string password = "Sunset2026!";
        int letters = 0, digits = 0, upper = 0, other = 0;

        foreach (char c in password)
        {
            if (char.IsLetter(c)) letters++;
            if (char.IsDigit(c)) digits++;
            if (char.IsUpper(c)) upper++;
            if (!char.IsLetterOrDigit(c)) other++;
        }

        Console.WriteLine($"letters={letters} digits={digits} upper={upper} symbols={other}");

        for (int i = password.Length - 1; i >= 0; i--)   // backwards with an index
        {
            Console.Write(password[i]);
        }
        Console.WriteLine();
    }
}

Output:

letters=6 digits=4 upper=1 symbols=1
!6202tesnuS

Joining strings

+ concatenates, and works with any type on the other side (it calls ToString()). For combining many values, prefer interpolation or string.Join:

using System;

class Program
{
    static void Main()
    {
        string first = "Ana", last = "Silva";
        int age = 31;

        Console.WriteLine(first + " " + last + ", " + age);
        Console.WriteLine($"{first} {last}, {age}");
        Console.WriteLine(string.Concat(first, last));
        Console.WriteLine(string.Join(" | ", "tea", "coffee", "juice"));
        Console.WriteLine("Total: " + 2 + 3);    // "Total: 23"
        Console.WriteLine("Total: " + (2 + 3));  // "Total: 5"
    }
}

Output:

Ana Silva, 31
Ana Silva, 31
AnaSilva
tea | coffee | juice
Total: 23
Total: 5

The last two lines show a precedence trap: + is evaluated left to right, so once the left side is a string, every following + is concatenation. Parenthesize arithmetic inside a concatenation.