String String String String Class

Definicja

Reprezentuje tekst jako sekwencję jednostek kodu UTF-16.Represents text as a sequence of UTF-16 code units.

public ref class String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>
Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
Dziedziczenie
StringStringStringString
Atrybuty
Implementuje

Uwagi

Ciąg jest sekwencyjną kolekcją znaków, która jest używana do reprezentowania tekstu.A string is a sequential collection of characters that is used to represent text. Obiekt jest sekwencyjną System.Char kolekcją obiektów, które System.Char reprezentują ciąg; obiekt odpowiada jednostce kodu UTF-16. StringA String object is a sequential collection of System.Char objects that represent a string; a System.Char object corresponds to a UTF-16 code unit. Wartość String obiektu jest zawartością sekwencyjnej System.Char kolekcji obiektów i ta wartość jest niezmienna (oznacza to, że jest ona tylko do odczytu).The value of the String object is the content of the sequential collection of System.Char objects, and that value is immutable (that is, it is read-only). Więcej informacji o niezmienności ciągów znajduje się w sekcji niezmienności i StringBuilder klasy w dalszej części tego tematu.For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic. Maksymalny rozmiar String obiektu w pamięci wynosi 2 GB lub około 1 000 000 000 znaków.The maximum size of a String object in memory is 2GB, or about 1 billion characters.

Uwaga

Przykłady języka C#, w tym artykule uruchamiane w Try.NET modułu uruchamiającego testy i Plac zabaw dla kodu wbudowanego.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Jeśli jest obecny, zaznacz Uruchom przycisk, aby uruchomić przykład, w oknie interaktywnym.When present, select the Run button to run an example in an interactive window. Po wykonaniu kodu, możesz go zmodyfikować i uruchomić zmodyfikowany kod, wybierając Uruchom ponownie.Once you execute the code, you can modify it and run the modified code by selecting Run again. Zmodyfikowanego kodu albo działa w oknie interaktywnym lub, jeśli kompilacja nie powiedzie się, w oknie interaktywnym Wyświetla wszystkie C# kompilatora komunikaty o błędach.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

W tej sekcji:In this section:

Tworzenie wystąpienia obiektu String Instantiating a String object
Obiekty char i znaki Unicode Char objects and Unicode characters
Ciągi i standard Unicode Strings and The Unicode Standard
Ciągi i osadzone znaki null Strings and embedded null characters
Ciągi i indeksy Strings and indexes
Ciągi o wartości null i puste ciągi Null strings and empty strings
Niezmienności i StringBuilder — Klasa Immutability and the StringBuilder class
Liczba porządkowa a operacje zależne od kultury Ordinal vs. culture-sensitive operations
Normalizacji Normalization
Operacje na ciągach według kategoriiString operations by category

Utworzenie wystąpienia obiektu StringInstantiating a String object

Można utworzyć wystąpienie String obiektu w następujący sposób:You can instantiate a String object in the following ways:

  • Przypisanie literału ciągu do String zmiennej.By assigning a string literal to a String variable. Jest to najczęściej stosowana metoda tworzenia ciągu.This is the most commonly used method for creating a string. Poniższy przykład używa przypisania do tworzenia kilku ciągów.The following example uses assignment to create several strings. Należy zauważyć, C#że w, ponieważ ukośnik odwrotny (\) jest znakiem ucieczki, literały ukośników odwrotnych w ciągu muszą być zmienione lub cały ciąg musi być. @-quotedNote that in C#, because the backslash (\) is an escape character, literal backslashes in a string must be escaped or the entire string must be @-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      
    
    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      
    
  • Wywoływanie String konstruktora klasy.By calling a String class constructor. Poniższy przykład tworzy wystąpienie ciągów, wywołując kilka konstruktorów klas.The following example instantiates strings by calling several class constructors. Należy zauważyć, że niektóre konstruktory zawierają wskaźniki do tablic znaków lub podpisanych tablic bajtów jako parametry.Note that some of the constructors include pointers to character arrays or signed byte arrays as parameters. Visual Basic nie obsługuje wywołań tych konstruktorów.Visual Basic does not support calls to these constructors. Aby uzyskać szczegółowe informacje String na temat konstruktorów String , zobacz podsumowanie konstruktora.For detailed information about String constructors, see the String constructor summary.

    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  
    
    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      
    
  • Za pomocą operatora łączenia ciągów (+ w C# i & lub + w Visual Basic) do tworzenia pojedynczego ciągu z dowolnej kombinacji String wystąpień i literałów ciągów.By using the string concatenation operator (+ in C# and & or + in Visual Basic) to create a single string from any combination of String instances and string literals. Poniższy przykład ilustruje użycie operatora łączenia ciągów.The following example illustrates the use of the string concatenation operator.

    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.
    
    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.
    
  • Pobierając właściwość lub wywołując metodę zwracającą ciąg.By retrieving a property or calling a method that returns a string. W poniższym przykładzie zastosowano metody String klasy, aby wyodrębnić podciąg z większego ciągu.The following example uses the methods of the String class to extract a substring from a larger 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
    
    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
    
  • Wywołując metodę formatowania, aby przekonwertować wartość lub obiekt na jego reprezentację w postaci ciągu.By calling a formatting method to convert a value or object to its string representation. Poniższy przykład używa funkcji formatowania złożonego , aby osadzić ciąg reprezentujący dwa obiekty w ciągu.The following example uses the composite formatting feature to embed the string representation of two objects into a string.

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

Obiekty char i znaki UnicodeChar objects and Unicode characters

Każdy znak w ciągu jest definiowany przez wartość skalarną Unicode, zwaną również literą kodu Unicode lub wartość porządkową (numeryczną) znaku Unicode.Each character in a string is defined by a Unicode scalar value, also called a Unicode code point or the ordinal (numeric) value of the Unicode character. Każdy punkt kodu jest kodowany przy użyciu kodowania UTF-16, a wartość liczbowa każdego elementu kodowania jest reprezentowana przez Char obiekt.Each code point is encoded by using UTF-16 encoding, and the numeric value of each element of the encoding is represented by a Char object.

Uwaga

Należy zauważyć, że ponieważ String wystąpienie składa się z sekwencyjnej kolekcji jednostek kodu UTF-16, można String utworzyć obiekt, który nie jest poprawnie sformułowanym ciągiem Unicode.Note that, because a String instance consists of a sequential collection of UTF-16 code units, it is possible to create a String object that is not a well-formed Unicode string. Na przykład można utworzyć ciąg, który ma dolny Surogat bez odpowiadającego znaku wieloskładnikowego.For example, it is possible to create a string that has a low surrogate without a corresponding high surrogate. Chociaż niektóre metody, takie jak metody kodowania i dekodowania obiektów w System.Text przestrzeni nazw, mogą wykonywać sprawdzenia, aby upewnić się, że ciągi są dobrze sformułowane, String członkowie klasy nie zapewnią, że ciąg jest poprawnie sformułowany.Although some methods, such as the methods of encoding and decoding objects in the System.Text namespace, may performs checks to ensure that strings are well-formed, String class members don't ensure that a string is well-formed.

Pojedynczy Char obiekt zazwyczaj reprezentuje pojedynczy punkt kodu; oznacza to, że wartość Char liczbowa jest równa punktowi kodu.A single Char object usually represents a single code point; that is, the numeric value of the Char equals the code point. Na przykład punkt kodu dla znaku "a" to U + 0061.For example, the code point for the character "a" is U+0061. Jednak punkt kodu może wymagać więcej niż jednego zakodowanego elementu (więcej niż jeden Char obiekt).However, a code point might require more than one encoded element (more than one Char object). Standard Unicode definiuje dwa typy znaków, które odpowiadają wielu Char obiektom: graphemes i dodatkowe punkty kodowe Unicode, które odnoszą się do znaków w dodatkowych płaszczyznach Unicode.The Unicode standard defines two types of characters that correspond to multiple Char objects: graphemes, and Unicode supplementary code points that correspond to characters in the Unicode supplementary planes.

  • Grapheme jest reprezentowane przez znak podstawowy, po którym następuje co najmniej jeden łączący się znak.A grapheme is represented by a base character followed by one or more combining characters. Na przykład znak ä jest reprezentowany przez Char obiekt, którego punkt kodu to u + 0061 Char , po którym następuje obiekt, którego punkt kodu to u + 0308.For example, the character ä is represented by a Char object whose code point is U+0061 followed by a Char object whose code point is U+0308. Ten znak może być również definiowany przez pojedynczy Char obiekt, który ma punkt kodu U + 00E4.This character can also be defined by a single Char object that has a code point of U+00E4. Jak pokazano na poniższym przykładzie, porównywanie kulturowe dla równości wskazuje, że te dwie reprezentacje są równe, chociaż zwykłe porównanie porządkowe nie jest.As the following example shows, a culture-sensitive comparison for equality indicates that these two representations are equal, although an ordinary ordinal comparison does not. Jeśli jednak dwa ciągi są znormalizowane, porównanie porządkowe wskazuje również, że są równe.However, if the two strings are normalized, an ordinal comparison also indicates that they are equal. (Aby uzyskać więcej informacji na temat normalizacji ciągów, Zobacz sekcję normalizacji).(For more information on normalizing strings, see the Normalization section.)

    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: 
    //       ä 
    //       ä 
    //       ä = ä (Culture-sensitive): True 
    //       ä = ä (Ordinal): False 
    //       ä = ä (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:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (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:
    '       ä
    '       ä
    '       ä = ä (Culture-sensitive): True
    '       ä = ä (Ordinal): False
    '       ä = ä (Normalized Ordinal): True
    
  • Dodatkowy punkt kodu Unicode (para dwuskładnikowa) jest reprezentowany przez Char obiekt, którego punkt kodowy jest dużym surogatem, a następnie Char obiektem, którego punkt kodowy jest dolnym surogatem.A Unicode supplementary code point (a surrogate pair) is represented by a Char object whose code point is a high surrogate followed by a Char object whose code point is a low surrogate. Jednostki kodu dla dużych surogatów mieszczą się w zakresie od U + D800 do U + DBFF.The code units of high surrogates range from U+D800 to U+DBFF. Jednostki kodu dla małych surogatów mieszczą się w zakresie od U + DC00 do U + DFFF.The code units of low surrogates range from U+DC00 to U+DFFF. Pary dwuskładnikowe służą do reprezentowania znaków w dodatkowych płaszczyznach 16 Unicode.Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. Poniższy przykład tworzy znak zastępczy i przekazuje go do Char.IsSurrogatePair(Char, Char) metody, aby określić, czy jest to para dwuskładnikowa.The following example creates a surrogate character and passes it to the Char.IsSurrogatePair(Char, Char) method to determine whether it is a surrogate pair.

    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+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
    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
    
    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
    

Ciągi i standard UnicodeStrings and the Unicode Standard

Znaki w ciągu są reprezentowane przez jednostki kodu kodowane w formacie UTF-16, które odpowiadają Char wartościom.Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

Każdy znak w ciągu ma skojarzoną kategorię znaków Unicode, która jest reprezentowana w programie .NET przez UnicodeCategory Wyliczenie.Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. Kategorię znaku lub pary zastępczej można określić, wywołując CharUnicodeInfo.GetUnicodeCategory metodę.The category of a character or a surrogate pair can be determined by calling the CharUnicodeInfo.GetUnicodeCategory method.

.NET obsługuje własnej tabeli znaków i ich odpowiedniej kategorii, który zapewnia, że określoną wersję implementacji programu .NET uruchomionych na różnych platformach zwraca informacje o kategorii identyczne znak..NET maintains its own table of characters and their corresponding categories, which ensures that a specific version of a .NET implementation running on different platforms returns identical character category information. Na platformie .NET Core w systemie Linux i macOS, informacje kategorii znaków są udostępniane przez składniki międzynarodowego standardu Unicode bibliotek.On .NET Core running on Linux and macOS, character category information is provided by International Components for Unicode libraries.

W poniższej tabeli wymieniono wersje programu .NET i wersji standardu Unicode, na którym są na podstawie ich kategorii znaków.The following table lists .NET versions and the versions of the Unicode Standard on which their character categories are based.

Wersja platformy .NET.NET version Wersja Unicode StandardVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Standard Unicode wersji 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 Standard Unicode wersji 5.0.0The Unicode Standard, Version 5.0.0
Program .NET Framework 3,5.NET Framework 3.5 Standard Unicode wersji 5.0.0The Unicode Standard, Version 5.0.0
Program .NET Framework 4.NET Framework 4 Standard Unicode wersji 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 Standard Unicode wersji wersji 6.3.0The Unicode Standard, Version 6.3.0
.NET framework 4.51.NET Framework 4.51 Standard Unicode wersji wersji 6.3.0The Unicode Standard, Version 6.3.0
.NET framework 4,52.NET Framework 4.52 Standard Unicode wersji wersji 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 Standard Unicode wersji wersji 6.3.0The Unicode Standard, Version 6.3.0
.NET framework 4.61.NET Framework 4.61 Standard Unicode wersji wersji 6.3.0The Unicode Standard, Version 6.3.0
.NET framework 4.6.2 lub nowszy.NET Framework 4.6.2 and later versions Standard Unicode wersji 8.0.0The Unicode Standard, Version 8.0.0
.NET core (wszystkie wersje).NET Core (all versions) Standard Unicode wersji 8.0.0The Unicode Standard, Version 8.0.0

Ponadto platforma .NET obsługuje Porównywanie ciągów i sortowanie na podstawie standardu Unicode.In addition, .NET supports string comparison and sorting based on the Unicode standard. W wersjach .NET Framework przez Program .NET Framework 4.NET Framework 4, .NET Framework zachowuje własną tabelę danych ciągu.In versions of the .NET Framework through the Program .NET Framework 4.NET Framework 4, the .NET Framework maintains its own table of string data. Jest to również prawdziwe w przypadku wersji .NET Framework rozpoczynających .NET Framework 4.5.NET Framework 4.5 się od uruchomienia w systemie Windows 7.This is also true of versions of the .NET Framework starting with the .NET Framework 4.5.NET Framework 4.5 running on Windows 7. .NET Framework 4.5.NET Framework 4.5 Począwszy od systemu operacyjnego Windows 8 i jego nowszych wersji, środowisko uruchomieniowe deleguje porównanie ciągów i sortowania do systemu operacyjnego.Starting with the .NET Framework 4.5.NET Framework 4.5 running on Window 8 and later versions of the Windows operating system, the runtime delegates string comparison and sorting operations to the operating system. W przypadku platformy .NET Core informacje o porównywaniu ciągów i sortowaniu są udostępniane przez składniki międzynarodowe dla bibliotek Unicode . W poniższej tabeli wymieniono wersje programu .NET i wersje standardu Unicode, w których są oparte porównywane i sortowane znaki.On .NET Core, string comparison and sorting information is provided by International Components for Unicode libraries.The following table lists the versions of .NET and the versions of the Unicode Standard on which character comparison and sorting are based.

Wersja platformy .NET.NET version Wersja Unicode StandardVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Standard Unicode wersji 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2,0The .NET Framework 2.0 Standard Unicode wersji 5.0.0The Unicode Standard, Version 5.0.0
Program .NET Framework 3,5.NET Framework 3.5 Standard Unicode wersji 5.0.0The Unicode Standard, Version 5.0.0
Program .NET Framework 4.NET Framework 4 Standard Unicode wersji 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5i nowszych w systemie Windows 7and later on Windows 7 Standard Unicode wersji 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5i nowszych wersjach systemu Windows 8 i nowszych systemów operacyjnych Windowsand later on Windows 8 and later Windows operating systems Standard Unicode wersji wersji 6.3.0The Unicode Standard, Version 6.3.0
.NET core (wszystkie wersje).NET Core (all versions) Zależy od wersji standardu Unicode obsługiwanego przez podstawowy system operacyjny.Depends on the version of the Unicode Standard supported by the underlying operating system.

Ciągi i osadzone znaki o wartości zerowejStrings and embedded null characters

W programie .NET String obiekt może zawierać osadzone znaki null, które są liczone jako część długości ciągu.In .NET, a String object can include embedded null characters, which count as a part of the string's length. Jednak w niektórych językach, takich jak C i C++, znak null wskazuje koniec ciągu; nie jest uważany za część ciągu i nie jest liczony jako część długości ciągu.However, in some languages such as C and C++, a null character indicates the end of a string; it is not considered a part of the string and is not counted as part of the string's length. Oznacza to, że następujące typowe założenia, że C C++ i programiści lub biblioteki w języku c C++ lub mogą wprowadzać ciągi niekoniecznie są ważne w przypadku String zastosowania do obiektów:This means that the following common assumptions that C and C++ programmers or libraries written in C or C++ might make about strings are not necessarily valid when applied to String objects:

  • Wartość zwracana przez strlen funkcję lub wcslen nie musi być równa String.Length.The value returned by the strlen or wcslen functions does not necessarily equal String.Length.

  • Ciąg utworzony przez strcpy_s lub wcscpy_s funkcji nie musi być identyczny z ciągiem utworzonym przez String.Copy metodę.The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the String.Copy method.

Należy upewnić się, że natywne C i C++ kod String , który tworzy wystąpienia obiektów, oraz String kod, który jest przesyłany przez wywołanie platformy, nie zakłada, że osadzony znak null oznacza koniec ciągu.You should ensure that native C and C++ code that instantiates String objects, and code that is passed String objects through platform invoke, don't assume that an embedded null character marks the end of the string.

Osadzone znaki null w ciągu są również traktowane inaczej, gdy ciąg jest sortowany (lub porównywany) i kiedy przeszukiwany jest ciąg.Embedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. Znaki null są ignorowane podczas przeprowadzania porównania z uwzględnieniem kultury między dwoma ciągami, w tym porównania przy użyciu niezmiennej kultury.Null characters are ignored when performing culture-sensitive comparisons between two strings, including comparisons using the invariant culture. Są one uznawane tylko za porównania porządkowe lub nieuwzględniające wielkości liter.They are considered only for ordinal or case-insensitive ordinal comparisons. Z drugiej strony osadzone znaki null są zawsze brane pod uwagę podczas wyszukiwania ciągu przy użyciu metod takich jak Contains, StartsWith, i IndexOf.On the other hand, embedded null characters are always considered when searching a string with methods such as Contains, StartsWith, and IndexOf.

Ciągi i indeksyStrings and indexes

Indeks jest pozycją Char obiektu (nie znakiem Unicode) Stringw.An index is the position of a Char object (not a Unicode character) in a String. Indeks jest liczony od zera liczbą nieujemną rozpoczynającą się od pierwszej pozycji w ciągu, która jest pozycją indeksu równą zero.An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. Wiele metod wyszukiwania, takich jak IndexOf i LastIndexOf, zwraca indeks znaku lub podciągu w wystąpieniu ciągu.A number of search methods, such as IndexOf and LastIndexOf, return the index of a character or substring in the string instance.

Właściwość umożliwia dostęp do pojedynczych Char obiektów według ich pozycji indeksu w ciągu. Chars[Range]The Chars[Range] property lets you access individual Char objects by their index position in the string. Ponieważ właściwość jest właściwością domyślną (w Visual Basic) lub indeksatorem (w programie C#), można uzyskać dostęp do poszczególnych Char obiektów w ciągu za pomocą kodu, takiego jak poniższy. Chars[Range]Because the Chars[Range] property is the default property (in Visual Basic) or the indexer (in C#), you can access the individual Char objects in a string by using code such as the following. Ten kod szuka białych znaków w ciągu, aby określić, ile wyrazów zawiera ciąg.This code looks for white space or punctuation characters in a string to determine how many words the string contains.

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

Ponieważ klasa implementuje interfejs, Char można także wykonać iterację obiektów w ciągu przy użyciu foreach konstrukcji, jak pokazano w poniższym przykładzie. IEnumerable StringBecause the String class implements the IEnumerable interface, you can also iterate through the Char objects in a string by using a foreach construct, as the following example shows.

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

Kolejne wartości indeksów mogą nie odpowiadać na kolejne znaki Unicode, ponieważ znak Unicode może być zakodowany jako więcej niż jeden Char obiekt.Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one Char object. W szczególności ciąg może zawierać jednoznakowe jednostki tekstu, które są tworzone przez znak podstawowy, po którym następuje co najmniej jeden łączenie znaków lub przez pary zastępcze.In particular, a string may contain multi-character units of text that are formed by a base character followed by one or more combining characters or by surrogate pairs. Aby współpracować ze znakami Unicode zamiast Char obiektów, System.Globalization.StringInfo Użyj klas i TextElementEnumerator .To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. Poniższy przykład ilustruje różnicę między kodem, który działa z Char obiektami i kodem, który działa ze znakami Unicode.The following example illustrates the difference between code that works with Char objects and code that works with Unicode characters. Porównuje liczbę znaków lub elementów tekstu w każdym słowie zdania.It compares the number of characters or text elements in each word of a sentence. Ciąg zawiera dwie sekwencje znaków podstawowych, po których następuje łączenie znaku.The string includes two sequences of a base character followed by a combining character.

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 émotion que "+
                     L"je commence à 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 émotion que "+
                 "je commence à 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
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 émotion que "+
                              "je commence à 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

Ten przykład działa z elementami tekstowymi przy użyciu StringInfo.GetTextElementEnumerator metody TextElementEnumerator i klasy do wyliczania wszystkich elementów tekstu w ciągu.This example works with text elements by using the StringInfo.GetTextElementEnumerator method and the TextElementEnumerator class to enumerate all the text elements in a string. Możesz również pobrać tablicę zawierającą indeks początkowy każdego elementu tekstowego, wywołując StringInfo.ParseCombiningCharacters metodę.You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

Aby uzyskać więcej informacji na temat pracy z jednostkami tekstu, Char a nie pojedynczymi StringInfo wartościami, zobacz Klasa.For more information about working with units of text rather than individual Char values, see the StringInfo class.

Ciągi zerowe i puste ciągiNull strings and empty strings

Ciąg, który został zadeklarowany, ale nie ma przypisanej wartości null.A string that has been declared but has not been assigned a value is null. Próba wywołania metod w tym ciągu zwraca wartość NullReferenceException.Attempting to call methods on that string throws a NullReferenceException. Ciąg o wartości null różni się od pustego ciągu, który jest ciągiem, którego wartością jest "" String.Empty.A null string is different from an empty string, which is a string whose value is "" or String.Empty. W niektórych przypadkach przekazywanie ciągu o wartości null lub pustego ciągu jako argumentu w wywołaniu metody zgłasza wyjątek.In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. Na przykład przekazywanie ciągu o wartości null do Int32.Parse metody ArgumentNullExceptionzgłasza, i przekazywanie pustego ciągu zgłasza FormatException.For example, passing a null string to the Int32.Parse method throws an ArgumentNullException, and passing an empty string throws a FormatException. W innych przypadkach argument metody może być ciągiem o wartości null lub ciągiem pustym.In other cases, a method argument can be either a null string or an empty string. Na przykład, jeśli dostarczasz IFormattable implementację klasy, chcesz zrównać zarówno ciąg o wartości null, jak i pusty ciąg z specyfikatorem formatu ogólnego ("G").For example, if you are providing an IFormattable implementation for a class, you want to equate both a null string and an empty string with the general ("G") format specifier.

Klasa obejmuje dwie metody wygodne, które umożliwiają przetestowanie, czy ciąg jest null lub pusty: StringThe String class includes the following two convenience methods that enable you to test whether a string is null or empty:

  • IsNullOrEmpty, która wskazuje, czy ciąg ma wartość null lub jest String.Emptyrówna.IsNullOrEmpty, which indicates whether a string is either null or is equal to String.Empty. Ta metoda eliminuje konieczność użycia kodu, takiego jak:This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace, która wskazuje, czy ciąg jest nullrówna String.Emptylub polega wyłącznie na znakach odstępu.IsNullOrWhiteSpace, which indicates whether a string is null, equals String.Empty, or consists exclusively of white-space characters. Ta metoda eliminuje konieczność użycia kodu, takiego jak:This method eliminates the need to use code such as the following:

    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 Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

W poniższym przykładzie zastosowano IsNullOrEmpty metodę IFormattable.ToString w implementacji klasy niestandardowej Temperature .The following example uses the IsNullOrEmpty method in the IFormattable.ToString implementation of a custom Temperature class. Metoda obsługuje ciągi formatu "G", "C", "F" i "K".The method supports the "G", "C", "F", and "K" format strings. Jeśli pusty ciąg formatu lub ciąg formatu, którego wartość jest null przenoszona do metody, jego wartość jest zmieniana na ciąg formatu "G".If an empty format string or a format string whose value is null is passed to the method, its value is changed to the "G" format string.

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

Niezmienność i klasa StringBuilderImmutability and the StringBuilder class

String Obiekt jest wywoływany jako niezmienny (tylko do odczytu), ponieważ jego wartość nie może być modyfikowana po utworzeniu.A String object is called immutable (read-only), because its value cannot be modified after it has been created. Metody, które pojawiają się String w celu zmodyfikowania obiektu String , faktycznie zwracają nowy obiekt, który zawiera modyfikację.Methods that appear to modify a String object actually return a new String object that contains the modification.

Ponieważ ciągi są niezmienne, procedury manipulowania ciągami, które wykonują powtarzające się operacje dodawania lub usuwania do elementów, które wydaje się być pojedynczym ciągiem, mogą dokładnie mieć znaczny spadek wydajności.Because strings are immutable, string manipulation routines that perform repeated additions or deletions to what appears to be a single string can exact a significant performance penalty. Na przykład poniższy kod używa generatora liczb losowych, aby utworzyć ciąg z 1000 znaków w zakresie 0x0001 do 0x052F.For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. Chociaż kod wydaje się używać łączenia ciągów do dołączania nowego znaku do istniejącego ciągu o nazwie str, w rzeczywistości tworzy nowy String obiekt dla każdej operacji łączenia.Although the code appears to use string concatenation to append a new character to the existing string named str, it actually creates a new String object for each concatenation operation.

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 += Convert.ToChar(rnd.Next(1, 0x0530)); 
         if (str.Length % 60 == 0)
            str += Environment.NewLine;          
      }                    
      sw.Write(str);
      sw.Close();
   }
}
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

