String Класс

Ссылка

Определение

Пространство имен:: System

Сборка:: System.Runtime.dll

Сборка:: mscorlib.dll

Сборка:: netstandard.dll

Важно!

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

Представляет текст как последовательность из частей кода UTF-16.

public ref class System::String sealed : IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>

public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>

public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, IParsable<System::String ^>, ISpanParsable<System::String ^>, System::Collections::Generic::IEnumerable<char>

public ref class System::String sealed : ICloneable, IComparable, IConvertible, System::Collections::IEnumerable

public ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::IEnumerable

public ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>

public sealed class String : IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>

public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>

public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, IParsable<string>, ISpanParsable<string>, System.Collections.Generic.IEnumerable<char>

[System.Serializable]
public sealed class String : ICloneable, IComparable, IConvertible, System.Collections.IEnumerable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>

public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.IEnumerable

public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.Generic.IEnumerable<char>

type string = class
    interface seq<char>
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>

type string = class
    interface seq<char>
    interface IEnumerable
    interface ICloneable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>

type string = class
    interface seq<char>
    interface IEnumerable
    interface ICloneable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
    interface IParsable<string>
    interface ISpanParsable<string>

type string = class
    interface seq<char>
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
    interface ICloneable

[<System.Serializable>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IComparable<string>
    interface seq<char>
    interface IEnumerable
    interface IEquatable<string>

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>

type string = class
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IEquatable<string>

type string = class
    interface IComparable
    interface IComparable<string>
    interface IEquatable<string>
    interface seq<char>
    interface IEnumerable

Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)

Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)

Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String), IParsable(Of String), ISpanParsable(Of String)

Public NotInheritable Class String
Implements ICloneable, IComparable, IConvertible, IEnumerable

Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable, IEquatable(Of String)

Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable(Of Char), IEquatable(Of String)

Наследование: Object
String

Атрибуты: SerializableAttribute ComVisibleAttribute

Реализации: IEnumerable<Char> IEnumerable IComparable IComparable<String> IConvertible IEquatable<String> ICloneable IParsable<String> IParsable<TSelf> ISpanParsable<String>

Строка — это последовательная коллекция символов, которая используется для представления текста. Объект String — это последовательная коллекция System.Char объектов, представляющих строку; System.Char объект соответствует единице кода UTF-16. Значение String объекта — это содержимое последовательной коллекции System.Char объектов, и это значение неизменяемо (то есть доступно только для чтения). Дополнительные сведения о неизменяемости строк см. в разделах Неизменяемость и Класс StringBuilder . Максимальный String размер объекта в памяти составляет 2 ГБ или около 1 миллиарда символов.

Дополнительные сведения об Юникоде, UTF-16, единицах кода, кодовых точках и Char типах и Rune см. в статье Общие сведения о кодировке символов в .NET.

Содержание

Создание экземпляра объекта String
Объекты Char и символы Юникода
Строки и стандарт Юникода
Строки и внедренные символы NULL
Строки и индексы
Строки null и пустые строки
Неизменяемость и класс StringBuilder
Порядковые и чувствительные к языку и региональным параметрам операции
Нормализация
Строковые операции по категориям

Создание экземпляра объекта String

Экземпляр объекта можно создать String следующими способами:

Путем назначения строкового литерала переменной String . Это наиболее часто используемый метод создания строки. В следующем примере используется назначение для создания нескольких строк. Обратите внимание, что в C# и F#, так как обратная косая черта (\) является escape-символом, литеральные обратные косые черты в строке должны быть экранированы или вся строка должна быть @-quoted.

using namespace System;

void main()
{
   String^ string1 = "This is a string created by assignment.";
   Console::WriteLine(string1);
   String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc";
   Console::WriteLine(string2a);
}
// The example displays the following output: 
//       This is a string created by assignment. 
//       The path is C:\PublicDocuments\Report1.doc

string string1 = "This is a string created by assignment.";
Console.WriteLine(string1);
string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
Console.WriteLine(string2a);
string string2b = @"The path is C:\PublicDocuments\Report1.doc";
Console.WriteLine(string2b);
// The example displays the following output:
//       This is a string created by assignment.
//       The path is C:\PublicDocuments\Report1.doc
//       The path is C:\PublicDocuments\Report1.doc

let string1 = "This is a string created by assignment."
printfn "%s" string1
let string2a = "The path is C:\\PublicDocuments\\Report1.doc"
printfn "%s" string2a
let string2b = @"The path is C:\PublicDocuments\Report1.doc"
printfn "%s" string2b
// The example displays the following output:
//       This is a string created by assignment.
//       The path is C:\PublicDocuments\Report1.doc
//       The path is C:\PublicDocuments\Report1.doc

Dim string1 As String = "This is a string created by assignment."
Console.WriteLine(string1)
Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc"
Console.WriteLine(string2)
' The example displays the following output:
'       This is a string created by assignment.
'       The path is C:\PublicDocuments\Report1.doc

Путем вызова конструктора String класса. В следующем примере создаются экземпляры строк путем вызова нескольких конструкторов классов. Обратите внимание, что некоторые конструкторы включают указатели на символьные массивы или массивы со знаком байтов в качестве параметров. Visual Basic не поддерживает вызовы этих конструкторов. Подробные сведения о String конструкторах см. в сводке по конструкторам String .

using namespace System;

void main()
{
   wchar_t chars[5] = L"word";
   char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };

   // Create a string from a character array. 
   String^ string1 = gcnew String(chars);
   Console::WriteLine(string1);

   // Create a string that consists of a character repeated 20 times. 
   String^ string2 = gcnew String('c', 20);
   Console::WriteLine(string2);

   String^ stringFromBytes = nullptr;
   String^ stringFromChars = nullptr;

   char * pbytes = &bytes[0];
   // Create a string from a pointer to a signed byte array.
   stringFromBytes = gcnew String(pbytes);

   wchar_t* pchars =  &chars[0];
   // Create a string from a pointer to a character array.
   stringFromChars = gcnew String(pchars);

   Console::WriteLine(stringFromBytes);
   Console::WriteLine(stringFromChars);
   Console::ReadLine();
}
// The example displays the following output: 
//       word 
//       cccccccccccccccccccc 
//       ABCDE 
//       word

char[] chars = { 'w', 'o', 'r', 'd' };
sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };

// Create a string from a character array.
string string1 = new string(chars);
Console.WriteLine(string1);

// Create a string that consists of a character repeated 20 times.
string string2 = new string('c', 20);
Console.WriteLine(string2);

string stringFromBytes = null;
string stringFromChars = null;
unsafe
{
   fixed (sbyte* pbytes = bytes)
   {
      // Create a string from a pointer to a signed byte array.
      stringFromBytes = new string(pbytes);
   }
   fixed (char* pchars = chars)
   {
      // Create a string from a pointer to a character array.
      stringFromChars = new string(pchars);
   }
}
Console.WriteLine(stringFromBytes);
Console.WriteLine(stringFromChars);
// The example displays the following output:
//       word
//       cccccccccccccccccccc
//       ABCDE
//       word

let chars = [| 'w'; 'o'; 'r'; 'd' |]
let bytes = [| 0x41y; 0x42y; 0x43y; 0x44y; 0x45y; 0x00y |]

// Create a string from a character array.
let string1 = String chars
printfn "%s" string1

// Create a string that consists of a character repeated 20 times.
let string2 = String('c', 20)
printfn "%s" string2

let stringFromBytes =
    // Create a string from a pointer to a signed byte array.
    use pbytes = fixed bytes
    String pbytes
let stringFromChars = 
    // Create a string from a pointer to a character array.
    use pchars = fixed chars
    String pchars

printfn $"{stringFromBytes}"
printfn $"{stringFromChars}"
// The example displays the following output:
//       word
//       cccccccccccccccccccc
//       ABCDE
//       word

Dim chars() As Char = { "w"c, "o"c, "r"c, "d"c }

' Create a string from a character array.
Dim string1 As New String(chars)
Console.WriteLine(string1)

' Create a string that consists of a character repeated 20 times.
Dim string2 As New String("c"c, 20)
Console.WriteLine(string2)
' The example displays the following output:
'       word
'       cccccccccccccccccccc

С помощью оператора объединения строк (+ в C# и F# и & или + в Visual Basic) для создания одной строки из любого сочетания экземпляров String и строковых литералов. В следующем примере показано использование оператора объединения строк.

String^ string1 = "Today is " + DateTime::Now.ToString("D") + ".";
Console::WriteLine(string1);

String^ string2 = "This is one sentence. " + "This is a second. ";
string2 += "This is a third sentence.";
Console::WriteLine(string2);
// The example displays output like the following: 
//    Today is Tuesday, July 06, 2011. 
//    This is one sentence. This is a second. This is a third sentence.

string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
Console.WriteLine(string1);

string string2 = "This is one sentence. " + "This is a second. ";
string2 += "This is a third sentence.";
Console.WriteLine(string2);
// The example displays output like the following:
//    Today is Tuesday, July 06, 2011.
//    This is one sentence. This is a second. This is a third sentence.

let string1 = "Today is " + DateTime.Now.ToString("D") + "."
printfn $"{string1}"

let string2 = "This is one sentence. " + "This is a second. "
let string2 = string2 + "This is a third sentence."
printfn $"{string2}"
// The example displays output like the following:
//    Today is Tuesday, July 06, 2011.
//    This is one sentence. This is a second. This is a third sentence.

Dim string1 As String = "Today is " + Date.Now.ToString("D") + "."  
Console.WriteLine(string1)
Dim string2 As String = "This is one sentence. " + "This is a second. "
string2 += "This is a third sentence."
Console.WriteLine(string2)      
' The example displays output like the following:
'    Today is Tuesday, July 06, 2011.
'    This is one sentence. This is a second. This is a third sentence.

Извлекая свойство или вызывая метод, возвращающий строку. В следующем примере методы String класса используются для извлечения подстроки из более крупной строки.

String^ sentence = "This sentence has five words.";
// Extract the second word.
int startPosition = sentence->IndexOf(" ") + 1;
String^ word2 = sentence->Substring(startPosition, 
                                    sentence->IndexOf(" ", startPosition) - startPosition);
Console::WriteLine("Second word: " + word2);

string sentence = "This sentence has five words.";
// Extract the second word.
int startPosition = sentence.IndexOf(" ") + 1;
string word2 = sentence.Substring(startPosition,
                                  sentence.IndexOf(" ", startPosition) - startPosition);
Console.WriteLine("Second word: " + word2);
// The example displays the following output:
//       Second word: sentence

let sentence = "This sentence has five words."
// Extract the second word.
let startPosition = sentence.IndexOf " " + 1
let word2 = 
    sentence.Substring(startPosition, sentence.IndexOf(" ", startPosition) - startPosition)
printfn $"Second word: {word2}"
// The example displays the following output:
//       Second word: sentence

Dim sentence As String = "This sentence has five words."
' Extract the second word.
Dim startPosition As Integer = sentence.IndexOf(" ") + 1
Dim word2 As String = sentence.Substring(startPosition, 
                                         sentence.IndexOf(" ", startPosition) - startPosition) 
Console.WriteLine("Second word: " + word2)
' The example displays the following output:
'       Second word: sentence

Путем вызова метода форматирования для преобразования значения или объекта в его строковое представление. В следующем примере функция составного форматирования используется для внедрения строкового представления двух объектов в строку.

DateTime^ dateAndTime = gcnew DateTime(2011, 7, 6, 7, 32, 0);
Double temperature = 68.3;
String^ result = String::Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                               dateAndTime, temperature);
Console::WriteLine(result);
// The example displays the following output: 
//       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.

DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
double temperature = 68.3;
string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                              dateAndTime, temperature);
Console.WriteLine(result);
// The example displays the following output:
//       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.

let dateAndTime = DateTime(2011, 7, 6, 7, 32, 0)
let temperature = 68.3
String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.", dateAndTime, temperature)
|> printfn "%s"
// The example displays the following output:
//       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.

Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM#
Dim temperature As Double = 68.3
Dim result As String = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                     dateAndTime, temperature)
Console.WriteLine(result)
' The example displays the following output:
'       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.

Объекты Char и символы Юникода

Каждый символ в строке определяется скалярным значением Юникода, также называемым кодовой точкой Юникода или порядковым (числовым) значением символа Юникода. Каждая кодовая точка кодируется с помощью кодировки UTF-16, а числовое значение каждого элемента кодировки представлено Char объектом .

Примечание

Обратите внимание, что, поскольку String экземпляр состоит из последовательной коллекции единиц кода UTF-16, можно создать String объект, который не является строкой Юникода правильного формата. Например, можно создать строку с низким суррогатом без соответствующего высокого суррогата. Хотя некоторые методы, такие как методы кодирования и декодирования объектов в System.Text пространстве имен, могут выполнять проверки правильности формата строк, String члены класса не гарантируют правильность формата строки.

Один Char объект обычно представляет одну кодовую точку, то есть числовое значение Char равно кодовой точке. Например, кодовая точка для символа "a" — U+0061. Однако для кодовой точки может потребоваться несколько закодированных элементов (более одного Char объекта). Стандарт Юникода определяет два типа символов, соответствующих нескольким Char объектам: graphemes и дополнительные кодовые точки Юникода, соответствующие символам в дополнительных плоскостях Юникода.

Графема представлена базовым символом, за которым следует один или несколько комбинированных символов. Например, символ ä представлен Char объектом, кодовая точка которого — U+0061, за которой следует Char объект, кодовая точка которого — U+0308. Этот символ также может быть определен одним Char объектом с кодовой точкой U+00E4. Как показано в следующем примере, сравнение на равенство с учетом языка и региональных параметров показывает, что эти два представления равны, хотя обычное порядковое сравнение не является. Однако если две строки нормализованы, порядковое сравнение также показывает, что они равны. (Дополнительные сведения о нормализации строк см. в разделе Нормализация .)

using namespace System;
using namespace System::Globalization;
using namespace System::IO;

void main()
{
   StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt");
   String^ grapheme = L"a" + L"\u0308";
   sw->WriteLine(grapheme);

   String^ singleChar = "\u00e4";
   sw->WriteLine(singleChar);

   sw->WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                  String::Equals(grapheme, singleChar, 
                              StringComparison::CurrentCulture));
   sw->WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                  String::Equals(grapheme, singleChar, 
                              StringComparison::Ordinal));
   sw->WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                  String::Equals(grapheme->Normalize(), 
                              singleChar->Normalize(), 
                              StringComparison::Ordinal));
   sw->Close(); 
}
// The example produces the following output: 
//       ä 
//       ä 
//       ä = ä (Culture-sensitive): True 
//       ä = ä (Ordinal): False 
//       ä = ä (Normalized Ordinal): True

using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\graphemes.txt");
      string grapheme = "\u0061\u0308";
      sw.WriteLine(grapheme);
      
      string singleChar = "\u00e4";
      sw.WriteLine(singleChar);
            
      sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                   String.Equals(grapheme, singleChar, 
                                 StringComparison.CurrentCulture));
      sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                   String.Equals(grapheme, singleChar, 
                                 StringComparison.Ordinal));
      sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                   String.Equals(grapheme.Normalize(), 
                                 singleChar.Normalize(), 
                                 StringComparison.Ordinal));
      sw.Close(); 
   }
}
// The example produces the following output:
//       ä
//       ä
//       ä = ä (Culture-sensitive): True
//       ä = ä (Ordinal): False
//       ä = ä (Normalized Ordinal): True

open System
open System.IO

do
    use sw = new StreamWriter(@".\graphemes.txt")
    let grapheme = "\u0061\u0308"
    sw.WriteLine grapheme

    let singleChar = "\u00e4"
    sw.WriteLine singleChar

    sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                String.Equals(grapheme, singleChar,
                                StringComparison.CurrentCulture))
    sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar,
                String.Equals(grapheme, singleChar,
                                StringComparison.Ordinal))
    sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar,
                String.Equals(grapheme.Normalize(),
                                singleChar.Normalize(),
                                StringComparison.Ordinal))
// The example produces the following output:
//       ä
//       ä
//       ä = ä (Culture-sensitive): True
//       ä = ä (Ordinal): False
//       ä = ä (Normalized Ordinal): True

Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\graphemes.txt")
      Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308)
      sw.WriteLine(grapheme)
      
      Dim singleChar As String = ChrW(&h00e4)
      sw.WriteLine(singleChar)
            
      sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                   String.Equals(grapheme, singleChar, 
                                 StringComparison.CurrentCulture))
      sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                   String.Equals(grapheme, singleChar, 
                                 StringComparison.Ordinal))
      sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                   String.Equals(grapheme.Normalize(), 
                                 singleChar.Normalize(), 
                                 StringComparison.Ordinal))
      sw.Close() 
   End Sub
End Module
' The example produces the following output:
'       ä
'       ä
'       ä = ä (Culture-sensitive): True
'       ä = ä (Ordinal): False
'       ä = ä (Normalized Ordinal): True

Дополнительная кодовая точка Юникода (суррогатная пара) представлена Char объектом, кодовая точка которого является суррогатом высокого уровня, за которой следует Char объект , кодовая точка которого является низкой суррогатной точкой. Единицы кода высоких суррогатов варьируются от U+D800 до U+DBFF. Единицы кода низких суррогатов варьируются от U+DC00 до U+DFFF. Суррогатные пары используются для представления символов в 16 дополнительных плоскостях Юникода. В следующем примере создается суррогатный символ и он передается методу Char.IsSurrogatePair(Char, Char) , чтобы определить, является ли он суррогатной парой.

using namespace System;

void main()
{
   String^ surrogate =  L"\xD800\xDC03" ;
   for (int ctr = 0; ctr < surrogate->Length; ctr++)
      Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr]));

   Console::WriteLine();
   Console::WriteLine("   Is Surrogate Pair: {0}", 
                      Char::IsSurrogatePair(surrogate[0], surrogate[1]));
   Console::ReadLine();
}
// The example displays the following output: 
//       U+D800 U+DC03 
//          Is Surrogate Pair: True

string surrogate = "\uD800\uDC03";
for (int ctr = 0; ctr < surrogate.Length; ctr++) 
   Console.Write($"U+{(ushort)surrogate[ctr]:X2} ");

Console.WriteLine();
Console.WriteLine("   Is Surrogate Pair: {0}", 
                  Char.IsSurrogatePair(surrogate[0], surrogate[1]));
// The example displays the following output:
//       U+D800 U+DC03
//          Is Surrogate Pair: True

open System

let surrogate = "\uD800\uDC03"
for i = 0 to surrogate.Length - 1 do
    printf $"U+{uint16 surrogate[i]:X2} "

printfn $"\n   Is Surrogate Pair: {Char.IsSurrogatePair(surrogate[0], surrogate[1])}"
// The example displays the following output:
//       U+D800 U+DC03
//          Is Surrogate Pair: True

Module Example
   Public Sub Main()
      Dim surrogate As String = ChrW(&hD800) + ChrW(&hDC03)
      For ctr As Integer = 0 To surrogate.Length - 1
         Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate(ctr)))
      Next   
      Console.WriteLine()
      Console.WriteLine("   Is Surrogate Pair: {0}", 
                        Char.IsSurrogatePair(surrogate(0), surrogate(1)))
   End Sub
End Module

' The example displays the following output:
'       U+D800 U+DC03
'          Is Surrogate Pair: True

Строки и стандарт Юникода

Символы в строке представлены единицами кода в кодировке UTF-16, которые соответствуют значениям Char .

Каждый символ в строке имеет связанную категорию символов Юникода, которая представлена в .NET перечислением UnicodeCategory . Категорию символа или суррогатной пары можно определить, вызвав CharUnicodeInfo.GetUnicodeCategory метод .

.NET поддерживает собственную таблицу символов с соответствующими категориями, которая гарантирует, что конкретные реализации .NET будут возвращать одни и те же данные по категориям символов на разных платформах. Во всех версиях .NET и на всех платформах ОС сведения о категории символов предоставляются в базе данных символов Юникода.

В следующей таблице перечислены версии .NET и версии стандарта Юникод, на котором основаны их категории символов.

