Строки в C#: длина, сравнение, escape-последовательности, verbatim и многострочные строки

string в C# это последовательность символов UTF-16 (значений char). Это ссылочный тип, но в важных отношениях он ведёт себя как значение: он неизменяемый, а == сравнивает текст, а не идентичность объектов. string это ключевое слово C# для типа .NET System.String; они взаимозаменяемы.

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

Вывод:

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

Строки неизменяемы

Ни один метод не изменяет строку на месте. ToUpper, Replace, Trim и все остальные методы возвращают новую строку и не трогают исходную. Забыть использовать возвращаемое значение очень частая ошибка при работе со строками:

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

Вывод:

[  maya  ]
[MAYA]
tea
tea and cake

Неизменяемость делает строки безопасными для совместного использования между потоками и для использования в качестве ключей словаря. Цена в том, что сборка строки по частям в цикле создаёт новую строку на каждом шаге; для этого используйте StringBuilder.

Длина и индексация

Length это свойство (без скобок). Индексатор s[i] возвращает char в позиции i, считая с 0, и доступен только для чтения:

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

Вывод:

7
A
1
IndexOutOfRangeException
XB-2931

C# 8 и новее принимают также индекс с конца: code[^1] это последний символ, то же самое, что code[code.Length - 1]. Чтобы взять несколько символов сразу, см. подстроки.

Length считает кодовые единицы UTF-16, а не то, что читатель видит как символы. Большинство букв в большинстве языков занимают одну единицу, но эмодзи и некоторые редкие письменности используют две (суррогатную пару), поэтому "👍".Length равно 2.

Сравнение строк

== и != сравнивают символы с учётом регистра. Во всех остальных случаях передавайте значение StringComparison, которое говорит, как сравнивать:

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

Вывод:

False
False
True
True
apple first
True
False
False
True

Какое сравнение использовать:

• Ordinal сравнивает числовые коды символов. Он быстрый, предсказуемый и одинаковый на любой машине. Используйте его для идентификаторов, имён файлов, ключей, значений протоколов и всего, что не показывается человеку.
• OrdinalIgnoreCase то же самое, но без учёта регистра. Правильный выбор для проверок без учёта регистра, например расширений файлов или HTTP-заголовков.
• CurrentCulture (и CurrentCultureIgnoreCase) следует правилам языка пользователя, поэтому сортирует слова так, как это сделал бы словарь этого языка. Используйте его для сортировки списков, которые видят пользователи.
• InvariantCulture использует правила с учётом культуры, которые не зависят от языковых настроек пользователя. Он всё равно зависит от библиотеки глобализации: современный .NET использует ICU, .NET Framework использует NLS Windows, и они могут по-разному упорядочивать некоторые строки.

string.Compare(a, b) и a.CompareTo(b) без StringComparison используют текущую культуру, поэтому их результаты различаются на разных машинах. Не сравнивайте через a.ToLower() == b.ToLower(): это создаёт две новые строки и в некоторых культурах даёт неверные ответы (классический случай турецкие i с точкой и без точки).

Вызов a.Equals(b), когда a равно null, выбрасывает NullReferenceException, тогда как a == b и статический string.Equals(a, b) безопасно обрабатывают null.

Escape-последовательности

Внутри обычного строкового литерала обратный слеш начинает escape-последовательность:

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

Вывод:

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

Нераспознанная последовательность, например "\d", это ошибка компиляции (CS1009, unrecognized escape sequence), и именно это происходит, когда путь Windows или регулярное выражение записаны как обычная строка.

Verbatim-строки и многострочные строки

Префикс @ перед литералом делает его verbatim (буквальным): обратные слеши становятся обычными символами, а строка может занимать несколько строк. Остаётся только одно экранирование "", которое даёт одну двойную кавычку.

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

Вывод:

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

Многострочная verbatim-строка включает всё между кавычками, в том числе отступы строк продолжения, поэтому такие строки обычно пишут вплотную к левому краю, как выше. Переводы строк в ней те же, что в исходном файле, поэтому файл, сохранённый с окончаниями строк Windows, даёт \r\n.

C# 11 добавил необработанные строковые литералы (raw string literals), которые решают обе проблемы. Они начинаются и заканчиваются тремя или более двойными кавычками, вообще не требуют экранирования и убирают отступ, равный отступу закрывающих кавычек:

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

Если само содержимое содержит """, начинайте и заканчивайте четырьмя кавычками. Необработанные литералы сочетаются и с интерполяцией ($"""..."""); см. интерполяция строк.

null, пустая строка и пробелы

Строковая переменная может быть null (строки нет вообще), пустой ("", длина 0) или содержать только пробельные символы. Два статических метода проверяют эти случаи без риска получить 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 == "");
    }
}

Вывод:

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

Для проверки пользовательского ввода почти всегда нужен string.IsNullOrWhiteSpace. string.Empty и "" это одно и то же значение; что писать, дело стиля.

Перебор символов

Строка перечисляема, поэтому foreach проходит по каждому char. У типа char есть статические методы для классификации символов:

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

Вывод:

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

Соединение строк

+ выполняет конкатенацию и работает с любым типом с другой стороны (вызывая ToString()). Для объединения многих значений лучше подходит интерполяция или 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"
    }
}

Вывод:

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

Последние две строки показывают ловушку приоритета: + вычисляется слева направо, поэтому как только левая часть стала строкой, каждый следующий + это конкатенация. Заключайте арифметику внутри конкатенации в скобки.