Można użyć StringBuilder klasy zamiast String klasy dla operacji, które wprowadzają wiele zmian do wartości ciągu.You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. W przeciwieństwie do wystąpień String klasy, StringBuilder obiekty są modyfikowalne; podczas łączenia, dołączania lub usuwania podciągów z ciągu, operacje są wykonywane na pojedynczym ciągu.Unlike instances of the String class, StringBuilder objects are mutable; when you concatenate, append, or delete substrings from a string, the operations are performed on a single string. Po zakończeniu modyfikowania wartości StringBuilder obiektu można wywołać jego StringBuilder.ToString metodę, aby przekonwertować ją na ciąg.When you have finished modifying the value of a StringBuilder object, you can call its StringBuilder.ToString method to convert it to a string. Poniższy przykład zastępuje String użycie w poprzednim przykładzie, aby połączyć 1000 losowe znaki z zakresu do 0x0001 do 0x052F StringBuilder z obiektem.The following example replaces the String used in the previous example to concatenate 1000 random characters in the range to 0x0001 to 0x052F with a StringBuilder object.

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(Convert.ToChar(rnd.Next(1, 0x0530))); 
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}
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

Operacje porządkowe vs. operacje zależne od kulturyOrdinal vs. culture-sensitive operations

Elementy członkowskie String klasy wykonują operacje na obiektach porządkowych lub wrażliwych na kulturę. StringMembers of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. Operacja porządkowa działa na wartości liczbowej każdego Char obiektu.An ordinal operation acts on the numeric value of each Char object. Operacje zależne od kultury działają na wartości String obiektu i pobierają wielkość liter, sortowanie, formatowanie i analizowanie reguł dla konta.A culture-sensitive operation acts on the value of the String object, and takes culture-specific casing, sorting, formatting, and parsing rules into account. Operacje zależne od kultury są wykonywane w kontekście jawnie zadeklarowanej kultury lub niejawnej bieżącej kultury.Culture-sensitive operations execute in the context of an explicitly declared culture or the implicit current culture. Dwa rodzaje operacji mogą generować różne wyniki, gdy są wykonywane na tym samym ciągu.The two kinds of operations can produce very different results when they are performed on the same string.

Platforma .NET obsługuje także wielokulturowe operacje na ciągach lingwistycznych przy użyciu niezmiennejCultureInfo.InvariantCulturekultury (), która jest luźno oparta na ustawieniach kultury w języku angielskim niezależnym od regionu..NET also supports culture-insensitive linguistic string operations by using the invariant culture (CultureInfo.InvariantCulture), which is loosely based on the culture settings of the English language independent of region. W przeciwieństwie System.Globalization.CultureInfo do innych ustawień, ustawienia niezmiennej kultury są gwarantowane, że są spójne na jednym komputerze, z systemu do systemu i między różnymi wersjami programu .NET.Unlike other System.Globalization.CultureInfo settings, the settings of the invariant culture are guaranteed to remain consistent on a single computer, from system to system, and across versions of .NET. Niezmienna kultura może być traktowana jako rodzaj czarnego pola, które zapewnia stabilność porównywania ciągów i porządkowanie we wszystkich kulturach.The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

Ważne

Jeśli aplikacja wykonuje decyzję o zabezpieczeniach dotyczącą identyfikatora symbolicznego, takiego jak nazwa pliku lub potok nazwany lub informacje o utrwalonych danych, takich jak dane tekstowe w pliku XML, operacja powinna używać porównania porządkowego zamiast porównania z uwzględnieniem kultury.If your application makes a security decision about a symbolic identifier such as a file name or named pipe, or about persisted data such as the text-based data in an XML file, the operation should use an ordinal comparison instead of a culture-sensitive comparison. Wynika to z faktu, że porównanie wrażliwe na kulturę może dać różne wyniki w zależności od kultury, podczas gdy porównanie porządkowe zależy wyłącznie od wartości binarnej porównywanych znaków.This is because a culture-sensitive comparison can yield different results depending on the culture in effect, whereas an ordinal comparison depends solely on the binary value of the compared characters.

Ważne

Większość metod wykonywania operacji na ciągach zawiera Przeciążenie, które ma parametr typu StringComparison, który pozwala określić, czy metoda wykonuje operacje porządkową lub zależną od kultury.Most methods that perform string operations include an overload that has a parameter of type StringComparison, which enables you to specify whether the method performs an ordinal or culture-sensitive operation. Ogólnie rzecz biorąc, należy wywołać to Przeciążenie, aby przeznaczenie metody zostało wyczyszczone.In general, you should call this overload to make the intent of your method call clear. Aby zapoznać się z najlepszymi rozwiązaniami i wskazówkami dotyczącymi używania porządkowej i kulturowej operacji na ciągach, zobacz najlepsze rozwiązania dotyczące używania ciągów.For best practices and guidance for using ordinal and culture-sensitive operations on strings, see Best Practices for Using Strings.