Версия .NET	Версия стандарта Юникод
.NET Framework 1.1	Стандарт Юникод, версия 4.0.0
.NET Framework 2.0	Стандарт Юникод, версия 5.0.0
.NET Framework 3,5	Стандарт Юникод, версия 5.0.0
.NET Framework 4	Стандарт Юникод, версия 5.0.0
.NET Framework 4,5	Стандарт Юникод, версия 6.3.0
.NET Framework 4.5.1	Стандарт Юникод, версия 6.3.0
.NET Framework 4.5.2	Стандарт Юникод, версия 6.3.0
.NET Framework 4.6	Стандарт Юникод, версия 6.3.0
.NET Framework 4.6.1	Стандарт Юникод, версия 6.3.0
.NET Framework 4.6.2 и более поздние версии	Стандарт Юникод, версия 8.0.0
.NET Core 2.1	Стандарт Юникод, версия 8.0.0
.NET Core 3.1	Стандарт Юникода, версия 11.0.0
.NET 5	Стандарт Юникода, версия 13.0.0

Кроме того, .NET поддерживает сравнение и сортировку строк на основе стандарта Юникода. платформа .NET Framework 4 и предыдущих версиях поддерживают собственную таблицу строковых данных. Это также относится к версиям платформа .NET Framework, начиная с платформа .NET Framework 4.5, работающих в Windows 7. Начиная с платформа .NET Framework 4.5, работающих в Операционной системе Windows 8 и более поздних версий, среда выполнения делегирует операции сравнения строк и сортировки операционной системе. В .NET Core и .NET 5+ сведения о сравнении и сортировке строк предоставляются международными компонентами для библиотек Юникода (за исключением версий Windows до обновления Windows 10 за май 2019 г.). В следующей таблице перечислены версии .NET и версии стандарта Юникода, на которых основаны сравнение и сортировка символов.

Версия .NET	Версия стандарта Юникод
.NET Framework 1.1	Стандарт Юникод, версия 4.0.0
.NET Framework 2.0	Стандарт Юникод, версия 5.0.0
.NET Framework 3,5	Стандарт Юникод, версия 5.0.0
.NET Framework 4	Стандарт Юникод, версия 5.0.0
.NET Framework 4.5 и более поздних версий в Windows 7	Стандарт Юникод, версия 5.0.0
платформа .NET Framework 4.5 и более поздних версий в операционных системах Windows 8 и более поздних версий	Стандарт Юникод, версия 6.3.0
.NET Core и .NET 5 или более поздней версии	Зависит от версии стандарта Юникода, поддерживаемой базовой операционной системой.

Строки и внедренные символы NULL

В .NET String объект может включать внедренные символы NULL, которые считаются частью длины строки. Однако в некоторых языках, таких как C и C++, символ NULL обозначает конец строки; он не считается частью строки и не учитывается как часть длины строки. Это означает, что следующие распространенные предположения, которые программисты C и C++ или библиотеки, написанные на языке C или C++, могут делать о строках, не обязательно являются допустимыми при применении к String объектам:

Значение, возвращаемое функциями strlen или wcslen , не обязательно равно String.Length.
Строка, созданная функциями strcpy_s или wcscpy_s , не обязательно идентична строке, созданной методом String.Copy .

Необходимо убедиться, что в собственном коде C и C++, который создает String экземпляры объектов, и коде, передаваемом String через вызов платформы, не предполагается, что внедренный символ NULL помечает конец строки.

Внедренные символы NULL в строке также обрабатываются по-разному при сортировке (или сравнении) строки и при поиске строки. Символы NULL игнорируются при сравнении двух строк с учетом языка и региональных параметров, включая сравнения с использованием инвариантного языка и региональных параметров. Они рассматриваются только для порядковых или порядковых сравнений без учета регистра. С другой стороны, внедренные символы NULL всегда учитываются при поиске строки с помощью таких методов, как Contains, StartsWithи IndexOf.

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

Индекс — это позиция Char объекта (не символа Юникода) в String. Индекс — это отсчитывающее от нуля неорицательное число, начинающееся с первой позиции в строке, которая является нулевой позицией индекса. Ряд методов поиска, таких как IndexOf и LastIndexOf, возвращают индекс символа или подстроки в экземпляре строки.

Свойство Chars[] позволяет получить доступ к отдельным Char объектам по их позиции индекса в строке. Chars[] Так как свойство является свойством по умолчанию (в Visual Basic) или индексатором (в C# и F#), вы можете получить доступ к отдельным Char объектам в строке с помощью следующего кода. Этот код ищет пробелы или знаки препинания в строке, чтобы определить, сколько слов содержит строка.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for (int ctr = 0; ctr < s1->Length; ctr++) {
         if (Char::IsPunctuation(s1[ctr]) | Char::IsWhiteSpace(s1[ctr]))
            nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                     s1, nWords);           
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.

string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
for (int ctr = 0; ctr < s1.Length; ctr++) {
   if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

for i = 0 to s1.Length - 1 do
    if Char.IsPunctuation s1[i] || Char.IsWhiteSpace s1[i] then
        nWords <- nWords + 1
printfn $"The sentence\n   {s1}\nhas {nWords} words."
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For ctr As Integer = 0 To s1.Length - 1
         If Char.IsPunctuation(s1(ctr)) Or Char.IsWhiteSpace(s1(ctr)) 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

String Так как класс реализует IEnumerable интерфейс, можно также выполнить итерацию Char по объектам в строке с помощью foreach конструкции, как показано в следующем примере.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

   s1 = s1->Trim();      
   for each (Char ch in s1)
   {
      if (Char::IsPunctuation(ch) | Char::IsWhiteSpace(ch))
         nWords++;              
   }
   Console::WriteLine("The sentence\n   {0}\nhas {1} words.",
                      s1, nWords);  
   Console::ReadLine();
}
// The example displays the following output: 
//       The sentence 
//          This string consists of a single short sentence. 
//       has 8 words.

string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
foreach (var ch in s1) {
   if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

for ch in s1 do
    if Char.IsPunctuation ch || Char.IsWhiteSpace ch then
        nWords <- nWords + 1
printfn $"The sentence\n   {s1}\nhas {nWords} words."
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

      s1 = s1.Trim()      
      For Each ch In s1
         If Char.IsPunctuation(ch) Or Char.IsWhiteSpace(ch) Then 
            nWords += 1              
         End If   
      Next
      Console.WriteLine("The sentence{2}   {0}{2}has {1} words.",
                        s1, nWords, vbCrLf)                                                                     
   End Sub
End Module
' The example displays the following output:
'       The sentence
'          This string consists of a single short sentence.
'       has 8 words.

Последовательные значения индекса могут не соответствовать последовательным символам Юникода, так как символ Юникода может быть закодирован как Char несколько объектов. В частности, строка может содержать многосимвийные единицы текста, сформированные базовым символом, за которым следует один или несколько объединяющих символов или суррогатных пар. Для работы с символами Юникода Char вместо объектов используйте классы System.Globalization.StringInfo и TextElementEnumerator или String.EnumerateRunes метод и структуру Rune . В следующем примере показана разница между кодом, который работает с Char объектами, и кодом, который работает с символами Юникода. Он сравнивает количество символов или текстовых элементов в каждом слове предложения. Строка содержит две последовательности базового символа, за которым следует объединяющий символ.

using namespace System;
using namespace System::Collections::Generic;
using namespace System::Globalization;

void main()
{
   // First sentence of The Mystery of the Yellow Room, by Leroux. 
   String^ opening = L"Ce n'est pas sans une certaine émotion que "+
                     L"je commence à raconter ici les aventures " +
                     L"extraordinaires de Joseph Rouletabille."; 
  
   // Character counters. 
   int nChars = 0;
   // Objects to store word count.
   List<int>^ chars = gcnew List<int>();
   List<int>^ elements = gcnew List<int>();

   for each (Char ch in opening) {
      // Skip the ' character. 
      if (ch == '\x0027') continue;

      if (Char::IsWhiteSpace(ch) | (Char::IsPunctuation(ch))) {
         chars->Add(nChars);
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   TextElementEnumerator^ te = StringInfo::GetTextElementEnumerator(opening);
   while (te->MoveNext()) {
      String^ s = te->GetTextElement();   
      // Skip the ' character. 
      if (s == "\x0027") continue;
      if ( String::IsNullOrEmpty(s->Trim()) | (s->Length == 1 && Char::IsPunctuation(Convert::ToChar(s)))) {
         elements->Add(nChars);         
         nChars = 0;
      }
      else {
         nChars++;
      }
   }

   // Display character counts.
   Console::WriteLine("{0,6} {1,20} {2,20}",
                      "Word #", "Char Objects", "Characters"); 
   for (int ctr = 0; ctr < chars->Count; ctr++) 
      Console::WriteLine("{0,6} {1,20} {2,20}",
                         ctr, chars[ctr], elements[ctr]); 
   Console::ReadLine();
}
// The example displays the following output:
//      Word #         Char Objects           Characters
//           0                    2                    2
//           1                    4                    4
//           2                    3                    3
//           3                    4                    4
//           4                    3                    3
//           5                    8                    8
//           6                    8                    7
//           7                    3                    3
//           8                    2                    2
//           9                    8                    8
//          10                    2                    1
//          11                    8                    8
//          12                    3                    3
//          13                    3                    3
//          14                    9                    9
//          15                   15                   15
//          16                    2                    2
//          17                    6                    6
//          18                   12                   12

// First sentence of The Mystery of the Yellow Room, by Leroux.
string opening = "Ce n'est pas sans une certaine émotion que "+
                 "je commence à raconter ici les aventures " +
                 "extraordinaires de Joseph Rouletabille."; 
// Character counters.
int nChars = 0;
// Objects to store word count.
List<int> chars = new List<int>();
List<int> elements = new List<int>();

foreach (var ch in opening) {
   // Skip the ' character.
   if (ch == '\u0027') continue;
        
   if (Char.IsWhiteSpace(ch) | (Char.IsPunctuation(ch))) {
      chars.Add(nChars);
      nChars = 0;
   }
   else {
      nChars++;
   }
}

System.Globalization.TextElementEnumerator te = 
   System.Globalization.StringInfo.GetTextElementEnumerator(opening);
while (te.MoveNext()) {
   string s = te.GetTextElement();   
   // Skip the ' character.
   if (s == "\u0027") continue;
   if ( String.IsNullOrEmpty(s.Trim()) | (s.Length == 1 && Char.IsPunctuation(Convert.ToChar(s)))) {
      elements.Add(nChars);         
      nChars = 0;
   }
   else {
      nChars++;
   }
}

// Display character counts.
Console.WriteLine("{0,6} {1,20} {2,20}",
                  "Word #", "Char Objects", "Characters"); 
for (int ctr = 0; ctr < chars.Count; ctr++) 
   Console.WriteLine("{0,6} {1,20} {2,20}",
                     ctr, chars[ctr], elements[ctr]); 
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12

open System
open System.Globalization

// First sentence of The Mystery of the Yellow Room, by Leroux.
let opening = "Ce n'est pas sans une certaine émotion que je commence à raconter ici les aventures extraordinaires de Joseph Rouletabille."
// Character counters.
let mutable nChars = 0
// Objects to store word count.
let chars = ResizeArray<int>()
let elements = ResizeArray<int>()

for ch in opening do
    // Skip the ' character.
    if ch <> '\u0027' then
        if Char.IsWhiteSpace ch || Char.IsPunctuation ch then
            chars.Add nChars
            nChars <- 0
        else
            nChars <- nChars + 1

let te = StringInfo.GetTextElementEnumerator opening
while te.MoveNext() do
    let s = te.GetTextElement()
    // Skip the ' character.
    if s <> "\u0027" then
        if String.IsNullOrEmpty(s.Trim()) || (s.Length = 1 && Char.IsPunctuation(Convert.ToChar s)) then
            elements.Add nChars
            nChars <- 0
        else
            nChars <- nChars + 1

// Display character counts.
printfn "%6s %20s %20s" "Word #" "Char Objects " "Characters"
for i = 0 to chars.Count - 1 do
    printfn "%6d %20d %20d" i chars[i] elements[i]
// The example displays the following output:
//       Word #         Char Objects           Characters
//            0                    2                    2
//            1                    4                    4
//            2                    3                    3
//            3                    4                    4
//            4                    3                    3
//            5                    8                    8
//            6                    8                    7
//            7                    3                    3
//            8                    2                    2
//            9                    8                    8
//           10                    2                    1
//           11                    8                    8
//           12                    3                    3
//           13                    3                    3
//           14                    9                    9
//           15                   15                   15
//           16                    2                    2
//           17                    6                    6
//           18                   12                   12

Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      ' First sentence of The Mystery of the Yellow Room, by Leroux.
      Dim opening As String = "Ce n'est pas sans une certaine émotion que "+
                              "je commence à raconter ici les aventures " +
                              "extraordinaires de Joseph Rouletabille." 
      ' Character counters.
      Dim nChars As Integer = 0
      ' Objects to store word count.
      Dim chars As New List(Of Integer)()
      Dim elements As New List(Of Integer)()
      
      For Each ch In opening
         ' Skip the ' character.
         If ch = ChrW(&h0027) Then Continue For
              
         If Char.IsWhiteSpace(ch) Or Char.IsPunctuation(ch) Then
            chars.Add(nChars)
            nChars = 0
         Else 
            nChars += 1
         End If
      Next

      Dim te As TextElementEnumerator = StringInfo.GetTextElementEnumerator(opening)
      Do While te.MoveNext()
         Dim s As String = te.GetTextElement()   
         ' Skip the ' character.
         If s = ChrW(&h0027) Then Continue Do
         If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s))) 
            elements.Add(nChars)         
            nChars = 0
         Else 
            nChars += 1
         End If
      Loop

      ' Display character counts.
      Console.WriteLine("{0,6} {1,20} {2,20}",
                        "Word #", "Char Objects", "Characters") 
      For ctr As Integer = 0 To chars.Count - 1 
         Console.WriteLine("{0,6} {1,20} {2,20}",
                           ctr, chars(ctr), elements(ctr)) 
      Next                        
   End Sub
End Module
' The example displays the following output:
'    Word #         Char Objects           Characters
'         0                    2                    2
'         1                    4                    4
'         2                    3                    3
'         3                    4                    4
'         4                    3                    3
'         5                    8                    8
'         6                    8                    7
'         7                    3                    3
'         8                    2                    2
'         9                    8                    8
'        10                    2                    1
'        11                    8                    8
'        12                    3                    3
'        13                    3                    3
'        14                    9                    9
'        15                   15                   15
'        16                    2                    2
'        17                    6                    6
'        18                   12                   12

Этот пример работает с текстовыми элементами StringInfo.GetTextElementEnumerator с помощью метода и TextElementEnumerator класса для перечисления всех текстовых элементов в строке. Можно также получить массив, содержащий начальный индекс каждого текстового элемента, вызвав StringInfo.ParseCombiningCharacters метод .

Дополнительные сведения о работе с единицами текста, а не с отдельными Char значениями, см. в статье Общие сведения о кодировке символов в .NET.

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

Строка, которая была объявлена, но не была присвоена значение , имеет значение null. При попытке вызвать методы в этой строке возникает исключение NullReferenceException. Строка NULL отличается от пустой строки, которая представляет собой строку со значением "" или String.Empty. В некоторых случаях передача строки null или пустой строки в качестве аргумента в вызове метода вызывает исключение. Например, передача пустой строки Int32.Parse в метод вызывает ArgumentNullExceptionисключение , а передача пустой строки вызывает исключение FormatException. В других случаях аргумент метода может быть пустой строкой или пустой строкой. Например, если вы предоставляете IFormattable реализацию для класса, необходимо приравнивать как пустую строку, так и пустую строку с описателем общего формата ("G").

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

IsNullOrEmpty, который указывает, равна null ли строка или .String.Empty Этот метод устраняет необходимость использования следующего кода:
```
if (str == nullptr || str->Equals(String::Empty))
```
```
if (str == null || str.Equals(String.Empty))
```
```
if str = null || str.Equals String.Empty then
```
```
If str Is Nothing OrElse str.Equals(String.Empty) Then
```

IsNullOrWhiteSpace, который указывает, является nullли строка , равна String.Emptyили состоит исключительно из пробелов. Этот метод устраняет необходимость использования следующего кода:

if (str == nullptr || str->Equals(String::Empty) || str->Trim()->Equals(String::Empty))

if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))

if str = null || str.Equals String.Empty || str.Trim().Equals String.Empty then

If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)

В следующем примере метод используется IsNullOrEmpty в IFormattable.ToString реализации пользовательского Temperature класса. Метод поддерживает строки формата "G", "C", "F" и "K". Если пустая строка форматирования или строка формата, значение null которой передается методу, ее значение меняется на строку формата "G".

public:
   virtual String^ ToString(String^ format, IFormatProvider^ provider) 
   {
      if (String::IsNullOrEmpty(format)) format = "G";  
      if (provider == nullptr) provider = CultureInfo::CurrentCulture;
      
      switch (Convert::ToUInt16(format->ToUpperInvariant()))
      {
         // Return degrees in Celsius.    
         case 'G':
         case 'C':
            return temp.ToString("F2", provider) + L"�C";
         // Return degrees in Fahrenheit.
         case 'F': 
            return (temp * 9 / 5 + 32).ToString("F2", provider) + L"�F";
         // Return degrees in Kelvin.
         case 'K':   
            return (temp + 273.15).ToString();
         default:
            throw gcnew FormatException(
                  String::Format("The {0} format string is not supported.", 
                                 format));
      }                                   
   }

public string ToString(string format, IFormatProvider provider) 
{
   if (String.IsNullOrEmpty(format)) format = "G";  
   if (provider == null) provider = CultureInfo.CurrentCulture;
   
   switch (format.ToUpperInvariant())
   {
      // Return degrees in Celsius.    
      case "G":
      case "C":
         return temp.ToString("F2", provider) + "°C";
      // Return degrees in Fahrenheit.
      case "F": 
         return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F";
      // Return degrees in Kelvin.
      case "K":   
         return (temp + 273.15).ToString();
      default:
         throw new FormatException(
               String.Format("The {0} format string is not supported.", 
                             format));
   }                                   
}

member _.ToString(format: string, provider: IFormatProvider) =
    let format = 
        if String.IsNullOrEmpty format then "G" else format
    
    let provider: IFormatProvider = 
        if provider = null then CultureInfo.CurrentCulture else provider

    match format.ToUpperInvariant() with
    // Return degrees in Celsius.
    | "G"
    | "C" ->
        temp.ToString("F2", provider) + "°C"
    // Return degrees in Fahrenheit.
    | "F" ->
        (temp * 9. / 5. + 32.).ToString("F2", provider) + "°F"
    // Return degrees in Kelvin.
    | "K" ->
        (temp + 273.15).ToString()
    | _ ->
        raise (FormatException(String.Format("The {0} format string is not supported.",format)))

Public Overloads Function ToString(fmt As String, provider As IFormatProvider) As String _
                Implements IFormattable.ToString
   If String.IsNullOrEmpty(fmt) Then fmt = "G"  
   If provider Is Nothing Then provider = CultureInfo.CurrentCulture
   
   Select Case fmt.ToUpperInvariant()
      ' Return degrees in Celsius.    
      Case "G", "C"
         Return temp.ToString("F2", provider) + "°C"
      ' Return degrees in Fahrenheit.
      Case "F" 
         Return (temp * 9 / 5 + 32).ToString("F2", provider) + "°F"
      ' Return degrees in Kelvin.
      Case "K"   
         Return (temp + 273.15).ToString()
      Case Else
         Throw New FormatException(
               String.Format("The {0} format string is not supported.", 
                             fmt))
    End Select                                   
End Function

Неизменяемость и класс StringBuilder

Объект String называется неизменяемым (только для чтения), так как его значение не может быть изменено после его создания. Методы, которые, как представляется, изменяют String объект, фактически возвращают новый String объект, содержащий изменение.

Так как строки являются неизменяемыми, процедуры работы со строками, выполняющие повторяющиеся сложения или удаления в одну строку, могут значительно ухитить производительность. Например, следующий код использует генератор случайных чисел для создания строки со 1000 символами в диапазоне 0x0001 0x052F. Хотя код, как представляется, использует объединение строк для добавления нового символа к существующей строке с именем str, он фактически создает новый String объект для каждой операции объединения.

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   String^ str = String::Empty;
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      str += Convert::ToChar(rnd->Next(1, 0x0530)); 
      if (str->Length % 60 == 0)
         str += Environment::NewLine;          
   }                    
   sw->Write(str);
   sw->Close();
}

