C# String: Length, Vergleich, Escape-Zeichen, Verbatim- und mehrzeilige Strings

Ein string ist in C# eine Folge von UTF-16-Zeichen (char-Werten). Er ist ein Referenztyp, verhält sich aber in den entscheidenden Punkten wie ein Wert: Er ist unveränderlich, und == vergleicht den Text statt der Objektidentität. string ist das C#-Schlüsselwort für den .NET-Typ System.String; beide sind austauschbar.

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");
    }
}

Ausgabe:

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

Strings sind unveränderlich

Keine Methode ändert einen String an Ort und Stelle. ToUpper, Replace, Trim und jede andere Methode geben einen neuen String zurück und lassen das Original unangetastet. Den Rückgabewert zu vergessen ist ein sehr häufiger 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);
    }
}

Ausgabe:

[  maya  ]
[MAYA]
tea
tea and cake

Durch die Unveränderlichkeit lassen sich Strings sicher zwischen Threads teilen und als Dictionary-Schlüssel verwenden. Der Preis: Wer einen String in einer Schleife Stück für Stück aufbaut, erzeugt bei jedem Schritt einen neuen String; dafür nimmst du StringBuilder.

Length und Indizierung

Length ist eine Property (ohne Klammern). Der Indexer s[i] gibt den char an Position i zurück, gezählt ab 0, und ist schreibgeschützt:

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));
    }
}

Ausgabe:

7
A
1
IndexOutOfRangeException
XB-2931

Ab C# 8 geht auch ein Index vom Ende aus: code[^1] ist das letzte Zeichen, dasselbe wie code[code.Length - 1]. Um mehrere Zeichen auf einmal zu nehmen, siehe Substring.

Length zählt UTF-16-Codeeinheiten, nicht das, was ein Leser als Zeichen wahrnimmt. Die meisten Buchstaben der meisten Sprachen sind eine Einheit, aber Emojis und einige seltene Schriften brauchen zwei (ein Surrogatpaar), daher ist "👍".Length gleich 2.

Strings vergleichen

== und != vergleichen die Zeichen und beachten Groß- und Kleinschreibung. Für alles andere übergibst du einen StringComparison-Wert, der festlegt, wie verglichen wird:

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
    }
}

Ausgabe:

False
False
True
True
apple first
True
False
False
True

Welcher Vergleich wann passt:

• Ordinal vergleicht die numerischen Zeichencodes. Das ist schnell, vorhersagbar und auf jedem Rechner gleich. Nimm es für Bezeichner, Dateinamen, Schlüssel, Protokollwerte und alles, was keinem Menschen angezeigt wird.
• OrdinalIgnoreCase ist dasselbe, ohne Beachtung der Schreibweise. Die richtige Wahl für Prüfungen ohne Groß- und Kleinschreibung, etwa bei Dateiendungen oder HTTP-Headern.
• CurrentCulture (und CurrentCultureIgnoreCase) folgt den Regeln der Sprache des Benutzers und sortiert Wörter also so, wie es ein Wörterbuch in dieser Sprache tun würde. Nimm es zum Sortieren von Listen, die Benutzern angezeigt werden.
• InvariantCulture verwendet kulturabhängige Regeln, die nicht von den Spracheinstellungen des Benutzers abhängen. Es hängt trotzdem von der Globalisierungsbibliothek ab: Modernes .NET nutzt ICU, .NET Framework nutzt Windows NLS, und beide können manche Strings unterschiedlich ordnen.

string.Compare(a, b) und a.CompareTo(b) ohne StringComparison verwenden die aktuelle Kultur, wodurch ihre Ergebnisse von Rechner zu Rechner variieren. Vermeide Vergleiche wie a.ToLower() == b.ToLower(): Sie erzeugen zwei neue Strings und liefern in manchen Kulturen falsche Ergebnisse (das türkische i mit und ohne Punkt ist der klassische Fall).

a.Equals(b) wirft eine NullReferenceException, wenn a null ist, während a == b und das statische string.Equals(a, b) sicher mit null umgehen.

Escape-Zeichen

In einem normalen String-Literal leitet ein Backslash eine Escape-Sequenz ein:

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");
    }
}

Ausgabe:

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

Eine unbekannte Sequenz wie "\d" ist ein Kompilierfehler (CS1009, unrecognized escape sequence). Genau das passiert, wenn ein Windows-Pfad oder ein regulärer Ausdruck als normaler String geschrieben wird.

Verbatim-Strings und mehrzeilige Strings

Ein vorangestelltes @ macht ein Literal zum Verbatim-String: Backslashes sind wörtliche Zeichen, und der String darf sich über mehrere Zeilen erstrecken. Die einzige verbleibende Escape-Sequenz ist "", die ein doppeltes Anführungszeichen erzeugt.

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);
    }
}

Ausgabe:

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

Ein mehrzeiliger Verbatim-String enthält alles zwischen den Anführungszeichen, auch die Einrückung der Folgezeilen. Deshalb werden sie meist wie oben bündig am linken Rand geschrieben. Die enthaltenen Zeilenumbrüche sind die aus der Quelldatei, eine mit Windows-Zeilenenden gespeicherte Datei erzeugt also \r\n.

C# 11 hat Raw-String-Literale eingeführt, die beide Probleme lösen. Sie beginnen und enden mit drei oder mehr doppelten Anführungszeichen, brauchen überhaupt kein Escaping und entfernen die Einrückung, um die die schließenden Anführungszeichen eingerückt sind:

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

Enthält der Inhalt selbst """, beginne und ende stattdessen mit vier Anführungszeichen. Raw-Literale lassen sich auch mit Interpolation kombinieren ($"""..."""); siehe String-Interpolation.

Null, leer und Leerraum

Eine String-Variable kann null sein (gar kein String), leer ("", Länge 0) oder nur Leerraum enthalten. Zwei statische Hilfsmethoden prüfen diese Fälle ohne Risiko einer 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 == "");
    }
}

Ausgabe:

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

Zur Validierung von Benutzereingaben ist string.IsNullOrWhiteSpace fast immer die richtige Wahl. string.Empty und "" sind derselbe Wert; was du schreibst, ist Stilfrage.

Schleifen über Zeichen

Ein String ist aufzählbar, also besucht foreach jeden char. Der Typ char hat statische Methoden, um Zeichen zu klassifizieren:

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();
    }
}

Ausgabe:

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

Strings verbinden

+ verkettet und funktioniert mit jedem Typ auf der anderen Seite (es ruft ToString() auf). Um viele Werte zu kombinieren, nimm lieber Interpolation oder 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"
    }
}

Ausgabe:

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

Die letzten beiden Zeilen zeigen eine Falle bei der Rangfolge: + wird von links nach rechts ausgewertet, sobald die linke Seite also ein String ist, ist jedes folgende + eine Verkettung. Setze Arithmetik innerhalb einer Verkettung in Klammern.