Operacje dotyczące wielkości liter, analizowania i formatowania, porównywania i sortowaniaoraz testowania pod kątem równości mogą być porządkowe lub wrażliwe na kulturę.Operations for casing, parsing and formatting, comparison and sorting, and testing for equality can be either ordinal or culture-sensitive. W poniższych sekcjach omówiono każdą kategorię operacji.The following sections discuss each category of operation.

Porada

Należy zawsze wywołać metodę przeciążenia metody, która sprawia, że cel wywołania metody jest wyczyszczony.You should always call a method overload that makes the intent of your method call clear. Compare(String, String) Na przykład zamiast wywołania metody w celu przeprowadzenia porównania z dwoma ciągami z uwzględnieniem kultury przy użyciu Konwencji bieżącej kultury, należy Compare(String, String, StringComparison) wywołać StringComparison.CurrentCulture metodę z wartością dla comparisonType argument.For example, instead of calling the Compare(String, String) method to perform a culture-sensitive comparison of two strings by using the conventions of the current culture, you should call the Compare(String, String, StringComparison) method with a value of StringComparison.CurrentCulture for the comparisonType argument. Aby uzyskać więcej informacji, zobacz najlepsze rozwiązania dotyczące używania ciągów.For more information, see Best Practices for Using Strings.

Można pobrać tabele wagi sortowania, zestaw plików tekstowych, które zawierają informacje o wagach znaków używanych w operacjach sortowania i porównywania dla systemów operacyjnych Windows, a także domyślną tabelę elementów sortowania Unicode, sortowanie tabela wag dla systemów Linux i macOS.You can download the Sorting Weight Tables, a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, and the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

Wielkość znakówCasing

Zasady dotyczące wielkości liter określają, jak zmienić wielkooć liter znaku Unicode; na przykład z małych i wielkich liter.Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. Często operacje dotyczące wielkości liter są wykonywane przed porównaniem ciągu.Often, a casing operation is performed before a string comparison. Na przykład ciąg może zostać przekonwertowany na wielkie litery, aby można go było porównać z innym ciągiem z wielką literą.For example, a string might be converted to uppercase so that it can be compared with another uppercase string. Możesz przekonwertować znaki w ciągu na ToLower małe, wywołując metodę lub ToLowerInvariant i konwertując je ToUpper na wielkie litery poprzez wywołanie metody lub ToUpperInvariant .You can convert the characters in a string to lowercase by calling the ToLower or ToLowerInvariant method, and you can convert them to uppercase by calling the ToUpper or ToUpperInvariant method. Ponadto można użyć TextInfo.ToTitleCase metody do przekonwertowania ciągu na wielkość liter.In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

Uwaga