using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      
      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         str += (char)rnd.Next(1, 0x0530);
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}

open System
open System.IO
open System.Text

do
    let rnd = Random()

    let mutable str = String.Empty
    use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)
    for _ = 0 to 1000 do
        str <- str + (rnd.Next(1, 0x0530) |> char |> string)
        if str.Length % 60 = 0 then
            str <- str + Environment.NewLine
    sw.Write str

Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      
      Dim str As String = String.Empty
      Dim sw As New StreamWriter(".\StringFile.txt", 
                           False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         str += ChrW(rnd.Next(1, &h0530)) 
         If str.Length Mod 60 = 0 Then str += vbCrLf          
      Next                    
      sw.Write(str)
      sw.Close()
   End Sub
End Module

Класс можно использовать StringBuilder вместо класса для String операций, которые вносят несколько изменений в значение строки. В отличие от экземпляров String класса, StringBuilder объекты являются изменяемыми; при сцепление, добавление или удаление подстрок из строки операции выполняются с одной строкой. Завершив изменение значения StringBuilder объекта, можно вызвать его StringBuilder.ToString метод, чтобы преобразовать его в строку. В следующем примере используется String для сцепления 1000 случайных символов в диапазоне для 0x0001 0x052F с StringBuilder объектом .

using namespace System;
using namespace System::IO;
using namespace System::Text;

void main()
{
   Random^ rnd = gcnew Random();

   StringBuilder^ sb = gcnew StringBuilder();
   StreamWriter^ sw = gcnew StreamWriter(".\\StringFile.txt", 
                        false, Encoding::Unicode);

   for (int ctr = 0; ctr <= 1000; ctr++) {
      sb->Append(Convert::ToChar(rnd->Next(1, 0x0530))); 
      if (sb->Length % 60 == 0)
         sb->AppendLine();          
   }                    
   sw->Write(sb->ToString());
   sw->Close();
}

using System;
using System.IO;
using System.Text;

public class Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append((char)rnd.Next(1, 0x0530));
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}

open System
open System.IO
open System.Text

do
    let rnd = Random()
    let sb = StringBuilder()
    use sw = new StreamWriter(@".\StringFile.txt", false, Encoding.Unicode)

    for _ = 0 to 1000 do
        sb.Append(rnd.Next(1, 0x0530) |> char) |> ignore
        if sb.Length % 60 = 0 then
            sb.AppendLine() |> ignore
    sw.Write(string sb)

Imports System.IO
Imports System.Text

Module Example
   Public Sub Main()
      Dim rnd As New Random()
      Dim sb As New StringBuilder()
      Dim sw As New StreamWriter(".\StringFile.txt", 
                                 False, Encoding.Unicode)

      For ctr As Integer = 0 To 1000
         sb.Append(ChrW(rnd.Next(1, &h0530))) 
         If sb.Length Mod 60 = 0 Then sb.AppendLine()          
      Next                    
      sw.Write(sb.ToString())
      sw.Close()
   End Sub
End Module

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

String Члены класса выполняют порядковые или лингвистические операции с объектом с учетом String языка и региональных параметров. Порядковая операция действует на числовое значение каждого Char объекта. Операция с учетом языка и региональных параметров действует на значение String объекта и учитывает правила регистра, сортировки, форматирования и синтаксического анализа, относящиеся к конкретному языку и региональным параметрам. Операции с учетом языка и региональных параметров выполняются в контексте явно объявленного языка и региональных параметров или неявного текущего языка и региональных параметров. Два типа операций могут давать очень разные результаты при их выполнении в одной строке.

.NET также поддерживает лингвистические строковые операции без учета языка и региональных параметров, используя инвариантный язык и региональные параметры (CultureInfo.InvariantCulture), которые свободно основаны на параметрах языка и региональных параметров английского языка независимо от региона. В отличие от других System.Globalization.CultureInfo параметров, параметры инвариантного языка и региональных параметров гарантированно будут оставаться согласованными на одном компьютере, от системы к системе и в разных версиях .NET. Инвариантный язык и региональные параметры можно рассматривать как своего рода черный ящик, обеспечивающий стабильность сравнения строк и упорядочения во всех языках и региональных параметрах.

Важно!

Если приложение принимает решение о безопасности относительно символьного идентификатора, например имени файла или именованного канала, или сохраняемых данных, таких как текстовые данные в XML-файле, операция должна использовать порядковое сравнение вместо сравнения с учетом языка и региональных параметров. Это связано с тем, что сравнение с учетом языка и региональных параметров может давать различные результаты в зависимости от языка и региональных параметров, в то время как порядковое сравнение зависит исключительно от двоичного значения сравниваемых символов.

Важно!

Большинство методов, выполняющих строковые операции, включают перегрузку с параметром типа StringComparison, который позволяет указать, выполняет ли метод порядковый номер или операцию с учетом языка и региональных параметров. Как правило, эту перегрузку следует вызывать, чтобы было ясно намерение вызова метода. Рекомендации и рекомендации по использованию порядкового номера и операций со строками с учетом языка и региональных параметров см. в статье Рекомендации по использованию строк.

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

Совет

Всегда следует вызывать перегрузку метода, которая делает намерение вызова метода ясным. Например, вместо вызова Compare(String, String) метода для сравнения двух строк с учетом языка и региональных параметров с помощью соглашений о текущем языке и региональных параметрах следует вызвать Compare(String, String, StringComparison) метод со значением StringComparison.CurrentCulture для аргумента comparisonType . Дополнительные сведения см. в разделе Рекомендации по использованию строк.

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

Windows (платформа .NET Framework и .NET Core): сортировка весовых таблиц
Обновление Windows 10 за май 2019 г. или более поздней версии (.NET 5+) и Linux и macOS (.NET Core и .NET 5+): таблица элементов сортировки Юникода по умолчанию

Регистр

Правила регистра определяют, как изменить прописную букву символа Юникода; например, из нижнего регистра в верхний регистр. Часто перед сравнением строк выполняется операция создания регистра. Например, строка может быть преобразована в верхний регистр, чтобы ее можно было сравнить с другой строкой в верхнем регистре. Символы в строке можно преобразовать в нижний регистр, вызвав ToLower метод или ToLowerInvariant , а можно преобразовать их в верхний регистр, вызвав ToUpper метод или ToUpperInvariant . Кроме того, метод можно использовать для TextInfo.ToTitleCase преобразования строки в регистр заголовка.

Примечание

.NET Core, работающий только в системах Linux и macOS: Поведение параметров сортировки для языков и региональных параметров C и Posix всегда учитывает регистр, так как эти языки и региональные параметры не используют ожидаемый порядок сортировки Юникода. Мы не рекомендуем использовать язык и региональные параметры, выбранные для C или Posix, для выполнения операций сортировки с учетом языка и региональных параметров, но без учета регистра.

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

Различия в сопоставлении вариантов ЛАТИНСКАЯ ПРОПИСНАЯ БУКВА I (U+0049), ЛАТИНСКАЯ МАЛЕНЬКАЯ БУКВА I (U+0069), ЛАТИНСКАЯ ПРОПИСНАЯ БУКВА I С ТОЧКОЙ ВЫШЕ (U+0130) и ЛАТИНСКАЯ МАЛЕНЬКАЯ БУКВА DOTLESS I (U+0131). В языках tr-TR (Турецкий (Турция)) и az-Latn-AZ (Азербайджан, латиница), а в нейтральных языках tr, az и az-Latn в нижнем регистре эквивалент LATIN CAPITAL LETTER I — LATIN SMALL LETTER DOTLESS I, а эквивалент в верхнем регистре LATIN SMALL LETTER I — LATIN CAPITAL LETTER I WITH DOT ABOVE. Во всех других языках и региональных параметрах, включая инвариантный язык и региональные параметры, LATIN SMALL LETTER I и LATIN ПРОПИСНАЯ БУКВА I являются эквивалентами в нижнем и верхнем регистре.

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

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   const string disallowed = "file";
   
   public static void Main()
   {
      IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
   }

   private static void IsAccessAllowed(String resource)
   {
      CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                 CultureInfo.CreateSpecificCulture("tr-TR") };
      String scheme = null;
      int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
      if (index > 0) 
         scheme = resource.Substring(0, index - 1);

      // Change the current culture and perform the comparison.
      foreach (var culture in cultures) {
         Thread.CurrentThread.CurrentCulture = culture;
         Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
         Console.WriteLine(resource);
         Console.WriteLine("Access allowed: {0}", 
                           ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       Culture: English (United States)
//       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
//       Access allowed: False
//       
//       Culture: Turkish (Turkey)
//       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
//       Access allowed: True

open System
open System.Globalization
open System.Threading

let disallowed = "file"

let isAccessAllowed (resource: string) =
    let cultures = 
        [| CultureInfo.CreateSpecificCulture "en-US"
           CultureInfo.CreateSpecificCulture "tr-TR" |]
    let index = resource.IndexOfAny [| '\\'; '/' |]
    let scheme =
        if index > 0 then
            resource.Substring(0, index - 1)
        else 
            null

    // Change the current culture and perform the comparison.
    for culture in cultures do
        Thread.CurrentThread.CurrentCulture <- culture
        printfn $"Culture: {CultureInfo.CurrentCulture.DisplayName}"
        printfn $"{resource}"
        printfn $"Access allowed: {String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase) |> not}"
        printfn ""
        
isAccessAllowed @"FILE:\\\c:\users\user001\documents\FinancialInfo.txt"
// The example displays the following output:
//       Culture: English (United States)
//       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
//       Access allowed: False
//
//       Culture: Turkish (Turkey)
//       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
//       Access allowed: True

Imports System.Globalization
Imports System.Threading

Module Example
   Const disallowed = "file"
   
   Public Sub Main()
      IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt")
   End Sub

   Private Sub IsAccessAllowed(resource As String)
      Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"),
                                        CultureInfo.CreateSpecificCulture("tr-TR") }
      Dim scheme As String = Nothing
      Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c })
      If index > 0 Then scheme = resource.Substring(0, index - 1)

      ' Change the current culture and perform the comparison.
      For Each culture In cultures
         Thread.CurrentThread.CurrentCulture = culture
         Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
         Console.WriteLine(resource)
         Console.WriteLine("Access allowed: {0}", 
                           Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase))      
         Console.WriteLine()
      Next   
   End Sub      
End Module
' The example displays the following output:
'       Culture: English (United States)
'       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
'       Access allowed: False
'       
'       Culture: Turkish (Turkey)
'       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
'       Access allowed: True

Различия в сопоставлении регистров между инвариантным языком и региональными параметрами и всеми другими языками и региональными параметрами. В этих случаях использование правил регистра инвариантного языка и региональных параметров для изменения символа на верхний или нижний регистр возвращает тот же символ. Для всех остальных языков и региональных параметров он возвращает другой символ. Некоторые из затронутых символов перечислены в следующей таблице.

Знак	Если изменено на	Возвращаемое значение
ЗНАК MICRON (U+00B5)	Прописные буквы	ГРЕЧЕСКАЯ ПРОПИСНАЯ БУКВА MU (U+-39C)
ЛАТИНСКАЯ ПРОПИСНАЯ БУКВА I С ТОЧКОЙ ВЫШЕ (U+0130)	Строчные буквы	ЛАТИНСКАЯ БУКВА I (U+0069)
ЛАТИНСКАЯ МАЛЕНЬКАЯ БУКВА БЕЗ ТОЧЕК I (U+0131)	Прописные буквы	ЛАТИНСКАЯ ПРОПИСНАЯ БУКВА I (U+0049)
ЛАТИНСКАЯ МАЛЕНЬКАЯ БУКВА ДЛИННАЯ S (U+017F)	Прописные буквы	ЛАТИНСКАЯ ПРОПИСНАЯ БУКВА S (U+0053)
ЛАТИНСКАЯ ПРОПИСНАЯ БУКВА D С НЕБОЛЬШОЙ БУКВОЙ Z С КАРОНОМ (U+01C5)	Строчные буквы	ЛАТИНСКАЯ МАЛЕНЬКАЯ БУКВА DZ С КАРОНОМ (U+01C6)
СОЧЕТАНИЕ ГРЕЧЕСКОГО YPOGEGRAMMENI (U+0345)	Прописные буквы	ГРЕЧЕСКАЯ ПРОПИСНАЯ БУКВА IOTA (U+0399)

Различия в сопоставлении регистров двухбуквенный смешанный регистр в диапазоне символов ASCII. В большинстве языков и региональных параметров двухбуквенный смешанный регистр равен эквивалентной двухбуквенной паре прописных или строчных регистров. Это не относится к следующим парам из двух букв в следующих языках и региональных параметрах, так как в каждом случае они сравниваются с диграфом:
- "lJ" и "nJ" в культуре hr-HR (Хорватский (Хорватия)).
- "cH" в cs-CZ (Чехия (Чешская Республика)) и sk-SK (Словацкий (Словакия)) культур.
- "aA" в культуре da-DK (Датский (Дания)).
- "cS", "dZ", "dZS", "nY", "sZ", "tY" и "zS" в культуре hu-HU (Венгерский (Венгрия)).
- "cH" и "lL" в культуре es-ES_tradnl (испанский (Испания, традиционная сортировка)).
- "cH", "gI", "kH", "nG" "nH", "pH", "qU", "tH" и "tR" в vi-VN (вьетнамский (Вьетнам)) культуры.
Однако необычно сталкиваться с ситуацией, когда сравнение этих пар с учетом языка и региональных параметров создает проблемы, так как эти пары являются редкими в фиксированных строках или идентификаторах.

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

using namespace System;
using namespace System::Globalization;
using namespace System::IO;

String^ ShowHexValue(String^ s);

void main()
{
   StreamWriter^ sw = gcnew StreamWriter(".\\case.txt");   
   array<String^>^ words = gcnew array<String^> { L"file", L"sıfır", L"ǅenana" };
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"),  
                                                               gcnew CultureInfo("tr-TR") };

   for each (String^ word in words) {
      sw->WriteLine("{0}:", word);
      for each (CultureInfo^ culture in cultures) {
         String^ name = String::IsNullOrEmpty(culture->Name) ? 
                              "Invariant" : culture->Name;
         String^ upperWord = word->ToUpper(culture);
         sw->WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                        upperWord, ShowHexValue(upperWord));

      }
      sw->WriteLine();  
   }
   sw->Close();
}

String^ ShowHexValue(String^ s)
{
   String^ retval = nullptr;
   for each (Char ch in s) {
      array<Byte>^ bytes = BitConverter::GetBytes(ch);
      retval += String::Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
   }
   return retval;
} 
// The example displays the following output: 
//    file: 
//        Invariant:    FILE               00 46 00 49 00 4C 00 45  
//            en-US:    FILE               00 46 00 49 00 4C 00 45  
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45  
//     
//    sıfır: 
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52  
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52  
//     
//    ǅenana: 
//        Invariant:  ǅENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41  
//            en-US:  ǄENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  
//            tr-TR:  ǄENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41

using System;
using System.Globalization;
using System.IO;

public class Example
{
   public static void Main()
   {
      StreamWriter sw = new StreamWriter(@".\case.txt");   
      string[] words = { "file", "sıfır", "ǅenana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

      foreach (var word in words) {
         sw.WriteLine("{0}:", word);
         foreach (var culture in cultures) {
            string name = String.IsNullOrEmpty(culture.Name) ? 
                                 "Invariant" : culture.Name;
            string upperWord = word.ToUpper(culture);
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord));
         }
         sw.WriteLine();  
      }
      sw.Close();
   }

   private static string ShowHexValue(string s)
   {
      string retval = null;
      foreach (var ch in s) {
         byte[] bytes = BitConverter.GetBytes(ch);
         retval += String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0]);     
      }
      return retval;
   } 
}
// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45 
//            en-US:    FILE               00 46 00 49 00 4C 00 45 
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
//    
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
//    
//    ǅenana:
//        Invariant:  ǅENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  ǄENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  ǄENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41

open System
open System.Globalization
open System.IO

let showHexValue (s: string) =
    let mutable retval = ""
    for ch in s do
        let bytes = BitConverter.GetBytes ch
        retval <- retval + String.Format("{0:X2} {1:X2} ", bytes[1], bytes[0])
    retval

do
    use sw = new StreamWriter(@".\case.txt")
    let words = [| "file"; "sıfır"; "ǅenana" |]
    let cultures = 
        [| CultureInfo.InvariantCulture 
           CultureInfo "en-US"
           CultureInfo "tr-TR" |]

    for word in words do
        sw.WriteLine("{0}:", word)
        for culture in cultures do
            let name =
                 if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name
            let upperWord = word.ToUpper culture
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, upperWord, showHexValue upperWord)
        sw.WriteLine()
    sw.Close()

// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45
//            en-US:    FILE               00 46 00 49 00 4C 00 45
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45
//
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52
//
//    ǅenana:
//        Invariant:  ǅENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41
//            en-US:  ǄENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41
//            tr-TR:  ǄENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41

Imports System.Globalization
Imports System.IO

Module Example
   Public Sub Main()
      Dim sw As New StreamWriter(".\case.txt")   
      Dim words As String() = { "file", "sıfır", "ǅenana" }
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"),  
                                        New CultureInfo("tr-TR") }

      For Each word In words
         sw.WriteLine("{0}:", word)
         For Each culture In cultures
            Dim name As String = If(String.IsNullOrEmpty(culture.Name),  
                                 "Invariant", culture.Name)
            Dim upperWord As String = word.ToUpper(culture)
            sw.WriteLine("   {0,10}: {1,7} {2, 38}", name, 
                         upperWord, ShowHexValue(upperWord))
     
         Next
         sw.WriteLine()  
      Next
      sw.Close()
   End Sub

   Private Function ShowHexValue(s As String) As String
      Dim retval As String = Nothing
      For Each ch In s
         Dim bytes() As Byte = BitConverter.GetBytes(ch)
         retval += String.Format("{0:X2} {1:X2} ", bytes(1), bytes(0))     
      Next
      Return retval
   End Function
End Module
' The example displays the following output:
'    file:
'        Invariant:    FILE               00 46 00 49 00 4C 00 45 
'            en-US:    FILE               00 46 00 49 00 4C 00 45 
'            tr-TR:    FİLE               00 46 01 30 00 4C 00 45 
'    
'    sıfır:
'        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52 
'            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52 
'    
'    ǅenana:
'        Invariant:  ǅENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
'            en-US:  ǄENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
'            tr-TR:  ǄENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41

Анализ и форматирование

Форматирование и анализ являются обратными операциями. Правила форматирования определяют способ преобразования значения, например даты и времени или числа, в его строковое представление, в то время как правила синтаксического анализа определяют способ преобразования строкового представления в значение, например дату и время. Как правила форматирования, так и синтаксического анализа зависят от культурных соглашений. В следующем примере показана неоднозначность, которая может возникнуть при интерпретации строки даты, зависят от языка и региональных параметров. Не зная соглашений о языках и региональных параметрах, которые использовались для создания строки даты, невозможно определить, представляют ли 01.03.2011, 01.03.2011 и 01.03.2011 г. 3 января 2011 г. или 1 марта 2011 г.

using namespace System;
using namespace System::Globalization;

void main()
{
   DateTime^ date = gcnew DateTime(2011, 3, 1);
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"), 
                                                               gcnew CultureInfo("fr-FR") };

   for each (CultureInfo^ culture in cultures)
      Console::WriteLine("{0,-12} {1}", String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date->ToString("d", culture));                                    
}
// The example displays the following output: 
//       Invariant    03/01/2011 
//       en-US        3/1/2011 
//       fr-FR        01/03/2011

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011

open System
open System.Globalization

let date = DateTime(2011, 3, 1)
let cultures = 
      [| CultureInfo.InvariantCulture
         CultureInfo "en-US"
         CultureInfo "fr-FR" |]

for culture in cultures do
    printfn $"""{(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),-12} {date.ToString("d", culture)}"""
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dat As Date = #3/1/2011#
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        New CultureInfo("en-US"), 
                                        New CultureInfo("fr-FR") }

      For Each culture In cultures
         Console.WriteLine("{0,-12} {1}", If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.ToString("d", culture))
      Next                                                         
   End Sub
