String w C#: Length, porównywanie, znaki ucieczki, stringi dosłowne i wieloliniowe

string w C# to ciąg znaków UTF-16 (wartości char). To typ referencyjny, ale w istotnych kwestiach zachowuje się jak wartość: jest niemutowalny, a == porównuje tekst, a nie tożsamość obiektu. string to słowo kluczowe C# dla typu .NET System.String; obu można używać zamiennie.

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

Wynik:

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

Stringi są niemutowalne

Żadna metoda nie zmienia stringa w miejscu. ToUpper, Replace, Trim i każda inna metoda zwracają nowy string, a oryginał zostaje nietknięty. Zapominanie o użyciu zwracanej wartości to bardzo częsty błąd przy stringach:

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

Wynik:

[  maya  ]
[MAYA]
tea
tea and cake

Dzięki niemutowalności stringi można bezpiecznie współdzielić między wątkami i używać jako kluczy słownika. Kosztem jest to, że budowanie stringa kawałek po kawałku w pętli tworzy nowy string na każdym kroku; do tego służy StringBuilder.

Length i indeksowanie

Length to właściwość (bez nawiasów). Indeksator s[i] zwraca char na pozycji i, licząc od 0, i służy tylko do odczytu:

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

Wynik:

7
A
1
IndexOutOfRangeException
XB-2931

C# 8 i nowsze przyjmują też indeks liczony od końca: code[^1] to ostatni znak, to samo co code[code.Length - 1]. Żeby pobrać kilka znaków naraz, zobacz substring.

Length liczy jednostki kodowe UTF-16, a nie to, co czytelnik widzi jako znaki. Większość liter w większości języków to jedna jednostka, ale emoji i niektóre rzadkie pisma używają dwóch (para surogatów), więc "👍".Length wynosi 2.

Porównywanie stringów

== i != porównują znaki z rozróżnianiem wielkości liter. W każdym innym przypadku przekaż wartość StringComparison, która mówi, jak porównywać:

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

Wynik:

False
False
True
True
apple first
True
False
False
True

Którego porównania użyć:

• Ordinal porównuje liczbowe kody znaków. Jest szybkie, przewidywalne i takie samo na każdej maszynie. Używaj go dla identyfikatorów, nazw plików, kluczy, wartości protokołów i wszystkiego, czego nie pokazujesz człowiekowi.
• OrdinalIgnoreCase działa tak samo, ale ignoruje wielkość liter. To właściwy wybór do sprawdzeń bez rozróżniania wielkości liter, takich jak rozszerzenia plików czy nagłówki HTTP.
• CurrentCulture (i CurrentCultureIgnoreCase) stosuje reguły języka użytkownika, więc sortuje słowa tak, jak słownik w tym języku. Używaj go do sortowania list pokazywanych użytkownikom.
• InvariantCulture stosuje reguły zależne od kultury, które nie zależą od ustawień językowych użytkownika. Nadal zależy jednak od biblioteki globalizacji: współczesny .NET używa ICU, .NET Framework używa NLS z Windows, a te dwie mogą inaczej porządkować niektóre stringi.

string.Compare(a, b) i a.CompareTo(b) bez StringComparison używają bieżącej kultury, przez co ich wyniki różnią się między maszynami. Unikaj porównywania przez a.ToLower() == b.ToLower(): tworzy to dwa nowe stringi i w niektórych kulturach daje błędne odpowiedzi (klasycznym przykładem jest tureckie i z kropką i bez kropki).

Wywołanie a.Equals(b), gdy a jest null, rzuca NullReferenceException, a a == b i statyczne string.Equals(a, b) bezpiecznie obsługują null.

Znaki ucieczki

W zwykłym literale stringa ukośnik wsteczny rozpoczyna sekwencję ucieczki:

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

Wynik:

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

Nierozpoznana sekwencja, taka jak "\d", to błąd kompilacji (CS1009, unrecognized escape sequence), i właśnie to się dzieje, gdy ścieżkę Windows albo wyrażenie regularne zapiszesz jako zwykły string.

Stringi dosłowne i wieloliniowe

Poprzedzenie literału znakiem @ czyni go dosłownym (verbatim): ukośniki wsteczne są zwykłymi znakami, a string może zajmować kilka linii. Jedyną pozostałą sekwencją ucieczki jest "", która daje jeden cudzysłów.

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

Wynik:

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

Dosłowny string wieloliniowy zawiera wszystko między cudzysłowami, łącznie z wcięciem kolejnych linii, dlatego zwykle zapisuje się je przy samym marginesie, jak powyżej. Znaki końca linii w środku są takie jak w pliku źródłowym, więc plik zapisany z końcami linii Windows daje \r\n.

C# 11 dodał surowe literały stringów (raw string literals), które rozwiązują oba problemy. Zaczynają się i kończą trzema lub więcej cudzysłowami, w ogóle nie wymagają znaków ucieczki i usuwają wcięcie równe wcięciu cudzysłowów zamykających:

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

Jeśli sama treść zawiera """, zacznij i zakończ czterema cudzysłowami. Surowe literały łączą się też z interpolacją ($"""..."""); zobacz interpolacja stringów.

Null, pusty string i białe znaki

Zmienna typu string może mieć wartość null (brak stringa), być pusta ("", długość 0) albo zawierać same białe znaki. Dwie statyczne metody pomocnicze sprawdzają te przypadki bez ryzyka 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 == "");
    }
}

Wynik:

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

Przy walidacji danych od użytkownika prawie zawsze potrzebujesz string.IsNullOrWhiteSpace. string.Empty i "" to ta sama wartość; to, którą zapiszesz, jest kwestią stylu.

Przechodzenie po znakach

String jest enumerowalny, więc foreach odwiedza każdy char. Typ char ma statyczne metody do klasyfikowania znaków:

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

Wynik:

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

Łączenie stringów

+ łączy stringi i działa z dowolnym typem po drugiej stronie (wywołuje ToString()). Do łączenia wielu wartości lepsza jest interpolacja albo 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"
    }
}

Wynik:

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

Dwie ostatnie linie pokazują pułapkę kolejności działań: + jest obliczany od lewej do prawej, więc gdy lewa strona jest już stringiem, każdy kolejny + oznacza konkatenację. Arytmetykę wewnątrz konkatenacji otaczaj nawiasami.