.NET core uruchomiony tylko w systemach Linux i macOS: Zachowanie sortowania dla języków C i Posix zawsze jest wielkość liter, ponieważ te kultur nie należy używać w oczekiwanej kolejności sortowania Unicode..NET Core running on Linux and macOS systems only: The collation behavior for the C and Posix cultures is always case-sensitive because these cultures do not use the expected Unicode collation order. Zalecamy użycie kultury innej niż C lub Posix dla operacji wrażliwych na kulturę, bez uwzględniania wielkości liter sortowania.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Operacje dotyczące wielkości liter mogą opierać się na regułach bieżącej kultury, określonej kulturze lub kulturze niezmiennej.Casing operations can be based on the rules of the current culture, a specified culture, or the invariant culture. Ponieważ mapowania wielkości liter mogą się różnić w zależności od używanej kultury, wynik operacji wielkości liter może się różnić w zależności od kultury.Because case mappings can vary depending on the culture used, the result of casing operations can vary based on culture. Rzeczywiste różnice w wielkości liter są trzy rodzaje:The actual differences in casing are of three kinds:

  • Różnice w mapowaniu przypadku Wielkiej litery I (U + 0049), małych LITERAch I (U + 0069), Wielkiej litery I z KROPKą powyżej (U + 0130) i MAŁĄ LITERą bez ZNAKiem i (U + 0131).Differences in the case mapping of LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130), and LATIN SMALL LETTER DOTLESS I (U+0131). W przypadku kultur TR-TR (turecki (Turcja)) i az-Latn-AZ (Azerbejdżan, łaciński), a w obszarze TR, AZ i az-Latn neutralnych, małe litery ALFABETu łacińskiego i są małymi LITERAmi bez znakiem i z wielką literą WIELKA LITERA I Z KROPKĄ POWYŻEJ.In the tr-TR (Turkish (Turkey)) and az-Latn-AZ (Azerbaijan, Latin) cultures, and in the tr, az, and az-Latn neutral cultures, the lowercase equivalent of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and the uppercase equivalent of LATIN SMALL LETTER I is LATIN CAPITAL LETTER I WITH DOT ABOVE. We wszystkich innych kulturach, w tym w niezmiennej kulturze, mała litera i Wielka litera, a to małe i wielkie litery.In all other cultures, including the invariant culture, LATIN SMALL LETTER I and LATIN CAPITAL LETTER I are lowercase and uppercase equivalents.

    W poniższym przykładzie pokazano, jak porównanie ciągów, które uniemożliwia dostęp do systemu plików, może się nie powieść, jeśli jest to zależne od porównania wielkości liter.The following example demonstrates how a string comparison designed to prevent file system access can fail if it relies on a culture-sensitive casing comparison. (Konwencje wielkości liter kultury niezmiennej powinny być używane).(The casing conventions of the invariant culture should have been used.)

    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
    
    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
    
  • Różnice w mapowaniu wielkości liter między kulturą niezmienną i wszystkimi innymi kulturami.Differences in case mappings between the invariant culture and all other cultures. W takich przypadkach, używając reguł wielkości liter kultury niezmiennej, aby zmienić znak na wielkie lub małe litery zwraca ten sam znak.In these cases, using the casing rules of the invariant culture to change a character to uppercase or lowercase returns the same character. Dla wszystkich innych kultur zwraca inny znak.For all other cultures, it returns a different character. Niektóre z tych znaków zostały wymienione w poniższej tabeli.Some of the affected characters are listed in the following table.

    ZnakCharacter W przypadku zmiany naIf changed to ZwracaReturns
    ZNAK MIKRO (U + 00B5)MICRON SIGN (U+00B5) Wielkie literyUppercase WIELKA LITERA GRECKA (U +-39C)GREEK CAPITAL LETTER MU (U+-39C)
    WIELKA LITERA I Z KROPKĄ POWYŻEJ (U + 0130)LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) Małe literyLowercase MAŁA LITERA I (U + 0069)LATIN SMALL LETTER I (U+0069)
    MAŁA LITERA Z KROPKĄ I (U + 0131)LATIN SMALL LETTER DOTLESS I (U+0131) Wielkie literyUppercase WIELKA LITERA I (U + 0049)LATIN CAPITAL LETTER I (U+0049)
    MAŁA LITERA S (U + 017F)LATIN SMALL LETTER LONG S (U+017F) Wielkie literyUppercase WIELKA LITERA S (U + 0053)LATIN CAPITAL LETTER S (U+0053)
    WIELKA LITERA D Z MAŁĄ LITERĄ Z ODWRÓCONYM DASZKIEM (U + 01C5)LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) Małe literyLowercase MAŁA LITERA DZ Z ODWRÓCONYM DASZKIEM (U + 01C6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    ŁĄCZENIE GRECKIEGO YPOGEGRAMMENI (U + 0345)COMBINING GREEK YPOGEGRAMMENI (U+0345) Wielkie literyUppercase WIELKA GRECKA LITERA JOTA (U + 0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • Różnice w mapowaniu przypadku dwuliterowych par przypadków mieszanych w zakresie znaków ASCII.Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. W większości kultur dwuliterowa para przypadków mieszanych jest równa równoważnej dwuliterowej pary wielkie lub małe litery.In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. Nie dotyczy to następujących dwuliterowych par w poniższych kulturach, ponieważ w każdym przypadku są one porównywane z wykresem:This is not true for the following two-letter pairs in the following cultures, because in each case they are compared to a digraph:

    • "lJ" i "nJ" w kulturze HR-HR (chorwacki (Chorwacja))."lJ" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • "cH" w kulturach CS-CZ (czeski (Czechy)) i SK-SK (słowacki (Słowacja))."cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • "aA" w kulturze da-DK (duński (Dania))."aA" in the da-DK (Danish (Denmark)) culture.

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" i "zS" w kulturze hu (węgierski))."cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • "cH" i "lL" w kulturze es-ES_tradnl (hiszpański (Hiszpania, tradycyjny))."cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU", "tH" i "tR" w kulturze VI-VN (wietnamski (Wietnam))."cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", and "tR" in the vi-VN (Vietnamese (Vietnam)) culture.

    Niemniej jednak zdarza się sytuacje, w których porównanie kulturowe tych par tworzy problemy, ponieważ te pary są nietypowe w stałych ciągach lub identyfikatorach.However, it is unusual to encounter a situation in which a culture-sensitive comparison of these pairs creates problems, because these pairs are uncommon in fixed strings or identifiers.

Poniższy przykład ilustruje niektóre różnice w regułach wielkości liter między kulturami podczas konwertowania ciągów na wielkie litery.The following example illustrates some of the differences in casing rules between cultures when converting strings to uppercase.

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"Dž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  
//     
//    Dženana: 
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41  
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  
//            tr-TR:  DŽ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", "Dž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 
//    
//    Dženana:
//        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
//            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
//            tr-TR:  DŽ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", "Dž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 
'    
'    Dženana:
'        Invariant:  DžENANA   01 C5 00 45 00 4E 00 41 00 4E 00 41 
'            en-US:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41 
'            tr-TR:  DŽENANA   01 C4 00 45 00 4E 00 41 00 4E 00 41  

Formatowanie i analizowanieParsing and formatting

Formatowanie i analizowanie to operacje odwrotne.Formatting and parsing are inverse operations. Reguły formatowania określają sposób konwersji wartości, takich jak Data i godzina lub liczba, na reprezentację w postaci ciągu, podczas gdy reguły analizy określają, jak konwertować reprezentację ciągu na wartość taką jak Data i godzina.Formatting rules determine how to convert a value, such as a date and time or a number, to its string representation, whereas parsing rules determine how to convert a string representation to a value such as a date and time. Reguły formatowania i analizowania są zależne od konwencji kulturowych.Both formatting and parsing rules are dependent on cultural conventions. Poniższy przykład ilustruje niejednoznaczność, która może powstać przy interpretacji ciągu daty specyficznej dla kultury.The following example illustrates the ambiguity that can arise when interpreting a culture-specific date string. Bez znajomości Konwencji kultury, która była używana do tworzenia ciągu daty, nie jest możliwe, że 03/01/2011, 3/1/2011 i 01/03/2011 reprezentuje 3 stycznia 2011 lub 1 marca 2011.Without knowing the conventions of the culture that was used to produce a date string, it is not possible to know whether 03/01/2011, 3/1/2011, and 01/03/2011 represent January 3, 2011 or March 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
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

Podobnie, jak pokazano w poniższym przykładzie, pojedynczy ciąg może generować różne daty w zależności od kultury, której konwencje są używane w operacji analizowania.Similarly, as the following example shows, a single string can produce different dates depending on the culture whose conventions are used in the parsing operation.

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

Porównanie ciągów i sortowanieString comparison and sorting

Konwencje do porównywania i sortowania ciągów różnią się od kultury do kultury.Conventions for comparing and sorting strings vary from culture to culture. Na przykład porządek sortowania może opierać się na fonetycznych lub w wizualnej reprezentacji znaków.For example, the sort order may be based on phonetics or on the visual representation of characters. W językach wschodnioazjatyckich znaki są sortowane według obrysu i pierwiastka z ideogramy.In East Asian languages, characters are sorted by the stroke and radical of ideographs. Sortowanie zależy również od języków zamówienia i kultur używanych dla alfabetu.Sorting also depends on the order languages and cultures use for the alphabet. Na przykład język duński ma znak "Æ", który jest sortowany po "Z" alfabetu.For example, the Danish language has an "Æ" character that it sorts after "Z" in the alphabet. Ponadto porównania mogą uwzględniać wielkość liter lub uwzględniać wielkość liter, a w niektórych przypadkach reguły dotyczące wielkości liter różnią się również kulturą.In addition, comparisons can be case-sensitive or case-insensitive, and in some cases casing rules also differ by culture. Porównanie porządkowe, z drugiej strony, używa punktów kodu Unicode poszczególnych znaków w ciągu podczas porównywania i sortowania ciągów.Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

Reguły sortowania określają kolejność alfabetyczną znaków Unicode i sposób, w jaki dwa ciągi porównują się ze sobą.Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. Na przykład String.Compare(String, String, StringComparison) Metoda porównuje dwa ciągi StringComparison w oparciu o parametr.For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. Jeśli wartość parametru to StringComparison.CurrentCulture, Metoda wykonuje porównanie lingwistyczne, które używa Konwencji bieżącej kultury; Jeśli wartość parametru to StringComparison.Ordinal, Metoda wykonuje porównanie porządkowe.If the parameter value is StringComparison.CurrentCulture, the method performs a linguistic comparison that uses the conventions of the current culture; if the parameter value is StringComparison.Ordinal, the method performs an ordinal comparison. W związku z tym, jak pokazano w poniższym przykładzie, jeśli bieżąca kultura jest w Stanach Zjednoczonych W języku angielskim pierwsze wywołanie String.Compare(String, String, StringComparison) metody (przy użyciu porównania z uwzględnieniem kultury) uważa wartość "a" mniejszą niż "a", ale drugie wywołanie tej samej metody (przy użyciu porównania porządkowej) traktuje "a" większe niż "a".Consequently, as the following example shows, if the current culture is U.S. English, the first call to the String.Compare(String, String, StringComparison) method (using culture-sensitive comparison) considers "a" less than "A", but the second call to the same method (using ordinal comparison) considers "a" greater than "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
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

Platforma .NET obsługuje reguły sortowania wyrazów, ciągów i porządkowych:.NET supports word, string, and ordinal sort rules:

  • Sortowanie wyrazów wykonuje porównanie z uwzględnieniem kultury ciągów, w których niektóre znaki niealfanumeryczne Unicode mogą mieć przypisane specjalne wagi.A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. Na przykład łącznik (-) może mieć przypisaną bardzo małą wagę, tak aby "coop" i "współ-op" pojawiły się obok siebie na sortowanej liście.For example, the hyphen (-) might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list. Aby zapoznać się z listą String metod, które porównują dwa ciągi przy użyciu reguł sortowania wyrazów, zobacz sekcję operacje na ciągach według kategorii .For a list of the String methods that compare two strings using word sort rules, see the String operations by category section.

  • Sortowanie ciągów wykonuje także porównanie z uwzględnieniem kultury.A string sort also performs a culture-sensitive comparison. Jest to podobne do sortowania wyrazów, z tą różnicą, że nie istnieją specjalne przypadki i wszystkie symbole inne niż alfanumeryczne są przed wszystkimi alfanumerycznymi znakami Unicode.It is similar to a word sort, except that there are no special cases, and all nonalphanumeric symbols come before all alphanumeric Unicode characters. Dwa ciągi można porównać przy użyciu reguł sortowania ciągów, wywołując CompareInfo.Compare przeciążenia metody, które options mają parametr, który CompareOptions.StringSortma wartość.Two strings can be compared using string sort rules by calling the CompareInfo.Compare method overloads that have an options parameter that is supplied a value of CompareOptions.StringSort. Należy zauważyć, że jest to jedyna metoda, którą platforma .NET oferuje do porównywania dwóch ciągów przy użyciu reguł sortowania ciągów.Note that this is the only method that .NET provides to compare two strings using string sort rules.

  • Sortowanie porządkowe porównuje ciągi na podstawie wartości liczbowej każdego Char obiektu w ciągu.An ordinal sort compares strings based on the numeric value of each Char object in the string. W porównaniu porządkowej jest automatycznie rozróżniana wielkość liter, ponieważ małe litery i wielkie litery znaku mają różne punkty kodów.An ordinal comparison is automatically case-sensitive because the lowercase and uppercase versions of a character have different code points. Jeśli jednak przypadek nie jest istotny, można określić porównanie porządkowe, które ignoruje wielkość liter.However, if case is not important, you can specify an ordinal comparison that ignores case. Jest to równoznaczne z konwertowaniem ciągu na wielkie litery przy użyciu niezmiennej kultury, a następnie przeprowadzenie porównania porządkowego w wyniku.This is equivalent to converting the string to uppercase by using the invariant culture and then performing an ordinal comparison on the result. Aby zapoznać się z listą String metod, które porównują dwa ciągi przy użyciu reguł sortowania porządkowego, zobacz sekcję operacje na ciągach według kategorii .For a list of the String methods that compare two strings using ordinal sort rules, see the String operations by category section.

Porównanie wrażliwe na kulturę to dowolne porównanie, które jawnie lub niejawnie używa CultureInfo obiektu, łącznie z niezmienną kulturą określoną CultureInfo.InvariantCulture przez właściwość.A culture-sensitive comparison is any comparison that explicitly or implicitly uses a CultureInfo object, including the invariant culture that is specified by the CultureInfo.InvariantCulture property. Niejawna kultura to bieżąca kultura, która jest określona przez Thread.CurrentCulture właściwości i. CultureInfo.CurrentCultureThe implicit culture is the current culture, which is specified by the Thread.CurrentCulture and CultureInfo.CurrentCulture properties. Istnieją znaczne różnice w kolejności sortowania znaków alfabetycznych (czyli znaków, dla których Char.IsLetter Właściwość zwraca wartość true) między kulturami.There is considerable variation in the sort order of alphabetic characters (that is, characters for which the Char.IsLetter property returns true) across cultures. Można określić porównanie wrażliwe na kulturę, które używa konwencji określonej kultury przez dostarczenie CultureInfo obiektu do metody porównywania ciągów, takiej jak. Compare(String, String, CultureInfo, CompareOptions)You can specify a culture-sensitive comparison that uses the conventions of a specific culture by supplying a CultureInfo object to a string comparison method such as Compare(String, String, CultureInfo, CompareOptions). Można określić porównanie wrażliwe na kulturę, które używa Konwencji bieżącej kultury, dostarczając StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase CompareOptions lub jakikolwiek element członkowski wyliczenia inne niż CompareOptions.Ordinal lub CompareOptions.OrdinalIgnoreCase do odpowiednich Compare Przeciążenie metody.You can specify a culture-sensitive comparison that uses the conventions of the current culture by supplying StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, or any member of the CompareOptions enumeration other than CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase to an appropriate overload of the Compare method. Porównanie wrażliwe na kulturę jest zwykle odpowiednie do sortowania, podczas gdy porównanie porządkowe nie jest.A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. Porównanie porządkowe jest ogólnie odpowiednie do określenia, czy dwa ciągi są równe (oznacza to, że w celu określenia tożsamości), podczas gdy porównanie wrażliwe na kulturę nie jest.An ordinal comparison is generally appropriate for determining whether two strings are equal (that is, for determining identity) whereas a culture-sensitive comparison is not.

Poniższy przykład ilustruje różnicę między porównaniem uwzględniającym kulturę i porządkową.The following example illustrates the difference between culture-sensitive and ordinal comparison. Przykład szacuje trzy ciągi, "Apple", "Æble" i "AEble", przy użyciu porównania porządkowego oraz Konwencji kultur da-DK i en-us (z których każda jest kulturą domyślną w momencie Compare wywołania metody).The example evaluates three strings, "Apple", "Æble", and "AEble", using ordinal comparison and the conventions of the da-DK and en-US cultures (each of which is the default culture at the time the Compare method is called). Ponieważ język duński traktuje znak "Æ" jako pojedynczą literę i sortuje ją po literze "Z" w alfabecie, ciąg "Æble" jest większy niż "Apple".Because the Danish language treats the character "Æ" as an individual letter and sorts it after "Z" in the alphabet, the string "Æble" is greater than "Apple". Jednakże "Æble" nie jest uważany za odpowiednik "AEble", więc wartość "Æble" jest również większa niż "AEble".However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "AEble". Kultura en-US nie zawiera litery "Æ", ale traktuje ją jako odpowiednik "AE", co wyjaśnia dlaczego "Æble" jest mniejsze niż "Apple", ale równe "AEble".The en-US culture doesn't include the letter"Æ" but treats it as equivalent to "AE", which explains why "Æble" is less than "Apple" but equal to "AEble". Porównanie porządkowe, z drugiej strony, uwzględnia wartość "Apple" jako "Æble" i "Æble", aby była większa niż "AEble".Ordinal comparison, on the other hand, considers "Apple" to be less than "Æble", and "Æble" to be greater than "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
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

Skorzystaj z następujących ogólnych wskazówek, aby wybrać odpowiednią metodę sortowania lub porównywania ciągów:Use the following general guidelines to choose an appropriate sorting or string comparison method:

  • Jeśli chcesz, aby ciągi były uporządkowane w oparciu o kulturę użytkownika, należy uporządkować je na podstawie Konwencji bieżącej kultury.If you want the strings to be ordered based on the user's culture, you should order them based on the conventions of the current culture. Jeśli kultura użytkownika ulegnie zmianie, porządek posortowanych ciągów również zostanie odpowiednio zmieniony.If the user's culture changes, the order of sorted strings will also change accordingly. Na przykład aplikacja tezaurusa powinna zawsze sortować słowa na podstawie kultury użytkownika.For example, a thesaurus application should always sort words based on the user's culture.

  • Jeśli chcesz, aby ciągi były uporządkowane na podstawie Konwencji określonej kultury, należy je zamówić, dostarczając CultureInfo obiekt, który reprezentuje tę kulturę do metody porównania.If you want the strings to be ordered based on the conventions of a specific culture, you should order them by supplying a CultureInfo object that represents that culture to a comparison method. Na przykład w aplikacji zaprojektowanej do uczenia studentów w konkretnym języku, chcesz, aby ciągi były uporządkowane na podstawie Konwencji jednej z kultur, które mówią ten język.For example, in an application designed to teach students a particular language, you want strings to be ordered based on the conventions of one of the cultures that speaks that language.

  • Jeśli chcesz, aby kolejność ciągów pozostała niezmieniona między kulturami, należy zamówić je na podstawie Konwencji niezmiennej kultury lub użyć porównania porządkowego.If you want the order of strings to remain unchanged across cultures, you should order them based on the conventions of the invariant culture or use an ordinal comparison. Można na przykład użyć sortowania porządkowego do organizowania nazw plików, procesów, muteksów lub nazwanych potoków.For example, you would use an ordinal sort to organize the names of files, processes, mutexes, or named pipes.

  • Aby zapoznać się z porównaniem obejmującym decyzję dotyczącą zabezpieczeń (np. czy nazwa użytkownika jest prawidłowa), należy zawsze wykonać test porządkowy dla równości, wywołując Equals metodę przeciążenia metody.For a comparison that involves a security decision (such as whether a username is valid), you should always perform an ordinal test for equality by calling an overload of the Equals method.

Uwaga

Zależne od kultury reguły sortowania i wielkości liter używane w porównaniu ciągów zależą od wersji platformy .NET.The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET. W .NET Framework 4,5 i nowszych wersjach uruchomionych w Windows 8Windows 8 systemie operacyjnym, sortowanie, wielkość liter, normalizacja i informacje o znakach Unicode są zgodne ze standardem Unicode 6,0.In the .NET Framework 4.5 and later versions running on the Windows 8Windows 8 operating system, sorting, casing, normalization, and Unicode character information conforms to the Unicode 6.0 standard. W innych systemach operacyjnych Windows jest zgodna ze standardem Unicode 5,0.On other Windows operating systems, it conforms to the Unicode 5.0 standard. W przypadku platformy .NET Core jest to zależne od wersji standardu Unicode obsługiwanego przez podstawowy system operacyjny.On .NET Core, it depends on the version of the Unicode Standard supported by the underlying operating system.

Więcej informacji o regułach sortowania wyraz, String i porządkowych znajduje się w System.Globalization.CompareOptions temacie.For more information about word, string, and ordinal sort rules, see the System.Globalization.CompareOptions topic. Aby uzyskać dodatkowe zalecenia dotyczące sytuacji, w których należy użyć każdej reguły, zobacz najlepsze rozwiązania dotyczące używania ciągów.For additional recommendations on when to use each rule, see Best Practices for Using Strings.

Zwykle nie są wywoływane metody porównywania ciągów, takie Compare jak bezpośrednie, aby określić kolejność sortowania ciągów.Ordinarily, you don't call string comparison methods such as Compare directly to determine the sort order of strings. Zamiast tego metody porównania są wywoływane przez metody sortowania, takie Array.Sort jak List<T>.Sortlub.Instead, comparison methods are called by sorting methods such as Array.Sort or List<T>.Sort. W poniższym przykładzie wykonywane są cztery różne operacje sortowania (sortowanie wyrazów przy użyciu bieżącej kultury, sortowanie wyrazów przy użyciu niezmiennej kultury, sortowanie porządkowe i sortowanie ciągów przy użyciu niezmiennej kultury) bez jawnego wywołania metody porównywania ciągów. Mimo że określają typ porównania do użycia.The following example performs four different sorting operations (word sort using the current culture, word sort using the invariant culture, ordinal sort, and string sort using the invariant culture) without explicitly calling a string comparison method, although they do specify the type of comparison to use. Należy zauważyć, że każdy typ sortowania generuje unikatową kolejność ciągów w tablicy.Note that each type of sort produces a unique ordering of strings in its array.

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
//     co­operative         co-op           co-op   cooperative          coop
//             cœur   cooperative     cooperative  co­operative   cooperative
//            coeur  co­operative    co­operative          cœur  co­operative
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
'     co­operative         co-op           co-op   cooperative          coop
'             cœur   cooperative     cooperative  co­operative   cooperative
'            coeur  co­operative    co­operative          cœur  co­operative

Porada

Wewnętrznie środowisko .NET używa kluczy sortowania do obsługi porównania ciągów wrażliwych na kulturę.Internally, .NET uses sort keys to support culturally sensitive string comparison. Każdy znak w ciągu zawiera kilka kategorii wag sortowania, takich jak Alphabetic, Case i diakrytycznych.Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. Klucz sortowania reprezentowany przez SortKey klasę zawiera repozytorium tych wag dla określonego ciągu.A sort key, represented by the SortKey class, provides a repository of these weights for a particular string. Jeśli aplikacja wykonuje dużą liczbę operacji wyszukiwania lub sortowania dla tego samego zestawu ciągów, można zwiększyć jej wydajność, generując i przechowując klucze sortowania dla wszystkich używanych przez niego ciągów.If your app performs a large number of searching or sorting operations on the same set of strings, you can improve its performance by generating and storing sort keys for all the strings that it uses. Gdy wymagana jest operacja sortowania lub porównywania, zamiast ciągów należy używać kluczy sortowania.When a sort or comparison operation is required, you use the sort keys instead of the strings. Aby uzyskać więcej informacji, zobacz SortKey Klasa.For more information, see the SortKey class.

Jeśli nie określisz Konwencji porównywania ciągów, metody sortowania, takie Array.Sort(Array) jak wykonywanie sortowania z uwzględnieniem wielkości liter w ciągach.If you don't specify a string comparison convention, sorting methods such as Array.Sort(Array) perform a culture-sensitive, case-sensitive sort on strings. Poniższy przykład ilustruje, jak zmiana bieżącej kultury wpływa na kolejność posortowanych ciągów w tablicy.The following example illustrates how changing the current culture affects the order of sorted strings in an array. Tworzy tablicę trzech ciągów.It creates an array of three strings. Po pierwsze ustawia System.Threading.Thread.CurrentThread.CurrentCulture właściwość na en-us i Array.Sort(Array) wywołuje metodę.First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the Array.Sort(Array) method. Powstały porządek sortowania jest oparty na konwencjach sortowania dla kultury angielskiej (Stany Zjednoczone).The resulting sort order is based on sorting conventions for the English (United States) culture. Następnie przykład ustawia System.Threading.Thread.CurrentThread.CurrentCulture właściwość na da-DK i ponownie Array.Sort wywołuje metodę.Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the Array.Sort method again. Zwróć uwagę, jak wynikowy porządek sortowania różni się od wyników en-US, ponieważ używa on Konwencji sortowania dla języka duńskiego (Dania).Notice how the resulting sort order differs from the en-US results because it uses the sorting conventions for Danish (Denmark).

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

Ostrzeżenie

Jeśli głównym celem w porównaniu ciągów jest określenie, czy są równe, należy wywołać String.Equals metodę.If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. Zazwyczaj należy użyć Equals do przeprowadzenia porównania porządkowego.Typically, you should use Equals to perform an ordinal comparison. String.Compare Metoda jest przeznaczona głównie do sortowania ciągów.The String.Compare method is intended primarily to sort strings.

Metody wyszukiwania ciągów, takie jak String.StartsWith i String.IndexOf, również mogą wykonywać porównania ciągów z uwzględnieniem kultury lub porządkową.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. Poniższy przykład ilustruje różnice między porównaniem porządkowym i kulturowym przy użyciu IndexOf metody.The following example illustrates the differences between ordinal and culture-sensitive comparisons using the IndexOf method. Wyszukiwanie zależne od kultury, w którym bieżąca kultura jest w języku angielskim (Stany Zjednoczone) traktuje podciąg "OE" w celu dopasowania do ligatur "o".A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". Ponieważ łącznik miękki (U + 00AD) jest znakiem o zerowej szerokości, wyszukiwanie traktuje łącznik miękki jako odpowiednik Empty i znajduje dopasowanie na początku ciągu.Because a soft hyphen (U+00AD) is a zero-width character, the search treats the soft hyphen as equivalent to Empty and finds a match at the beginning of the string. Wyszukiwanie porządkowe, z drugiej strony, nie znajduje dopasowania w obu przypadkach.An ordinal search, on the other hand, does not find a match in either case.

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 co­operative at position 0
//       '­' found in co­operative 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 co­operative at position 0
'       '­' found in co­operative at position 2

Wyszukiwanie ciągówSearching Strings

Metody wyszukiwania ciągów, takie jak String.StartsWith i String.IndexOf, również mogą wykonywać porównania ciągów z uwzględnieniem kulturowym lub porządkowym, aby określić, czy znak lub podciąg zostanie znaleziony w określonym ciągu.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons to determine whether a character or substring is found in a specified string.

Metody wyszukiwania w String klasie, która wyszukuje pojedynczy znak, taki IndexOf jak metoda lub jeden z zestawu IndexOfAny znaków, takich jak metoda, wszystkie wykonują wyszukiwanie porządkowe.The search methods in the String class that search for an individual character, such as the IndexOf method, or one of a set of characters, such as the IndexOfAny method, all perform an ordinal search. Aby przeprowadzić wyszukiwanie znaków z uwzględnieniem kultury, należy wywołać CompareInfo metodę, taką jak CompareInfo.IndexOf(String, Char) lub CompareInfo.LastIndexOf(String, Char).To perform a culture-sensitive search for a character, you must call a CompareInfo method such as CompareInfo.IndexOf(String, Char) or CompareInfo.LastIndexOf(String, Char). Należy zauważyć, że wyniki wyszukiwania znaku przy użyciu wartości porządkowej i porównywania kulturowego mogą być bardzo inne.Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. Na przykład wyszukiwanie złożonego znaku Unicode, takiego jak ligatury "Æ" (U + 00C6), może pasować do każdego wystąpienia jego składników w poprawnej sekwencji, takiej jak "AE" (U + 041U + 0045), w zależności od kultury.For example, a search for a precomposed Unicode character such as the ligature "Æ" (U+00C6) might match any occurrence of its components in the correct sequence, such as "AE" (U+041U+0045), depending on the culture. Poniższy przykład ilustruje różnicę między String.IndexOf(Char) metodami i CompareInfo.IndexOf(String, Char) podczas wyszukiwania pojedynczego znaku.The following example illustrates the difference between the String.IndexOf(Char) and CompareInfo.IndexOf(String, Char) methods when searching for an individual character. Ligatury "æ" (U + 00E6) znajdują się w ciągu "anten" w przypadku stosowania Konwencji kultury en-US, ale nie w przypadku stosowania Konwencji kultury da-DK lub podczas przeprowadzania porównania porządkowego.The ligature "æ" (U+00E6) is found in the string "aerial" when using the conventions of the en-US culture, but not when using the conventions of the da-DK culture or when performing an ordinal comparison.

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

Z drugiej strony metody klasy String , które wyszukują ciąg, a nie znak wykonują wyszukiwanie wrażliwe na kulturę, jeśli opcje wyszukiwania nie są jawnie określone przez parametr typu. StringComparisonOn the other hand, String class methods that search for a string rather than a character perform a culture-sensitive search if search options are not explicitly specified by a parameter of type StringComparison. Jedynym wyjątkiem jest Contains, który wykonuje wyszukiwanie porządkowe.The sole exception is Contains, which performs an ordinal search.

Testowanie pod kątem równościTesting for equality

String.Compare Użyj metody, aby określić relację dwóch ciągów w kolejności sortowania.Use the String.Compare method to determine the relationship of two strings in the sort order. Zwykle jest to operacja zależna od kultury.Typically, this is a culture-sensitive operation. Z kolei Wywołaj String.Equals metodę, aby sprawdzić równość.In contrast, call the String.Equals method to test for equality. Ponieważ test pod kątem równości zwykle porównuje dane wprowadzane przez użytkownika z nieznanym ciągiem, takim jak prawidłowa nazwa użytkownika, hasło lub ścieżka systemu plików, jest zazwyczaj operacją porządkową.Because the test for equality usually compares user input with some known string, such as a valid user name, a password, or a file system path, it is typically an ordinal operation.

Ostrzeżenie

Istnieje możliwość przetestowania pod kątem równości przez wywołanie String.Compare metody i określenie, czy zwracana wartość jest równa zero.It is possible to test for equality by calling the String.Compare method and determining whether the return value is zero. Jednak ta metoda nie jest zalecana.However, this practice is not recommended. Aby określić, czy dwa ciągi są równe, należy wywołać jedno z przeciążeń String.Equals metody.To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. Preferowanym przeciążeniem wywołania jest metoda wystąpienia Equals(String, StringComparison) lub metoda statyczna Equals(String, String, StringComparison) , System.StringComparison ponieważ obie metody zawierają parametr jawnie określający typ porównania.The preferred overload to call is either the instance Equals(String, StringComparison) method or the static Equals(String, String, StringComparison) method, because both methods include a System.StringComparison parameter that explicitly specifies the type of comparison.

Poniższy przykład ilustruje niebezpieczeństwo wykonywania porównania z uwzględnieniem kultury dla równości, gdy zamiast tego należy użyć numeru porządkowego.The following example illustrates the danger of performing a culture-sensitive comparison for equality when an ordinal one should be used instead. W takim przypadku celem kodu jest zabronienie dostępu systemu plików z adresów URL zaczynających się od "FILE://" lub "file://" przez wykonanie porównania bez uwzględniania wielkości liter początku adresu URL z ciągiem "FILE://".In this case, the intent of the code is to prohibit file system access from URLs that begin with "FILE://" or "file://" by performing a case-insensitive comparison of the beginning of a URL with the string "FILE://". Jednakże jeśli porównanie wrażliwe na kulturę jest wykonywane przy użyciu kultury tureckiej (Turcja) na adres URL zaczynający się od "file://", porównanie dla równości nie powiedzie się, ponieważ turecki wielką literą małych liter "i" jest "i" zamiast "I".However, if a culture-sensitive comparison is performed using the Turkish (Turkey) culture on a URL that begins with "file://", the comparison for equality fails, because the Turkish uppercase equivalent of the lowercase "i" is "İ" instead of "I". W efekcie dostęp do systemu plików jest przypadkowo dozwolony.As a result, file system access is inadvertently permitted. Z drugiej strony, jeśli zostanie wykonane porównanie porządkowe, porównywanie dla równości powiedzie się i dostęp do systemu plików jest zabroniony.On the other hand, if an ordinal comparison is performed, the comparison for equality succeeds, and file system access is denied.

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

NormalizacjaNormalization

Niektóre znaki Unicode mają wiele reprezentacji.Some Unicode characters have multiple representations. Na przykład dowolny z następujących punktów kodu może reprezentować literę "ắ":For example, any of the following code points can represent the letter "ắ":

  • U+1EAFU+1EAF

  • U+0103 U+0301U+0103 U+0301

  • U+0061 U+0306 U+0301U+0061 U+0306 U+0301

Wiele reprezentacji pojedynczego znaku komplikuje wyszukiwanie, sortowanie, dopasowywanie i inne operacje na ciągach.Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

Standard Unicode definiuje proces o nazwie normalizing, który zwraca jedną reprezentację binarną znaku Unicode dla którejkolwiek z jego równoważnych reprezentacji binarnych.The Unicode standard defines a process called normalization that returns one binary representation of a Unicode character for any of its equivalent binary representations. Normalizacja może używać kilku algorytmów nazywanych formularzami normalizacji, które są zgodne z różnymi regułami.Normalization can use several algorithms, called normalization forms, that follow different rules. Platforma .NET obsługuje normalizacji Unicode w postaci C, D, KC i KD..NET supports Unicode normalization forms C, D, KC, and KD. Gdy ciągi zostały znormalizowane do tego samego formularza normalizacji, można je porównać przy użyciu porównania porządkowego.When strings have been normalized to the same normalization form, they can be compared by using ordinal comparison.

Porównanie porządkowe to binarne porównanie wartości skalarnej Unicode odpowiednich Char obiektów w każdym ciągu.An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. String Klasa zawiera szereg metod, które mogą wykonać porównanie porządkowe, w tym następujące:The String class includes a number of methods that can perform an ordinal comparison, including the following:

Można określić, czy ciąg jest znormalizowany do normalizacji w postaci C, wywołując String.IsNormalized() metodę, lub można wywołać metodę, aby określić, String.IsNormalized(NormalizationForm) czy ciąg jest znormalizowany do określonego formularza normalizacji.You can determine whether a string is normalized to normalization form C by calling the String.IsNormalized() method, or you can call the String.IsNormalized(NormalizationForm) method to determine whether a string is normalized to a specified normalization form. Możesz również wywołać metodę, String.Normalize() Aby skonwertować ciąg na normalizację w postaci C lub można String.Normalize(NormalizationForm) wywołać metodę, aby przekonwertować ciąg na określony formularz normalizacji.You can also call the String.Normalize() method to convert a string to normalization form C, or you can call the String.Normalize(NormalizationForm) method to convert a string to a specified normalization form. Informacje krok po kroku dotyczące normalizacji i porównywania ciągów można znaleźć w Normalize() tematach i. Normalize(NormalizationForm)For step-by-step information about normalizing and comparing strings, see the Normalize() and Normalize(NormalizationForm) methods.

Poniższy prosty przykład ilustruje normalizację ciągów.The following simple example illustrates string normalization. Definiuje literę "ố" na trzy różne sposoby w trzech różnych ciągach i używa porównania porządkowego dla równości, aby określić, że każdy ciąg różni się od pozostałych dwóch ciągów.It defines the letter "ố" in three different ways in three different strings, and uses an ordinal comparison for equality to determine that each string differs from the other two strings. Następnie konwertuje każdy ciąg na obsługiwane formularze normalizacji i ponownie wykonuje porównanie porządkowe każdego ciągu w określonym formularzu normalizacji.It then converts each string to the supported normalization forms, and again performs an ordinal comparison of each string in a specified normalization form. W każdym przypadku drugi test pod kątem równości pokazuje, że ciągi są równe.In each case, the second test for equality shows that the strings are equal.

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) = sống (0073 006F 0302 0301 006E 0067): False 
//       sống (0073 00F4 0301 006E 0067) = số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: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = số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: 
//        
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True 
//       sống (0073 006F 0302 0301 006E 0067) = số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 += String.Format("{0} ", Convert.ToUInt16(ch).ToString("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) = sống (0073 006F 0302 0301 006E 0067): False
//       sống (0073 00F4 0301 006E 0067) = số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:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = số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:
//       
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
//       sống (0073 006F 0302 0301 006E 0067) = số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) = sống (0073 006F 0302 0301 006E 0067): False
'       sống (0073 00F4 0301 006E 0067) = số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:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = số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:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

Aby uzyskać więcej informacji na temat normalizacji i normalizacji, System.Text.NormalizationFormZobacz, a także #15 w standardzie Unicode: Formy normalizacji Unicode i normalizacja często zadawane pytania w witrynie sieci Web Unicode.org.For more information about normalization and normalization forms, see System.Text.NormalizationForm, as well as Unicode Standard Annex #15: Unicode Normalization Forms and the Normalization FAQ on the unicode.org website.

Operacje na ciągach według kategoriiString operations by category

String Klasa zawiera elementy członkowskie do porównywania ciągów, testowania ciągów pod kątem równości, znajdowania znaków lub podciągów w ciągu, modyfikowania ciągu, wyodrębniania podciągów z ciągu, łączenia ciągów, formatowania wartości, kopiowania ciągu i normalizowanie ciągu.The String class provides members for comparing strings, testing strings for equality, finding characters or substrings in a string, modifying a string, extracting substrings from a string, combining strings, formatting values, copying a string, and normalizing a string.

Porównywanie ciągówComparing strings

Można porównać ciągi, aby określić ich względne położenie w porządku sortowania przy użyciu następujących String metod:You can compare strings to determine their relative position in the sort order by using the following String methods:

  • CompareZwraca liczbę całkowitą, która wskazuje związek jednego ciągu z drugim ciągiem w kolejności sortowania.Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinalZwraca liczbę całkowitą, która wskazuje związek jednego ciągu z drugim ciągiem na podstawie porównania ich punktów kodowych.CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareToZwraca liczbę całkowitą, która wskazuje związek bieżącego wystąpienia ciągu z drugim ciągiem w kolejności sortowania.CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. Metoda udostępnia implementacje IComparable<T> i dla Stringklasy. IComparable CompareTo(String)The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

Testowanie ciągów pod kątem równościTesting strings for equality

Należy wywołać metodę Equals , aby określić, czy dwa ciągi są równe.You call the Equals method to determine whether two strings are equal. Wystąpienie Equals(String, String, StringComparison) i przeciążenia statyczne Equals(String, StringComparison) pozwalają określić, czy porównanie ma być zależne od kultury, czy też w przypadku ignorowania.The instance Equals(String, String, StringComparison) and the static Equals(String, StringComparison) overloads let you specify whether the comparison is culture-sensitive or ordinal, and whether case is considered or ignored. Większość testów dla równości to liczba porządkowa, a porównania równości, które określają dostęp do zasobów systemowych (takich jak obiekt systemu plików), powinny zawsze być porządkowe.Most tests for equality are ordinal, and comparisons for equality that determine access to a system resource (such as a file system object) should always be ordinal.

Znajdowanie znaków w ciąguFinding characters in a string

String Klasa zawiera dwa rodzaje metod wyszukiwania:The String class includes two kinds of search methods:

Ostrzeżenie

Jeśli chcesz wyszukać ciąg dla określonego wzorca, a nie określony podciąg, należy użyć wyrażeń regularnych.If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. Aby uzyskać więcej informacji, zobacz wyrażenia regularne programu .NET.For more information, see .NET Regular Expressions.

Modyfikowanie ciąguModifying a string

String Klasa zawiera następujące metody, które pojawiają się w celu zmodyfikowania wartości ciągu:The String class includes the following methods that appear to modify the value of a string:

  • InsertWstawia ciąg do bieżącego String wystąpienia.Insert inserts a string into the current String instance.

  • PadLeftWstawia jedno lub więcej wystąpień określonego znaku na początku ciągu.PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRightWstawia jedno lub więcej wystąpień określonego znaku na końcu ciągu.PadRight inserts one or more occurrences of a specified character at the end of a string.

  • Removeusuwa podciąg z bieżącego String wystąpienia.Remove deletes a substring from the current String instance.

  • Replacezamienia podciąg na inny podciąg w bieżącym String wystąpieniu.Replace replaces a substring with another substring in the current String instance.

  • ToLoweri ToLowerInvariant Konwertuj wszystkie znaki w ciągu na małe litery.ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUpperi ToUpperInvariant Konwertuj wszystkie znaki w ciągu na wielkie litery.ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • Trimusuwa wszystkie wystąpienia znaku od początku i końca ciągu.Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEndusuwa wszystkie wystąpienia znaku z końca ciągu.TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStartusuwa wszystkie wystąpienia znaku od początku ciągu.TrimStart removes all occurrences of a character from the beginning of a string.

Ważne

Wszystkie metody modyfikacji ciągu zwracają nowy String obiekt.All string modification methods return a new String object. Nie modyfikują wartości bieżącego wystąpienia.They don't modify the value of the current instance.

Wyodrębnianie podciągów z ciągu znakówExtracting substrings from a string

String.Split Metoda oddziela pojedynczy ciąg do wielu ciągów.The String.Split method separates a single string into multiple strings. Przeciążenia metody umożliwiają określenie wielu ograniczników, aby określić maksymalną liczbę podciągów wyznaczonych przez metodę i określić, czy puste ciągi (które występują w przypadku sąsiadujących ograniczników) są uwzględniane między zwracanymi ciągami.Overloads of the method allow you to specify multiple delimiters, to determine the maximum number of substrings that the method extracts, and to determine whether empty strings (which occur when delimiters are adjacent) are included among the returned strings.

Łączenie ciągówCombining strings

Do łączenia String ciągów można używać następujących metod:The following String methods can be used for string concatenation:

  • Concatłączy jeden lub więcej podciągów w jeden ciąg.Concat combines one or more substrings into a single string.

  • Joinłączy jeden lub więcej podciągów w jeden element i dodaje separator między każdym podciągiem.Join concatenates one or more substrings into a single element and adds a separator between each substring.

Formatowanie wartościFormatting values

String.Format Metoda używa funkcji formatowania złożonego, aby zastąpić jeden lub więcej symboli zastępczych w ciągu ciągiem reprezentującym jakiś obiekt lub wartość.The String.Format method uses the composite formatting feature to replace one or more placeholders in a string with the string representation of some object or value. Format Metoda jest często używana do wykonywania następujących czynności:The Format method is often used to do the following:

  • Aby osadzić ciąg reprezentujący wartość liczbową w ciągu.To embed the string representation of a numeric value in a string.

  • Aby osadzić ciąg reprezentujący wartość daty i godziny w ciągu.To embed the string representation of a date and time value in a string.

  • Aby osadzić ciąg reprezentujący wartość wyliczenia w ciągu.To embed the string representation of an enumeration value in a string.

  • Aby osadzić ciąg reprezentujący kilka obiektów, które obsługują IFormattable interfejs w ciągu.To embed the string representation of some object that supports the IFormattable interface in a string.

  • Aby wyjustować lub justować do lewej, podciąg w polu w większym ciągu.To right-justify or left-justify a substring in a field within a larger string.

Aby uzyskać szczegółowe informacje na temat formatowania operacji i przykładów, Format Zobacz Podsumowanie przeciążenia.For detailed information about formatting operations and examples, see the Format overload summary.

Kopiowanie ciąguCopying a string

Można wywołać następujące String metody, aby utworzyć kopię ciągu:You can call the following String methods to make a copy of a string:

  • CloneZwraca odwołanie do istniejącego String obiektu.Clone returns a reference to an existing String object.

  • Copytworzy kopię istniejącego ciągu.Copy creates a copy of an existing string.

  • CopyTokopiuje część ciągu do tablicy znaków.CopyTo copies a portion of a string to a character array.

Normalizowanie ciąguNormalizing a string

W standardzie Unicode pojedynczy znak może mieć wiele punktów kodowych.In Unicode, a single character can have multiple code points. Normalizacja konwertuje te znaki równoważne na tę samą reprezentację binarną.Normalization converts these equivalent characters into the same binary representation. Metoda wykonuje normalizację, String.IsNormalized a Metoda określa, czy ciąg jest znormalizowany. String.NormalizeThe String.Normalize method performs the normalization, and the String.IsNormalized method determines whether a string is normalized.

Aby uzyskać więcej informacji i zapoznać się z przykładem, zapoznaj się z sekcją normalizacji wcześniej w tym temacie.For more information and an example, see the Normalization section earlier in this topic.

Konstruktory

String(Char*) String(Char*) String(Char*) String(Char*)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy znaków Unicode.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32) String(Char*, Int32, Int32)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy znaków Unicode, początkowej pozycji znaku w tej tablicy i długości.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