End Module
' The example displays the following output:
'       Invariant    03/01/2011
'       en-US        3/1/2011
'       fr-FR        01/03/2011

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

using namespace System;
using namespace System::Globalization;

void main()
{
   String^ dateString = "07/10/2011";
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               CultureInfo::CreateSpecificCulture("en-GB"), 
                                                               CultureInfo::CreateSpecificCulture("en-US") };
   Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                "Month", "Day");
   for each (CultureInfo^ culture in cultures) {
      DateTime date = DateTime::Parse(dateString, culture);
      Console::WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                        String::IsNullOrEmpty(culture->Name) ?
                        "Invariant" : culture->Name, 
                        date.Month, date.Day);
   }                      
}
// The example displays the following output: 
//       Date String     Culture    Month      Day 
//        
//       07/10/2011    Invariant        7       10 
//       07/10/2011        en-GB       10        7 
//       07/10/2011        en-US        7       10

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      string dateString = "07/10/2011";
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 CultureInfo.CreateSpecificCulture("en-GB"), 
                                 CultureInfo.CreateSpecificCulture("en-US") };
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}\n", "Date String", "Culture", 
                                                 "Month", "Day");
      foreach (var culture in cultures) {
         DateTime date = DateTime.Parse(dateString, culture);
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.Month, date.Day);
      }                      
   }
}
// The example displays the following output:
//       Date String     Culture    Month      Day
//       
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10

open System
open System.Globalization

let dateString = "07/10/2011"
let cultures = 
    [| CultureInfo.InvariantCulture
       CultureInfo.CreateSpecificCulture "en-GB"
       CultureInfo.CreateSpecificCulture "en-US" |]
printfn $"""{"Date String",-12} {"Culture",10} {"Month",8} {"Day",8}\n"""
for culture in cultures do
    let date = DateTime.Parse(dateString, culture)
    printfn $"""{dateString,-12} {(if String.IsNullOrEmpty culture.Name then "Invariant" else culture.Name),10} {date.Month,8} {date.Day,8}"""
// The example displays the following output:
//       Date String     Culture    Month      Day
//
//       07/10/2011    Invariant        7       10
//       07/10/2011        en-GB       10        7
//       07/10/2011        en-US        7       10

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim dateString As String = "07/10/2011"
      Dim cultures() As CultureInfo = { CultureInfo.InvariantCulture, 
                                        CultureInfo.CreateSpecificCulture("en-GB"), 
                                        CultureInfo.CreateSpecificCulture("en-US") }
      Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", "Date String", "Culture", 
                                                 "Month", "Day")
      Console.WriteLine()                                                 
      For Each culture In cultures
         Dim dat As Date = DateTime.Parse(dateString, culture)
         Console.WriteLine("{0,-12} {1,10} {2,8} {3,8}", dateString, 
                           If(String.IsNullOrEmpty(culture.Name), 
                           "Invariant", culture.Name), 
                           dat.Month, dat.Day)
      Next
   End Sub
End Module
' The example displays the following output:
'       Date String     Culture    Month      Day
'       
'       07/10/2011    Invariant        7       10
'       07/10/2011        en-GB       10        7
'       07/10/2011        en-US        7       10

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

Соглашения о сравнении и сортировке строк зависят от языка и региональных параметров. Например, порядок сортировки может основываться на фонетике или визуальном представлении символов. В восточноазиатских языках символы сортируются по росчерку и радикальным идиографам. Сортировка также зависит от языков порядка и региональных параметров, используемых для алфавита. Например, датский язык имеет символ "Æ", который сортируется после "Z" в алфавите. Кроме того, в сравнениях может учитываться регистр или регистр, а правила регистра могут отличаться в зависимости от языка и региональных параметров. Порядковое сравнение, с другой стороны, использует кодовые точки Юникода отдельных символов в строке при сравнении и сортировке строк.

Правила сортировки определяют алфавитный порядок символов Юникода и то, как две строки сравниваются друг с другом. Например, String.Compare(String, String, StringComparison) метод сравнивает две строки на StringComparison основе параметра . Если значение параметра равно StringComparison.CurrentCulture, метод выполняет лингвистическое сравнение, которое использует соглашения текущего языка и региональных параметров; если значение параметра равно StringComparison.Ordinal, метод выполняет порядковое сравнение. Следовательно, как показано в следующем примере, если текущим языком и региональными параметрами является английский (США), первый вызов String.Compare(String, String, StringComparison) метода (с использованием сравнения с учетом языка и региональных параметров) считает "a" меньше ,чем "A", а второй вызов того же метода (с использованием порядкового сравнения) считает "a" больше "A".

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("en-US");
   Console::WriteLine(String::Compare("A", "a", StringComparison::CurrentCulture));
   Console::WriteLine(String::Compare("A", "a", StringComparison::Ordinal));
}
// The example displays the following output: 
//       1 
//       -32

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32

open System
open System.Globalization
open System.Threading

Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "en-US"
printfn $"""{String.Compare("A", "a", StringComparison.CurrentCulture)}"""
printfn $"""{String.Compare("A", "a", StringComparison.Ordinal)}"""
// The example displays the following output:
//       1
//       -32

Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US")
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture))
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       1                                                                                     
'       -32

.NET поддерживает правила сортировки слов, строк и порядковых номеров:

Сортировка слов выполняет сравнение строк с учетом языка и региональных параметров, в которых некоторым символам Юникода могут быть назначены специальные весовые коэффициенты. Например, дефису (-) может быть присвоен очень небольшой вес, чтобы "coop" и "co-op" отображались рядом друг с другом в отсортированных списках. Список String методов, сравнивающих две строки с помощью правил сортировки слов, см. в разделе Строковые операции по категориям .
Сортировка строк также выполняет сравнение с учетом языка и региональных параметров. Это похоже на сортировку слов, за исключением того, что не существует особых случаев, и все неальфаковые цифровые символы находятся перед всеми буквенно-цифровыми символами Юникода. Две строки можно сравнить с помощью правил сортировки строк, вызвав CompareInfo.Compare перегрузки метода с параметром options , который предоставляется со значением CompareOptions.StringSort. Обратите внимание, что это единственный метод, который предоставляет .NET для сравнения двух строк с помощью правил сортировки строк.
Порядковая сортировка сравнивает строки на основе числовых значений каждого Char объекта в строке. Порядковый номер сравнения автоматически учитывает регистр, так как строчные и прописные версии символа имеют разные кодовые точки. Однако если регистр не важен, можно указать порядковый номер сравнения, игнорирующий регистр. Это эквивалентно преобразованию строки в верхний регистр с помощью инвариантного языка и региональных параметров, а затем выполнения порядкового сравнения результата. Список String методов, сравнивающих две строки с помощью порядковых правил сортировки, см. в разделе Строковые операции по категориям .

Сравнение с учетом языка и региональных параметров — это любое сравнение, которое явно или неявно использует CultureInfo объект , включая инвариантный язык и региональные параметры, заданные свойством CultureInfo.InvariantCulture . Неявным языком и региональными параметрами является текущий язык и региональные параметры, заданные Thread.CurrentCulture свойствами и CultureInfo.CurrentCulture . Порядок сортировки алфавитных символов (то есть символов, для которых Char.IsLetter свойство возвращает true) в разных языках и региональных параметрах значительно отличается. Вы можете указать сравнение с учетом языка и региональных параметров, которое использует соглашения определенного языка и региональных параметров, предоставив CultureInfo объект методу сравнения строк, например Compare(String, String, CultureInfo, CompareOptions). Вы можете указать сравнение с учетом языка и региональных параметров, которое использует соглашения текущего языка и региональных параметров, указав StringComparison.CurrentCulture, или любой член перечисления, StringComparison.CurrentCultureIgnoreCaseотличный CompareOptions от CompareOptions.Ordinal или CompareOptions.OrdinalIgnoreCase , соответствующей перегрузке Compare метода . Сравнение с учетом языка и региональных параметров обычно подходит для сортировки, а порядковый номер — нет. Порядковое сравнение обычно подходит для определения равенства двух строк (т. е. для определения идентификатора), в то время как сравнение с учетом языка и региональных параметров — нет.

В следующем примере показана разница между сравнением с учетом языка и региональных параметров и порядкового номера. В примере вычисляются три строки: "Apple", "Æble" и "AEble", используя порядковое сравнение и соглашения языка и региональных параметров da-DK и en-US (каждый из которых является языком и региональными параметрами по умолчанию на момент Compare вызова метода). Поскольку датский язык рассматривает символ "Æ" как отдельную букву и сортирует его после "Z" в алфавите, строка "Æble" больше,чем "Apple". Однако "Æble" не считается эквивалентом "AEble", поэтому "Æble" также больше, чем "AEble". Язык en-US не включает букву "Æ", но рассматривает ее как эквивалент "AE", что объясняет, почему "Æble" меньше, чем "Apple", но равно "AEble". Порядковый номер сравнения, с другой стороны, считает, что "Apple" меньше, чем "Æble", а "Æble" — больше, чем "AEble".

using System;
using System.Globalization;
using System.Threading;

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";
      
      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133

open System
open System.Globalization
open System.Threading

let str1 = "Apple"
let str2 = "Æble"
let str3 = "AEble"

// Set the current culture to Danish in Denmark.
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"

// Set the current culture to English in the U.S.
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
printfn $"Current culture: {CultureInfo.CurrentCulture.Name}"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n"

// Perform an ordinal comparison.
printfn "Ordinal comparison"
printfn $"Comparison of {str1} with {str2}: {String.Compare(str1, str2, StringComparison.Ordinal)}"
printfn $"Comparison of {str2} with {str3}: {String.Compare(str2, str3, StringComparison.Ordinal)}"
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133

Imports System.Globalization
Imports System.Threading

Public Module Example
   Public Sub Main()
      Dim str1 As String = "Apple"
      Dim str2 As String = "Æble"
      Dim str3 As String = "AEble"
      
      ' Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name)
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, String.Compare(str2, str3))
      Console.WriteLine()
      
      ' Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison")
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal))
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal))
   End Sub
End Module
' The example displays the following output:
'       Current culture: da-DK
'       Comparison of Apple with Æble: -1
'       Comparison of Æble with AEble: 1
'       
'       Current culture: en-US
'       Comparison of Apple with Æble: 1
'       Comparison of Æble with AEble: 0
'       
'       Ordinal comparison
'       Comparison of Apple with Æble: -133
'       Comparison of Æble with AEble: 133

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

Если вы хотите, чтобы строки упорядочивалися на основе языка и региональных параметров пользователя, следует упорядочить их на основе соглашений о текущем языке и региональных параметрах. Если язык и региональные параметры пользователя изменяются, порядок отсортированных строк также изменится соответствующим образом. Например, приложение тезауруса всегда должно сортировать слова на основе языка и региональных параметров пользователя.
Если вы хотите, чтобы строки были упорядочены на основе соглашений конкретного языка и региональных параметров, их следует упорядочить, предоставив CultureInfo объект, представляющий этот язык и региональные параметры, методу сравнения. Например, в приложении, предназначенном для обучения учащихся определенному языку, требуется упорядочить строки на основе соглашений одного из языков, говорящих на этом языке.
Если вы хотите, чтобы порядок строк оставался неизменным в разных языках и региональных параметрах, следует упорядочить их на основе соглашений инвариантного языка и региональных параметров или использовать порядковое сравнение. Например, порядковая сортировка используется для упорядочения имен файлов, процессов, мьютексов или именованных каналов.
Для сравнения, включающего решение о безопасности (например, допустимо ли имя пользователя), следует всегда выполнять порядковую проверку на равенство путем вызова перегрузки Equals метода .

Примечание

Правила сортировки и регистра с учетом языка и региональных параметров, используемые при сравнении строк, зависят от версии .NET. В .NET Core сравнение строк зависит от версии Стандарта Юникод, поддерживаемой базовой операционной системой. В платформа .NET Framework 4.5 и более поздних версиях, работающих в Windows 8 или более поздних версиях, сортировка, регистр, нормализация и символьные данные Юникода соответствуют стандарту Юникода 6.0. В других операционных системах Windows они соответствуют стандарту Юникода 5.0.

Дополнительные сведения о текстовых, строковых и порядковых правилах сортировки см. в System.Globalization.CompareOptions этой статье. Дополнительные рекомендации по использованию каждого правила см. в разделе Рекомендации по использованию строк.

Как правило, вы не вызываете методы сравнения строк, такие как Compare напрямую, чтобы определить порядок сортировки строк. Вместо этого методы сравнения вызываются методами сортировки, такими как Array.Sort или List<T>.Sort. В следующем примере выполняется четыре различных операции сортировки (сортировка слов с использованием текущего языка и региональных параметров, сортировка слов с помощью инвариантного языка и региональных параметров, сортировка порядковых номеров и сортировка строк с помощью инвариантного языка и региональных параметров) без явного вызова метода сравнения строк, хотя они и указывают используемый тип сравнения. Обратите внимание, что каждый тип сортировки создает уникальный порядок строк в своем массиве.

using namespace System;
using namespace System::Collections;
using namespace System::Collections::Generic;
using namespace System::Globalization;

// IComparer<String> implementation to perform string sort. 
ref class SCompare : System::Collections::Generic::IComparer<String^>
{
public:
   SCompare() {};

   virtual int Compare(String^ x, String^ y)
   {
      return CultureInfo::CurrentCulture->CompareInfo->Compare(x, y, CompareOptions::StringSort);
   }
};

void main()
{
   array<String^>^ strings = gcnew array<String^> { "coop", "co-op", "cooperative", 
                                                    L"co\x00ADoperative", L"c�ur", "coeur" };

   // Perform a word sort using the current (en-US) culture. 
   array<String^>^ current = gcnew array<String^>(strings->Length); 
   strings->CopyTo(current, 0); 
   Array::Sort(current, StringComparer::CurrentCulture);

   // Perform a word sort using the invariant culture. 
   array<String^>^ invariant = gcnew array<String^>(strings->Length);
   strings->CopyTo(invariant, 0); 
   Array::Sort(invariant, StringComparer::InvariantCulture);

   // Perform an ordinal sort. 
   array<String^>^ ordinal = gcnew array<String^>(strings->Length);
   strings->CopyTo(ordinal, 0); 
   Array::Sort(ordinal, StringComparer::Ordinal);

   // Perform a string sort using the current culture. 
   array<String^>^ stringSort = gcnew array<String^>(strings->Length);
   strings->CopyTo(stringSort, 0); 
   Array::Sort(stringSort, gcnew SCompare());

   // Display array values
   Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                     "Original", "Word Sort", "Invariant Word", 
                     "Ordinal Sort", "String Sort");
   for (int ctr = 0; ctr < strings->Length; ctr++)
      Console::WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                         strings[ctr], current[ctr], invariant[ctr], 
                         ordinal[ctr], stringSort[ctr] );          
}
// The example displays the following output: 
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort 
//     
//             coop          c�ur            c�ur         co-op         co-op 
//            co-op         coeur           coeur         coeur          c�ur 
//      cooperative          coop            coop          coop         coeur 
//      co�operative         co-op           co-op   cooperative          coop 
//             c�ur   cooperative     cooperative   co�operative   cooperative 
//            coeur   co�operative     co�operative          c�ur   co�operative

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
 
public class Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

      // Perform a word sort using the current (en-US) culture.
      string[] current = new string[strings.Length]; 
      strings.CopyTo(current, 0); 
      Array.Sort(current, StringComparer.CurrentCulture);

      // Perform a word sort using the invariant culture.
      string[] invariant = new string[strings.Length];
      strings.CopyTo(invariant, 0); 
      Array.Sort(invariant, StringComparer.InvariantCulture);

      // Perform an ordinal sort.
      string[] ordinal = new string[strings.Length];
      strings.CopyTo(ordinal, 0); 
      Array.Sort(ordinal, StringComparer.Ordinal);

      // Perform a string sort using the current culture.
      string[] stringSort = new string[strings.Length];
      strings.CopyTo(stringSort, 0); 
      Array.Sort(stringSort, new SCompare());

      // Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}\n", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort");
      for (int ctr = 0; ctr < strings.Length; ctr++)
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings[ctr], current[ctr], invariant[ctr], 
                           ordinal[ctr], stringSort[ctr] );          
   }
}

// IComparer<String> implementation to perform string sort.
internal class SCompare : IComparer<String>
{
   public int Compare(string x, string y)
   {
      return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort);
   }
}
// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//    
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     cooperative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  cooperative   cooperative
//            coeur  cooperative    cooperative          cœur  cooperative

open System
open System.Collections.Generic
open System.Globalization

// IComparer<String> implementation to perform string sort using an F# object expression.
let scompare = 
    { new IComparer<String> with
        member _.Compare(x, y) =
            CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort) }

let strings = [| "coop"; "co-op"; "cooperative"; "co\u00ADoperative"; "cœur"; "coeur" |]

// Perform a word sort using the current (en-US) culture.
let current = Array.copy strings
Array.Sort(current, StringComparer.CurrentCulture)

// Perform a word sort using the invariant culture.
let invariant = Array.copy strings
Array.Sort(invariant, StringComparer.InvariantCulture)

// Perform an ordinal sort.
let ordinal = Array.copy strings
Array.Sort(ordinal, StringComparer.Ordinal)

// Perform a string sort using the current culture.
let stringSort = Array.copy strings
Array.Sort(stringSort, scompare)

// Display array values
printfn "%13s %13s %15s %13s %13s\n" "Original" "Word Sort" "Invariant Word" "Ordinal Sort" "String Sort"
for i = 0 to strings.Length - 1 do
    printfn "%13s %13s %15s %13s %13s\n" strings[i] current[i] invariant[i] ordinal[i] stringSort[i]

// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     cooperative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  cooperative   cooperative
//            coeur  cooperative    cooperative          cœur  cooperative

Imports System.Collections
Imports System.Collections.Generic
Imports System.Globalization

Module Example
   Public Sub Main()
      Dim strings() As String = { "coop", "co-op", "cooperative", 
                                  "co" + ChrW(&h00AD) + "operative", 
                                  "cœur", "coeur" }

      ' Perform a word sort using the current (en-US) culture.
      Dim current(strings.Length - 1) As String  
      strings.CopyTo(current, 0) 
      Array.Sort(current, StringComparer.CurrentCulture)

      ' Perform a word sort using the invariant culture.
      Dim invariant(strings.Length - 1) As String
      strings.CopyTo(invariant, 0) 
      Array.Sort(invariant, StringComparer.InvariantCulture)

      ' Perform an ordinal sort.
      Dim ordinal(strings.Length - 1) As String
      strings.CopyTo(ordinal, 0) 
      Array.Sort(ordinal, StringComparer.Ordinal)

      ' Perform a string sort using the current culture.
      Dim stringSort(strings.Length - 1) As String
      strings.CopyTo(stringSort, 0) 
      Array.Sort(stringSort, new SCompare())

      ' Display array values
      Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                        "Original", "Word Sort", "Invariant Word", 
                        "Ordinal Sort", "String Sort")
      Console.WriteLine()
                                                      
      For ctr As Integer = 0 To strings.Length - 1
         Console.WriteLine("{0,13} {1,13} {2,15} {3,13} {4,13}", 
                           strings(ctr), current(ctr), invariant(ctr), 
                           ordinal(ctr), stringSort(ctr))   
      Next                                  
   End Sub
End Module

' IComparer<String> implementation to perform string sort.
Friend Class SCompare : Implements IComparer(Of String)
   Public Function Compare(x As String, y As String) As Integer _
                   Implements IComparer(Of String).Compare
      Return CultureInfo.CurrentCulture.CompareInfo.Compare(x, y, CompareOptions.StringSort)
   End Function
End Class
' The example displays the following output:
'         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
'    
'             coop          cœur            cœur         co-op         co-op
'            co-op         coeur           coeur         coeur          cœur
'      cooperative          coop            coop          coop         coeur
'     cooperative         co-op           co-op   cooperative          coop
'             cœur   cooperative     cooperative  cooperative   cooperative
'            coeur  cooperative    cooperative          cœur  cooperative

Совет

