C#: строки (Strings)

Содержание

Объединение (concatenation) строк
Сравнение строк
Поиск в строке и перечисление
Строковые операции
Конструирование строк
null и пустые строки
Методы манипулирования строками
Объединение и разбиение строк
Сравнение строк
StringBuilder
Кодировка
Форматирование и разбор (Formatting and Parsing)
Интернирование строк

Тип string (синоним System.String) представляет беспрерывную последовательность юникод символов. Строковые литералы указываются внутри двойных кавычек.

string a = "Heat";

1	string a = "Heat";

String — ссылочный тип, однако операторы отношений взаимодействуют со строками как со значимыми типами:

string a = "test", b = "test";
Console.Write (a == b); // True

1 2	string a = "test", b = "test"; Console.Write (a == b); // True

Управляющие последовательности, применимые к типу char, могут использоваться и внутри строк:

string a = "Here's a tab:\t";

1	string a = "Here's a tab:\t";

Недостаток этого в том, что если нужно использовать символ обратного слэша \, его нужно писать дважды (экранировать):

string a1 = "\\\\server\\fileshare\\helloworld.cs";

1	string a1 = "\\\\server\\fileshare\\helloworld.cs";

Чтобы избежать этой проблемы можно использовать дословные (буквальные, verbatim) строковые литералы. Эти литералы начинаются с символа @ и не поддерживают управляющих последовательностей. Они могут занимать несколько строк. Чтобы использовать внутри дословных литералов двойные кавычки их нужно писать дважды.

string a2 = @"\\server\fileshare\helloworld.cs";

1	string a2 = @"\\server\fileshare\helloworld.cs";

Объединение (concatenation) строк

Оператор + объединяет две строки:

string s = "a" + "b";

1	string s = "a" + "b";

Один из операндов может быть и не строкой. В этом случает для него скрыто будет вызван метод ToString:

string s = "a" + 5; // a5

1	string s = "a" + 5; // a5

Многократное использование оператора + для построения большой составной строки может быть не эффективным. Для этой цели лучше использовать тип System.Text.StringBuilder, который представляет динамически изменяющуюся строку и включает методы Append, Insert, Remove, и Replace.

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

Строки не поддерживают операторы < и >. Вместо них для сравнения строк нужно использовать строковой метод CompareTo, который возвращает 1 если первая строка предшествует второй, -1 если вторая строка предшествует первой и 0 если строки равны:

Console.Write ("Boston".CompareTo ("Austin")); // 1
Console.Write ("Boston".CompareTo ("Boston")); // 0
Console.Write ("Boston".CompareTo ("Chicago")); // -1

Console.Write ("Boston".CompareTo ("Austin")); // 1

Console.Write ("Boston".CompareTo ("Boston")); // 0

Console.Write ("Boston".CompareTo ("Chicago")); // -1

Поиск в строке и перечисление

Строковой индексатор возвращает символ с указанной позицией:

Console.Write ("word"[2]); // r

1	Console.Write ("word"[2]); // r

string реализует интерфейс IEnumerable<char>, поэтому по символам строки можно проходить с помощью foreach:

foreach (char c in "123") Console.Write (c + ","); // 1,2,3,

1	foreach (char c in "123") Console.Write (c + ","); // 1,2,3,

Простейшими методами для выполнения поиска в строке являются Contains, StartsWith, и EndsWith, все они возвращают true или false:

Console.WriteLine ("quick brown fox".Contains ("brown")); // True
Console.WriteLine ("quick brown fox".EndsWith ("fox")); // True

1 2	Console.WriteLine ("quick brown fox".Contains ("brown")); // True Console.WriteLine ("quick brown fox".EndsWith ("fox")); // True

Метод IndexOf возвращает позицию первого вхождения заданного символа или подстроки (или -1 если символ или подстрока не найдены):

Console.WriteLine ("abcde".IndexOf("cd")); // 2

1	Console.WriteLine ("abcde".IndexOf("cd")); // 2