String(Char, Int32) String(Char, Int32) String(Char, Int32) String(Char, Int32)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony znak Unicode powtórzony określoną liczbę razy.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

String(Char[]) String(Char[]) String(Char[]) String(Char[])

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez tablicę znaków Unicode.Initializes a new instance of the String class to the value indicated by an array of Unicode characters.

String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32) String(Char[], Int32, Int32)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez tablicę znaków Unicode, początkową pozycję znaku w tej tablicy i długość.Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>) String(ReadOnlySpan<Char>)
String(SByte*) String(SByte*) String(SByte*) String(SByte*)

Inicjuje nowe wystąpienie String klasy do wartości wskazywanej przez wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32) String(SByte*, Int32, Int32)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, pozycji początkowej w tej tablicy i długości.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding) String(SByte*, Int32, Int32, Encoding)

Inicjuje nowe wystąpienie String klasy do wartości wskazanej przez określony wskaźnik do tablicy 8-bitowych liczb całkowitych ze znakiem, czyli pozycji początkowej w tej tablicy, długości Encoding i obiektu.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Pola

Empty Empty Empty Empty

Reprezentuje pusty ciąg.Represents the empty string. To pole jest tylko do odczytu.This field is read-only.

Właściwości

Chars[Index] Chars[Index] Chars[Index] Chars[Index]
Chars[Int32] Chars[Int32] Chars[Int32] Chars[Int32]