Внутри .NET использует ключи сортировки для поддержки сравнения строк с учетом языка и региональных параметров. Каждому символу в строке присваивается несколько категорий весов сортировки, включая алфавитный, регистр и диакритический. Ключ сортировки, представленный классом SortKey , предоставляет репозиторий этих весовых коэффициентов для определенной строки. Если приложение выполняет большое количество операций поиска или сортировки в одном наборе строк, вы можете повысить его производительность, создав и сохранив ключи сортировки для всех строк, которые оно использует. Если требуется операция сортировки или сравнения, вместо строк используются ключи сортировки. Дополнительные сведения см. в описании класса SortKey.

Если не указать соглашение о сравнении строк, методы сортировки, такие как Array.Sort(Array) сортировка строк с учетом языка и региональных параметров с учетом регистра. В следующем примере показано, как изменение текущего языка и региональных параметров влияет на порядок отсортированных строк в массиве. Он создает массив из трех строк. Во-первых System.Threading.Thread.CurrentThread.CurrentCulture , он задает свойству значение en-US и вызывает Array.Sort(Array) метод . Итоговый порядок сортировки основан на соглашениях о сортировке для английского языка (США) языка и региональных параметров. Далее в примере свойству System.Threading.Thread.CurrentThread.CurrentCulture присваивается значение da-DK и снова вызывается Array.Sort метод . Обратите внимание, что результирующий порядок сортировки отличается от результатов en-US, так как в нем используются соглашения о сортировке для Датского (Дания).

using System;
using System.Globalization;
using System.Threading;

public class ArraySort
{
   public static void Main(String[] args)
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray);
   }
   public static void PrintIndexAndValues(string[] myArray)
   {
      for (int i = myArray.GetLowerBound(0); i <=
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble

open System
open System.Globalization
open System.Threading

let printIndexAndValues (myArray: string[]) =
    for i = myArray.GetLowerBound 0 to myArray.GetUpperBound 0 do
        printfn $"[{i}]: {myArray[i]}" 
    printfn ""

// Create and initialize a new array to store the strings.
let stringArray = [| "Apple"; "Æble"; "Zebra" |]

// Display the values of the array.
printfn "The original string array:"
printIndexAndValues stringArray

// Set the CurrentCulture to "en-US".
Thread.CurrentThread.CurrentCulture <- CultureInfo "en-US"
// Sort the values of the array.
Array.Sort stringArray

// Display the values of the array.
printfn "After sorting for the culture \"en-US\":"
printIndexAndValues stringArray

// Set the CurrentCulture to "da-DK".
Thread.CurrentThread.CurrentCulture <- CultureInfo "da-DK"
// Sort the values of the Array.
Array.Sort stringArray

// Display the values of the array.
printfn "After sorting for the culture \"da-DK\":"
printIndexAndValues stringArray
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble

Imports System.Globalization
Imports System.IO
Imports System.Threading

Public Class TextToFile   
   Public Shared Sub Main()
      ' Creates and initializes a new array to store 
      ' these date/time objects.
      Dim stringArray() As String = { "Apple", "Æble", "Zebra"}
      
      ' Displays the values of the array.
      Console.WriteLine("The original string array:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("en-US")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Display the values of the array.
      Console.WriteLine("After sorting for the ""en-US"" culture:")
      PrintIndexAndValues(stringArray)
      
      ' Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = New CultureInfo("da-DK")
      ' Sort the values of the Array.
      Array.Sort(stringArray)
      
      ' Displays the values of the Array.
      Console.WriteLine("After sorting for the culture ""da-DK"":")
      PrintIndexAndValues(stringArray)
   End Sub

   Public Shared Sub PrintIndexAndValues(myArray() As String)
      For i As Integer = myArray.GetLowerBound(0) To myArray.GetUpperBound(0)
         Console.WriteLine("[{0}]: {1}", i, myArray(i))
      Next
      Console.WriteLine()
   End Sub 
End Class
' The example displays the following output:
'       The original string array:
'       [0]: Apple
'       [1]: Æble
'       [2]: Zebra
'       
'       After sorting for the "en-US" culture:
'       [0]: Æble
'       [1]: Apple
'       [2]: Zebra
'       
'       After sorting for the culture "da-DK":
'       [0]: Apple
'       [1]: Zebra
'       [2]: Æble

Предупреждение

Если основной целью сравнения строк является определение их равенства, следует вызвать String.Equals метод . Как правило, для выполнения порядкового сравнения следует использовать Equals . Метод String.Compare предназначен в основном для сортировки строк.

Методы поиска строк, такие как String.StartsWith и String.IndexOf, также могут выполнять сравнение строк с учетом языка и региональных параметров или порядкового номера. В следующем примере показаны различия между порядковый номер и сравнение с учетом языка и региональных параметров с помощью IndexOf метода . Поиск с учетом языка и региональных параметров, в котором текущим языком и региональными параметрами является английский (США), считает подстроку "oe" в соответствии с лигатурой "й". Так как мягкий дефис (U+00AD) является символом нулевой ширины, поиск рассматривает мягкий дефис как эквивалент Empty и находит совпадение в начале строки. Порядковый поиск, с другой стороны, не находит совпадение ни в том, ни в другом случае.

using namespace System;

void FindInString(String^ s, String^ substring, StringComparison options);

void main()
{
   // Search for "oe" and "�u" in "�ufs" and "oeufs".
   String^ s1 = L"�ufs";
   String^ s2 = L"oeufs";
   FindInString(s1, "oe", StringComparison::CurrentCulture);
   FindInString(s1, "oe", StringComparison::Ordinal);
   FindInString(s2, "�u", StringComparison::CurrentCulture);
   FindInString(s2, "�u", StringComparison::Ordinal);
   Console::WriteLine();

   String^ s3 = L"co\x00ADoperative";
   FindInString(s3, L"\x00AD", StringComparison::CurrentCulture);
   FindInString(s3, L"\x00AD", StringComparison::Ordinal);
}

void FindInString(String^ s, String^ substring, StringComparison options)
{
   int result = s->IndexOf(substring, options);
   if (result != -1)
      Console::WriteLine("'{0}' found in {1} at position {2}", 
                        substring, s, result);
   else
      Console::WriteLine("'{0}' not found in {1}", 
                        substring, s);                                                  
}
// The example displays the following output:
//      'oe' found in oufs at position 0
//      'oe' not found in oufs
//      'ou' found in oeufs at position 0
//      'ou' not found in oeufs
//
//      '-' found in co-operative at position 0
//      '-' found in co-operative at position 2

using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();
      
      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '' found in cooperative at position 0
//       '' found in cooperative at position 2

open System

let findInString (s: string) (substring: string) (options: StringComparison) =
    let result = s.IndexOf(substring, options)
    if result <> -1 then
        printfn $"'{substring}' found in {s} at position {result}"
    else
        printfn $"'{substring}' not found in {s}"

// Search for "oe" and "œu" in "œufs" and "oeufs".
let s1 = "œufs"
let s2 = "oeufs"
findInString s1 "oe" StringComparison.CurrentCulture
findInString s1 "oe" StringComparison.Ordinal
findInString s2 "œu" StringComparison.CurrentCulture
findInString s2 "œu" StringComparison.Ordinal
printfn ""

let s3 = "co\u00ADoperative"
findInString s3 "\u00AD" StringComparison.CurrentCulture
findInString s3 "\u00AD" StringComparison.Ordinal

// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//
//       '' found in cooperative at position 0
//       '' found in cooperative at position 2

Module Example
   Public Sub Main()
      ' Search for "oe" and "œu" in "œufs" and "oeufs".
      Dim s1 As String = "œufs"
      Dim s2 As String = "oeufs"
      FindInString(s1, "oe", StringComparison.CurrentCulture)
      FindInString(s1, "oe", StringComparison.Ordinal)
      FindInString(s2, "œu", StringComparison.CurrentCulture)
      FindInString(s2, "œu", StringComparison.Ordinal)
      Console.WriteLine()
      
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s3 As String = "co" + softHyphen + "operative"
      FindInString(s3, softHyphen, StringComparison.CurrentCulture)
      FindInString(s3, softHyphen, StringComparison.Ordinal)
   End Sub

   Private Sub FindInString(s As String, substring As String, 
                            options As StringComparison)
      Dim result As Integer = s.IndexOf(substring, options)
      If result <> -1
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result)
      Else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s)
      End If                                                                          
   End Sub
End Module
' The example displays the following output:
'       'oe' found in œufs at position 0
'       'oe' not found in œufs
'       'œu' found in oeufs at position 0
'       'œu' not found in oeufs
'       
'       '' found in cooperative at position 0
'       '' found in cooperative at position 2

Поиск в строках

Методы поиска строк, такие как String.StartsWith и , также могут выполнять сравнения строк с учетом языка и String.IndexOfрегиональных параметров или порядковых номеров, чтобы определить, найден ли символ или подстрока в указанной строке.

Методы поиска в String классе, которые ищут отдельный символ, например IndexOf метод, или один из наборов символов, например IndexOfAny метод , выполняют порядковый поиск. Чтобы выполнить поиск символа с учетом языка и региональных параметров, необходимо вызвать CompareInfo метод, например CompareInfo.IndexOf(String, Char) или CompareInfo.LastIndexOf(String, Char). Обратите внимание, что результаты поиска символа с помощью порядкового и языкового сравнения могут быть очень разными. Например, поиск предварительно скомпилированного символа Юникода, например лигатуры "Æ" (U+00C6), может соответствовать любому вхождениям его компонентов в правильной последовательности, например "AE" (U+041U+0045), в зависимости от языка и региональных параметров. В следующем примере показана разница между методами String.IndexOf(Char) и CompareInfo.IndexOf(String, Char) при поиске отдельного символа. Лигатура "æ" (U+00E6) находится в строке "aerial" при использовании соглашений языка и региональных параметров en-US, но не при использовании соглашений языка и региональных параметров da-DK или при выполнении порядкового сравнения.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6
      
      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));
      
      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0

open System.Globalization

let cultureNames = [| "da-DK"; "en-US" |]
let str = "aerial"
let ch = 'æ'  // U+00E6

printf "Ordinal comparison -- "
printfn $"Position of '{ch}' in {str}: {str.IndexOf ch}"
                  
for cultureName in cultureNames do
    let ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
    printf $"{cultureName} cultural comparison -- "
    printfn $"Position of '{ch}' in {str}: {ci.IndexOf(str, ch)}"
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim cultureNames() As String = { "da-DK", "en-US" }
      Dim ci As CompareInfo
      Dim str As String = "aerial"
      Dim ch As Char = "æ"c  ' U+00E6
      
      Console.Write("Ordinal comparison -- ")
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch))
      
      For Each cultureName In cultureNames
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo
         Console.Write("{0} cultural comparison -- ", cultureName)
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch))
      Next
   End Sub
End Module
' The example displays the following output:
'       Ordinal comparison -- Position of 'æ' in aerial: -1
'       da-DK cultural comparison -- Position of 'æ' in aerial: -1
'       en-US cultural comparison -- Position of 'æ' in aerial: 0

С другой стороны, методы класса, которые ищут строку, String а не символ, выполняют поиск с учетом языка и региональных параметров, если параметры поиска явно не указаны параметром типа StringComparison. Единственным исключением является Contains, который выполняет порядковый поиск.

Тестирование на равенство

Используйте метод , String.Compare чтобы определить связь двух строк в порядке сортировки. Как правило, это операция с учетом языка и региональных параметров. В отличие от этого, вызовите String.Equals метод для проверки на равенство. Поскольку проверка на равенство обычно сравнивает введенные пользователем данные с некоторой известной строкой, такой как допустимое имя пользователя, пароль или путь к файловой системе, обычно это порядковый номер.

Предупреждение

Можно проверить равенство, вызвав String.Compare метод и определив, равно ли возвращаемое значение нулю. Однако такая практика не рекомендуется. Чтобы определить, равны ли две строки, необходимо вызвать одну из перегрузок String.Equals метода . Предпочтительной перегрузкой для вызова является метод экземпляра Equals(String, StringComparison) или статический Equals(String, String, StringComparison) метод, так как оба метода включают System.StringComparison параметр, который явно указывает тип сравнения.

В следующем примере показана опасность выполнения сравнения с учетом языка и региональных параметров на равенство, если вместо него следует использовать порядковый номер. В этом случае код предназначен для запрета доступа к файловой системе с URL-адресов, которые начинаются с "FILE://" или "file://", путем сравнения начала URL-адреса без учета регистра со строкой "FILE://". Однако если сравнение с учетом языка и региональных параметров выполняется с использованием языка и региональных параметров (Турция) в URL-адресе, который начинается с "file://", сравнение на равенство завершается ошибкой, так как эквивалент нижнего регистра "i" на турецком языке является "İ" вместо "I". В результате доступ к файловой системе непреднамеренно разрешен. С другой стороны, если выполняется порядковый номер сравнения, сравнение на равенство будет выполнено успешно, и доступ к файловой системе будет запрещен.

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

bool TestForEquality(String^ str, StringComparison cmp);

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("tr-TR");      

   String^ filePath = "file://c:/notes.txt";

   Console::WriteLine("Culture-sensitive test for equality:");
   if (! TestForEquality(filePath, StringComparison::CurrentCultureIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);

   Console::WriteLine("\nOrdinal test for equality:");
   if (! TestForEquality(filePath, StringComparison::OrdinalIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);
}

bool TestForEquality(String^ str, StringComparison cmp)
{
      int position = str->IndexOf("://");
      if (position < 0) return false;

      String^ substring = str->Substring(0, position);  
      return substring->Equals("FILE", cmp);
}
// The example displays the following output: 
//       Culture-sensitive test for equality: 
//       Access to file://c:/notes.txt is allowed. 
//        
//       Ordinal test for equality: 
//       Access to file://c:/notes.txt is not allowed.

using System;
using System.Globalization;
using System.Threading;

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";
      
      Console.WriteLine("Culture-sensitive test for equality:");
      if (! TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
      
      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.

open System
open System.Globalization
open System.Threading

let testForEquality (str: string) (cmp: StringComparison) =
    let position = str.IndexOf "://"
    if position < 0 then false
    else
        let substring = str.Substring(0, position)
        substring.Equals("FILE", cmp)

Thread.CurrentThread.CurrentCulture <- CultureInfo.CreateSpecificCulture "tr-TR"

let filePath = "file://c:/notes.txt"

printfn "Culture-sensitive test for equality:"
if not (testForEquality filePath StringComparison.CurrentCultureIgnoreCase) then
    printfn $"Access to {filePath} is allowed."
else
    printfn $"Access to {filePath} is not allowed."

printfn "\nOrdinal test for equality:"
if not (testForEquality filePath StringComparison.OrdinalIgnoreCase) then
    printfn $"Access to {filePath} is allowed."
else
    printfn $"Access to {filePath} is not allowed."

// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.

Imports System.Globalization
Imports System.Threading

Module Example
   Public Sub Main()
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR")      

      Dim filePath As String = "file://c:/notes.txt"
      
      Console.WriteLine("Culture-sensitive test for equality:")
      If Not TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
      Console.WriteLine()
      
      Console.WriteLine("Ordinal test for equality:")
      If Not TestForEquality(filePath, StringComparison.OrdinalIgnoreCase) Then
         Console.WriteLine("Access to {0} is allowed.", filePath)
      Else
         Console.WriteLine("Access to {0} is not allowed.", filePath)
      End If       
   End Sub
   
   Private Function TestForEquality(str As String, cmp As StringComparison) As Boolean
      Dim position As Integer = str.IndexOf("://")
      If position < 0 Then Return False

      Dim substring As String = str.Substring(0, position)  
      Return substring.Equals("FILE", cmp)
   End Function
End Module
' The example displays the following output:
'       Culture-sensitive test for equality:
'       Access to file://c:/notes.txt is allowed.
'       
'       Ordinal test for equality:
'       Access to file://c:/notes.txt is not allowed.

Нормализация

Некоторые символы Юникода имеют несколько представлений. Например, любая из следующих кодовых точек может представлять букву "ắ":

U+1EAF
U+0103 U+0301
U+0061 U+0306 U+0301

Несколько представлений для одного символа усложняют поиск, сортировку, сопоставление и другие строковые операции.

Стандарт Юникода определяет процесс, называемый нормализацией, который возвращает одно двоичное представление символа Юникода для любого из эквивалентных двоичных представлений. Нормализация может использовать несколько алгоритмов, называемых формами нормализации, которые следуют разным правилам. .NET поддерживает формы нормализации Юникода C, D, KC и KD. Если строки были нормализованы в той же форме нормализации, их можно сравнить с помощью порядкового сравнения.

Порядковое сравнение — это двоичное сравнение скалярного значения Юникода соответствующих Char объектов в каждой строке. Класс String включает в себя ряд методов, которые могут выполнять порядковое сравнение, в том числе следующие:

Любая перегрузка Compareметодов , Equals, StartsWith, EndsWith, IndexOfи LastIndexOf , которая включает StringComparison параметр . Метод выполняет порядковое сравнение, если вы указываете значение StringComparison.Ordinal или OrdinalIgnoreCase для этого параметра.
Перегрузки CompareOrdinal метода .
Методы, использующие порядковый номер по умолчанию, такие как Contains, Replaceи Split.
Методы, выполняющие поиск Char значения или элементов в массиве Char в строковом экземпляре. К таким методам относятся IndexOf(Char) и Split(Char[]).

Вы можете определить, нормализуется ли строка в форме нормализации C, вызвав String.IsNormalized() метод или вызвать String.IsNormalized(NormalizationForm) метод , чтобы определить, нормализуется ли строка в указанную форму нормализации. Можно также вызвать String.Normalize() метод для преобразования строки в форму нормализации C или вызвать String.Normalize(NormalizationForm) метод для преобразования строки в указанную форму нормализации. Пошаговые сведения о нормализации и сравнении строк см. в Normalize() методах и Normalize(NormalizationForm) .

В следующем простом примере показана нормализация строк. Он определяет букву "ố" тремя различными способами в трех разных строках и использует порядковое сравнение для равенства, чтобы определить, что каждая строка отличается от двух других строк. Затем каждая строка преобразуется в поддерживаемые формы нормализации и снова выполняет порядковое сравнение каждой строки в указанной форме нормализации. В каждом случае второй тест на равенство показывает, что строки равны.

using namespace System;
using namespace System::Globalization;
using namespace System::IO;
using namespace System::Text;

public ref class Example
{
private:
   StreamWriter^ sw;

   void TestForEquality(... array<String^>^  words)
   {
      for (int ctr = 0; ctr <= words->Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words->Length - 1; ctr2++) 
            sw->WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr]->Equals(words[ctr2], StringComparison::Ordinal));
   }

   String^ ShowBytes(String^ str)
   {
      String^ result = nullptr;
      for each (Char ch in str)
         result += String::Format("{0} ", Convert::ToUInt16(ch).ToString("X4")); 
      return result->Trim();            
   } 

   array<String^>^ NormalizeStrings(NormalizationForm nf, ... array<String^>^ words)
   {
      for (int ctr = 0; ctr < words->Length; ctr++)
         if (! words[ctr]->IsNormalized(nf))
            words[ctr] = words[ctr]->Normalize(nf); 
      return words;   
   }

public: 
   void Execute()
   {
      sw = gcnew StreamWriter(".\\TestNorm1.txt");

      // Define three versions of the same word.  
      String^ s1 = L"sống";        // create word with U+1ED1 
      String^ s2 = L"s\x00F4\x0301ng";
      String^ s3 = L"so\x0302\x0301ng";

      TestForEquality(s1, s2, s3);      
      sw->WriteLine();

      // Normalize and compare strings using each normalization form. 
      for each (String^ formName in Enum::GetNames(NormalizationForm::typeid))
      {
         sw->WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum::Parse(NormalizationForm::typeid, formName);
         array<String^>^ sn = NormalizeStrings(nf, s1, s2, s3 );
         TestForEquality(sn);           
         sw->WriteLine("\n");                                        
      }

      sw->Close(); 
   }
};

void main()
{
   Example^ ex = gcnew Example();
   ex->Execute();
}
// The example produces the following output:
// The example displays the following output: 
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False 
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False 
//        
//       Normalization FormC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//        
//        
//       Normalization FormKC: 
//        
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True 
//        
//        
//       Normalization FormKD: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

using System;
using System.Globalization;
using System.IO;
using System.Text;