Методы StartsWith, EndsWith и IndexOf перегружены и могут принимать enum StringComparison или объект CultureInfo, чтобы управлять чувствительность к регистру и культуре:

"abcdef".StartsWith("abc", StringComparison.InvariantCultureIgnoreCase)

1	"abcdef".StartsWith("abc", StringComparison.InvariantCultureIgnoreCase)

Метод IndexOf также может принимать startPosition — индекс, с которого должен начинаться поиск.

Метод LastIndexOf похож на IndexOf, но ищет начиная с конца строки.

Метод IndexOfAny возвращает позицию первого вхождения любого символа из набора, а метод LastIndexOfAny делает тоже самое в обратном направлении:

Console.Write ("ab,cd ef".IndexOfAny (new char[] {' ', ','} )); // 2
Console.Write ("pas5w0rd".IndexOfAny ("0123456789".ToCharArray() )); // 3

1 2	Console.Write ("ab,cd ef".IndexOfAny (new char[] {' ', ','} )); // 2 Console.Write ("pas5w0rd".IndexOfAny ("0123456789".ToCharArray() )); // 3

Строковые операции

Поскольку строка является неизменной, все ее методы возвращают новое значения, оставляя исходную строку нетронутой. Помимо указанных выше строка имеет следующие методы:

Substring — извлекает часть строки
Insert и Remove — вставляют и удаляют символы в указанную позицию
PadLeft и PadRight — добавляют пробелы в начали и конце строки
TrimStart, TrimEnd, и Trim удаляют пробелы
ToUpper и ToLower — преобразуют строку в верхний или нижний регистр
Split — разбивает строку на подстроки по переданному разделителю
Join — объединяет подстроки в строку

Конструирование строк

Простейший способ создать строку — это присвоение литерала:

string s1 = "Hello";

1	string s1 = "Hello";

Чтобы создать строку из повторяющейся последовательности символов можно использовать конструктор string:

Console.Write (new string ('*', 10)); // **********

1	Console.Write (new string ('', 10)); // *********

Строку можно сконструировать из массива char. Метод ToCharArray делает обратное:

char[] ca = "Hello".ToCharArray();
string s = new string (ca); // s = "Hello"

1 2	char[] ca = "Hello".ToCharArray(); string s = new string (ca); // s = "Hello"

null и пустые строки

Чтобы создать пустую строку можно использовать литерал, либо статическое поле string.Empty. Пустая строка имеет нулевую длину и ее свойство Length равно нулю:

string empty = "";
Console.WriteLine (empty == ""); // True
Console.WriteLine (empty == string.Empty); // True
Console.WriteLine (empty.Length == 0); // True

string empty = "";

Console.WriteLine (empty == ""); // True

Console.WriteLine (empty == string.Empty); // True

Console.WriteLine (empty.Length == 0); // True

Поскольку строки являются ссылочными типами они могут принимать значение null:

string nullString = null;
Console.WriteLine (nullString == null); // True
Console.WriteLine (nullString == ""); // False
Console.WriteLine (nullString.Length == 0); // NullReferenceException

string nullString = null;

Console.WriteLine (nullString == null); // True

Console.WriteLine (nullString == ""); // False

Console.WriteLine (nullString.Length == 0); // NullReferenceException

Статический метод string.IsNullOrEmpty позволяет проверить является ли строка null или пустой.

Методы манипулирования строками

Поскольку строка является неизменяемой, все методы манипулирующие строкой возвращают новую строку, оставляя исходную незатронутой.

Метод Substring извлекает часть строки:

string left3 = "12345".Substring (0, 3); // left3 = "123";
string mid3 = "12345".Substring (1, 3); // mid3 = "234";
string end3 = "12345".Substring (2); // end3 = "345";

string left3 = "12345".Substring (0, 3); // left3 = "123";

string mid3 = "12345".Substring (1, 3); // mid3 = "234";

string end3 = "12345".Substring (2); // end3 = "345";

Методы Insert и Remove вставляют либо удаляют символы в указанной позиции:

string s1 = "helloworld".Insert (5, ", "); // s1 = "hello, world"
string s2 = s1.Remove (5, 2); // s2 = "helloworld";

1 2	string s1 = "helloworld".Insert (5, ", "); // s1 = "hello, world" string s2 = s1.Remove (5, 2); // s2 = "helloworld";

Методы PadLeft и PadRight дополняют строку до заданной длины слева или справа указанным символом или пробелом если символ не указан. Если входная строка длиннее заданной длины для дополнения, исходная строка возвращается неизмененной:

Console.WriteLine ("12345".PadLeft (9, '*')); // ****12345
Console.WriteLine ("12345".PadLeft (9));      //     12345

1 2	Console.WriteLine ("12345".PadLeft (9, '')); // ***12345 Console.WriteLine ("12345".PadLeft (9)); // 12345

Методы TrimStart и TrimEnd удаляют указанные символы с начала или конца строки, а метод Trim с двух сторон. Если символ для удаления не указан, удаляется пробельные символы:

Console.WriteLine (" abc \t\r\n ".Trim().Length); // 3

1	Console.WriteLine (" abc \t\r\n ".Trim().Length); // 3

Метод Replace заменяет все непересекающиеся вхождения заданного символа или подстроки на другой символ или строку:

Console.WriteLine ("to be done".Replace (" ", " | ") ); // to | be | done
Console.WriteLine ("to be done".Replace (" ", "") ); // tobedone

1 2	Console.WriteLine ("to be done".Replace (" ", " \| ") ); // to \| be \| done Console.WriteLine ("to be done".Replace (" ", "") ); // tobedone

Методы ToUpper и ToLower возвращают версию входной строки в верхнем или нижнем регистре с учетом языковых настроек пользователя, а методы ToUpperInvariant и ToLowerInvariant без их учета.

Объединение и разбиение строк

Метод Split принимает предложение и возвращает массив слов. По умолчанию в качестве разделителей метод использует пробельные символы. Перегруженная версия может принимать массив разделителей char или string. Также метод может принимать enum StringSplitOptions, который имеет опцию для удаления пустых элементов.

string[] words = "The quick brown fox".Split();
foreach (string word in words)
Console.Write (word + "|"); // The|quick|brown|fox|

string[] words = "The quick brown fox".Split();

foreach (string word in words)

Статический метод Join выполняет действие противоположное методу Split. Он требует указания разделителя и строкового массива.

string[] words = "The quick brown fox".Split();
string together = string.Join (" ", words); // The quick brown fox

1 2	string[] words = "The quick brown fox".Split(); string together = string.Join (" ", words); // The quick brown fox

Статический метод Concat похож на Join, но принимает только строковой массив без разделителя. Он полностью эквивалентен операции +:

string sentence = string.Concat ("The", " quick", " brown", " fox");
string sameSentence = "The" + " quick" + " brown" + " fox";

1 2	string sentence = string.Concat ("The", " quick", " brown", " fox"); string sameSentence = "The" + " quick" + " brown" + " fox";

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

При сравнении строк применяются два базовых алгоритма:

ординальное сравнение — символы интерпретируются как числа согласно их числовым кодам в Unicode
сравнение чувствительно к культуре — символы интерпретируются со ссылкой на конкретный язык. Существует две специальные культуры: текущая культура — культура заданная в настройках конкретной машины; инвариантная культура — одинакова для всех компьютеров (американская культура)

Для сравнения эквивалентности строк можно использовать оператор == или один из методов Equals типа string. Последний существует в двух вариантах: статический и экземплярный. Статически метод полезен тем, что он работает, когда одна или обе строки равны null:

public bool Equals (string value, StringComparison comparisonType);
public static bool Equals (string a, string b, StringComparison comparisonType);

1 2	public bool Equals (string value, StringComparison comparisonType); public static bool Equals (string a, string b, StringComparison comparisonType);

Оператор == и метод string.Equals вызванный без параметров всегда выполняют ординальное сравнение, чувствительное к регистру. Метод string.Equals вызванный с дополнительным параметром StringComparison comparisonType может выполнять сравнение с учетом культуры и нечувствиетльное к регистру. StringComparison определен следующим образом:

public enum StringComparison
{
    CurrentCulture, // Чувствительное к регистру
    CurrentCultureIgnoreCase,
    InvariantCulture, // Чувствительное к регистру
    InvariantCultureIgnoreCase,
    Ordinal,
    OrdinalIgnoreCase
}

public enum StringComparison

{

CurrentCulture, // Чувствительное к регистру

CurrentCultureIgnoreCase,

InvariantCulture, // Чувствительное к регистру

InvariantCultureIgnoreCase,

Ordinal,

OrdinalIgnoreCase

}

Пример:

Console.WriteLine (string.Equals ("foo", "FOO",
                   StringComparison.OrdinalIgnoreCase)); // True
Console.WriteLine ("ṻ" == "ǖ"); // False
Console.WriteLine (string.Equals ("ṻ", "ǖ",
                   StringComparison.CurrentCulture)); // Зависит от настроек локали

Console.WriteLine (string.Equals ("foo", "FOO",

StringComparison.OrdinalIgnoreCase)); // True

Console.WriteLine ("ṻ" == "ǖ"); // False

Console.WriteLine (string.Equals ("ṻ", "ǖ",

StringComparison.CurrentCulture)); // Зависит от настроек локали

Для сравнения порядка могут быть использованы либо экземплярный метод CompareTo, либо статические Compare и CompareOrdinal. Они возвращают положительное, отрицательное число либо ноль в зависимости от того находится ли первое значение до, после или рядом со вторым.

Метод CompareTo выполняет чувствительное к культуре и регистру сравнение. Методы Compare и CompareOrdinal в зависимости от переданных аргументов могут выполнять разные виды сравнения:

public int CompareTo (string strB);
public static int Compare (string strA, string strB, StringComparison comparisonType);
public static int Compare (string strA, string strB, bool ignoreCase, CultureInfo culture);
public static int Compare (string strA, string strB, bool ignoreCase);
public static int CompareOrdinal (string strA, string strB);

public int CompareTo (string strB);

public static int Compare (string strA, string strB, StringComparison comparisonType);

public static int Compare (string strA, string strB, bool ignoreCase, CultureInfo culture);

public static int Compare (string strA, string strB, bool ignoreCase);

public static int CompareOrdinal (string strA, string strB);

Примеры:

Console.WriteLine ("Boston".CompareTo ("Austin")); // 1
Console.WriteLine ("Boston".CompareTo ("Boston")); // 0
Console.WriteLine ("Boston".CompareTo ("Chicago")); // −1
Console.WriteLine ("ṻ".CompareTo ("ǖ")); // 0
Console.WriteLine ("foo".CompareTo ("FOO")); // −1
Console.WriteLine (string.Compare ("foo", "FOO", true)); // 0
// CultureInfo is defined in the System.Globalization namespace
CultureInfo german = CultureInfo.GetCultureInfo ("de-DE");
int i = string.Compare ("Müller", "Muller", false, german);

Console.WriteLine ("Boston".CompareTo ("Austin")); // 1

Console.WriteLine ("Boston".CompareTo ("Boston")); // 0

Console.WriteLine ("Boston".CompareTo ("Chicago")); // −1

Console.WriteLine ("ṻ".CompareTo ("ǖ")); // 0

Console.WriteLine ("foo".CompareTo ("FOO")); // −1

Console.WriteLine (string.Compare ("foo", "FOO", true)); // 0

// CultureInfo is defined in the System.Globalization namespace

CultureInfo german = CultureInfo.GetCultureInfo ("de-DE");

int i = string.Compare ("Müller", "Muller", false, german);

StringBuilder

Класс System.Text.StringBuilder представляет изменяемую (редактируемую) строку. С его помощью можно добавлять (метод Append), вставлять (Insert), удалять (Remove) и заменять (Replace) подстроки, не заменяя целиком StringBuilder. Конструктор StringBuilder дополнительно может принимать начальное значение строки, а также стартовую длину строки (по умолчанию 16 символов). Использование класса StringBuilder для построения строк более эффективно, чем выполнение множества конкатенаций строк.

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 50; i++) sb.Append (i + ",");
Console.WriteLine (sb.ToString());
// Результат:
0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,
27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,