Pobiera obiekt w określonym położeniu w bieżącym String obiekcie. CharGets the Char object at a specified position in the current String object.

Chars[Range] Chars[Range] Chars[Range] Chars[Range]
Length Length Length Length

Pobiera liczbę znaków w bieżącym String obiekcie.Gets the number of characters in the current String object.

Metody

Clone() Clone() Clone() Clone()

Zwraca odwołanie do tego wystąpienia String.Returns a reference to this instance of String.

Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32) Compare(String, Int32, String, Int32, Int32)

Porównuje podciągi dwóch określonych String obiektów i zwraca liczbę całkowitą, która wskazuje ich położenie względne w kolejności sortowania.Compares substrings of two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean) Compare(String, Int32, String, Int32, Int32, Boolean)

Porównuje podciągi dwóch określonych String obiektów, ignorując lub honoruje ich wielkości liter i zwraca liczbę całkowitą, która wskazuje ich względne położenie w kolejności sortowania.Compares substrings of two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo) Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)

Porównuje podciągi dwóch określonych String obiektów, ignorując lub honoruje ich przypadki i wykorzystując informacje specyficzne dla kultury, które mają wpływ na porównanie, i zwraca liczbę całkowitą, która wskazuje ich położenie względne w kolejności sortowania.Compares substrings of two specified String objects, ignoring or honoring their case and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions) Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)

Porównuje podciągi dwóch określonych String obiektów przy użyciu określonych opcji porównania i informacji specyficznych dla kultury, które mają wpływ na porównanie, i zwraca liczbę całkowitą, która wskazuje na relację dwóch podciągów na siebie w kolejność sortowania.Compares substrings of two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two substrings to each other in the sort order.

Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison) Compare(String, Int32, String, Int32, Int32, StringComparison)

Porównuje podciągi dwóch określonych String obiektów przy użyciu określonych reguł i zwraca liczbę całkowitą wskazującą ich położenie względne w kolejności sortowania.Compares substrings of two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

Compare(String, String) Compare(String, String) Compare(String, String) Compare(String, String)

Porównuje dwa String określone obiekty i zwraca liczbę całkowitą, która wskazuje ich położenie względne w kolejności sortowania.Compares two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean) Compare(String, String, Boolean)

Porównuje dwa String określone obiekty, ignorując lub honoruje ich przypadki i zwraca liczbę całkowitą, która wskazuje ich położenie względne w kolejności sortowania.Compares two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo) Compare(String, String, Boolean, CultureInfo)

Porównuje dwa String określone obiekty, ignorując lub honoruje ich przypadki, i przy użyciu informacji specyficznych dla kultury, które mają wpływ na porównanie, i zwraca liczbę całkowitą, która wskazuje ich względne położenie w kolejności sortowania.Compares two specified String objects, ignoring or honoring their case, and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions) Compare(String, String, CultureInfo, CompareOptions)

Porównuje dwa String określone obiekty przy użyciu określonych opcji porównania i informacje specyficzne dla kultury, które mają wpływ na porównanie, i zwraca liczbę całkowitą, która wskazuje relację dwóch ciągów do siebie w kolejności sortowania.Compares two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two strings to each other in the sort order.

Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison) Compare(String, String, StringComparison)

Porównuje dwa String określone obiekty przy użyciu określonych reguł i zwraca liczbę całkowitą, która wskazuje ich położenie względne w kolejności sortowania.Compares two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32) CompareOrdinal(String, Int32, String, Int32, Int32)

Porównuje podciągi dwóch określonych String obiektów przez obliczenie wartości liczbowych odpowiednich Char obiektów w każdym podciągu.Compares substrings of two specified String objects by evaluating the numeric values of the corresponding Char objects in each substring.

CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String) CompareOrdinal(String, String)

Porównuje dwa String określone obiekty przez ocenę wartości liczbowych odpowiednich Char obiektów w każdym ciągu.Compares two specified String objects by evaluating the numeric values of the corresponding Char objects in each string.

CompareTo(Object) CompareTo(Object) CompareTo(Object) CompareTo(Object)

Porównuje to wystąpienie z określonym Object i wskazuje, czy to wystąpienie poprzedza, następuje po lub występuje w tym samym położeniu w kolejności sortowania, jak określono Object.Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object.

CompareTo(String) CompareTo(String) CompareTo(String) CompareTo(String)

Porównuje to wystąpienie z określonym String obiektem i wskazuje, czy to wystąpienie poprzedza, następuje po lub występuje w tym samym położeniu w kolejności sortowania co określony ciąg.Compares this instance with a specified String object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string.

Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>) Concat(IEnumerable<String>)

Łączy elementy członkowskie skonstruowanej IEnumerable<T> kolekcji typu. StringConcatenates the members of a constructed IEnumerable<T> collection of type String.

Concat(Object) Concat(Object) Concat(Object) Concat(Object)

Tworzy reprezentację ciągu określonego obiektu.Creates the string representation of a specified object.

Concat(Object, Object) Concat(Object, Object) Concat(Object, Object) Concat(Object, Object)

Łączy reprezentacje ciągów dwóch określonych obiektów.Concatenates the string representations of two specified objects.

Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object) Concat(Object, Object, Object)

Łączy ciąg reprezentujący trzy określone obiekty.Concatenates the string representations of three specified objects.

Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object) Concat(Object, Object, Object, Object)

Łączy reprezentacje ciągów czterech określonych obiektów i wszystkich obiektów określonych w opcjonalnej liście parametrów o zmiennej długości.Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

Concat(Object[]) Concat(Object[]) Concat(Object[]) Concat(Object[])

Łączy reprezentacje ciągów elementów w określonej Object tablicy.Concatenates the string representations of the elements in a specified Object array.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Łączy ciąg reprezentujący dwa określone zakresy znaków tylko do odczytu.Concatenates the string representations of two specified read-only character spans.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Łączy ciąg reprezentujący trzy określone zakresy znaków tylko do odczytu.Concatenates the string representations of three specified read-only character spans.

Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>) Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)

Łączy ciąg reprezentujący cztery określone zakresy znaków tylko do odczytu.Concatenates the string representations of four specified read-only character spans.

Concat(String, String) Concat(String, String) Concat(String, String) Concat(String, String)

Łączy dwa określone wystąpienia elementu String.Concatenates two specified instances of String.

Concat(String, String, String) Concat(String, String, String) Concat(String, String, String) Concat(String, String, String)

Łączy trzy określone wystąpienia String.Concatenates three specified instances of String.

Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String) Concat(String, String, String, String)

Łączy cztery określone wystąpienia String.Concatenates four specified instances of String.

Concat(String[]) Concat(String[]) Concat(String[]) Concat(String[])

Łączy elementy określonej String tablicy.Concatenates the elements of a specified String array.

Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>) Concat<T>(IEnumerable<T>)

Łączy elementy członkowskie IEnumerable<T> implementacji.Concatenates the members of an IEnumerable<T> implementation.

Contains(Char) Contains(Char) Contains(Char) Contains(Char)

Zwraca wartość wskazującą, czy określony znak występuje w tym ciągu.Returns a value indicating whether a specified character occurs within this string.

Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison) Contains(Char, StringComparison)

Zwraca wartość wskazującą, czy określony znak występuje w tym ciągu, przy użyciu określonych reguł porównywania.Returns a value indicating whether a specified character occurs within this string, using the specified comparison rules.

Contains(String) Contains(String) Contains(String) Contains(String)

Zwraca wartość wskazującą, czy w tym ciągu występuje określony podciąg.Returns a value indicating whether a specified substring occurs within this string.

Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison) Contains(String, StringComparison)

Zwraca wartość wskazującą, czy określony ciąg występuje w tym ciągu, przy użyciu określonych reguł porównywania.Returns a value indicating whether a specified string occurs within this string, using the specified comparison rules.

Copy(String) Copy(String) Copy(String) Copy(String)

Tworzy nowe wystąpienie String o takiej samej wartości jak określona String.Creates a new instance of String with the same value as a specified String.

CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32) CopyTo(Int32, Char[], Int32, Int32)

Kopiuje określoną liczbę znaków z określonego położenia w tym wystąpieniu do określonej pozycji w tablicy znaków Unicode.Copies a specified number of characters from a specified position in this instance to a specified position in an array of Unicode characters.

Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>) Create<TState>(Int32, TState, SpanAction<Char,TState>)
EndsWith(Char) EndsWith(Char) EndsWith(Char) EndsWith(Char)
EndsWith(String) EndsWith(String) EndsWith(String) EndsWith(String)

Określa, czy koniec tego wystąpienia ciągu pasuje do określonego ciągu.Determines whether the end of this string instance matches the specified string.

EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo) EndsWith(String, Boolean, CultureInfo)

Określa, czy koniec tego wystąpienia ciągu pasuje do określonego ciągu w porównaniu z określoną kulturą.Determines whether the end of this string instance matches the specified string when compared using the specified culture.

EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison) EndsWith(String, StringComparison)

Określa, czy koniec tego wystąpienia ciągu pasuje do określonego ciągu w porównaniu z określoną opcją porównania.Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.

EnumerateRunes() EnumerateRunes() EnumerateRunes() EnumerateRunes()

Zwraca Wyliczenie Rune z tego ciągu.Returns an enumeration of Rune from this string.

Equals(Object) Equals(Object) Equals(Object) Equals(Object)

Określa, czy to wystąpienie i określony obiekt, który również musi być String obiektem, mają tę samą wartość.Determines whether this instance and a specified object, which must also be a String object, have the same value.

Equals(String) Equals(String) Equals(String) Equals(String)

Określa, czy to wystąpienie i inny String określony obiekt mają tę samą wartość.Determines whether this instance and another specified String object have the same value.

Equals(String, String) Equals(String, String) Equals(String, String) Equals(String, String)

Określa, czy dwa String określone obiekty mają tę samą wartość.Determines whether two specified String objects have the same value.

Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison) Equals(String, String, StringComparison)

Określa, czy dwa String określone obiekty mają tę samą wartość.Determines whether two specified String objects have the same value. Parametr określa kulturę, wielkość liter i reguły sortowania używane w porównaniu.A parameter specifies the culture, case, and sort rules used in the comparison.

Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison) Equals(String, StringComparison)

Określa, czy ten ciąg i określony String obiekt mają tę samą wartość.Determines whether this string and a specified String object have the same value. Parametr określa kulturę, wielkość liter i reguły sortowania używane w porównaniu.A parameter specifies the culture, case, and sort rules used in the comparison.

Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object) Format(IFormatProvider, String, Object)

Zamienia element formatu lub elementy w określonym ciągu na ciąg reprezentujący odpowiadający obiekt.Replaces the format item or items in a specified string with the string representation of the corresponding object. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object) Format(IFormatProvider, String, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący dwa określone obiekty.Replaces the format items in a string with the string representation of two specified objects. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object) Format(IFormatProvider, String, Object, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący trzy określone obiekty.Replaces the format items in a string with the string representation of three specified objects. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.An parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[]) Format(IFormatProvider, String, Object[])