public class Example
{
   private static StreamWriter sw;
   
   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

      // Define three versions of the same word. 
      string s1 = "sống";        // create word with U+1ED1
      string s2 = "s\u00F4\u0301ng";
      string s3 = "so\u0302\u0301ng";

      TestForEquality(s1, s2, s3);      
      sw.WriteLine();

      // Normalize and compare strings using each normalization form.
      foreach (string formName in Enum.GetNames(typeof(NormalizationForm)))
      {
         sw.WriteLine("Normalization {0}:\n", formName); 
         NormalizationForm nf = (NormalizationForm) Enum.Parse(typeof(NormalizationForm), formName);
         string[] sn = NormalizeStrings(nf, s1, s2, s3);
         TestForEquality(sn);           
         sw.WriteLine("\n");                                        
      }
      
      sw.Close();   
   }

   private static void TestForEquality(params string[] words)
   {
      for (int ctr = 0; ctr <= words.Length - 2; ctr++)
         for (int ctr2 = ctr + 1; ctr2 <= words.Length - 1; ctr2++) 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words[ctr], ShowBytes(words[ctr]),
                         words[ctr2], ShowBytes(words[ctr2]),
                         words[ctr].Equals(words[ctr2], StringComparison.Ordinal));
   }

   private static string ShowBytes(string str)
   {
      string result = null;
      foreach (var ch in str)
         result += $"{(ushort)ch:X4} ";
      return result.Trim();            
   } 
   
   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       
//       Normalization FormC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       
//       
//       Normalization FormKC:
//       
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       
//       
//       Normalization FormKD:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

open System
open System.IO
open System.Text

do
    use sw = new StreamWriter(@".\TestNorm1.txt")

    let showBytes (str: string) =
        let mutable result = ""
        for ch in str do
            result <- result + $"{uint16 ch:X4} "
        result.Trim()
    
    let testForEquality (words: string[]) =
        for ctr = 0 to words.Length - 2 do
            for ctr2 = ctr + 1 to words.Length - 1 do
                sw.WriteLine("{0} ({1}) = {2} ({3}): {4}",
                            words[ctr], showBytes(words[ctr]),
                            words[ctr2], showBytes(words[ctr2]),
                            words[ctr].Equals(words[ctr2], StringComparison.Ordinal))

    let normalizeStrings nf (words: string[]) =
        for i = 0 to words.Length - 1 do
            if not (words[i].IsNormalized nf) then
                words[i] <- words[i].Normalize nf
        words

    // Define three versions of the same word.
    let s1 = "sống"        // create word with U+1ED1
    let s2 = "s\u00F4\u0301ng"
    let s3 = "so\u0302\u0301ng"

    testForEquality [| s1; s2; s3 |]
    sw.WriteLine()

    // Normalize and compare strings using each normalization form.
    for formName in Enum.GetNames typeof<NormalizationForm> do
        sw.WriteLine("Normalization {0}:\n", formName)
        let nf = Enum.Parse(typeof<NormalizationForm>, formName) :?> NormalizationForm
        let sn = normalizeStrings nf [| s1; s2; s3|]
        testForEquality sn
        sw.WriteLine "\n"

// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
//
//       Normalization FormC:
//
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//
//
//       Normalization FormD:
//
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//
//
//       Normalization FormKC:
//
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
//
//
//       Normalization FormKD:
//
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

Imports System.Globalization
Imports System.IO
Imports System.Text

Module Example
   Private sw As StreamWriter
       
   Public Sub Main()
      sw = New StreamWriter(".\TestNorm1.txt")

      ' Define three versions of the same word. 
      Dim s1 As String = "sống"        ' create word with U+1ED1
      Dim s2 AS String = "s" + ChrW(&h00F4) + ChrW(&h0301) + "ng"
      Dim s3 As String = "so" + ChrW(&h0302) + ChrW(&h0301) + "ng"

      TestForEquality(s1, s2, s3)      
      sw.WriteLine()

      ' Normalize and compare strings using each normalization form.
      For Each formName In [Enum].GetNames(GetType(NormalizationForm))
         sw.WriteLine("Normalization {0}:", formName) 
         Dim nf As NormalizationForm = CType([Enum].Parse(GetType(NormalizationForm), formName),  
                                             NormalizationForm)
         Dim sn() As String = NormalizeStrings(nf, s1, s2, s3)
         TestForEquality(sn)           
         sw.WriteLine(vbCrLf)                                        
      Next
      
      sw.Close()   
   End Sub

   Private Sub TestForEquality(ParamArray words As String())
      For ctr As Integer = 0 To words.Length - 2
         For ctr2 As Integer = ctr + 1 To words.Length - 1 
            sw.WriteLine("{0} ({1}) = {2} ({3}): {4}", 
                         words(ctr), ShowBytes(words(ctr)),
                         words(ctr2), ShowBytes(words(ctr2)),
                         words(ctr).Equals(words(ctr2), StringComparison.Ordinal))
         Next                
      Next   
   End Sub

   Private Function ShowBytes(str As String) As String
      Dim result As String = Nothing
      For Each ch In str
         result += String.Format("{0} ", Convert.ToUInt16(ch).ToString("X4")) 
      Next
      Return result.Trim()            
   End Function  
   
   Private Function NormalizeStrings(nf As NormalizationForm, ParamArray words() As String) As String()
      For ctr As Integer = 0 To words.Length - 1
         If Not words(ctr).IsNormalized(nf) Then
            words(ctr) = words(ctr).Normalize(nf)
         End If    
      Next
      Return words   
   End Function
End Module
' The example displays the following output:
'       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
'       sống (0073 1ED1 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       
'       Normalization FormC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       
'       
'       Normalization FormKC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormKD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

Дополнительные сведения о формах нормализации и нормализации см. в разделе System.Text.NormalizationForm, а также в стандартном приложении Юникода No 15: Формы нормализации Юникода и часто задаваемых вопросов о нормализации на веб-сайте unicode.org.

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

Класс String предоставляет члены для сравнения строк, проверки строк на равенство, поиска символов или подстрок в строке, изменения строки, извлечения подстрок из строки, объединения строк, форматирования значений, копирования строки и нормализации строки.

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

Вы можете сравнить строки, чтобы определить их относительное положение в порядке сортировки, используя следующие String методы:

Compare возвращает целое число, указывающее связь одной строки со второй строкой в порядке сортировки.
CompareOrdinal возвращает целое число, указывающее связь одной строки со второй строкой на основе сравнения их кодовых точек.
CompareTo возвращает целое число, указывающее связь текущего экземпляра строки со второй строкой в порядке сортировки. Метод CompareTo(String) предоставляет IComparable реализации и IComparable<T> для String класса .

Проверка строк на равенство

Вызывается метод , Equals чтобы определить, равны ли две строки. Экземпляр Equals(String, String, StringComparison) и статические Equals(String, StringComparison) перегрузки позволяют указать, учитывается ли сравнение языка и региональных параметров или порядковый номер, а также учитывается ли регистр. Большинство тестов на равенство являются порядковые, а сравнения на равенство, определяющие доступ к системным ресурсам (например, объекту файловой системы), всегда должны быть порядковые.

Поиск символов в строке

Класс String включает два типа методов поиска:

Методы, возвращающие Boolean значение, указывающие, присутствует ли определенная подстрока в экземпляре строки. К ним относятся методы Contains, EndsWithи StartsWith .
Методы, указывающие начальную позицию подстроки в экземпляре строки. К ним относятся методы IndexOf, IndexOfAny, LastIndexOfи LastIndexOfAny .

Предупреждение

Если вы хотите искать в строке определенный шаблон, а не определенную подстроку, следует использовать регулярные выражения. Дополнительные сведения см. в разделе Регулярные выражения .NET.

Изменение строки

Класс String включает следующие методы, которые изменяют значение строки:

Insert вставляет строку в текущий String экземпляр .
PadLeft вставляет одно или несколько вхождений указанного символа в начале строки.
PadRight вставляет одно или несколько вхождений указанного символа в конец строки.
Remove удаляет подстроку из текущего String экземпляра.
Replace заменяет подстроку другой подстрокой в текущем String экземпляре.
ToLower и ToLowerInvariant преобразуйте все символы в строке в нижний регистр.
ToUpper и ToUpperInvariant преобразуйте все символы в строке в верхний регистр.
Trim Удаляет все вхождения символа из начала и конца строки.
TrimEnd Удаляет все вхождения символа из конца строки.
TrimStart Удаляет все вхождения символа из начала строки.

Важно!

Все методы изменения строки возвращают новый String объект . Они не изменяют значение текущего экземпляра.

Извлечение подстрок из строки

Метод String.Split разделяет одну строку на несколько строк. Перегрузки метода позволяют указать несколько разделителей, ограничить количество подстрок, извлекаемых методом, обрезать пробелы из подстрок и указать, включаются ли пустые строки (которые возникают, когда разделители находятся рядом) в возвращаемых строках.

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

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

Concat объединяет одну или несколько подстрок в одну строку.
Join объединяет одну или несколько подстрок в один элемент и добавляет разделитель между каждой подстрокой.

Значения форматирования

Метод String.Format использует функцию составного форматирования для замены одного или нескольких заполнителей в строке строковым представлением какого-либо объекта или значения. Метод Format часто используется для выполнения следующих действий:

Внедрение строкового представления числового значения в строку.
Внедрение строкового представления значения даты и времени в строку.
Внедрение строкового представления значения перечисления в строку.
Для внедрения строкового представления объекта, поддерживающего IFormattable интерфейс, в строку.
Для обоснования правого или левого обоснования подстроки в поле в большей строке.

Подробные сведения об операциях форматирования и примеры см. в сводке по перегрузкам Format .

Копируют строку

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

Clone возвращает ссылку на существующий String объект .
Copy создает копию существующей строки.
CopyTo копирует часть строки в массив символов.

Нормализация строки

В Юникоде один символ может иметь несколько кодовых точек. Нормализация преобразует эти эквивалентные символы в одно и то же двоичное представление. Метод String.Normalize выполняет нормализацию, а String.IsNormalized метод определяет, нормализуется ли строка.

Дополнительные сведения и пример см. в разделе Нормализация ранее в этом разделе.

Конструкторы

String(Char*)	Инициализирует новый экземпляр класса String значением, определенным указателем на массив знаков Юникода.
String(Char*, Int32, Int32)	Инициализирует новый экземпляр класса String значением, которое определяется заданным указателем на массив знаков Юникода, начальной позицией знака в этом массиве и длиной.
String(Char, Int32)	Инициализирует новый экземпляр класса String значением, полученным путем повторения заданного знака Юникода указанное число раз.
String(Char[])	Инициализирует новый экземпляр класса String символами Юникода, заданными в виде массива символов.
String(Char[], Int32, Int32)	Инициализирует новый экземпляр класса String значением, заданным массивом знаков Юникода, начальной позицией знака в пределах данного массива и длиной.
String(ReadOnlySpan<Char>)	Инициализирует новый экземпляр класса String символами Юникода, заданными в виде доступного только для чтения диапазона.
String(SByte*)	Инициализирует новый экземпляр класса String значением, определенным указателем на массив 8-разрядных целых чисел со знаком.
String(SByte*, Int32, Int32)	Инициализирует новый экземпляр класса String значением, определяемым заданным указателем на массив 8-разрядных целых чисел со знаком, начальной позицией в пределах массива и длиной.
String(SByte*, Int32, Int32, Encoding)	Инициализирует новый экземпляр класса String значением, определенным заданным указателем на массив 8-разрядных целых чисел со знаком, начальной позицией в пределах этого массива, длиной и объектом Encoding.

Поля

Empty

Представляет пустую строку. Это поле доступно только для чтения.

Свойства

Chars[Int32]	Возвращает объект Char в указанной позиции в текущем объекте String.
Length	Возвращает число знаков в текущем объекте String.

Методы