StringBuilder sb = new StringBuilder();

for (int i = 0; i < 50; i++) sb.Append (i + ",");

Console.WriteLine (sb.ToString());

// Результат:

0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,

27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,

Метод AppendLine добавляет подстроку и завершает ее символами новой строки (\r\n). Метод AppendFormat принимает смешанную форматную строку точно как String.Format. Класс StringBuilder также содержит свойство Length и индексатор для получения и установки отдельных символов.

Для очистки содержимого StringBuilder нужно либо создать новый экземпляр, либо установить его свойство Length равным 0 (последний вариант не уменьшит объем занимаемой памяти).

Кодировка

Стандартной кодировкой .NET для символов и строк является UTF-16, а для потокового ввода-вывода — UTF-8.

Класс System.Text.Encoding является базовым классом для типов, инкапсулирующих кодировки текста. Создать экземпляр Encoding можно с помощью статического метода Encoding.GetEncoding, передав ему стандартное имя IANA:

Encoding utf8 = Encoding.GetEncoding ("utf-8");
Encoding chinese = Encoding.GetEncoding ("GB18030");

1 2	Encoding utf8 = Encoding.GetEncoding ("utf-8"); Encoding chinese = Encoding.GetEncoding ("GB18030");

Экземпляры наиболее распространенных кодировок также могут быть получены через статические свойства Encoding:

Encoding.UTF8
Encoding.Unicode // utf-16
Encoding.UTF32
Encoding.ASCII

Encoding.UTF8

Encoding.Unicode // utf-16

Encoding.UTF32

Encoding.ASCII

Статический метод GetEncodings возвращает список всех поддерживаемых кодировок:

foreach (EncodingInfo info in Encoding.GetEncodings())
    Console.WriteLine (info.Name);

1 2	foreach (EncodingInfo info in Encoding.GetEncodings()) Console.WriteLine (info.Name);

Также экземпляр Encoding можно создать с помощью конструктора. В этом случае можно задать дополнительные параметры, передав необходимые аргументы.

Форматирование и разбор (Formatting and Parsing)

Форматирование — преобразование в строку, разбор (парсинг) — преобразование из строки.

Методы ToString и Parse

Методы ToString и Parse являются стандартным механизмом для форматирования и разбора строк. ToString обеспечивает осмысленный вывод для всех простых значимых типов (bool, DateTime, DateTimeOffset, TimeSpan, Guid и всех числовых типов). Для обратной операции в каждом из указанных типов определен статический метод Parse:

string s = true.ToString(); // s = "True"
bool b = bool.Parse (s); // b = true

1 2	string s = true.ToString(); // s = "True" bool b = bool.Parse (s); // b = true

Метод Parse генерирует исключение FormatException в случае неудачной попытки разбора. Многие типы также определяют метод TryParse, который в случае неудачной попытки разбора возвращает false вместо генерации исключения.

Методы ToString, Parse и TryParse для числовых типов и классов DateTime и DateTimeOffset учитывают местные настройки культуры. Также им можно передать объект CultureInfo, содержащий иные настройки культуры, которые будут использованы вместо местных:

Console.WriteLine (double.Parse ("1.234")); // В России даст 1234
double x = double.Parse ("1.234", CultureInfo.InvariantCulture); // 1,234
string x = 1.234.ToString (CultureInfo.InvariantCulture);

Console.WriteLine (double.Parse ("1.234")); // В России даст 1234

double x = double.Parse ("1.234", CultureInfo.InvariantCulture); // 1,234

string x = 1.234.ToString (CultureInfo.InvariantCulture);

Интерфейс IFormattable

Метод ToString числовых типов и типов DateTime/DateTimeOffset реализует интерфейс IFormattable — стандартный интерфейс для поддержки форматных строк и поставщиков форматов:

public interface IFormattable
{
    string ToString (string format, IFormatProvider formatProvider);
}

public interface IFormattable

{

string ToString (string format, IFormatProvider formatProvider);

}

В связи с этим метод ToString указанных типов может принимать в качестве дополнительных аргументов форматную строку и/или поставщиков форматов. Форматная строка предоставляет инструкции, поставщик формата определяет, как эти инструкции должны применяться:

NumberFormatInfo f = new NumberFormatInfo();
f.CurrencySymbol = "$";
Console.WriteLine (3.ToString ("C", f)); // $ 3.00

NumberFormatInfo f = new NumberFormatInfo();

f.CurrencySymbol = "$";

Console.WriteLine (3.ToString ("C", f)); // $ 3.00

В примере "C" — форматная строка, которая означает денежное значение (currency), а объект NumberFormatInfo — поставщик формата, определяющий, как должно визуализироваться денежное значение.

Если для форматной строки и поставщика указать null, будут использованы стандартные варианты. Стандартный поставщик формата — CultureInfo.CurrentCulture, который отражает настройки панели управления компьютера во время выполнения:

Console.WriteLine (10.3.ToString ("C", null)); // $10.30

1	Console.WriteLine (10.3.ToString ("C", null)); // $10.30

Для удобства большинство типов перегружаю метод ToString, чтобы null для поставщика можно было не указывать:

Console.WriteLine (10.3.ToString ("C")); // $10.30
Console.WriteLine (10.3.ToString ("F4")); // 10.3000

1 2	Console.WriteLine (10.3.ToString ("C")); // $10.30 Console.WriteLine (10.3.ToString ("F4")); // 10.3000

Вызов ToString без аргументов эквивалентен использованию стандартного поставщика формата с пустой форматной строкой.

Форматная строка

Существует два вида форматных строк:

стандартные форматные строки — обеспечивают общее управление форматированием при преобразовании числа или даты/времени в строку; состоят из одной буквы, за которой может следовать цифра
специальные форматные строки — позволяют контролировать при форматировании каждый символ с помощью шаблона, сотоящего из произвольного количества предопределенных символов

Подробно форматные строки для чисел и даты/времени рассматриваются в разделах, посвященных этим типам.

Поставщики форматов (Format Providers)

Поставщики форматов дают большую гибкость при форматировании и разборе строки, а также чувствительны к культуре. В .NET определены три поставщика формата (все реализуют интерфейс IFormatProvider):

NumberFormatInfo
DateTimeFormatInfo
CultureInfo

Все типы enum также поддерживают форматирование, но специальный поставщик формата для них не предусмотрен.

В контексте поставщиков формата CultureInfo представляет собой механизм косвенного обращения к двум другим поставщикам формата — NumberFormatInfo или DateTimeFormatInfo. Он возвращает NumberFormatInfo или DateTimeFormatInfo применимый к региональным настройкам культуры:

CultureInfo uk = CultureInfo.GetCultureInfo ("en-GB");
Console.WriteLine (3.ToString ("C", uk)); // £3.00

1 2	CultureInfo uk = CultureInfo.GetCultureInfo ("en-GB"); Console.WriteLine (3.ToString ("C", uk)); // £3.00

В следующем примере показано как можно использовать поставщик формата NumberFormatInfo. В примере создается экземпляр поставщика и изменяется разделитель групп с запятой на пробел:

NumberFormatInfo f = new NumberFormatInfo ();
f.NumberGroupSeparator = " ";
Console.WriteLine (12345.6789.ToString ("N3", f)); // 12 345.679

NumberFormatInfo f = new NumberFormatInfo ();

f.NumberGroupSeparator = " ";

Console.WriteLine (12345.6789.ToString ("N3", f)); // 12 345.679

Начальные настройки поставщиков NumberFormatInfo и DateTimeFormatInfo основаны на инвариантной культуре.

Все поставщики форматов реализуют интерфейс IFormatProvider:

public interface IFormatProvider 
{ 
    object GetFormat (Type formatType); 
}