Zamienia elementy formatu w ciągu na ciąg reprezentujący odpowiadające obiekty w określonej tablicy.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Parametr dostarcza informacje o formatowaniu specyficzne dla kultury.A parameter supplies culture-specific formatting information.

Format(String, Object) Format(String, Object) Format(String, Object) Format(String, Object)

Zamienia jeden lub więcej elementów formatu ciągu na ciąg reprezentujący określony obiekt.Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object) Format(String, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący dwa określone obiekty.Replaces the format items in a string with the string representation of two specified objects.

Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object) Format(String, Object, Object, Object)

Zamienia elementy formatu ciągu na ciąg reprezentujący trzy określone obiekty.Replaces the format items in a string with the string representation of three specified objects.

Format(String, Object[]) Format(String, Object[]) Format(String, Object[]) Format(String, Object[])

Zamienia element formatu w określonym ciągu na ciąg reprezentujący odpowiadający obiekt w określonej tablicy.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

GetEnumerator() GetEnumerator() GetEnumerator() GetEnumerator()

Pobiera obiekt, który może wykonywać iterację poszczególnych znaków w tym ciągu.Retrieves an object that can iterate through the individual characters in this string.

GetHashCode() GetHashCode() GetHashCode() GetHashCode()

Zwraca kod skrótu dla tego ciągu.Returns the hash code for this string.

GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>) GetHashCode(ReadOnlySpan<Char>)

Zwraca kod skrótu dla podanego zakresu znaków tylko do odczytu.Returns the hash code for the provided read-only character span.

GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison) GetHashCode(ReadOnlySpan<Char>, StringComparison)

Zwraca kod skrótu dla podanego zakresu znaków tylko do odczytu przy użyciu określonych reguł.Returns the hash code for the provided read-only character span using the specified rules.

GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison) GetHashCode(StringComparison)

Zwraca kod skrótu dla tego ciągu przy użyciu określonych reguł.Returns the hash code for this string using the specified rules.

GetPinnableReference() GetPinnableReference() GetPinnableReference() GetPinnableReference()

Zwraca odwołanie do elementu ciągu pod indeksem zero.Returns a reference to the element of the string at index zero.

GetType() GetType() GetType() GetType()

Pobiera Type bieżącego wystąpienia.Gets the Type of the current instance.

(Inherited from Object)
GetTypeCode() GetTypeCode() GetTypeCode() GetTypeCode()

StringZwraca klasę TypeCode dla klasy.Returns the TypeCode for class String.

IndexOf(Char) IndexOf(Char) IndexOf(Char) IndexOf(Char)

Raportuje indeks (liczony od zera) pierwszego wystąpienia określonego znaku Unicode w tym ciągu.Reports the zero-based index of the first occurrence of the specified Unicode character in this string.

IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32) IndexOf(Char, Int32)

Raportuje indeks (liczony od zera) pierwszego wystąpienia określonego znaku Unicode w tym ciągu.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. Wyszukiwanie rozpocznie się z określoną pozycją znaku.The search starts at a specified character position.

IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32) IndexOf(Char, Int32, Int32)

Raportuje indeks (liczony od zera) pierwszego wystąpienia określonego znaku w tym wystąpieniu.Reports the zero-based index of the first occurrence of the specified character in this instance. Wyszukiwanie zaczyna się od określonej pozycji znaku i bada określoną liczbę pozycji znaku.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison) IndexOf(Char, StringComparison)

Raportuje indeks (liczony od zera) pierwszego wystąpienia określonego znaku Unicode w tym ciągu.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. Parametr określa typ wyszukiwania do użycia dla określonego znaku.A parameter specifies the type of search to use for the specified character.

IndexOf(String) IndexOf(String) IndexOf(String) IndexOf(String)

Raportuje indeks pierwszego wystąpienia określonego ciągu w tym wystąpieniu liczony od zera.Reports the zero-based index of the first occurrence of the specified string in this instance.

IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32) IndexOf(String, Int32)

Raportuje indeks pierwszego wystąpienia określonego ciągu w tym wystąpieniu liczony od zera.Reports the zero-based index of the first occurrence of the specified string in this instance. Wyszukiwanie rozpocznie się z określoną pozycją znaku.The search starts at a specified character position.

IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32) IndexOf(String, Int32, Int32)

Raportuje indeks pierwszego wystąpienia określonego ciągu w tym wystąpieniu liczony od zera.Reports the zero-based index of the first occurrence of the specified string in this instance. Wyszukiwanie zaczyna się od określonej pozycji znaku i bada określoną liczbę pozycji znaku.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison) IndexOf(String, Int32, Int32, StringComparison)

Raportuje indeks (liczony od zera) pierwszego wystąpienia określonego ciągu w bieżącym String obiekcie.Reports the zero-based index of the first occurrence of the specified string in the current String object. Parametry określają początkową pozycję wyszukiwania w bieżącym ciągu, liczbę znaków w bieżącym ciągu do wyszukania oraz typ wyszukiwania do użycia dla określonego ciągu.Parameters specify the starting search position in the current string, the number of characters in the current string to search, and the type of search to use for the specified string.

IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison) IndexOf(String, Int32, StringComparison)

Raportuje indeks (liczony od zera) pierwszego wystąpienia określonego ciągu w bieżącym String obiekcie.Reports the zero-based index of the first occurrence of the specified string in the current String object. Parametry określają początkową pozycję wyszukiwania w bieżącym ciągu i typ wyszukiwania do użycia dla określonego ciągu.Parameters specify the starting search position in the current string and the type of search to use for the specified string.

IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison) IndexOf(String, StringComparison)

Raportuje indeks (liczony od zera) pierwszego wystąpienia określonego ciągu w bieżącym String obiekcie.Reports the zero-based index of the first occurrence of the specified string in the current String object. Parametr określa typ wyszukiwania do użycia dla określonego ciągu.A parameter specifies the type of search to use for the specified string.

IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[]) IndexOfAny(Char[])

Raportuje indeks (liczony od zera) pierwszego wystąpienia w tym wystąpieniu dowolnego znaku w określonej tablicy znaków Unicode.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters.

IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32) IndexOfAny(Char[], Int32)

Raportuje indeks (liczony od zera) pierwszego wystąpienia w tym wystąpieniu dowolnego znaku w określonej tablicy znaków Unicode.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. Wyszukiwanie rozpocznie się z określoną pozycją znaku.The search starts at a specified character position.

IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32) IndexOfAny(Char[], Int32, Int32)

Raportuje indeks (liczony od zera) pierwszego wystąpienia w tym wystąpieniu dowolnego znaku w określonej tablicy znaków Unicode.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. Wyszukiwanie zaczyna się od określonej pozycji znaku i bada określoną liczbę pozycji znaku.The search starts at a specified character position and examines a specified number of character positions.

Insert(Int32, String) Insert(Int32, String) Insert(Int32, String) Insert(Int32, String)

Zwraca nowy ciąg, w którym zostanie wstawiony określony ciąg w określonym położeniu indeksu w tym wystąpieniu.Returns a new string in which a specified string is inserted at a specified index position in this instance.

Intern(String) Intern(String) Intern(String) Intern(String)

Pobiera odwołanie systemu do określonego String.Retrieves the system's reference to the specified String.

IsInterned(String) IsInterned(String) IsInterned(String) IsInterned(String)

Pobiera odwołanie do określonego String.Retrieves a reference to a specified String.

IsNormalized() IsNormalized() IsNormalized() IsNormalized()

Wskazuje, czy ten ciąg jest w postaci C normalizacji Unicode.Indicates whether this string is in Unicode normalization form C.

IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm) IsNormalized(NormalizationForm)

Wskazuje, czy ten ciąg znajduje się w określonym formularzu normalizacji Unicode.Indicates whether this string is in the specified Unicode normalization form.

IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String) IsNullOrEmpty(String)

Wskazuje, czy określony ciąg jest null lub pustym ciągiem ("").Indicates whether the specified string is null or an empty string ("").

IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String) IsNullOrWhiteSpace(String)

Wskazuje, czy określony ciąg jest nullpusty lub zawiera tylko znaki odstępu.Indicates whether a specified string is null, empty, or consists only of white-space characters.

Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[]) Join(Char, Object[])
Join(Char, String[]) Join(Char, String[]) Join(Char, String[]) Join(Char, String[])
Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32) Join(Char, String[], Int32, Int32)
Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>) Join(String, IEnumerable<String>)

Łączy elementy członkowskie skonstruowanej IEnumerable<T> kolekcji typu Stringprzy użyciu określonego separatora między poszczególnymi elementami członkowskimi.Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.

Join(String, Object[]) Join(String, Object[]) Join(String, Object[]) Join(String, Object[])

Łączy elementy tablicy obiektów przy użyciu określonego separatora między poszczególnymi elementami.Concatenates the elements of an object array, using the specified separator between each element.

Join(String, String[]) Join(String, String[]) Join(String, String[]) Join(String, String[])

Łączy wszystkie elementy tablicy ciągów przy użyciu określonego separatora między każdym elementem.Concatenates all the elements of a string array, using the specified separator between each element.

Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32) Join(String, String[], Int32, Int32)

Łączy określone elementy tablicy ciągów przy użyciu określonego separatora między każdym elementem.Concatenates the specified elements of a string array, using the specified separator between each element.

Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>) Join<T>(Char, IEnumerable<T>)
Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>) Join<T>(String, IEnumerable<T>)

Łączy elementy członkowskie kolekcji przy użyciu określonego separatora między poszczególnymi elementami członkowskimi.Concatenates the members of a collection, using the specified separator between each member.

LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char) LastIndexOf(Char)

Raportuje pozycję indeksu (liczony od zera) ostatniego wystąpienia określonego znaku Unicode w tym wystąpieniu.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32) LastIndexOf(Char, Int32)

Raportuje pozycję indeksu (liczony od zera) ostatniego wystąpienia określonego znaku Unicode w tym wystąpieniu.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i jest przeprowadzane w kierunku początku ciągu znaków.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32) LastIndexOf(Char, Int32, Int32)

Raportuje pozycję indeksu (liczony od zera) ostatniego wystąpienia określonego znaku Unicode w podciągu w tym wystąpieniu.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i przechodzi do tyłu w kierunku początku ciągu dla określonej liczby pozycji znaku.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String) LastIndexOf(String) LastIndexOf(String) LastIndexOf(String)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia określonego ciągu w tej instancji.Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32) LastIndexOf(String, Int32)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia określonego ciągu w tej instancji.Reports the zero-based index position of the last occurrence of a specified string within this instance. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i jest przeprowadzane w kierunku początku ciągu znaków.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32) LastIndexOf(String, Int32, Int32)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia określonego ciągu w tej instancji.Reports the zero-based index position of the last occurrence of a specified string within this instance. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i przechodzi do tyłu w kierunku początku ciągu dla określonej liczby pozycji znaku.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison) LastIndexOf(String, Int32, Int32, StringComparison)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia określonego ciągu w tej instancji.Reports the zero-based index position of the last occurrence of a specified string within this instance. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i przechodzi do tyłu w kierunku początku ciągu dla określonej liczby pozycji znaku.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Parametr określa typ porównania do wykonania podczas wyszukiwania określonego ciągu.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison) LastIndexOf(String, Int32, StringComparison)

Raportuje indeks od zera ostatniego wystąpienia określonego ciągu w bieżącym String obiekcie.Reports the zero-based index of the last occurrence of a specified string within the current String object. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i jest przeprowadzane w kierunku początku ciągu znaków.The search starts at a specified character position and proceeds backward toward the beginning of the string. Parametr określa typ porównania do wykonania podczas wyszukiwania określonego ciągu.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison) LastIndexOf(String, StringComparison)

Raportuje indeks od zera ostatniego wystąpienia określonego ciągu w bieżącym String obiekcie.Reports the zero-based index of the last occurrence of a specified string within the current String object. Parametr określa typ wyszukiwania do użycia dla określonego ciągu.A parameter specifies the type of search to use for the specified string.

LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[]) LastIndexOfAny(Char[])

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia — w tym przypadku jeden znak lub więcej, określone w tablicy Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array.

LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32) LastIndexOfAny(Char[], Int32)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia — w tym przypadku jeden znak lub więcej, określone w tablicy Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i jest przeprowadzane w kierunku początku ciągu znaków.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32) LastIndexOfAny(Char[], Int32, Int32)

Raporty pozycji indeksu zaczynającego się od zera dla ostatniego wystąpienia — w tym przypadku jeden znak lub więcej, określone w tablicy Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. Wyszukiwanie rozpoczyna się od określonej pozycji znaku i przechodzi do tyłu w kierunku początku ciągu dla określonej liczby pozycji znaku.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

MemberwiseClone() MemberwiseClone() MemberwiseClone() MemberwiseClone()

Tworzy płytką kopię bieżącego Object.Creates a shallow copy of the current Object.

(Inherited from Object)
Normalize() Normalize() Normalize() Normalize()

Zwraca nowy ciąg, którego wartość tekstowa jest taka sama jak ten ciąg, ale której reprezentacja binarna jest zgodna z formą normalizacji Unicode C.Returns a new string whose textual value is the same as this string, but whose binary representation is in Unicode normalization form C.

Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm) Normalize(NormalizationForm)

Zwraca nowy ciąg, którego wartość tekstowa jest taka sama jak ten ciąg, ale której reprezentacja binarna znajduje się w określonym formularzu normalizacji Unicode.Returns a new string whose textual value is the same as this string, but whose binary representation is in the specified Unicode normalization form.

PadLeft(Int32) PadLeft(Int32) PadLeft(Int32) PadLeft(Int32)

Zwraca nowy ciąg, który wyrównuje znaki w tym wystąpieniu przez uzupełnienie ich spacjami po lewej stronie, dla określonej całkowitej długości.Returns a new string that right-aligns the characters in this instance by padding them with spaces on the left, for a specified total length.

PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char) PadLeft(Int32, Char)

Zwraca nowy ciąg, który wyrównuje znaki w tym wystąpieniu przez uzupełnienie ich po lewej stronie z określonym znakiem Unicode, dla określonej całkowitej długości.Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified Unicode character, for a specified total length.

PadRight(Int32) PadRight(Int32) PadRight(Int32) PadRight(Int32)

Zwraca nowy ciąg, który wyrównuje znaki w tym ciągu przez uzupełnienie ich spacjami po prawej stronie, dla określonej całkowitej długości.Returns a new string that left-aligns the characters in this string by padding them with spaces on the right, for a specified total length.

PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char) PadRight(Int32, Char)

Zwraca nowy ciąg, który wyrównuje znaki w tym ciągu przez uzupełnienie ich po prawej stronie z określonym znakiem Unicode, dla określonej całkowitej długości.Returns a new string that left-aligns the characters in this string by padding them on the right with a specified Unicode character, for a specified total length.

Remove(Int32) Remove(Int32) Remove(Int32) Remove(Int32)

Zwraca nowy ciąg, w którym wszystkie znaki w bieżącym wystąpieniu, zaczynając od określonej pozycji i kontynuując ostatnią pozycję, zostały usunięte.Returns a new string in which all the characters in the current instance, beginning at a specified position and continuing through the last position, have been deleted.

Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32) Remove(Int32, Int32)