Clone()	Возвращает ссылку на данный экземпляр класса String.
Compare(String, Int32, String, Int32, Int32)	Сравнивает подстроки двух указанных объектов String и возвращает целое число, которое показывает их относительное положение в порядке сортировки.
Compare(String, Int32, String, Int32, Int32, Boolean)	Сравнивает подстроки двух заданных объектов String (с учетом или без учета регистра) и возвращает целое число, которое показывает их относительное положение в порядке сортировки.
Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)	Сравнивает подстроки двух заданных объектов String (с учетом или без учета регистра), используя сведения о языке и региональных параметрах, и возвращает целое число, которое показывает их относительное положение в порядке сортировки.
Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)	Сравнивает подстроки двух заданных объектов String, используя указанные параметры сравнения и сведения о языке и региональных параметрах, которые влияют на сравнение, и возвращает целое число, показывающее связь между двумя подстроками в порядке сортировки.
Compare(String, Int32, String, Int32, Int32, StringComparison)	Сравнивает подстроки двух указанных объектов String с использованием заданных правил и возвращает целое число, которое показывает их относительное положение в порядке сортировки.
Compare(String, String)	Сравнивает два указанных объекта String и возвращает целое число, которое показывает их относительное положение в порядке сортировки.
Compare(String, String, Boolean)	Сравнивает два указанных объекта String (с учетом или без учета регистра) и возвращает целое число, которое показывает их относительное положение в порядке сортировки.
Compare(String, String, Boolean, CultureInfo)	Сравнивает два указанных объекта String (с учетом или без учета регистра), используя сведения о языке и региональных параметрах, и возвращает целое число, которое показывает их относительное положение в порядке сортировки.
Compare(String, String, CultureInfo, CompareOptions)	Сравнивает два заданных объекта String, используя указанные параметры сравнения и сведения о языке и региональных параметрах, которые влияют на сравнение, и возвращает целое число, показывающее связь между двумя строками в порядке сортировки.
Compare(String, String, StringComparison)	Сравнивает два указанных объекта String с использованием заданных правил и возвращает целое число, которое показывает их относительное положение в порядке сортировки.
CompareOrdinal(String, Int32, String, Int32, Int32)	Сравнивает подстроки двух указанных объектов String, вычисляя числовые значения соответствующих объектов Char в каждой подстроке.
CompareOrdinal(String, String)	Сравнивает два указанных объекта String, оценивая числовые значения соответствующих объектов Char в каждой строке.
CompareTo(Object)	Сравнивает данный экземпляр с указанным объектом Object и показывает, расположен ли экземпляр перед, после или в той же позиции в порядке сортировки, что и заданный объект Object.
CompareTo(String)	Сравнивает данный экземпляр с заданным объектом String и показывает, расположен ли данный экземпляр перед, после или на той же позиции в порядке сортировки, что и заданная строка.
Concat(IEnumerable<String>)	Сцепляет элементы созданной коллекции IEnumerable<T> типа String.
Concat(Object)	Создает строковое представление указанного объекта.
Concat(Object, Object)	Сцепляет строковые представления двух указанных объектов.
Concat(Object, Object, Object)	Сцепляет строковые представления трех указанных объектов.
Concat(Object, Object, Object, Object)	Сцепляет строковые представления четырех указанных объектов и любые объекты, заданные в необязательном списке параметров переменной длины.
Concat(Object[])	Сцепляет строковые представления элементов указанного массива Object.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Сцепляет строковые представления двух указанных диапазонов символов только для чтения.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Сцепляет строковые представления трех указанных диапазонов символов только для чтения.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Сцепляет строковые представления четырех указанных диапазонов символов только для чтения.
Concat(String, String)	Сцепляет два указанных экземпляра String.
Concat(String, String, String)	Сцепляет три указанных экземпляра String.
Concat(String, String, String, String)	Сцепляет четыре указанных экземпляра String.
Concat(String[])	Сцепляет элементы указанного массива String.
Concat<T>(IEnumerable<T>)	Сцепляет элементы реализации IEnumerable<T>.
Contains(Char)	Возвращает значение, указывающее, встречается ли указанный символ внутри этой строки.
Contains(Char, StringComparison)	Возвращает значение, указывающее, встречается ли указанный символ внутри этой строки, используя указанные правила сравнения.
Contains(String)	Возвращает значение, указывающее, встречается ли указанная подстрока внутри этой строки.
Contains(String, StringComparison)	Возвращает значение, указывающее, встречается ли указанная строка внутри этой строки, используя указанные правила сравнения.
Copy(String)	Является устаревшей. Создает экземпляр String, имеющий то же значение, что и указанный экземпляр String.
CopyTo(Int32, Char[], Int32, Int32)	Копирует заданное число знаков, начиная с указанной позиции в этом экземпляре до указанной позиции в массиве знаков Юникода.
CopyTo(Span<Char>)	Копирует содержимое этой строки в целевой диапазон.
Create(IFormatProvider, DefaultInterpolatedStringHandler)	Создает новую строку с помощью указанного поставщика для управления форматированием указанной интерполированной строки.
Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)	Создает новую строку с помощью указанного поставщика для управления форматированием указанной интерполированной строки.
Create<TState>(Int32, TState, SpanAction<Char,TState>)	Создает строку определенной длины и инициализирует ее после создания с помощью указанного обратного вызова.
EndsWith(Char)	Определяет, совпадает ли конец данного экземпляра строки с указанным символом.
EndsWith(String)	Определяет, совпадает ли конец данного экземпляра строки с указанной строкой.
EndsWith(String, Boolean, CultureInfo)	Определяет, совпадает ли конец данного экземпляра строки с заданной строкой при сравнении с учетом заданного языка и региональных параметров.
EndsWith(String, StringComparison)	Определяет, совпадает ли конец экземпляра строки с заданной строкой при сравнении с учетом заданного параметра сравнения.
EnumerateRunes()	Возвращает перечисление Rune из этой строки.
Equals(Object)	Определяет, равны ли значения этого экземпляра и указанного объекта, который также должен быть объектом String.
Equals(String)	Определяет, равны ли значения этого экземпляра и указанного объекта String.
Equals(String, String)	Определяет, совпадают ли значения двух указанных объектов String.
Equals(String, String, StringComparison)	Определяет, совпадают ли значения двух указанных объектов String. Параметр определяет язык и региональные параметры, учет регистра и правила сортировки, используемые при сравнении.
Equals(String, StringComparison)	Определяет, равны ли значения этой строки и указанного объекта String. Параметр определяет язык и региональные параметры, учет регистра и правила сортировки, используемые при сравнении.
Format(IFormatProvider, CompositeFormat, Object[])	Заменяет элемент форматирования или элементы в на CompositeFormat строковое представление соответствующих объектов в указанном формате.
Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)	Заменяет элемент форматирования или элементы в на CompositeFormat строковое представление соответствующих объектов в указанном формате.
Format(IFormatProvider, String, Object)	Заменяет элементы формата в указанной строке строковым представлением соответствующего объекта. Параметр предоставляет сведения об особенностях форматирования, связанных с языком и региональными параметрами.
Format(IFormatProvider, String, Object, Object)	Заменяет элементы формата в строке строковым представлением двух указанных объектов. Параметр предоставляет сведения об особенностях форматирования, связанных с языком и региональными параметрами.
Format(IFormatProvider, String, Object, Object, Object)	Заменяет элементы формата в строке строковым представлением трех указанных объектов. Параметр предоставляет сведения об особенностях форматирования, связанных с языком и региональными параметрами.
Format(IFormatProvider, String, Object[])	Заменяет элементы формата в строке строковым представлениями соответствующих объектов в указанном массиве. Параметр предоставляет сведения об особенностях форматирования, связанных с языком и региональными параметрами.
Format(String, Object)	Заменяет один или более элементов формата в строке строковым представлением указанного объекта.
Format(String, Object, Object)	Заменяет элементы формата в строке строковым представлением двух указанных объектов.
Format(String, Object, Object, Object)	Заменяет элементы формата в строке строковым представлением трех указанных объектов.
Format(String, Object[])	Заменяет элемент формата в указанной строке строковым представлением соответствующего объекта в указанном массиве.
Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)	Заменяет элемент форматирования или элементы в на CompositeFormat строковое представление соответствующих объектов в указанном формате.
Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)	Заменяет элемент форматирования или элементы в на CompositeFormat строковое представление соответствующих объектов в указанном формате.
Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)	Заменяет элемент форматирования или элементы в на CompositeFormat строковое представление соответствующих объектов в указанном формате.
GetEnumerator()	Извлекает объект, который может выполнять итерацию отдельных знаков данной строки.
GetHashCode()	Возвращает хэш-код для этой строки.
GetHashCode(ReadOnlySpan<Char>)	Возвращает хэш-код для предоставленного диапазона символов, доступного только для чтения.
GetHashCode(ReadOnlySpan<Char>, StringComparison)	Возвращает хэш-код для предоставленного диапазона символов, доступного только для чтения, используя указанные правила.
GetHashCode(StringComparison)	Возвращает хэш-код для этой строки, используя указанные правила.
GetPinnableReference()	Возвращает ссылку на элемент строки при нулевом индексе. Этот метод предназначен для поддержки компиляторов .NET и не предназначен для вызова из пользовательского кода.
GetType()	Возвращает объект Type для текущего экземпляра. (Унаследовано от Object)
GetTypeCode()	Возвращает TypeCode для класса String.
IndexOf(Char)	Возвращает индекс с отсчетом от нуля первого вхождения указанного символа Юникода в данной строке.
IndexOf(Char, Int32)	Возвращает индекс с отсчетом от нуля первого вхождения указанного символа Юникода в данной строке. Поиск начинается с указанной позиции знака.
IndexOf(Char, Int32, Int32)	Возвращает индекс с отсчетом от нуля первого вхождения указанного символа в данном экземпляре. Поиск начинается с указанной позиции знака; проверяется заданное количество позиций.
IndexOf(Char, StringComparison)	Возвращает индекс с отсчетом от нуля первого вхождения указанного символа Юникода в данной строке. Параметр определяет тип поиска заданного символа.
IndexOf(String)	Возвращает индекс с отсчетом от нуля первого вхождения значения указанной строки в данном экземпляре.
IndexOf(String, Int32)	Возвращает индекс с отсчетом от нуля первого вхождения значения указанной строки в данном экземпляре. Поиск начинается с указанной позиции знака.
IndexOf(String, Int32, Int32)	Возвращает индекс с отсчетом от нуля первого вхождения значения указанной строки в данном экземпляре. Поиск начинается с указанной позиции знака; проверяется заданное количество позиций.
IndexOf(String, Int32, Int32, StringComparison)	Возвращает индекс с отсчетом от нуля первого вхождения указанной строки в текущем объекте String. Параметры задают начальную позицию поиска в текущей строке, количество проверяемых знаков текущей строки и тип поиска.
IndexOf(String, Int32, StringComparison)	Возвращает индекс с отсчетом от нуля первого вхождения указанной строки в текущем объекте String. Параметры задают начальную позицию поиска в текущей строке и тип поиска.
IndexOf(String, StringComparison)	Возвращает индекс с отсчетом от нуля первого вхождения указанной строки в текущем объекте String. Параметр определяет тип поиска заданной строки.
IndexOfAny(Char[])	Возвращает индекс с отсчетом от нуля первого обнаруженного в данном экземпляре символа из указанного массива символов Юникода.
IndexOfAny(Char[], Int32)	Возвращает индекс с отсчетом от нуля первого обнаруженного в данном экземпляре символа из указанного массива символов Юникода. Поиск начинается с указанной позиции знака.
IndexOfAny(Char[], Int32, Int32)	Возвращает индекс с отсчетом от нуля первого обнаруженного в данном экземпляре символа из указанного массива символов Юникода. Поиск начинается с указанной позиции знака; проверяется заданное количество позиций.
Insert(Int32, String)	Возвращает новую строку, в которой указанная строка вставляется в указанной позиции индекса в данном экземпляре.
Intern(String)	Извлекает системную ссылку на указанный объект String.
IsInterned(String)	Извлекает ссылку на указанный объект String.
IsNormalized()	Указывает, находится ли данная строка в форме нормализации Юникода C.
IsNormalized(NormalizationForm)	Указывает, находится ли данная строка в заданной форме нормализации Юникода.
IsNullOrEmpty(String)	Указывает, действительно ли указанная строка является строкой `null` или пустой строкой ("").
IsNullOrWhiteSpace(String)	Указывает, имеет ли указанная строка значение `null`, является ли она пустой строкой или строкой, состоящей только из символов-разделителей.
Join(Char, Object[])	Сцепляет строковые представления объектов из массива, помещая между ними заданный разделитель.
Join(Char, String[])	Сцепляет строки из массива, помещая между ними заданный разделитель.
Join(Char, String[], Int32, Int32)	Сцепляет до `count` строк из массива начиная с элемента из `value` в позиции `startIndex`, помещая между ними заданный разделитель.
Join(String, IEnumerable<String>)	Сцепляет элементы созданной коллекции IEnumerable<T> типа String, помещая между ними заданный разделитель.
Join(String, Object[])	Сцепляет элементы массива объектов, помещая между ними заданный разделитель.
Join(String, String[])	Сцепляет все элементы массива строк, помещая между ними заданный разделитель.
Join(String, String[], Int32, Int32)	Сцепляет указанные элементы массива строк, помещая между ними заданный разделитель.
Join<T>(Char, IEnumerable<T>)	Сцепляет элементы созданной коллекции, помещая между ними заданный разделитель.
Join<T>(String, IEnumerable<T>)	Сцепляет элементы созданной коллекции, помещая между ними заданный разделитель.
LastIndexOf(Char)	Возвращает позицию индекса с отсчетом от нуля последнего вхождения указанного символа Юникода в пределах данного экземпляра.
LastIndexOf(Char, Int32)	Возвращает позицию индекса с отсчетом от нуля последнего вхождения указанного символа Юникода в пределах данного экземпляра. Поиск начинается с указанной позиции символа и выполняется в обратном направлении до начала строки.
LastIndexOf(Char, Int32, Int32)	Возвращает позицию индекса с отсчетом от нуля последнего вхождения указанного символа Юникода в подстроке в пределах данного экземпляра. Поиск начинается с указанной позиции символа и выполняется в обратном направлении до начала строки для заданного числа позиций символов.
LastIndexOf(String)	Возвращает позицию индекса с отсчетом от нуля последнего вхождения указанной строки в данном экземпляре.
LastIndexOf(String, Int32)	Возвращает позицию индекса с отсчетом от нуля последнего вхождения указанной строки в данном экземпляре. Поиск начинается с указанной позиции символа и выполняется в обратном направлении до начала строки.
LastIndexOf(String, Int32, Int32)	Возвращает позицию индекса с отсчетом от нуля последнего вхождения указанной строки в данном экземпляре. Поиск начинается с указанной позиции символа и выполняется в обратном направлении до начала строки для заданного числа позиций символов.
LastIndexOf(String, Int32, Int32, StringComparison)	Возвращает позицию индекса с отсчетом от нуля последнего вхождения указанной строки в данном экземпляре. Поиск начинается с указанной позиции символа и выполняется в обратном направлении до начала строки для заданного числа позиций символов. Параметр определяет тип сравнения для выполнения во время поиска заданной строки.
LastIndexOf(String, Int32, StringComparison)	Возвращает индекс с отсчетом от нуля последнего вхождения указанной строки в текущем объекте String. Поиск начинается с указанной позиции символа и выполняется в обратном направлении до начала строки. Параметр определяет тип сравнения для выполнения во время поиска заданной строки.
LastIndexOf(String, StringComparison)	Возвращает индекс с отсчетом от нуля последнего вхождения указанной строки в текущем объекте String. Параметр определяет тип поиска заданной строки.
LastIndexOfAny(Char[])	Возвращает позицию индекса с отсчетом от нуля последнего вхождения в данном экземпляре какого-либо одного или нескольких символов, указанных в массиве символов Юникода.
LastIndexOfAny(Char[], Int32)	Возвращает позицию индекса с отсчетом от нуля последнего вхождения в данном экземпляре какого-либо одного или нескольких символов, указанных в массиве символов Юникода. Поиск начинается с указанной позиции символа и выполняется в обратном направлении до начала строки.
LastIndexOfAny(Char[], Int32, Int32)	Возвращает позицию индекса с отсчетом от нуля последнего вхождения в данном экземпляре какого-либо одного или нескольких символов, указанных в массиве символов Юникода. Поиск начинается с указанной позиции символа и выполняется в обратном направлении до начала строки для заданного числа позиций символов.
MemberwiseClone()	Создает неполную копию текущего объекта Object. (Унаследовано от Object)
Normalize()	Возвращает новую строку, текстовое значение которой совпадает с данной строкой, а двоичное представление находится в нормализованной форме C Юникода.
Normalize(NormalizationForm)	Возвращает новую строку, текстовое значение которой совпадает с данной строкой, а двоичное представление находится в заданной нормализованной форме Юникода.
PadLeft(Int32)	Возвращает новую строку, в которой знаки данного экземпляра выровнены по правому краю путем добавления слева символов-разделителей до указанной общей длины.
PadLeft(Int32, Char)	Возвращает новую строку, в которой знаки данного экземпляра выровнены по правому краю путем добавления слева пробелов или указанного знака Юникода до указанной общей длины.
PadRight(Int32)	Возвращает новую строку, в которой знаки данной строки выровнены по левому краю путем добавления справа пробелов до указанной общей длины.
PadRight(Int32, Char)	Возвращает новую строку, в которой знаки данной строки выровнены по левому краю путем добавления справа пробелов или указанного знака Юникода до указанной общей длины.
Remove(Int32)	Возвращает новую строку, в которой были удалены все символы, начиная с указанной позиции и до конца в текущем экземпляре.
Remove(Int32, Int32)	Возвращает новую строку, в которой было удалено указанное число символов в указанной позиции.
Replace(Char, Char)	Возвращает новую строку, в которой все вхождения заданного знака Юникода в текущем экземпляре заменены другим заданным знаком Юникода.
Replace(String, String)	Возвращает новую строку, в которой все вхождения заданной строки в текущем экземпляре заменены другой заданной строкой.
Replace(String, String, Boolean, CultureInfo)	Возвращает новую строку, в которой все вхождения заданной строки в текущем экземпляре заменены другой заданной строкой с использованием указанных языка и региональных параметры, а также учета регистра.
Replace(String, String, StringComparison)	Возвращает новую строку, в которой все вхождения заданной строки в текущем экземпляре заменены другой заданной строкой с использованием указанного типа сравнения.
ReplaceLineEndings()	Заменяет все последовательности новой строки в текущей строке на NewLine.
ReplaceLineEndings(String)	Заменяет все последовательности новой строки в текущей строке на `replacementText`.
Split(Char, Int32, StringSplitOptions)	Разбивает строку на максимальное число подстрок на основе указанного символа-разделителя и, при необходимости, параметров. Разбивает строку на максимальное число подстрок на основе указанного разделителя символов, при необходимости исключая пустые подстроки из результата.
Split(Char, StringSplitOptions)	Разбивает строку на подстроки на основе указанного символа-разделителя и, при необходимости, параметров.
Split(Char[])	Разбивает строку на подстроки на основе указанных символов-разделителей.
Split(Char[], Int32)	Разбивает строку на максимальное число подстрок на основе указанных символов-разделителей.
Split(Char[], Int32, StringSplitOptions)	Разбивает строку на максимальное число подстрок на основе указанных символов-разделителей и, при необходимости, параметров.
Split(Char[], StringSplitOptions)	Разбивает строку на подстроки на основе указанных символов-разделителей и параметров.
Split(String, Int32, StringSplitOptions)	Разбивает строку на максимальное число подстрок на основе указанной строки-разделителя и, при необходимости, параметров.
Split(String, StringSplitOptions)	Разделяет строку на подстроки в соответствии с указанной строкой-разделителем.
Split(String[], Int32, StringSplitOptions)	Разбивает строку на максимальное число подстрок на основе указанных строк-разделителей и, при необходимости, параметров.
Split(String[], StringSplitOptions)	Разбивает строку на подстроки на основе указанных строк-разделителей и, при необходимости, параметров.
StartsWith(Char)	Определяет, начинается ли данный экземпляр строки с указанного символа.
StartsWith(String)	Определяет, совпадает ли начало данного экземпляра строки с указанной строкой.
StartsWith(String, Boolean, CultureInfo)	Определяет, совпадает ли начало экземпляра строки с заданной строкой при сравнении с учетом заданного языка и региональных параметров.
StartsWith(String, StringComparison)	Определяет, совпадает ли начало этого экземпляра строки с заданной строкой при сравнении с учетом заданного параметра сравнения.
Substring(Int32)	Извлекает подстроку из данного экземпляра. Подстрока начинается в указанном положении символов и продолжается до конца строки.
Substring(Int32, Int32)	Извлекает подстроку из данного экземпляра. Подстрока начинается с указанной позиции знака и имеет указанную длину.
ToCharArray()	Копирует знаки данного экземпляра в массив знаков Юникода.
ToCharArray(Int32, Int32)	Копирует знаки из указанной подстроки данного экземпляра в массив знаков Юникода.
ToLower()	Возвращает копию этой строки, переведенную в нижний регистр.
ToLower(CultureInfo)	Возвращает копию этой строки, переведенную в нижний регистр, используя правила определения регистра заданного языка и региональных параметров.
ToLowerInvariant()	Возвращает копию этого объекта String , переведенную в нижний регистр, используя правила учета регистра инвариантного языка и региональных параметров.
ToString()	Возвращает этот экземпляр String; реальное преобразование не осуществляется.
ToString(IFormatProvider)	Возвращает этот экземпляр String; реальное преобразование не осуществляется.
ToUpper()	Возвращает копию этой строки, переведенную в верхний регистр.
ToUpper(CultureInfo)	Возвращает копию этой строки, переведенную в верхний регистр, используя правила определения регистра заданного языка и региональных параметров.
ToUpperInvariant()	Возвращает копию этого объекта String , переведенную в верхний регистр, используя правила учета регистра инвариантного языка и региональных параметров.
Trim()	Удаляет все начальные и конечные символы пробела из текущей строки.
Trim(Char)	Удаляет все начальные и конечные экземпляры символа из текущей строки.
Trim(Char[])	Удаляет все начальные и конечные вхождения набора символов, заданного в виде массива, из текущей строки.
TrimEnd()	Удаляет все конечные символы пробела из текущей строки.
TrimEnd(Char)	Удаляет все конечные вхождения символа из текущей строки.
TrimEnd(Char[])	Удаляет все конечные вхождения набора символов, заданного в виде массива, из текущей строки.
TrimStart()	Удаляет все начальные символы пробела из текущей строки.
TrimStart(Char)	Удаляет все начальные вхождения указанного символа из текущей строки.
TrimStart(Char[])	Удаляет все начальные вхождения набора символов, заданного в виде массива, из текущей строки.
TryCopyTo(Span<Char>)	Копирует содержимое этой строки в диапазон назначения.

Операторы

Equality(String, String)	Определяет, равны ли значения двух указанных строк.
Implicit(String to ReadOnlySpan<Char>)	Определяет неявное преобразование указанной строки в доступный только для чтения диапазон символов.
Inequality(String, String)	Определяет, различаются ли значения двух указанных строк.

Явные реализации интерфейса