public interface IFormatProvider

{

object GetFormat (Type formatType);

}

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

string Format (string format, object arg, IFormatProvider formatProvider);

1	string Format (string format, object arg, IFormatProvider formatProvider);

String.Format и смешанная форматная строка

Статический метод Format предоставляет удобный способ построения строк путем внедрения в нее значений переменных. Внедряемые переменные могут быть любого типа, метод Format просто вызывает на них ToString. Первым аргументом методу передается смешанная форматная строка (строка в которую внедряются переменные), а за ней по очереди все внедряемые переменные:

string composite = "It's {0} degrees in {1} on this {2} morning";
string s = string.Format (composite, 35, "Perth", DateTime.Now.DayOfWeek);
// s == "It's 35 degrees in Perth on this Friday morning"

string composite = "It's {0} degrees in {1} on this {2} morning";

string s = string.Format (composite, 35, "Perth", DateTime.Now.DayOfWeek);

// s == "It's 35 degrees in Perth on this Friday morning"

Числа в фигурных скобках называются форматными переменными. Число соответствует позиции аргумента, а за ним может дополнительно следовать запятая и минимальная ширина и/или двоеточие и форматная строка. Минимальная ширина предназначена для выравнивания колонок (отрицательные значения выравнивают влево, положительные — вправо):

string composite = "Name={0,-20} Credit Limit={1,15:C}";
Console.WriteLine (string.Format (composite, "Mary", 500));
Console.WriteLine (string.Format (composite, "Elizabeth", 20000));
// Результат:
Name=Mary           Credit Limit=        $500.00
Name=Elizabeth      Credit Limit=     $20,000.00

string composite = "Name={0,-20} Credit Limit={1,15:C}";

Console.WriteLine (string.Format (composite, "Mary", 500));

Console.WriteLine (string.Format (composite, "Elizabeth", 20000));

// Результат:

Name=Mary Credit Limit= $500.00

Name=Elizabeth Credit Limit= $20,000.00

Смешанную форматную строку также можно добавлять к StringBuilder (через метод AppendFormat) и к TextWriter для ввода-вывода.

Метод string.Format может также принимать необязательный поставщик формата:

string s = string.Format (CultureInfo.InvariantCulture, "{0}", someObject);

1	string s = string.Format (CultureInfo.InvariantCulture, "{0}", someObject);

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

Интернирование строк — это механизм, при котором одинаковые литералы представляют собой один объект в памяти. В рамках процесса существует одна внутренняя хеш-таблица, ключами которой являются строки, а значениями — ссылки на них. Во время компиляции литеральные строки последовательно заносятся в эту таблицу. Каждая строка в таблице встречается только один раз. На этапе выполнения ссылки на литеральные строки присваиваются из этой таблицы. Можно поместить строку во внутреннюю таблицу во время выполнения с помощью метода String.Intern. Также можно проверить, содержится ли строка во внутренней таблице с помощью метода String.IsInterned.

Например, следующий код вернет true, т.к. оба параметра ссылаются на один объект из внутренней хэш-таблицы:

string str = “literal string”;
return object.ReferenceEquals(str, “literalstring”);

1 2	string str = “literal string”; return object.ReferenceEquals(str, “literalstring”);

Строки, формирующиеся динамически, во внутреннюю хэш-таблицу не заносятся. Чтобы механизм интернирования заработал для них, их нужно вручную добавить в хэш-таблицу с помощью метода String.Intern:

string str = “literal”;
str += “ string”; // Создает новую строку
// без следующей строчки кода, метод вернул бы false
str = string.Intern(str);
return object.ReferenceEquals(str, “literalstring”);

string str = “literal”;

str += “ string”; // Создает новую строку

// без следующей строчки кода, метод вернул бы false

str = string.Intern(str);

return object.ReferenceEquals(str, “literalstring”);

Интернирование позволяет сэкономить память и ускорить сравнение строк. Однако сам процесс добавления строк в хэш-таблицу может быть весьма ресурсоемким.