Zwraca nowy ciąg, w którym usunięto określoną liczbę znaków w bieżącym wystąpieniu rozpoczynającym się w określonej pozycji.Returns a new string in which a specified number of characters in the current instance beginning at a specified position have been deleted.

Replace(Char, Char) Replace(Char, Char) Replace(Char, Char) Replace(Char, Char)

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego znaku Unicode w tym wystąpieniu są zamieniane na inny określony znak Unicode.Returns a new string in which all occurrences of a specified Unicode character in this instance are replaced with another specified Unicode character.

Replace(String, String) Replace(String, String) Replace(String, String) Replace(String, String)

Zwraca nowy ciąg, w którym wszystkie wystąpienia określonego ciągu w bieżącym wystąpieniu są zastępowane innym określonym ciągiem.Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.

Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo) Replace(String, String, Boolean, CultureInfo)
Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison) Replace(String, String, StringComparison)
Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions) Split(Char, Int32, StringSplitOptions)
Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions) Split(Char, StringSplitOptions)
Split(Char[]) Split(Char[]) Split(Char[]) Split(Char[])

Dzieli ciąg na podciągi, które są oparte na znakach w tablicy.Splits a string into substrings that are based on the characters in an array.

Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32) Split(Char[], Int32)

Dzieli ciąg na maksymalną liczbę podciągów w oparciu o znaki w tablicy.Splits a string into a maximum number of substrings based on the characters in an array. Należy również określić maksymalną liczbę podciągów do zwrócenia.You also specify the maximum number of substrings to return.

Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions) Split(Char[], Int32, StringSplitOptions)

Dzieli ciąg na maksymalną liczbę podciągów w oparciu o znaki w tablicy.Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions) Split(Char[], StringSplitOptions)

Dzieli ciąg na podciągi w oparciu o znaki w tablicy.Splits a string into substrings based on the characters in an array. Można określić, czy podciągi mają zawierać puste elementy tablicy.You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions) Split(String, Int32, StringSplitOptions)
Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions) Split(String, StringSplitOptions)
Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions) Split(String[], Int32, StringSplitOptions)

Dzieli ciąg na maksymalną liczbę podciągów na podstawie ciągów w tablicy.Splits a string into a maximum number of substrings based on the strings in an array. Można określić, czy podciągi mają zawierać puste elementy tablicy.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions) Split(String[], StringSplitOptions)

Dzieli ciąg na podciągi na podstawie ciągów w tablicy.Splits a string into substrings based on the strings in an array. Można określić, czy podciągi mają zawierać puste elementy tablicy.You can specify whether the substrings include empty array elements.

StartsWith(Char) StartsWith(Char) StartsWith(Char) StartsWith(Char)
StartsWith(String) StartsWith(String) StartsWith(String) StartsWith(String)

Określa, czy początek tego wystąpienia ciągu pasuje do określonego ciągu.Determines whether the beginning of this string instance matches the specified string.

StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo) StartsWith(String, Boolean, CultureInfo)

Określa, czy początek tego wystąpienia ciągu pasuje do określonego ciągu w porównaniu z określoną kulturą.Determines whether the beginning of this string instance matches the specified string when compared using the specified culture.

StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison) StartsWith(String, StringComparison)

Określa, czy początek tego wystąpienia ciągu pasuje do określonego ciągu w porównaniu z określoną opcją porównania.Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.

Substring(Index) Substring(Index) Substring(Index) Substring(Index)
Substring(Int32) Substring(Int32) Substring(Int32) Substring(Int32)

Pobiera podciąg z tego wystąpienia.Retrieves a substring from this instance. Podciąg zaczyna się od określonej pozycji znaku i przechodzi do końca ciągu.The substring starts at a specified character position and continues to the end of the string.

Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32) Substring(Int32, Int32)

Pobiera podciąg z tego wystąpienia.Retrieves a substring from this instance. Podciąg zaczyna się od określonej pozycji znaku i ma określoną długość.The substring starts at a specified character position and has a specified length.

Substring(Range) Substring(Range) Substring(Range) Substring(Range)
ToCharArray() ToCharArray() ToCharArray() ToCharArray()

Kopiuje znaki w tym wystąpieniu do tablicy znaków Unicode.Copies the characters in this instance to a Unicode character array.

ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32) ToCharArray(Int32, Int32)

Kopiuje znaki w określonym podciągu w tym wystąpieniu do tablicy znaków Unicode.Copies the characters in a specified substring in this instance to a Unicode character array.

ToLower() ToLower() ToLower() ToLower()

Zwraca kopię tego ciągu przekonwertowaną na małe litery.Returns a copy of this string converted to lowercase.

ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo) ToLower(CultureInfo)

Zwraca kopię tego ciągu przekonwertowaną na małe litery przy użyciu reguł wielkości liter w określonej kulturze.Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.

ToLowerInvariant() ToLowerInvariant() ToLowerInvariant() ToLowerInvariant()

Zwraca kopię tego String obiektu przekonwertowaną na małe litery przy użyciu reguł wielkości liter dla niezmiennej kultury.Returns a copy of this String object converted to lowercase using the casing rules of the invariant culture.

ToString() ToString() ToString() ToString()

Zwraca to wystąpienie String; nie jest wykonywana żadna rzeczywista konwersja.Returns this instance of String; no actual conversion is performed.

ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider) ToString(IFormatProvider)

Zwraca to wystąpienie String; nie jest wykonywana żadna rzeczywista konwersja.Returns this instance of String; no actual conversion is performed.

ToUpper() ToUpper() ToUpper() ToUpper()

Zwraca kopię tego ciągu przekonwertowaną na wielkie litery.Returns a copy of this string converted to uppercase.

ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo) ToUpper(CultureInfo)

Zwraca kopię tego ciągu przekonwertowaną na wielkie litery przy użyciu reguł wielkości liter w określonej kulturze.Returns a copy of this string converted to uppercase, using the casing rules of the specified culture.

ToUpperInvariant() ToUpperInvariant() ToUpperInvariant() ToUpperInvariant()

Zwraca kopię tego String obiektu przekonwertowaną na wielkie litery przy użyciu reguł wielkości liter dla niezmiennej kultury.Returns a copy of this String object converted to uppercase using the casing rules of the invariant culture.

Trim() Trim() Trim() Trim()

Usuwa wszystkie wiodące i końcowe znaki białych z bieżącego String obiektu.Removes all leading and trailing white-space characters from the current String object.

Trim(Char) Trim(Char) Trim(Char) Trim(Char)
Trim(Char[]) Trim(Char[]) Trim(Char[]) Trim(Char[])

Usuwa wszystkie początkowe i końcowe wystąpienia zestawu znaków określonego w tablicy z bieżącego String obiektu.Removes all leading and trailing occurrences of a set of characters specified in an array from the current String object.

TrimEnd() TrimEnd() TrimEnd() TrimEnd()
TrimEnd(Char) TrimEnd(Char) TrimEnd(Char) TrimEnd(Char)
TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[]) TrimEnd(Char[])

Usuwa wszystkie końcowe wystąpienia zestawu znaków określone w tablicy z bieżącego String obiektu.Removes all trailing occurrences of a set of characters specified in an array from the current String object.

TrimStart() TrimStart() TrimStart() TrimStart()
TrimStart(Char) TrimStart(Char) TrimStart(Char) TrimStart(Char)
TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[]) TrimStart(Char[])

Usuwa wszystkie wiodące wystąpienia zestawu znaków określone w tablicy z bieżącego String obiektu.Removes all leading occurrences of a set of characters specified in an array from the current String object.

Operatory

Equality(String, String) Equality(String, String) Equality(String, String) Equality(String, String)

Określa, czy dwa określone ciągi mają tę samą wartość.Determines whether two specified strings have the same value.

Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>) Implicit(String to ReadOnlySpan<Char>)
Inequality(String, String) Inequality(String, String) Inequality(String, String) Inequality(String, String)

Określa, czy dwa określone ciągi mają różne wartości.Determines whether two specified strings have different values.

Jawne implementacje interfejsu

IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object) IComparable.CompareTo(Object)
IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode() IConvertible.GetTypeCode()
IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider) IConvertible.ToBoolean(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToBoolean(IFormatProvider)Zobacz.For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider) IConvertible.ToByte(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToByte(IFormatProvider)Zobacz.For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider) IConvertible.ToChar(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToChar(IFormatProvider)Zobacz.For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider) IConvertible.ToDateTime(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToDateTime(IFormatProvider)Zobacz.For a description of this member, see ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider) IConvertible.ToDecimal(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToDecimal(IFormatProvider)Zobacz.For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider) IConvertible.ToDouble(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToDouble(IFormatProvider)Zobacz.For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider) IConvertible.ToInt16(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToInt16(IFormatProvider)Zobacz.For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider) IConvertible.ToInt32(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToInt32(IFormatProvider)Zobacz.For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider) IConvertible.ToInt64(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToInt64(IFormatProvider)Zobacz.For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider) IConvertible.ToSByte(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToSByte(IFormatProvider)Zobacz.For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider) IConvertible.ToSingle(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToSingle(IFormatProvider)Zobacz.For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider) IConvertible.ToString(IFormatProvider)
IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider) IConvertible.ToType(Type, IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToType(Type, IFormatProvider)Zobacz.For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider) IConvertible.ToUInt16(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToUInt16(IFormatProvider)Zobacz.For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider) IConvertible.ToUInt32(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToUInt32(IFormatProvider)Zobacz.For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider) IConvertible.ToUInt64(IFormatProvider)

Aby uzyskać opis tego elementu członkowskiego, ToUInt64(IFormatProvider)Zobacz.For a description of this member, see ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator() IEnumerable.GetEnumerator()

Zwraca moduł wyliczający, który wykonuje iterację String bieżącego obiektu.Returns an enumerator that iterates through the current String object.

IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator() IEnumerable<Char>.GetEnumerator()

Zwraca moduł wyliczający, który wykonuje iterację String bieżącego obiektu.Returns an enumerator that iterates through the current String object.

Metody rozszerzania

CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>) CopyToDataTable<T>(IEnumerable<T>)

DataRow T IEnumerable<T> Zwraca obiekt, DataRow który zawiera kopie obiektów, z uwzględnieniem obiektu wejściowego, w którym parametr generyczny jest. DataTableReturns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler) CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

Kopiuje DataRow obiekty do określonego DataTable, przy użyciu obiektu wejściowego IEnumerable<T> , w którym jest T DataRowparametr generyczny.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable) Cast<TResult>(IEnumerable)

Rzutuje elementy IEnumerable elementu do określonego typu.Casts the elements of an IEnumerable to the specified type.

OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable) OfType<TResult>(IEnumerable)

Filtruje elementy IEnumerable w oparciu o określony typ.Filters the elements of an IEnumerable based on a specified type.

AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable) AsParallel(IEnumerable)

Włącza przetwarzanie równoległe zapytania.Enables parallelization of a query.

AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable) AsQueryable(IEnumerable)

IEnumerable KonwertujeIQueryabledo.Converts an IEnumerable to an IQueryable.

AsMemory(String) AsMemory(String) AsMemory(String) AsMemory(String)

Tworzy nowy ReadOnlyMemory<Char> element względem części ciągu docelowego.Creates a new ReadOnlyMemory<Char> over the portion of the target string.

AsMemory(String, Index) AsMemory(String, Index) AsMemory(String, Index) AsMemory(String, Index)

Tworzy nową ReadOnlyMemory<Char> wartość dla części ciągu docelowego, zaczynając od określonego indeksu.Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified index.

AsMemory(String, Int32) AsMemory(String, Int32) AsMemory(String, Int32) AsMemory(String, Int32)

Tworzy nową ReadOnlyMemory<Char> dla części ciągu docelowego, zaczynając od określonej pozycji znaku.Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified character position.

AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32) AsMemory(String, Int32, Int32)

Tworzy nową ReadOnlyMemory<Char> wartość dla części ciągu docelowego, zaczynając od określonej pozycji o długości.Creates a new ReadOnlyMemory<Char> over a portion of the target string beginning at a specified position with a length.

AsMemory(String, Range) AsMemory(String, Range) AsMemory(String, Range) AsMemory(String, Range)

Tworzy nową ReadOnlyMemory<Char> wartość powyżej określonego zakresu ciągu docelowego.Creates a new ReadOnlyMemory<Char> over a specified range of the target string.

AsSpan(String) AsSpan(String) AsSpan(String) AsSpan(String)

Tworzy nowy zakres tylko do odczytu dla części ciągu docelowego z określonego położenia dla określonej liczby znaków.Creates a new read-only span over a portion of the target string from a specified position for a specified number of characters.

AsSpan(String, Int32) AsSpan(String, Int32) AsSpan(String, Int32) AsSpan(String, Int32)

Tworzy nowy zakres tylko do odczytu dla części ciągu docelowego od określonego położenia do końca ciągu.Creates a new read-only span over a portion of the target string from a specified position to the end of the string.

AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32) AsSpan(String, Int32, Int32)

Tworzy nowy zakres tylko do odczytu w ciągu.Creates a new read-only span over a string.

IsNormalized(String) IsNormalized(String) IsNormalized(String) IsNormalized(String)

Wskazuje, czy określony ciąg jest w postaci C normalizacji Unicode.Indicates whether the specified string is in Unicode normalization form C.

IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm) IsNormalized(String, NormalizationForm)

Wskazuje, czy ciąg znajduje się w określonym formularzu normalizacji Unicode.Indicates whether a string is in a specified Unicode normalization form.

Normalize(String) Normalize(String) Normalize(String) Normalize(String)

Normalizuje ciąg do formularza normalizacji Unicode C.Normalizes a string to a Unicode normalization form C.

Normalize(String, NormalizationForm) Normalize(String, NormalizationForm) Normalize(String, NormalizationForm) Normalize(String, NormalizationForm)

Normalizuje ciąg do określonego formularza normalizacji Unicode.Normalizes a string to the specified Unicode normalization form.

Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>) Ancestors<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName) Ancestors<T>(IEnumerable<T>, XName)

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy nadrzędne każdego węzła w kolekcji źródłowej.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>) DescendantNodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>) Descendants<T>(IEnumerable<T>)

Zwraca kolekcję elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName) Descendants<T>(IEnumerable<T>, XName)

Zwraca przefiltrowany kolekcji elementów, które zawierają elementy podrzędne każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>) Elements<T>(IEnumerable<T>)

Zwraca kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName) Elements<T>(IEnumerable<T>, XName)

Zwraca filtrowaną kolekcję elementów podrzędnych każdego elementu i dokumentu w kolekcji źródłowej.Returns a filtered collection of the child elements of every element and document in the source collection. Kolekcja zawiera tylko elementy, które XName mają zgodne.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>) InDocumentOrder<T>(IEnumerable<T>)

Zwraca kolekcję węzłów, która zawiera wszystkie węzły w kolekcji źródłowej, posortowane w kolejności dokumentu.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>) Nodes<T>(IEnumerable<T>)

Zwraca kolekcję węzłów podrzędnych każdego dokumentu i elementu w kolekcji źródłowej.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>) Remove<T>(IEnumerable<T>)

Usuwa każdy węzeł w kolekcji źródłowej z węzła nadrzędnego.Removes every node in the source collection from its parent node.

Dotyczy

Bezpieczeństwo wątkowe

Ten typ jest bezpieczny wątkowo.This type is thread safe.

Zobacz też