IComparable.CompareTo(Object)	Сравнивает данный экземпляр с указанным объектом Object и показывает, расположен ли экземпляр перед, после или в той же позиции в порядке сортировки, что и заданный объект Object.
IConvertible.GetTypeCode()	Возвращает TypeCode для класса String.
IConvertible.ToBoolean(IFormatProvider)	Описание этого члена см. в разделе ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Описание этого члена см. в разделе ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Описание этого члена см. в разделе ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Описание этого члена см. в разделе ToDateTime(IFormatProvider).
IConvertible.ToDecimal(IFormatProvider)	Описание этого члена см. в разделе ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Описание этого члена см. в разделе ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Описание этого члена см. в разделе ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Описание этого члена см. в разделе ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Описание этого члена см. в разделе ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Описание этого члена см. в разделе ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Описание этого члена см. в разделе ToSingle(IFormatProvider).
IConvertible.ToString(IFormatProvider)	Описание этого члена см. в разделе ToString(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Описание этого члена см. в разделе ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Описание этого члена см. в разделе ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Описание этого члена см. в разделе ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Описание этого члена см. в разделе ToUInt64(IFormatProvider).
IEnumerable.GetEnumerator()	Возвращает перечислитель, выполняющий перебор элементов текущего объекта String.
IEnumerable<Char>.GetEnumerator()	Возвращает перечислитель, выполняющий перебор элементов текущего объекта String.
IParsable<String>.Parse(String, IFormatProvider)	Анализирует строку в значение.
IParsable<String>.TryParse(String, IFormatProvider, String)	Представляет текст как последовательность из частей кода UTF-16.
ISpanParsable<String>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Анализирует диапазон символов в значение.
ISpanParsable<String>.TryParse(ReadOnlySpan<Char>, IFormatProvider, String)	Представляет текст как последовательность из частей кода UTF-16.

Методы расширения

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Создает из FrozenDictionary<TKey,TValue> объекта в соответствии с указанной IEnumerable<T> функцией селектора ключей.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Создает словарь FrozenDictionary<TKey,TValue> из объекта IEnumerable<T> в соответствии с заданными функциями селектора ключа и селектора элемента.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Создает с FrozenSet<T> указанными значениями.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Создает неизменяемый массив на основе указанной коллекции.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Создает неизменяемый словарь на основе существующей коллекции элементов, применяя функцию преобразования к исходным ключам.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Создает неизменяемый словарь на основе последовательности, подвергнутой определенному преобразованию.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Выполняет перечисление и преобразование последовательности и создает неизменяемый словарь на основе ее содержимого.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Выполняет перечисление и преобразование последовательности и создает на основе ее содержимого неизменяемый словарь с использованием указанной функции сравнения ключей.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Выполняет перечисление и преобразование последовательности и создает на основе ее содержимого неизменяемый словарь с использованием указанных функций сравнения ключей и значений.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Выполняет перечисление последовательности и создает неизменяемый набор хэширования на основе ее содержимого.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Выполняет перечисление последовательности, создает неизменяемый набор хэширования на основе ее содержимого и использует указанную функцию сравнения для типа набора.
ToImmutableList<TSource>(IEnumerable<TSource>)	Выполняет перечисление последовательности и создает неизменяемый список на основе ее содержимого.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Выполняет перечисление и преобразование последовательности и создает неизменяемый отсортированный словарь на основе ее содержимого.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Выполняет перечисление и преобразование последовательности и создает на основе ее содержимого неизменяемый отсортированный словарь с использованием указанной функции сравнения ключей.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Выполняет перечисление и преобразование последовательности и создает на основе ее содержимого неизменяемый отсортированный словарь с использованием указанных функций сравнения ключей и значений.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Выполняет перечисление последовательности и создает неизменяемый отсортированный набор на основе ее содержимого.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Выполняет перечисление последовательности, создает неизменяемый отсортированный набор на основе ее содержимого и использует указанную функцию сравнения.
CopyToDataTable<T>(IEnumerable<T>)	Возвращает объект DataTable, содержащий копии объектов DataRow при заданном входном объекте IEnumerable<T> и универсальном параметре `T`, равном DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Копирует объекты DataRow в указанный объект DataTable с заданным входным объектом IEnumerable<T>, где универсальный параметр `T` имеет значение DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Копирует объекты DataRow в указанный объект DataTable с заданным входным объектом IEnumerable<T>, где универсальный параметр `T` имеет значение DataRow.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Применяет к последовательности агрегатную функцию.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Применяет к последовательности агрегатную функцию. Указанное начальное значение используется в качестве исходного значения агрегатной операции.
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Применяет к последовательности агрегатную функцию. Указанное начальное значение служит исходным значением для агрегатной операции, а указанная функция используется для выбора результирующего значения.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Проверяет, все ли элементы последовательности удовлетворяют условию.
Any<TSource>(IEnumerable<TSource>)	Проверяет, содержит ли последовательность какие-либо элементы.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Проверяет, удовлетворяет ли какой-либо элемент последовательности заданному условию.
Append<TSource>(IEnumerable<TSource>, TSource)	Добавляет значение в конец последовательности.
AsEnumerable<TSource>(IEnumerable<TSource>)	Возвращает входное значение, типизированное как IEnumerable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Вычисляет среднее для последовательности значений типа Decimal, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Вычисляет среднее для последовательности значений типа Double, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Вычисляет среднее для последовательности значений типа Int32, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Вычисляет среднее для последовательности значений типа Int64, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Вычисляет среднее для последовательности значений Decimal обнуляемого типа, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Вычисляет среднее для последовательности значений Double обнуляемого типа, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Вычисляет среднее для последовательности значений Int32 обнуляемого типа, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Вычисляет среднее для последовательности значений Int64 обнуляемого типа, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Вычисляет среднее для последовательности значений Single обнуляемого типа, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Вычисляет среднее для последовательности значений типа Single, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Cast<TResult>(IEnumerable)	Приводит элементы объекта IEnumerable к заданному типу.
Chunk<TSource>(IEnumerable<TSource>, Int32)	Разбивает элементы последовательности на блоки размером не более `size`.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Объединяет две последовательности.
Contains<TSource>(IEnumerable<TSource>, TSource)	Определяет, содержится ли указанный элемент в последовательности, используя компаратор проверки на равенство по умолчанию.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Определяет, содержит ли последовательность заданный элемент, используя указанный компаратор IEqualityComparer<T>.
Count<TSource>(IEnumerable<TSource>)	Возвращает количество элементов в последовательности.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Возвращает число, представляющее количество элементов последовательности, удовлетворяющих заданному условию.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Возвращает элементы указанной последовательности или одноэлементную коллекцию, содержащую значение параметра типа по умолчанию, если последовательность пуста.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Возвращает элементы указанной последовательности или одноэлементную коллекцию, содержащую указанное значение, если последовательность пуста.
Distinct<TSource>(IEnumerable<TSource>)	Возвращает различающиеся элементы последовательности, используя для сравнения значений компаратор проверки на равенство по умолчанию.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Возвращает различающиеся элементы последовательности, используя для сравнения значений указанный компаратор IEqualityComparer<T>.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Возвращает отдельные элементы из последовательности в соответствии с указанной функцией селектора ключей.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Возвращает отдельные элементы из последовательности в соответствии с указанной функцией селектора ключей и с помощью указанного компаратора для сравнения ключей.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Возвращает элемент по указанному индексу в последовательности.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Возвращает элемент по указанному индексу в последовательности.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Возвращает элемент последовательности по указанному индексу или значение по умолчанию, если индекс вне допустимого диапазона.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Возвращает элемент последовательности по указанному индексу или значение по умолчанию, если индекс вне допустимого диапазона.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Находит разность множеств, представленных двумя последовательностями, используя для сравнения значений компаратор проверки на равенство по умолчанию.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Находит разность множеств, представленных двумя последовательностями, используя для сравнения значений указанный компаратор IEqualityComparer<T>.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Создает разность наборов двух последовательностей в соответствии с указанной функцией селектора ключей.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Создает разность наборов двух последовательностей в соответствии с указанной функцией селектора ключей.
First<TSource>(IEnumerable<TSource>)	Возвращает первый элемент последовательности.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Возвращает первый элемент последовательности, удовлетворяющий указанному условию.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Возвращает первый элемент последовательности или значение по умолчанию, если последовательность не содержит элементов.
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)	Возвращает первый элемент последовательности или указанное значение по умолчанию, если последовательность не содержит элементов.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Возвращает первый элемент последовательности, удовлетворяющий указанному условию, или значение по умолчанию, если ни одного такого элемента не найдено.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Возвращает первый элемент последовательности, удовлетворяющий условию, или указанное значение по умолчанию, если такой элемент не найден.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Группирует элементы последовательности в соответствии с заданной функцией селектора ключа.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Группирует элементы последовательности в соответствии с заданной функцией селектора ключа и сравнивает ключи с помощью указанного компаратора.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Группирует элементы последовательности в соответствии с заданной функцией селектора ключа и проецирует элементы каждой группы с помощью указанной функции.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Группирует элементы последовательности в соответствии с функцией селектора ключа. Ключи сравниваются с помощью компаратора, элементы каждой группы проецируются с помощью указанной функции.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Группирует элементы последовательности в соответствии с заданной функцией селектора ключа и создает результирующее значение для каждой группы и ее ключа.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Группирует элементы последовательности в соответствии с заданной функцией селектора ключа и создает результирующее значение для каждой группы и ее ключа. Ключи сравниваются с использованием заданного компаратора.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Группирует элементы последовательности в соответствии с заданной функцией селектора ключа и создает результирующее значение для каждой группы и ее ключа. Элементы каждой группы проецируются с помощью указанной функции.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Группирует элементы последовательности в соответствии с заданной функцией селектора ключа и создает результирующее значение для каждой группы и ее ключа. Значения ключей сравниваются с помощью указанного компаратора, элементы каждой группы проецируются с помощью указанной функции.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Устанавливает корреляцию между элементами двух последовательностей на основе равенства ключей и группирует результаты. Для сравнения ключей используется компаратор проверки на равенство по умолчанию.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Устанавливает корреляцию между элементами двух последовательностей на основе равенства ключей и группирует результаты. Для сравнения ключей используется указанный компаратор IEqualityComparer<T>.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Находит пересечение множеств, представленных двумя последовательностями, используя для сравнения значений компаратор проверки на равенство по умолчанию.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Находит пересечение множеств, представленных двумя последовательностями, используя для сравнения значений указанный компаратор IEqualityComparer<T>.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Создает набор пересечения двух последовательностей в соответствии с указанной функцией селектора ключей.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Создает набор пересечения двух последовательностей в соответствии с указанной функцией селектора ключей.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Устанавливает корреляцию между элементами двух последовательностей на основе сопоставления ключей. Для сравнения ключей используется компаратор проверки на равенство по умолчанию.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Устанавливает корреляцию между элементами двух последовательностей на основе сопоставления ключей. Для сравнения ключей используется указанный компаратор IEqualityComparer<T>.
Last<TSource>(IEnumerable<TSource>)	Возвращает последний элемент последовательности.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Возвращает последний элемент последовательности, удовлетворяющий указанному условию.
LastOrDefault<TSource>(IEnumerable<TSource>)	Возвращает последний элемент последовательности или значение по умолчанию, если последовательность не содержит элементов.
LastOrDefault<TSource>(IEnumerable<TSource>, TSource)	Возвращает последний элемент последовательности или указанное значение по умолчанию, если последовательность не содержит элементов.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Возвращает последний элемент последовательности, удовлетворяющий указанному условию, или значение по умолчанию, если ни одного такого элемента не найдено.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Возвращает последний элемент последовательности, удовлетворяющий условию, или указанное значение по умолчанию, если такой элемент не найден.
LongCount<TSource>(IEnumerable<TSource>)	Возвращает значение типа Int64, представляющее общее число элементов в последовательности.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Возвращает значение типа Int64, представляющее число элементов последовательности, удовлетворяющих заданному условию.
Max<TSource>(IEnumerable<TSource>)	Возвращает максимальное значение, содержащееся в универсальной последовательности.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Возвращает максимальное значение, содержащееся в универсальной последовательности.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает максимальное значение типа Decimal.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает максимальное значение типа Double.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает максимальное значение типа Int32.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает максимальное значение типа Int64.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает максимальное значение Decimal обнуляемого типа.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает максимальное значение Double обнуляемого типа.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает максимальное значение Int32 обнуляемого типа.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает максимальное значение Int64 обнуляемого типа.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает максимальное значение Single обнуляемого типа.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает максимальное значение типа Single.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Вызывает функцию преобразования для каждого элемента универсальной последовательности и возвращает максимальное результирующее значение.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Возвращает максимальное значение в универсальной последовательности в соответствии с указанной функцией селектора ключей.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Возвращает максимальное значение в универсальной последовательности в соответствии с указанной функцией селектора ключей и компаратором ключей.
Min<TSource>(IEnumerable<TSource>)	Возвращает минимальное значение, содержащееся в универсальной последовательности.
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Возвращает минимальное значение, содержащееся в универсальной последовательности.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает минимальное значение типа Decimal.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает минимальное значение типа Double.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает минимальное значение типа Int32.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает минимальное значение типа Int64.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает минимальное значение Decimal обнуляемого типа.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает минимальное значение Double обнуляемого типа.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает минимальное значение Int32 обнуляемого типа.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает минимальное значение Int64 обнуляемого типа.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает минимальное значение Single обнуляемого типа.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Вызывает функцию преобразования для каждого элемента последовательности и возвращает минимальное значение типа Single.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Вызывает функцию преобразования для каждого элемента универсальной последовательности и возвращает минимальное результирующее значение.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Возвращает минимальное значение в универсальной последовательности в соответствии с указанной функцией селектора ключей.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Возвращает минимальное значение в универсальной последовательности в соответствии с указанной функцией селектора ключей и компаратором ключей.
OfType<TResult>(IEnumerable)	Выполняет фильтрацию элементов объекта IEnumerable по заданному типу.
Order<T>(IEnumerable<T>)	Сортирует элементы последовательности в порядке возрастания.
Order<T>(IEnumerable<T>, IComparer<T>)	Сортирует элементы последовательности в порядке возрастания.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Сортирует элементы последовательности в порядке возрастания ключа.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Сортирует элементы последовательности в порядке возрастания с использованием указанного компаратора.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Сортирует элементы последовательности в порядке убывания ключа.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Сортирует элементы последовательности в порядке убывания с использованием указанного компаратора.
OrderDescending<T>(IEnumerable<T>)	Сортирует элементы последовательности в порядке убывания.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	Сортирует элементы последовательности в порядке убывания.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Добавляет значение в начало последовательности.
Reverse<TSource>(IEnumerable<TSource>)	Изменяет порядок элементов последовательности на противоположный.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Проецирует каждый элемент последовательности в новую форму.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Проецирует каждый элемент последовательности в новую форму, добавляя индекс элемента.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Проецирует каждый элемент последовательности в объект IEnumerable<T> и объединяет результирующие последовательности в одну последовательность.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Проецирует каждый элемент последовательности в объект IEnumerable<T> и объединяет результирующие последовательности в одну последовательность. Индекс каждого элемента исходной последовательности используется в проецированной форме этого элемента.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Проецирует каждый элемент последовательности в объект IEnumerable<T>, объединяет результирующие последовательности в одну и вызывает функцию селектора результата для каждого элемента этой последовательности.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Проецирует каждый элемент последовательности в объект IEnumerable<T>, объединяет результирующие последовательности в одну и вызывает функцию селектора результата для каждого элемента этой последовательности. Индекс каждого элемента исходной последовательности используется в промежуточной проецированной форме этого элемента.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Определяет, совпадают ли две последовательности, используя для сравнения элементов компаратор проверки на равенство по умолчанию, предназначенный для их типа.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Определяет, совпадают ли две последовательности, используя для сравнения элементов указанный компаратор IEqualityComparer<T>.
Single<TSource>(IEnumerable<TSource>)	Возвращает единственный элемент последовательности и генерирует исключение, если число элементов последовательности отлично от 1.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Возвращает единственный элемент последовательности, удовлетворяющий указанному условию, и вызывает исключение, если таких элементов больше одного.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Возвращает единственный элемент последовательности или значение по умолчанию, если последовательность пуста; если в последовательности более одного элемента, генерируется исключение.
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)	Возвращает единственный элемент последовательности или указанное значение по умолчанию, если последовательность пуста; Этот метод создает исключение, если в последовательности содержится несколько элементов.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Возвращает единственный элемент последовательности, удовлетворяющий указанному условию, или значение по умолчанию, если такого элемента не существует; если условию удовлетворяет более одного элемента, вызывается исключение.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Возвращает единственный элемент последовательности, удовлетворяющий указанному условию, или заданное значение по умолчанию, если такого элемента не существует; Этот метод создает исключение, если условию удовлетворяет несколько элементов.
Skip<TSource>(IEnumerable<TSource>, Int32)	Пропускает заданное число элементов в последовательности и возвращает остальные элементы.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Возвращает новую перечислимую коллекцию, содержащую элементы из `source` с исключенными `count` элементами из конца исходной коллекции.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Пропускает элементы в последовательности, пока они удовлетворяют заданному условию, и затем возвращает оставшиеся элементы.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Пропускает элементы в последовательности, пока они удовлетворяют заданному условию, и затем возвращает оставшиеся элементы. Индекс элемента используется в логике функции предиката.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Вычисляет сумму последовательности значений типа Decimal, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Вычисляет сумму последовательности значений типа Double, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Вычисляет сумму последовательности значений типа Int32, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Вычисляет сумму последовательности значений типа Int64, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Вычисляет сумму последовательности значений Decimal обнуляемого типа, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Вычисляет сумму последовательности значений Double обнуляемого типа, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Вычисляет сумму последовательности значений Int32 обнуляемого типа, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Вычисляет сумму последовательности значений Int64 обнуляемого типа, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Вычисляет сумму последовательности значений Single обнуляемого типа, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Вычисляет сумму последовательности значений типа Single, получаемой в результате применения функции преобразования к каждому элементу входной последовательности.
Take<TSource>(IEnumerable<TSource>, Int32)	Возвращает указанное число подряд идущих элементов с начала последовательности.
Take<TSource>(IEnumerable<TSource>, Range)	Возвращает указанный диапазон смежных элементов из последовательности.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Возвращает новую перечислимую коллекцию, содержащую последние `count` элементов из `source`.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Возвращает цепочку элементов последовательности, удовлетворяющих указанному условию.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Возвращает цепочку элементов последовательности, удовлетворяющих указанному условию. Индекс элемента используется в логике функции предиката.
ToArray<TSource>(IEnumerable<TSource>)	Создает массив из объекта IEnumerable<T>.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Создает словарь Dictionary<TKey,TValue> из объекта IEnumerable<T> в соответствии с заданной функцией селектора ключа.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Создает словарь Dictionary<TKey,TValue> из объекта IEnumerable<T> в соответствии с заданной функцией селектора ключа и компаратором ключей.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Создает словарь Dictionary<TKey,TValue> из объекта IEnumerable<T> в соответствии с заданными функциями селектора ключа и селектора элемента.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Создает словарь Dictionary<TKey,TValue> из объекта IEnumerable<T> в соответствии с заданным компаратором и функциями селектора ключа и селектора элемента.
ToHashSet<TSource>(IEnumerable<TSource>)	Создает HashSet<T> из IEnumerable<T>.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Создает HashSet<T> из IEnumerable<T> с использованием `comparer` для сравнения ключей.
ToList<TSource>(IEnumerable<TSource>)	Создает List<T> из IEnumerable<T>.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Создает словарь Lookup<TKey,TElement> из объекта IEnumerable<T> в соответствии с заданной функцией селектора ключа.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Создает словарь Lookup<TKey,TElement> из объекта IEnumerable<T> в соответствии с заданной функцией селектора ключа и компаратором ключей.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Создает словарь Lookup<TKey,TElement> из объекта IEnumerable<T> в соответствии с заданными функциями селектора ключа и селектора элемента.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Создает объект Lookup<TKey,TElement> из объекта IEnumerable<T> в соответствии с заданным компаратором и функциями селектора ключа и селектора элемента.
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)	Пытается определить количество элементов в последовательности без принудительного перечисления.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Находит объединение множеств, представленных двумя последовательностями, используя для сравнения значений компаратор проверки на равенство по умолчанию.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Находит объединение множеств, представленных двумя последовательностями, используя указанный компаратор IEqualityComparer<T>.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Создает объединение наборов двух последовательностей в соответствии с указанной функцией селектора ключей.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Создает объединение наборов двух последовательностей в соответствии с указанной функцией селектора ключей.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Выполняет фильтрацию последовательности значений на основе заданного предиката.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Выполняет фильтрацию последовательности значений на основе заданного предиката. Индекс каждого элемента используется в логике функции предиката.
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)	Создает последовательность кортежей с элементами из двух указанных последовательностей.
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)	Создает последовательность кортежей с элементами из трех указанных последовательностей.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Применяет указанную функцию к соответствующим элементам двух последовательностей, что дает последовательность результатов.
AsParallel(IEnumerable)	Позволяет осуществлять параллельный запрос.
AsParallel<TSource>(IEnumerable<TSource>)	Позволяет осуществлять параллельный запрос.
AsQueryable(IEnumerable)	Преобразовывает коллекцию IEnumerable в объект IQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Преобразовывает универсальный объект IEnumerable<T> в универсальный объект IQueryable<T>.
AsMemory(String)	Создает новый `ReadOnlyMemory<Char>` для части целевой строки.
AsMemory(String, Index)	Создает новый `ReadOnlyMemory<Char>` на основе части целевой строки, начиная с указанного индекса.
AsMemory(String, Int32)	Создает новый `ReadOnlyMemory<Char>` на основе части целевой строки, начиная с указанной позиции символа.
AsMemory(String, Int32, Int32)	Создает новый `ReadOnlyMemory<Char>` на основе части целевой строки, начиная с указанной позиции с заданной длиной.
AsMemory(String, Range)	Создает новый `ReadOnlyMemory<Char>` с заданным диапазоном целевой строки.
AsSpan(String)	Создает новый диапазон, доступный только для чтения, для строки.
AsSpan(String, Index)	Создает новый ReadOnlySpan<T> объект над частью целевой строки от указанной позиции до конца строки.
AsSpan(String, Int32)	Создает новый диапазон, предназначенный только для чтения, для части целевой строки, начиная с указанной позиции и до конца строки.
AsSpan(String, Int32, Int32)	Создает новый диапазон, предназначенный только для чтения, для части целевой строки, начиная с указанной позиции и с учетом заданного числа символов.
AsSpan(String, Range)	Создает новый ReadOnlySpan<T> объект над частью целевой строки, используя начальный и конечный индексы диапазона.
IsNormalized(String)	Указывает, находится ли данная строка в заданной форме нормализации Юникода C.
IsNormalized(String, NormalizationForm)	Указывает, находится ли строка в заданной форме нормализации Юникода.
Normalize(String)	Нормализует строку в заданную нормализованную форму Юникода C.
Normalize(String, NormalizationForm)	Нормализует строку в заданную нормализованную форму Юникода.
Ancestors<T>(IEnumerable<T>)	Возвращает коллекцию элементов, содержащую предков каждого узла в исходной коллекции.
Ancestors<T>(IEnumerable<T>, XName)	Возвращает отфильтрованную коллекцию элементов, содержащую предков каждого узла в исходной коллекции. В коллекцию включаются только элементы, соответствующие XName.
DescendantNodes<T>(IEnumerable<T>)	Возвращает коллекцию подчиненных узлов каждого документа и элемента в исходной коллекции.
Descendants<T>(IEnumerable<T>)	Возвращает коллекцию элементов, содержащую подчиненные элементы каждого элемента и документа в исходной коллекции.
Descendants<T>(IEnumerable<T>, XName)	Возвращает отфильтрованную коллекцию элементов, содержащую подчиненные элементы каждого элемента и документа в исходной коллекции. В коллекцию включаются только элементы, соответствующие XName.
Elements<T>(IEnumerable<T>)	Возвращает коллекцию дочерних элементов каждого элемента и документа в исходной коллекции.
Elements<T>(IEnumerable<T>, XName)	Возвращает отфильтрованную коллекцию дочерних элементов каждого элемента и документа в исходной коллекции. В коллекцию включаются только элементы, соответствующие XName.
InDocumentOrder<T>(IEnumerable<T>)	Возвращает коллекцию узлов, содержащую все узлы в исходной коллекции, отсортированные в порядке следования документов.
Nodes<T>(IEnumerable<T>)	Возвращает коллекцию дочерних узлов каждого документа и элемента в исходной коллекции.
Remove<T>(IEnumerable<T>)	Удаление каждого узла в исходной коллекции из родительского узла.

Применяется к

Потокобезопасность

Данный тип потокобезопасен.

String Класс

Определение

Комментарии

Создание экземпляра объекта String

Объекты Char и символы Юникода

Строки и стандарт Юникода

Строки и внедренные символы NULL

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

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

Неизменяемость и класс StringBuilder

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

Регистр

Анализ и форматирование

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

Поиск в строках

Тестирование на равенство

Нормализация

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

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

Проверка строк на равенство

Поиск символов в строке

Изменение строки

Извлечение подстрок из строки

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

Значения форматирования

Копируют строку

Нормализация строки

Конструкторы

Поля

Свойства

Методы

Операторы

Явные реализации интерфейса

Методы расширения

Применяется к

Потокобезопасность

См. также раздел

Обратная связь

Обратная связь

Дополнительные ресурсы