String String String String Class

Definice

Představuje text jako posloupnost jednotek kódu 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)
Dědičnost
StringStringStringString
Atributy
Implementuje

Poznámky

Řetězec je sekvenční kolekce znaků, která se používá k reprezentaci textu.A string is a sequential collection of characters that is used to represent text. Objekt je sekvenční System.Char kolekce objektů, které System.Char představují řetězec; objekt odpovídá jednotce kódu 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. Hodnota String objektu je obsah sekvenční System.Char kolekce objektů a tato hodnota je neměnná (to znamená, že je jen pro čtení).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). Další informace o neměnnosti řetězců naleznete v části neměnnosti a třídy StringBuilder dále v tomto tématu.For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic. Maximální velikost String objektu v paměti je 2 GB nebo přibližně 1 000 000 000 znaků.The maximum size of a String object in memory is 2GB, or about 1 billion characters.

Poznámka

Některé příklady jazyka C# v tomto článku spustit Try.NET runner a playground vloženého kódu.Some of the C# examples in this article run in the Try.NET inline code runner and playground. Pokud je přítomen, vyberte spustit tlačítko spustit příklad v interaktivním okně.When present, select the Run button to run an example in an interactive window. Jakmile se při spuštění kódu, můžete upravit a spustit upravený kód tak, že vyberete spustit znovu.Once you execute the code, you can modify it and run the modified code by selecting Run again. Upravené kód je buď spuštěn v interaktivním okně, nebo pokud kompilace se nezdaří, interaktivní okno zobrazuje všechny jazyka C# kompilátoru chybové zprávy.The modified code either runs in the interactive window or, if compilation fails, the interactive window displays all C# compiler error messages.

V této části:In this section:

Vytvoření instance objektu String Instantiating a String object
Objekty char a znaky Unicode Char objects and Unicode characters
Řetězce a Standard Unicode Strings and The Unicode Standard
Řetězce a vložené znaky null Strings and embedded null characters
Řetězce a indexy Strings and indexes
Řetězce s hodnotou null a prázdné řetězce Null strings and empty strings
Neměnnosti a třída StringBuilder Immutability and the StringBuilder class
Ordinální operace vs. operace závislé na jazykové verzi Ordinal vs. culture-sensitive operations
Normalizace Normalization
Operace s řetězci podle kategorieString operations by category

Vytvoření instance objektu řetězceInstantiating a String object

Instance String objektu lze vytvořit následujícími způsoby:You can instantiate a String object in the following ways:

  • Přiřazením řetězcového literálu String proměnné.By assigning a string literal to a String variable. Jedná se o nejčastěji používanou metodu pro vytvoření řetězce.This is the most commonly used method for creating a string. Následující příklad používá přiřazení pro vytvoření několika řetězců.The following example uses assignment to create several strings. Všimněte si, C#že v, protože zpětné lomítko (\) je řídicí znak, literální zpětná lomítka v řetězci musí být uvozena nebo musí být @-quotedcelý řetězec.Note 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      
    
  • Voláním String konstruktoru třídy.By calling a String class constructor. Následující příklad vytvoří instanci řetězce voláním několika konstruktorů třídy.The following example instantiates strings by calling several class constructors. Všimněte si, že některé konstruktory obsahují ukazatele na pole znaků nebo pole bajtů se znaménkem jako parametry.Note that some of the constructors include pointers to character arrays or signed byte arrays as parameters. Visual Basic nepodporuje volání těchto konstruktorů.Visual Basic does not support calls to these constructors. Podrobné informace o String konstruktorech String naleznete v souhrnu konstruktoru.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      
    
  • Pomocí operátoru zřetězení řetězce (+ in C# a & nebo + v Visual Basic) k vytvoření jednoho řetězce z jakékoli kombinace String instancí a řetězcových literálů.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. Následující příklad ilustruje použití operátoru zřetězení řetězce.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.
    
  • Načtením vlastnosti nebo voláním metody, která vrací řetězec.By retrieving a property or calling a method that returns a string. Následující příklad používá metody String třídy k extrakci podřetězce z většího řetězce.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
    
  • Voláním metody formátování pro převod hodnoty nebo objektu na jeho řetězcovou reprezentaci.By calling a formatting method to convert a value or object to its string representation. V následujícím příkladu je použita funkce složeného formátování pro vložení řetězcové reprezentace dvou objektů do řetězce.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.      
    

Objekty znaků a znaky kódování UnicodeChar objects and Unicode characters

Každý znak v řetězci je definován skalární hodnotou Unicode, označovanou také jako bod kódu Unicode nebo pořadové (číselná) hodnota 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ždý bod kódu je kódován pomocí kódování UTF-16 a číselná hodnota každého prvku kódování je reprezentována Char objektem.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.

Poznámka

Všimněte si, že vzhledem String k tomu, že instance obsahuje sekvenční kolekci jednotek kódu UTF-16, je možné String vytvořit objekt, který není řetězec Unicode ve správném formátu.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. Například je možné vytvořit řetězec, který má nízkou náhradu bez odpovídající vysoké náhrady.For example, it is possible to create a string that has a low surrogate without a corresponding high surrogate. I když některé metody, jako například metody kódování a dekódování objektů v System.Text oboru názvů, mohou provádět kontroly, aby bylo zajištěno, že jsou řetězce ve správném formátu, String členové třídy nezajistí, že je řetězec ve správném formátu.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.

Jeden Char objekt obvykle představuje jeden kódový bod; tj. číselná hodnota Char se rovná bodu kódu.A single Char object usually represents a single code point; that is, the numeric value of the Char equals the code point. Například bod kódu pro znak "a" je U + 0061.For example, the code point for the character "a" is U+0061. Bod kódu však může vyžadovat více než jeden kódovaný element (více než jeden Char objekt).However, a code point might require more than one encoded element (more than one Char object). Standard Unicode definuje dva typy znaků, které odpovídají více Char objektům: graphemes a doplňkovým kódovým bodům Unicode, které odpovídají znakům v doplňkových rovinách 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 je reprezentována pomocí základního znaku následovaného jedním nebo více kombinací znaků.A grapheme is represented by a base character followed by one or more combining characters. Například znak ä je reprezentován Char objektem, jehož bod kódu je u + 0061 následovaný objektem, Char jehož bod kódu je 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. Tento znak může být také definován jediným Char objektem, který má bod kódu u + 00E4.This character can also be defined by a single Char object that has a code point of U+00E4. Jak ukazuje následující příklad, porovnání zohledňující jazykovou verzi pro rovnost značí, že tyto dvě reprezentace jsou stejné, přestože běžné ordinální porovnávání nikoli.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. Pokud jsou však dva řetězce normalizovány, ordinální porovnávání také indikuje, že se shodují.However, if the two strings are normalized, an ordinal comparison also indicates that they are equal. (Další informace o normalizaci řetězců naleznete v části normalizace .)(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
    
  • Doplňkový bod kódu Unicode (náhradní pár) je reprezentován Char objektem, jehož kódovým bodem je vysoký náhrada následovaný Char objektem, jehož kódovým bodem je nízká náhrada.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. Jednotky kódu vysoké náhrady v rozsahu od U + D800 do U + DBFF.The code units of high surrogates range from U+D800 to U+DBFF. Jednotky kódu nízkého rozsahu nahrazení od U + DC00 do U + DFFF.The code units of low surrogates range from U+DC00 to U+DFFF. Náhradní páry slouží k reprezentaci znaků v doplňkových rovinách 16 Unicode.Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. Následující příklad vytvoří náhradní znak a předá ho Char.IsSurrogatePair(Char, Char) metodě k určení, zda se jedná o náhradní pár.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
    

Řetězce a Standard UnicodeStrings and the Unicode Standard

Znaky v řetězci jsou reprezentovány kódovanými kódovými jednotkami UTF-16, Char které odpovídají hodnotám.Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

Každý znak v řetězci má přidruženou kategorii znaků Unicode, která je vyjádřena v rozhraní .NET UnicodeCategory výčtem.Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. Kategorii znaku nebo náhradního páru lze určit voláním CharUnicodeInfo.GetUnicodeCategory metody.The category of a character or a surrogate pair can be determined by calling the CharUnicodeInfo.GetUnicodeCategory method.

.NET udržuje svůj vlastní tabulku znaků a jejich příslušných kategorií, což zajistí, že konkrétní verzi implementace .NET běžící na různých platformách vrátí informace o kategoriích identické 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. V rozhraní .NET Core běží na Linuxu a macOS je poskytována informace o kategoriích znaků mezinárodní součásti pro kódování Unicode knihovny.On .NET Core running on Linux and macOS, character category information is provided by International Components for Unicode libraries.

Následující tabulka uvádí verze rozhraní .NET a standardu Unicode, na kterém jsou na základě kategorií znaků.The following table lists .NET versions and the versions of the Unicode Standard on which their character categories are based.

Verze rozhraní .NET.NET version Verze Unicode StandardVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Standard Unicode verze 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 Standard Unicode verze 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 Standard Unicode verze 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Standard Unicode verze 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 Standard Unicode verze 6.3.0The Unicode Standard, Version 6.3.0
Rozhraní .NET framework 4.51.NET Framework 4.51 Standard Unicode verze 6.3.0The Unicode Standard, Version 6.3.0
Rozhraní .NET framework 4.52.NET Framework 4.52 Standard Unicode verze 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 Standard Unicode verze 6.3.0The Unicode Standard, Version 6.3.0
Rozhraní .NET framework 4.61.NET Framework 4.61 Standard Unicode verze 6.3.0The Unicode Standard, Version 6.3.0
Rozhraní .NET framework 4.6.2 a novějších verzích.NET Framework 4.6.2 and later versions Standard Unicode verze 8.0.0The Unicode Standard, Version 8.0.0
.NET core (všechny verze).NET Core (all versions) Standard Unicode verze 8.0.0The Unicode Standard, Version 8.0.0

Rozhraní .NET navíc podporuje porovnání řetězců a řazení na základě standardu Unicode.In addition, .NET supports string comparison and sorting based on the Unicode standard. Ve verzích .NET Framework prostřednictvím .NET Framework 4.NET Framework 4, .NET Framework udržuje vlastní tabulku řetězcových dat.In versions of the .NET Framework through the .NET Framework 4.NET Framework 4, the .NET Framework maintains its own table of string data. To platí také pro verze .NET Framework počínaje .NET Framework 4.5.NET Framework 4.5 verzí spuštěnou v systému 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. Od verze běžící v okně a novějších verzích operačního systému Windows modul runtime deleguje operace porovnání a řazení řetězců k operačnímu systému. .NET Framework 4.5.NET Framework 4.5Starting 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. V .NET Core jsou porovnání řetězců a informace o řazení poskytovány mezinárodními součástmi pro knihovny Unicode . V následující tabulce jsou uvedeny verze rozhraní .NET a verze Standard Unicode, na kterých jsou založeny porovnání a řazení znaků.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.

Verze rozhraní .NET.NET version Verze Unicode StandardVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Standard Unicode verze 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2,0The .NET Framework 2.0 Standard Unicode verze 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 Standard Unicode verze 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Standard Unicode verze 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5a novější ve Windows 7and later on Windows 7 Standard Unicode verze 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5a novější ve Windows 8 a novějších operačních systémech Windowsand later on Windows 8 and later Windows operating systems Standard Unicode verze 6.3.0The Unicode Standard, Version 6.3.0
.NET core (všechny verze).NET Core (all versions) Závisí na verzi standardu Unicode, kterou podporuje základní operační systém.Depends on the version of the Unicode Standard supported by the underlying operating system.

Řetězce a vložené znaky nullStrings and embedded null characters

V rozhraní .NET String může objekt obsahovat vložené znaky null, které se počítají jako součást délky řetězce.In .NET, a String object can include embedded null characters, which count as a part of the string's length. Nicméně v některých jazycích, jako je C a C++, znak null označuje konec řetězce; není považována za součást řetězce a není počítána jako součást délky řetězce.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. To znamená, že následující běžné předpoklady, které c C++ a programátory nebo knihovny napsané C++ v jazyce c nebo které mohou vzdávat řetězce, nemusí String nutně platit při použití u objektů: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:

  • Hodnota vrácená strlen funkcemi nebo wcslen se nemusí nutně rovnat String.Length.The value returned by the strlen or wcslen functions does not necessarily equal String.Length.

  • Řetězec vytvořený strcpy_s funkcemi nebo wcscpy_s není nutně totožný s řetězcem vytvořeným String.Copy metodou.The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the String.Copy method.

Měli byste zajistit, aby nativní jazyk C++ C a kód, String který vytváří instance objektů, a kód String , který je předaný objektům prostřednictvím vyvolání platformy, Nepředpokládat, že vložená znak null označuje konec řetězce.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.

Vložené znaky null v řetězci jsou také zpracovány jinak, když je řetězec seřazen (nebo porovnán) a když je prohledáván řetězec.Embedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. Znaky null jsou ignorovány při provádění porovnání zohledňující jazykovou verzi mezi dvěma řetězci, včetně porovnávání pomocí invariantní jazykové verze.Null characters are ignored when performing culture-sensitive comparisons between two strings, including comparisons using the invariant culture. Jsou považovány za pouze anglické a řadové porovnávání bez rozlišování velkých a malých písmen.They are considered only for ordinal or case-insensitive ordinal comparisons. Na druhé straně jsou vložené prázdné znaky vždy zváženy při hledání řetězce pomocí metod Contains, jako jsou, StartsWitha IndexOf.On the other hand, embedded null characters are always considered when searching a string with methods such as Contains, StartsWith, and IndexOf.

Řetězce a indexyStrings and indexes

Index je pozice Char objektu (nikoli znak Unicode) Stringv.An index is the position of a Char object (not a Unicode character) in a String. Index je nula, nezáporné číslo, které začíná od první pozice v řetězci, což je pozice indexu nula.An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. Několik metod hledání, například IndexOf a LastIndexOf, vrátí index znaku nebo podřetězce v instanci řetězce.A number of search methods, such as IndexOf and LastIndexOf, return the index of a character or substring in the string instance.

Vlastnost umožňuje přístup k jednotlivým Char objektům podle jejich indexu na pozici v řetězci. Chars[Int32]The Chars[Int32] property lets you access individual Char objects by their index position in the string. Vzhledem k tomu, že C# Char vlastnostjevýchozívlastnost(vVisualBasic)neboindexer(v),můžetekjednotlivýmobjektůmvřetězcipřistupovatpomocíkódu,jakojenapříkladChars[Int32] následující.Because the Chars[Int32] 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. Tento kód vyhledá v řetězci prázdné znaky nebo interpunkční znaménka, aby bylo možné určit, kolik slov řetězec obsahuje.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.

Vzhledem k tomu, že IEnumerable Char foreach třída implementuje rozhraní, můžete také iterovat objekty v řetězci pomocí konstrukce, jak ukazuje následující příklad. 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.

Po sobě jdoucí hodnoty indexu nemusí odpovídat po sobě jdoucích znaků Unicode, protože znak Unicode může být kódovaný jako Char více než jeden objekt.Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one Char object. Konkrétně řetězec může obsahovat více znakových jednotek textu, které jsou tvořeny základním znakem následovaným jedním nebo více znaky kombinování nebo náhradními páry.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. Chcete-li pracovat se znaky Unicode Char namísto objektů, System.Globalization.StringInfo použijte třídy TextElementEnumerator a.To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. Následující příklad znázorňuje rozdíl mezi kódem, který pracuje s Char objekty a kódem, který pracuje se znaky Unicode.The following example illustrates the difference between code that works with Char objects and code that works with Unicode characters. Porovnává počet znaků nebo textových prvků v každém slově věty.It compares the number of characters or text elements in each word of a sentence. Řetězec obsahuje dva sekvence základního znaku následovaného kombinovaným znakem.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

Tento příklad pracuje s textovými prvky pomocí StringInfo.GetTextElementEnumerator metody TextElementEnumerator a třídy pro zobrazení výčtu všech textových prvků v řetězci.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. Můžete také načíst pole, které obsahuje počáteční index každého prvku text voláním StringInfo.ParseCombiningCharacters metody.You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

Další informace o práci s jednotkami textu namísto individuálních Char hodnot StringInfo naleznete v tématu Třída.For more information about working with units of text rather than individual Char values, see the StringInfo class.

Řetězce null a prázdné řetězceNull strings and empty strings

Řetězec, který byl deklarován, ale nebyl mu přiřazena hodnota null.A string that has been declared but has not been assigned a value is null. Pokus o volání metod v tomto řetězci vyvolá výjimku NullReferenceException.Attempting to call methods on that string throws a NullReferenceException. Řetězec s hodnotou null se liší od prázdného řetězce, což je řetězec, jehož hodnota je "" String.Emptynebo.A null string is different from an empty string, which is a string whose value is "" or String.Empty. V některých případech předejte prázdný řetězec nebo prázdný řetězec jako argument ve volání metody vyvolá výjimku.In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. Například předání řetězce Int32.Parse s hodnotou null metodě ArgumentNullExceptionvyvolá výjimku a předáním prázdného řetězce vyvolá výjimku FormatException.For example, passing a null string to the Int32.Parse method throws an ArgumentNullException, and passing an empty string throws a FormatException. V jiných případech může být argumentem metody buď řetězec s hodnotou null, nebo prázdný řetězec.In other cases, a method argument can be either a null string or an empty string. Například Pokud poskytujete IFormattable implementaci pro třídu, je třeba, aby byl řetězec null a prázdný řetězec s obecným specifikátorem formátu ("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.

Třída obsahuje následující dvě vhodné metody, které umožňují otestovat, zda je null řetězec nebo prázdný: StringThe String class includes the following two convenience methods that enable you to test whether a string is null or empty:

  • IsNullOrEmpty, který označuje, zda je řetězec buď null nebo se String.Emptyrovná.IsNullOrEmpty, which indicates whether a string is either null or is equal to String.Empty. Tato metoda eliminuje nutnost použití kódu, jako je následující: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, který označuje, zda je nullřetězec, String.Emptyrovná se nebo se skládá pouze z prázdných znaků.IsNullOrWhiteSpace, which indicates whether a string is null, equals String.Empty, or consists exclusively of white-space characters. Tato metoda eliminuje nutnost použití kódu, jako je následující: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)
    

Následující příklad používá IsNullOrEmpty metodu IFormattable.ToString v implementaci vlastní Temperature třídy.The following example uses the IsNullOrEmpty method in the IFormattable.ToString implementation of a custom Temperature class. Metoda podporuje řetězce formátu "G", "C", "F" a "K".The method supports the "G", "C", "F", and "K" format strings. Pokud je prázdný řetězec formátu nebo formátovací řetězec, jehož hodnota null je předána metodě, je jeho hodnota změněna na formátovací řetězec "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

Neměnitelnost a třída StringBuilderImmutability and the StringBuilder class

String Objekt je označován jako neměnný (jen pro čtení), protože jeho hodnotu nelze po vytvoření změnit.A String object is called immutable (read-only), because its value cannot be modified after it has been created. Metody, které se zobrazují pro String úpravu objektu, skutečně vracejí String nový objekt, který obsahuje úpravu.Methods that appear to modify a String object actually return a new String object that contains the modification.

Vzhledem k tomu, že řetězce jsou neměnné, jsou rutiny manipulace s řetězci, které provedou opakované dodatky nebo odstraněné k tomu, co vypadá jako jeden řetězec, mohou přesně vytěžovat významné snížení výkonu.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. Například následující kód používá generátor náhodných čísel k vytvoření řetězce s 1000 znaky v rozsahu 0x0001 až 0x052F.For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. I když se kód zdá použít zřetězení řetězců pro připojení nového znaku k existujícímu řetězci s názvem str, vytvoří ve skutečnosti nový String objekt pro každou operaci zřetězení.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

Můžete použít StringBuilder třídu namísto String třídy pro operace, které provedou více změn hodnoty řetězce.You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. Na rozdíl od instancí String StringBuilder třídy jsou objekty proměnlivé; při zřetězení, připojení nebo odstranění podřetězců z řetězce se operace provádějí na jednom řetězci.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 dokončení úprav hodnoty StringBuilder objektu můžete zavolat jeho StringBuilder.ToString metodu a převést ji na řetězec.When you have finished modifying the value of a StringBuilder object, you can call its StringBuilder.ToString method to convert it to a string. Následující příklad nahrazuje String použití v předchozím příkladu k zřetězení 1000 náhodných znaků v rozsahu až po 0x0001 0x052F StringBuilder s objektem.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

Řádové operace vs. operace zohledňující jazykovou verziOrdinal vs. culture-sensitive operations

Členové třídy provádějí String v objektu buď pořadové, nebo (jazykové) operace závislé na jazykové verzi. StringMembers of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. Ordinální operace funguje na číselné hodnotě každého Char objektu.An ordinal operation acts on the numeric value of each Char object. Operace zohledňující jazykovou verzi funguje na hodnotě String objektu a v účtu bere ohled na velká a malá písmena, řazení, formátování a analýzu.A culture-sensitive operation acts on the value of the String object, and takes culture-specific casing, sorting, formatting, and parsing rules into account. Operace závislé na jazykové verzi se spouštějí v kontextu explicitně deklarované jazykové verze nebo implicitní aktuální jazykové verze.Culture-sensitive operations execute in the context of an explicitly declared culture or the implicit current culture. Dva druhy operací mohou při provádění na stejném řetězci způsobit velmi odlišné výsledky.The two kinds of operations can produce very different results when they are performed on the same string.

.NET také podporuje operace s jazykovým řetězcem nezávislé na jazykové verzi pomocí neutrální jazykové verzeCultureInfo.InvariantCulture(), která je volně založena na nastavení jazykové verze anglického jazyka nezávislého na oblasti..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. Na rozdíl od System.Globalization.CultureInfo jiných nastavení je zaručeno, že nastavení neutrální jazykové verze zůstane konzistentní v jednom počítači, ze systému na systém a napříč verzemi rozhraní .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. Invariantní jazyková verze se může zobrazit jako druh černého pole, které zajišťuje stabilitu porovnávání řetězců a řazení napříč všemi kulturami.The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

Důležité

Pokud vaše aplikace provádí rozhodnutí o zabezpečení symbolického identifikátoru, jako je například název souboru nebo pojmenovaný kanál, nebo o trvalá data, jako jsou data založená na textu v souboru XML, operace by měla místo porovnání zohledňující jazykovou verzi použít ordinální porovnávání.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. Důvodem je, že porovnání zohledňující jazykovou verzi může vracet různé výsledky v závislosti na jazykové verzi v důsledku, zatímco ordinální porovnávání závisí výhradně na binární hodnotě porovnávaných znaků.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.

Důležité

Většina metod, které provádějí operace s řetězci, zahrnuje přetížení, které má parametr StringComparisontypu, který umožňuje určit, zda metoda provádí operaci s pořadovým číslem nebo zohledňující jazykovou verzi.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. Obecně byste měli zavolat toto přetížení, aby se záměr vašeho volání metody vymazal.In general, you should call this overload to make the intent of your method call clear. Osvědčené postupy a pokyny pro použití řadových operací a operací závislých na jazykové verzi na řetězcích najdete v tématu osvědčené postupy pro použití řetězců.For best practices and guidance for using ordinal and culture-sensitive operations on strings, see Best Practices for Using Strings.

Operace pro velká a malá písmena, analýzy a formátování, porovnání a řazenía testování rovnosti může být buď ordinální, nebo závislé na jazykové verzi.Operations for casing, parsing and formatting, comparison and sorting, and testing for equality can be either ordinal or culture-sensitive. V následujících částech jsou pojednávají jednotlivé kategorie operací.The following sections discuss each category of operation.

Tip

Vždy byste měli volat přetížení metody, které dělá záměr volání metody Clear.You should always call a method overload that makes the intent of your method call clear. Například namísto volání Compare(String, String) metody pro provedení porovnání zohledňující jazykovou verzi dvou řetězců pomocí konvencí aktuální jazykové verze byste měli Compare(String, String, StringComparison) zavolat StringComparison.CurrentCulture metodu s hodnotou pro 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. Další informace najdete v tématu osvědčené postupy pro používání řetězců.For more information, see Best Practices for Using Strings.

Můžete si stáhnout tabulky váhy řazení, sadu textových souborů, které obsahují informace o váhu znaků používaných při řazení a porovnávání operací pro operační systémy Windows, a výchozí tabulku prvků kolace sady Unicode, řazení Tabulka váhy pro Linux a 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.

Velikost písmenCasing

Pravidla pro velká a malá písmena určují, jak změnit velikost písmen znaků Unicode; například z malých a velkých písmen.Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. Operace velkých a malých písmen se často provádí před porovnáním řetězců.Often, a casing operation is performed before a string comparison. Například řetězec může být převeden na velká písmena, aby jej bylo možné porovnat s jiným řetězcem velkých písmen.For example, a string might be converted to uppercase so that it can be compared with another uppercase string. Znaky v řetězci můžete převést ToLower na malá písmena voláním metody nebo ToLowerInvariant a můžete je převést ToUpper na velká písmena voláním metody nebo 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. Kromě toho můžete použít TextInfo.ToTitleCase metodu pro převod řetězce na nadpisový případ.In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

Poznámka

.NET core využívající pouze systémy Linux a macOS: Chování řazení pro jazyky C a Posix jazykové verze je vždy velká a malá písmena, protože tyto jazykové verze nepoužívejte očekávaném pořadí řazení sady 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. Doporučujeme používat jazykovou verzi než C nebo Posix k provedení operace řazení zohledňující jazykovou verzi, velká a malá písmena.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

Operace s velkými a malými písmeny můžou být založené na pravidlech aktuální jazykové verze, zadané jazykové verzi nebo invariantní jazykové verze.Casing operations can be based on the rules of the current culture, a specified culture, or the invariant culture. Vzhledem k tomu, že mapování případu se může lišit v závislosti na použité jazykové verzi, výsledek operací s velikostí písmen se může lišit v závislosti na jazykové verzi.Because case mappings can vary depending on the culture used, the result of casing operations can vary based on culture. Skutečné rozdíly v malých a velkých písmenech mají tři typy:The actual differences in casing are of three kinds:

  • Rozdíly v mapování velikosti písmen v LATINCE – velké písmeno I (U + 0049), malé písmeno latinky I (U + 0069), velké písmeno latinky I s tečkou nad (U + 0130) a malé písmeno latinky i bez TEČKy (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). V rámci tr-TR (turečtina (Turecko)) a az-Latn-AZ (Ázerbájdžán, Latin) a v rámci TR, AZ a az-Latn neutrální jazykové verze je malý ekvivalent TUČNého písmene latinky I v latince a malý ekvivalent malých písmen v latince. VELKÉ PÍSMENO LATINKY I S TEČKOU NAHOŘEIn 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. V všech ostatních jazykových verzích, včetně invariantní jazykové verze, je malé písmeno I a Latinská TUČNé písmeno I malými a velkými ekvivalenty.In all other cultures, including the invariant culture, LATIN SMALL LETTER I and LATIN CAPITAL LETTER I are lowercase and uppercase equivalents.

    Následující příklad ukazuje, jakým způsobem porovnání řetězců navržené k zabránění přístupu k systému souborů může selhat, pokud se spoléhá na porovnání malých a velkých písmen v jazykové verzi.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. (Měly by se použít konvence pro velká a malá písmena.)(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
    
  • Rozdíly v případě mapování mezi neutrální jazykové verze a všemi ostatními kulturami.Differences in case mappings between the invariant culture and all other cultures. V těchto případech použití pravidel malých a velkých písmen v neutrální jazykové verzi pro změnu znaku na velká a malá písmena vrátí stejný znak.In these cases, using the casing rules of the invariant culture to change a character to uppercase or lowercase returns the same character. Pro všechny ostatní jazykové verze vrátí jiný znak.For all other cultures, it returns a different character. Některé z ovlivněných znaků jsou uvedeny v následující tabulce.Some of the affected characters are listed in the following table.

    ZnakCharacter Pokud se změní naIf changed to VracíReturns
    MICRON – ZNAMÉNKO (U + 00B5)MICRON SIGN (U+00B5) Velká písmenaUppercase ŘECKÉ VELKÉ PÍSMENO MU (U + – 39C)GREEK CAPITAL LETTER MU (U+-39C)
    VELKÉ PÍSMENO LATINKY I S TEČKOU NAD (U + 0130)LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) MaláLowercase MALÉ PÍSMENO LATINKY I (U + 0069)LATIN SMALL LETTER I (U+0069)
    MALÉ PÍSMENO LATINKY BEZ TEČKY (U + 0131)LATIN SMALL LETTER DOTLESS I (U+0131) Velká písmenaUppercase VELKÉ PÍSMENO LATINKY I (U + 0049)LATIN CAPITAL LETTER I (U+0049)
    MALÉ PÍSMENO LATINKY DLOUHÉ S (U + 017F)LATIN SMALL LETTER LONG S (U+017F) Velká písmenaUppercase VELKÉ PÍSMENO LATINKY S (U + 0053)LATIN CAPITAL LETTER S (U+0053)
    VELKÉ PÍSMENO LATINKY D S MALÝM PÍSMENEM Z S HÁČKEM (U + 01C5)LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) MaláLowercase MALÉ PÍSMENO LATINKY DZ S HÁČKEM (U + 01C6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    DIAKRITICKÉ ZNAMÉNKO ŘECKÉ IÓTA IÓTA (U + 0345)COMBINING GREEK YPOGEGRAMMENI (U+0345) Velká písmenaUppercase ŘECKÉ VELKÉ PÍSMENO IÓTA (U + 0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • Rozdíly v případě mapování kombinovaných dvojic velkých a malých písmen v rozsahu znaků ASCII.Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. Ve většině jazykových verzí je smíšená dvojice malých a velkých písmen rovna ekvivalentní dvojici velkých a malých písmen nebo dvěma písmeny.In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. To není pravdivé pro následující páry dvou písmen v následujících jazykových verzích, protože v každém případě jsou porovnány s grafem: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" a "Newarku" v jazykové verzi HR-HR (chorvatština (Chorvatsko))."lJ" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • "cH" v jazykových verzích cs-CZ (Čeština (Česká republika)) a SK-SK (slovenské (Slovensko))."cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • "aA" v jazykové verzi da-DK (dánština, Dánsko))."aA" in the da-DK (Danish (Denmark)) culture.

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" a "zS" v jazykové verzi hu-HU (maďarština (Maďarsko))."cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • "cH" a "lL" v jazykové verzi ES-ES_tradnl (španělština (Španělsko, tradiční řazení))."cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU", "tH" a "tR" v jazykové verzi VI-VN (Vietnam))."cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", and "tR" in the vi-VN (Vietnamese (Vietnam)) culture.

    Není však neobvyklé narazit na situaci, kdy porovnání zohledňující jazykovou verzi těchto párů vytvoří problémy, protože tyto páry jsou Neběžné v pevných řetězcích nebo identifikátorech.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.

Následující příklad ilustruje některé rozdíly v pravidlech malých a velkých písmen mezi kulturami při převodu řetězců na velká písmena.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  

Analýza a formátováníParsing and formatting

Formátování a analýza jsou operace invertované.Formatting and parsing are inverse operations. Pravidla formátování určují, jak převést hodnotu, například datum a čas nebo číslo, na jeho řetězcové vyjádření, zatímco pravidla analýzy určují, jak převést řetězcovou reprezentaci na hodnotu, jako je datum a čas.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. Pravidla formátování i analýzy jsou závislá na jazykových konvencích.Both formatting and parsing rules are dependent on cultural conventions. Následující příklad ilustruje nejednoznačnost, která může vzniknout při interpretaci řetězce data specifického pro jazykovou verzi.The following example illustrates the ambiguity that can arise when interpreting a culture-specific date string. Bez znalosti konvencí jazykové verze, která byla použita k vytvoření řetězce data, není možné zjistit, zda 03/01/2011, 3/1/2011 a 01/03/2011 představuje 3. ledna 2011 nebo 1. března 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

Podobně jak ukazuje následující příklad, jeden řetězec může vytvořit různá data v závislosti na jazykové verzi, jejíž konvence jsou používány v rámci operace analýzy.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

Porovnávání a řazení řetězcůString comparison and sorting

Konvence pro porovnávání a řazení řetězců se liší od jazykové verze až po jazykovou verzi.Conventions for comparing and sorting strings vary from culture to culture. Například pořadí řazení může být založené na výslovnosti nebo na vizuálním znázornění znaků.For example, the sort order may be based on phonetics or on the visual representation of characters. Ve východoasijských jazycích jsou znaky řazeny podle úhozů a radikálu ideografických znaků.In East Asian languages, characters are sorted by the stroke and radical of ideographs. Řazení závisí také na pořadí, které jazyky a jazykové verze používají pro abecedu.Sorting also depends on the order languages and cultures use for the alphabet. Dánský jazyk má například znak „Æ“, který se abecedně řadí za znak „Z“.For example, the Danish language has an "Æ" character that it sorts after "Z" in the alphabet. Kromě toho porovnávání může rozlišovat velká a malá písmena, a v některých případech se pravidla pro velká a malá písmena liší také podle jazykové verze.In addition, comparisons can be case-sensitive or case-insensitive, and in some cases casing rules also differ by culture. Ordinální porovnávání na druhé straně používá body kódu Unicode jednotlivých znaků v řetězci při porovnávání a řazení řetězců.Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

Pravidla řazení určují abecední pořadí znaků Unicode a způsob porovnávání dvou řetězců.Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. Například String.Compare(String, String, StringComparison) Metoda porovná dva řetězce na základě StringComparison parametru.For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. Pokud je StringComparison.CurrentCulturehodnota parametru, metoda provede jazykové porovnání, které používá konvence aktuální jazykové verze; je StringComparison.Ordinal-li hodnota parametru, metoda provede ordinální porovnání.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. V důsledku toho jak ukazuje následující příklad, pokud je aktuální jazyková verze USA Angličtina, první volání String.Compare(String, String, StringComparison) metody (s použitím porovnání zohledňující jazykovou verzi) posuzuje "a" menší než "a", ale druhé volání stejné metody (pomocí ordinálního porovnání) bere v úvahu "a" větší než "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

.NET podporuje pravidla pro řazení slov, řetězců a pořadových čísel:.NET supports word, string, and ordinal sort rules:

  • Řazení slov provádí porovnávání zohledňující jazykovou verzi řetězců, ve kterých některé nealfanumerické znaky Unicode mohou mít přiřazena zvláštní závaží.A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. Například spojovník (-) může mít velmi malou přiřazenou váhu, aby se "Coop" a "Co-op" zobrazovaly vedle sebe v seřazeném seznamu.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. Seznam String metod, které porovnávají dva řetězce pomocí pravidel řazení slov, naleznete v části operace s řetězci podle kategorií .For a list of the String methods that compare two strings using word sort rules, see the String operations by category section.

  • Řazení řetězců také provádí porovnání zohledňující jazykovou verzi.A string sort also performs a culture-sensitive comparison. Je podobný jako při řazení slov, s výjimkou toho, že neexistují žádné zvláštní případy, přičemž všechny nealfanumerické symboly přicházejí před všemi alfanumerickými znaky 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. Dva řetězce lze porovnat pomocí pravidel pro CompareInfo.Compare řazení řetězců voláním přetížení metody, která options má parametr, který má parametr, který CompareOptions.StringSortje zadán jako hodnota.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. Všimněte si, že toto je jediná metoda, kterou .NET poskytuje pro porovnání dvou řetězců pomocí pravidel pro řazení řetězců.Note that this is the only method that .NET provides to compare two strings using string sort rules.

  • Ordinální řazení porovná řetězce na základě číselné hodnoty jednotlivých Char objektů v řetězci.An ordinal sort compares strings based on the numeric value of each Char object in the string. Ordinální porovnávání je automaticky rozlišuje velká a malá písmena, protože verze písmen a velká písmena znaku mají různé body kódu.An ordinal comparison is automatically case-sensitive because the lowercase and uppercase versions of a character have different code points. Nicméně pokud případ není důležité, můžete zadat ordinální porovnávání, které ignoruje velikost písmen.However, if case is not important, you can specify an ordinal comparison that ignores case. To je ekvivalentní k převodu řetězce na velká písmena pomocí invariantní jazykové verze a následného porovnání na základě pořadového čísla.This is equivalent to converting the string to uppercase by using the invariant culture and then performing an ordinal comparison on the result. Seznam String metod, které porovnávají dva řetězce pomocí pravidel pro ordinální řazení, naleznete v části operace s řetězci podle kategorií .For a list of the String methods that compare two strings using ordinal sort rules, see the String operations by category section.

Porovnání zohledňující jazykovou verzi je jakékoli porovnání, které explicitně nebo implicitně CultureInfo používá objekt, včetně neutrální jazykové verze, která je určena CultureInfo.InvariantCulture vlastností.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. Implicitní jazyková verze je aktuální jazyková verze, která je určena Thread.CurrentCulture vlastnostmi a. CultureInfo.CurrentCultureThe implicit culture is the current culture, which is specified by the Thread.CurrentCulture and CultureInfo.CurrentCulture properties. Existují značná variace v pořadí řazení abecedních znaků (tj. znaky, pro které se Char.IsLetter vrátí truevlastnost) napříč 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. Můžete určit porovnání zohledňující jazykovou verzi, které používá konvence konkrétní jazykové verze, a to CultureInfo zadáním objektu do metody porovnání řetězce, jako je například. 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). Můžete určit porovnání zohledňující jazykovou verzi, které používá konvence aktuální jazykové verze, a to StringComparison.CurrentCulturezadáním, nebo libovolným členem CompareOptions výčtu, StringComparison.CurrentCultureIgnoreCasekterý CompareOptions.Ordinal je CompareOptions.OrdinalIgnoreCase jiný než nebo do vhodného Compare přetížení metodyYou 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. Porovnávání závislé na jazykové verzi je všeobecně vhodné pro řazení, zatímco ordinální porovnávání není.A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. Ordinální porovnávání je všeobecně vhodné pro určení, zda jsou dva řetězce stejné (tj. pro určení identity), zatímco porovnání zohledňující jazykovou verzi není.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.

Následující příklad znázorňuje rozdíl mezi porovnáváním a ordinálním porovnáním závislého na jazykové verzi.The following example illustrates the difference between culture-sensitive and ordinal comparison. V příkladu jsou vyhodnoceny tři řetězce, "Apple", "Æble" a "AEble", pomocí ordinálního porovnání a konvence pro kultury da-DK a EN-US (každou z nich je výchozí jazyková verze v době Compare volání 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). Vzhledem k tomu, že Dánská verze považuje znak "Æ" za jednotlivá písmena a seřadí je po "Z" v abecedním jazyce, řetězec "Æble" je větší než "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". "Æble" ale nepovažuje za ekvivalent "AEble", takže "Æble" je také větší než "AEble".However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "AEble". Jazyková verze en-US neobsahuje písmeno "Æ", ale považuje ho za ekvivalent "AE", což vysvětluje, proč "Æble" je menší než "Apple", ale je rovno "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". Ordinální porovnávání na druhé straně bere v úvahu, že "Apple" bude menší než "Æble" a "Æble" bude větší než "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

Použijte následující obecné pokyny k výběru vhodné metody řazení nebo porovnávání řetězců:Use the following general guidelines to choose an appropriate sorting or string comparison method:

  • Chcete-li, aby byly řetězce uspořádány na základě jazykové verze uživatele, měli byste je seřadit podle konvencí aktuální jazykové verze.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. Pokud se změní jazyková verze uživatele, pořadí seřazených řetězců se změní také odpovídajícím způsobem.If the user's culture changes, the order of sorted strings will also change accordingly. Například aplikace tezauru by měla vždy seřadit slova založená na jazykové verzi uživatele.For example, a thesaurus application should always sort words based on the user's culture.

  • Chcete-li, aby byly řetězce seřazeny na základě konvencí konkrétní jazykové verze, měli byste je seřadit zadáním CultureInfo objektu, který představuje tuto jazykovou verzi pro metodu porovnání.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. Například v aplikaci navržené pro výuku studentů konkrétního jazyka chcete, aby byly řetězce seřazeny na základě konvencí jedné z kultur, které procházejí tento jazyk.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.

  • Pokud chcete, aby pořadí řetězců zůstalo v různých jazykových verzích beze změny, měli byste je seřadit na základě konvencí invariantní jazykové verze nebo použití ordinálního porovnání.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. Například můžete použít ordinální řazení k uspořádání názvů souborů, procesů, mutexů nebo pojmenovaných kanálů.For example, you would use an ordinal sort to organize the names of files, processes, mutexes, or named pipes.

  • Pro porovnání, které zahrnuje rozhodnutí o zabezpečení (například zda je uživatelské jméno platné), byste měli vždy provést ordinální test rovnosti voláním přetížení Equals 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.

Poznámka

Pravidla třídění a rozlišování velkých a malých písmen použité v porovnání s řetězci závisí na verzi rozhraní .NET.The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET. V .NET Framework 4,5 a novějších verzích spuštěných v Windows 8Windows 8 operačním systému jsou informace o řazení, velikosti písmen, normalizaci a znakové sadě Unicode v souladu se 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. V jiných operačních systémech Windows odpovídá standardu Unicode 5,0.On other Windows operating systems, it conforms to the Unicode 5.0 standard. V .NET Core závisí na verzi standardu Unicode, kterou podporuje základní operační systém.On .NET Core, it depends on the version of the Unicode Standard supported by the underlying operating system.

Další informace o pravidlech řazení slov, řetězců a pořadových čísel najdete v System.Globalization.CompareOptions tématu.For more information about word, string, and ordinal sort rules, see the System.Globalization.CompareOptions topic. Další doporučení týkající se použití jednotlivých pravidel najdete v tématu osvědčené postupy pro používání řetězců.For additional recommendations on when to use each rule, see Best Practices for Using Strings.

Obvykle nevoláte metody porovnání řetězců, jako je Compare například přímo k určení pořadí řazení řetězců.Ordinarily, you don't call string comparison methods such as Compare directly to determine the sort order of strings. Místo toho metody porovnání jsou volány pomocí metod řazení, Array.Sort jako List<T>.Sortje nebo.Instead, comparison methods are called by sorting methods such as Array.Sort or List<T>.Sort. Následující příklad provádí čtyři různé operace řazení (slovo řazení pomocí aktuální jazykové verze, řazení slov pomocí neutrální jazykové verze, ordinální řazení a řazení řetězců s použitím neutrální jazykové verze) bez explicitního volání metody porovnání řetězců. i když určují typ porovnání, které se má použít.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. Všimněte si, že každý typ řazení vytvoří jedinečné řazení řetězců ve svém poli.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

Tip

Interně rozhraní .NET používá klíče řazení pro podporu porovnávání důvěrných řetězců citlivá na jazyk.Internally, .NET uses sort keys to support culturally sensitive string comparison. Jednotlivým znakům v řetězci je přiřazeno několik kategorií důležitosti řazení, včetně abecedy, velikosti písmen a diakritických znamének.Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. Klíč řazení reprezentovaný SortKey třídou poskytuje úložiště těchto vah pro konkrétní řetězec.A sort key, represented by the SortKey class, provides a repository of these weights for a particular string. Pokud vaše aplikace provádí velký počet operací vyhledávání nebo řazení u stejné sady řetězců, můžete zvýšit výkon tím, že vygenerujete a uložíte klíče řazení pro všechny řetězce, které používá.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. Když je potřeba operace seřadit nebo porovnat, použijte místo řetězců klíče řazení.When a sort or comparison operation is required, you use the sort keys instead of the strings. Další informace naleznete v tématu SortKey třída.For more information, see the SortKey class.

Pokud nezadáte konvenci pro porovnání řetězců, metody řazení, jako Array.Sort(Array) je například provedení řazení závislého na jazykové verzi, u řetězců.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. Následující příklad ukazuje, jak změna aktuální jazykové verze ovlivňuje pořadí seřazených řetězců v poli.The following example illustrates how changing the current culture affects the order of sorted strings in an array. Vytvoří pole tří řetězců.It creates an array of three strings. Nejprve je vlastnost System.Threading.Thread.CurrentThread.CurrentCulture nastavena na hodnotu en-US a je volána metoda Array.Sort(Array).First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the Array.Sort(Array) method. Výsledné pořadí řazení vychází z konvencí řazení pro anglickou (USA) jazykovou verzi.The resulting sort order is based on sorting conventions for the English (United States) culture. Dále je v příkladu vlastnost System.Threading.Thread.CurrentThread.CurrentCulture nastavena na hodnotu da-DK a je znovu volána metoda Array.Sort.Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the Array.Sort method again. Výsledné pořadí se liší od výsledků pro možnost en-US, protože jsou použity konvence řazení pro dánštinu (Dánsko).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

Varování

Pokud vaše primární účel při porovnávání řetězců určuje, zda jsou stejné, měli byste zavolat String.Equals metodu.If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. Obvykle byste měli použít Equals k provedení pořadového porovnání.Typically, you should use Equals to perform an ordinal comparison. String.Compare Metoda je určena hlavně pro řazení řetězců.The String.Compare method is intended primarily to sort strings.

Metody vyhledávání řetězců, například String.StartsWith a String.IndexOf, mohou také provádět porovnání řetězců závislé na jazykové verzi nebo pořadí.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. Následující příklad znázorňuje rozdíly mezi ordinálními a závislými porovnáváními pomocí IndexOf metody.The following example illustrates the differences between ordinal and culture-sensitive comparisons using the IndexOf method. Hledání zohledňující jazykovou verzi, ve kterém je aktuální jazyková verze Angličtina (USA), považuje podřetězec "OE", aby odpovídal této ligaturě "œ".A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". Vzhledem k tomu, že měkké spojovník (U + 00AD) je znak s nulovou šířkou, hledání zpracuje měkký spojovník jako ekvivalent Empty a vyhledá shodu na začátku řetězce.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. Hledání podle pořadového čísla na druhé straně nenalezne shodu v obou případech.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

Hledání řetězcůSearching Strings

Metody vyhledávání řetězců, jako String.StartsWith je například a String.IndexOf, mohou také provádět porovnání řetězců závislé na jazykové verzi nebo pořadí, aby bylo možné určit, zda je znak nebo podřetězec nalezen v zadaném řetězci.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 vyhledávání ve String třídě, které hledají jednotlivý znak, jako je IndexOf například metoda nebo jedna ze sady znaků, jako je IndexOfAny například metoda, provádí hledání pořadového čísla.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. Chcete-li provést vyhledávání závislé na jazykové verzi pro znak, je nutné zavolat CompareInfo metodu, CompareInfo.IndexOf(String, Char) například nebo 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). Všimněte si, že výsledky hledání znaku pomocí pořadí a porovnání zohledňující jazykovou verzi mohou být velmi odlišné.Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. Například hledání předsloženého znaku Unicode, jako je například ligatura "Æ" (U + 00C6), může odpovídat jakémukoli výskytu jeho komponent ve správném pořadí, například "AE" (U + 041U + 0045) v závislosti na jazykové verzi.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. Následující příklad ukazuje rozdíl mezi String.IndexOf(Char) metodami a CompareInfo.IndexOf(String, Char) při hledání jednotlivého znaku.The following example illustrates the difference between the String.IndexOf(Char) and CompareInfo.IndexOf(String, Char) methods when searching for an individual character. Při použití konvencí jazykové verze en-US se v řetězci "leteckých" nachází ligatura "æ" (U + 00E6), ale ne při použití konvencí jazykové verze da-DK nebo při provádění ordinálního porovnání.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

Na druhé straně String metody třídy, které hledají řetězec, nikoli znak, provádějí vyhledávání zohledňující jazykovou verzi, pokud možnosti vyhledávání nejsou explicitně určeny parametrem typu StringComparison.On 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. Jedinou výjimkou je Contains, že provádí hledání pořadového čísla.The sole exception is Contains, which performs an ordinal search.

Testování rovnostiTesting for equality

String.Compare Použijte metodu k určení vztahu dvou řetězců v pořadí řazení.Use the String.Compare method to determine the relationship of two strings in the sort order. Obvykle se jedná o operaci zohledňující jazykovou verzi.Typically, this is a culture-sensitive operation. Naproti tomu volejte String.Equals metodu pro otestování rovnosti.In contrast, call the String.Equals method to test for equality. Vzhledem k tomu, že test rovnosti obvykle porovnává vstup uživatele s nějakým známým řetězcem, jako je platné uživatelské jméno, heslo nebo cesta systému souborů, obvykle se jedná o ordinální operaci.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.

Varování

Je možné otestovat rovnost voláním String.Compare metody a určením, zda je návratová hodnota nulová.It is possible to test for equality by calling the String.Compare method and determining whether the return value is zero. Tento postup se ale nedoporučuje.However, this practice is not recommended. Chcete-li zjistit, zda jsou dva řetězce stejné, měli byste zavolat jedno z přetížení String.Equals metody.To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. Preferované přetížení pro volání je buď metoda instance Equals(String, StringComparison) , nebo statická Equals(String, String, StringComparison) metoda, System.StringComparison protože obě metody obsahují parametr, který explicitně určuje typ porovnání.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.

Následující příklad znázorňuje nebezpečí provádění porovnání zohledňující jazykovou verzi při rovnosti, pokud by měla být místo toho použita ordinální číslo One.The following example illustrates the danger of performing a culture-sensitive comparison for equality when an ordinal one should be used instead. V tomto případě záměrem kódu je zakázat přístup k systému souborů z adres URL, které začínají na "FILE://" nebo "file://", a to tak, že se na začátku adresy URL nerozlišuje velká a malá písmena, s řetězcem "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://". Nicméně pokud je porovnání zohledňující jazykovou verzi provedeno pomocí turecké jazykové verze (Turecko) na adrese URL, která začíná řetězcem "file://", porovnání rovnosti se nepodaří, protože turecká Velká ekvivalenta malých písmen "i" je "i" místo "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". V důsledku toho je přístup k systému souborů neúmyslně povolen.As a result, file system access is inadvertently permitted. Na druhé straně, pokud je prováděno ordinální porovnávání, je porovnání rovnosti úspěšné a přístup k systému souborů byl odepřen.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.

NormalizaceNormalization

Některé znaky Unicode mají více reprezentace.Some Unicode characters have multiple representations. Například kterýkoli z následujících bodů kódu může představovat písmeno "ắ":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

Více reprezentace pro jeden znak ztěžuje hledání, řazení, spárování a další řetězcové operace.Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

Standard Unicode definuje proces s názvem normalizace, který vrací jednu binární reprezentaci znaku Unicode pro jakékoli ekvivalentní binární reprezentace.The Unicode standard defines a process called normalization that returns one binary representation of a Unicode character for any of its equivalent binary representations. Normalizace může použít několik algoritmů nazývaných formy normalizace, které následují různá pravidla.Normalization can use several algorithms, called normalization forms, that follow different rules. Rozhraní .NET podporuje formy normalizace Unicode C, D, KC a KD..NET supports Unicode normalization forms C, D, KC, and KD. Když jsou řetězce normalizovány na stejnou formu normalizace, lze je porovnat pomocí ordinálního porovnání.When strings have been normalized to the same normalization form, they can be compared by using ordinal comparison.

Ordinální porovnávání je binární porovnání skalární hodnoty Unicode odpovídajících Char objektů v každém řetězci.An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. String Třída obsahuje několik metod, které mohou provádět ordinální porovnávání, včetně následujících:The String class includes a number of methods that can perform an ordinal comparison, including the following:

Můžete určit, zda je řetězec normalizován na formu normalizace C voláním String.IsNormalized() metody, nebo můžete String.IsNormalized(NormalizationForm) zavolat metodu, abyste zjistili, zda je řetězec normalizován na zadaný normalizační tvar.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. Můžete také zavolat String.Normalize() metodu pro převod řetězce na formu normalizace C, nebo můžete String.Normalize(NormalizationForm) zavolat metodu pro převod řetězce na zadaný normalizační tvar.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. Podrobné informace o normalizaci a porovnávání řetězců naleznete v tématu Normalize() metody a. Normalize(NormalizationForm)For step-by-step information about normalizing and comparing strings, see the Normalize() and Normalize(NormalizationForm) methods.

Následující jednoduchý příklad znázorňuje normalizaci řetězců.The following simple example illustrates string normalization. Definuje písmeno "ố" ve třech různých způsobech ve třech různých řetězcích a používá ordinální porovnávání pro rovnost k určení, že se každý řetězec liší od ostatních dvou řetězců.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. Pak převede každý řetězec na podporované formy normalizace a znovu provede ordinální porovnávání každého řetězce v zadaném formuláři normalizace.It then converts each string to the supported normalization forms, and again performs an ordinal comparison of each string in a specified normalization form. V každém případě druhý test rovnosti ukazuje, že jsou řetězce stejné.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

Další informace o normalizaci a normalizačních formulářích naleznete v části System.Text.NormalizationForma v příloze Standard Unicode #15: Formy normalizace Unicode a Nejčastější dotazy týkající se normalizace na webu 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.

Operace s řetězci podle kategorieString operations by category

String Třída poskytuje členy pro porovnávání řetězců, testování řetězců pro rovnost, hledání znaků nebo podřetězců v řetězci, úpravu řetězce, extrakci podřetězců z řetězce, kombinování řetězců, formátování hodnot, kopírování řetězce a normalizace řetězce.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.

Porovnávání řetězcůComparing strings

Můžete porovnat řetězce a určit jejich relativní pozici v pořadí řazení pomocí následujících String metod:You can compare strings to determine their relative position in the sort order by using the following String methods:

  • CompareVrátí celé číslo, které označuje vztah jednoho řetězce k druhému řetězci v pořadí řazení.Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinalVrátí celé číslo, které označuje vztah jednoho řetězce k druhému řetězci na základě porovnání jejich kódových bodů.CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareTovrací celé číslo, které určuje vztah aktuální instance řetězce k druhému řetězci v pořadí řazení.CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. Metoda poskytuje implementaceIComparable<T> aproString třídu. IComparable CompareTo(String)The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

Testování rovnosti řetězcůTesting strings for equality

Voláním Equals metody určíte, zda jsou dva řetězce stejné.You call the Equals method to determine whether two strings are equal. Instance Equals(String, String, StringComparison) a statická Equals(String, StringComparison) přetížení umožňují určit, zda je porovnávání závislé na jazykové verzi nebo pořadové číslo a zda je případ považován za považovat za nebo ignorován.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. Většina testů rovnosti je ordinální a porovnání rovnosti, které určuje přístup k systémovému zdroji (například objekt systému souborů), by mělo být vždy ordinální.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.

Vyhledávání znaků v řetězciFinding characters in a string

String Třída obsahuje dva druhy vyhledávacích metod:The String class includes two kinds of search methods:

Varování

Pokud chcete vyhledat řetězec pro konkrétní vzor, nikoli konkrétní podřetězec, měli byste použít regulární výrazy.If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. Další informace najdete v tématu regulární výrazy .NET.For more information, see .NET Regular Expressions.

Úprava řetězceModifying a string

String Třída obsahuje následující metody, které se zobrazí pro úpravu hodnoty řetězce:The String class includes the following methods that appear to modify the value of a string:

  • InsertVloží řetězec do aktuální String instance.Insert inserts a string into the current String instance.

  • PadLeftVloží jeden nebo více výskytů zadaného znaku na začátek řetězce.PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRightVloží jeden nebo více výskytů zadaného znaku na konci řetězce.PadRight inserts one or more occurrences of a specified character at the end of a string.

  • Removeodstraní podřetězec z aktuální String instance.Remove deletes a substring from the current String instance.

  • ReplaceNahradí podřetězec jiným podřetězcem v aktuální String instanci.Replace replaces a substring with another substring in the current String instance.

  • ToLowera ToLowerInvariant převeďte všechny znaky v řetězci na malá písmena.ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUppera ToUpperInvariant převeďte všechny znaky v řetězci na velká písmena.ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • TrimOdebere všechny výskyty znaku ze začátku a konce řetězce.Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEndOdebere všechny výskyty znaku z konce řetězce.TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStartOdebere všechny výskyty znaku ze začátku řetězce.TrimStart removes all occurrences of a character from the beginning of a string.

Důležité

Všechny metody změny řetězce vrací nový String objekt.All string modification methods return a new String object. Nemění hodnotu aktuální instance.They don't modify the value of the current instance.

Extrahování podřetězců z řetězceExtracting substrings from a string

String.Split Metoda odděluje jeden řetězec do více řetězců.The String.Split method separates a single string into multiple strings. Přetížení metody umožňují zadat více oddělovačů k určení maximálního počtu podřetězců, které metoda extrahuje, a k určení, zda jsou prázdné řetězce (které se vyskytují v případě sousedících oddělovačů) zahrnuty mezi vracené řetězce.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.

Kombinování řetězcůCombining strings

Pro zřetězení řetězců lze použít následující String metody:The following String methods can be used for string concatenation:

  • Concatkombinuje jeden nebo více podřetězců do jednoho řetězce.Concat combines one or more substrings into a single string.

  • JoinZřetězí jeden nebo více podřetězců do jednoho prvku a přidá oddělovač mezi každým podřetězcem.Join concatenates one or more substrings into a single element and adds a separator between each substring.

Formátování hodnotFormatting values

String.Format Metoda používá funkci složeného formátování k nahrazení jednoho nebo více zástupných symbolů v řetězci s řetězcovou reprezentací některého objektu nebo hodnoty.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 se často používá k následujícím akcím:The Format method is often used to do the following:

  • Pro vložení řetězcové reprezentace číselné hodnoty do řetězce.To embed the string representation of a numeric value in a string.

  • Pro vložení řetězcové reprezentace hodnoty data a času v řetězci.To embed the string representation of a date and time value in a string.

  • Pro vložení řetězcové reprezentace hodnoty výčtu do řetězce.To embed the string representation of an enumeration value in a string.

  • Pro vložení řetězcové reprezentace nějakého objektu, který podporuje IFormattable rozhraní v řetězci.To embed the string representation of some object that supports the IFormattable interface in a string.

  • K pravému nebo levému bloku v poli v rámci většího řetězce.To right-justify or left-justify a substring in a field within a larger string.

Podrobné informace o operacích formátování a příkladech naleznete v Format souhrnu přetížení.For detailed information about formatting operations and examples, see the Format overload summary.

Kopírování řetězceCopying a string

Můžete zavolat následující String metody pro vytvoření kopie řetězce:You can call the following String methods to make a copy of a string:

  • CloneVrátí odkaz na existující String objekt.Clone returns a reference to an existing String object.

  • CopyVytvoří kopii existujícího řetězce.Copy creates a copy of an existing string.

  • CopyTozkopíruje část řetězce do pole znaků.CopyTo copies a portion of a string to a character array.

Normalizace řetězceNormalizing a string

V kódování Unicode může mít jeden znak více kódových bodů.In Unicode, a single character can have multiple code points. Normalizace převede tyto ekvivalentní znaky do stejné binární reprezentace.Normalization converts these equivalent characters into the same binary representation. Metoda provádí normalizaci String.IsNormalized a metoda určuje, zda je řetězec normalizován. String.NormalizeThe String.Normalize method performs the normalization, and the String.IsNormalized method determines whether a string is normalized.

Další informace a příklad najdete v části normalizace výše v tomto tématu.For more information and an example, see the Normalization section earlier in this topic.

Konstruktory

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

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole znaků 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)

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole znaků Unicode, počáteční pozici znaku v tomto poli a délku.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)

Inicializuje novou instanci String třídy na hodnotu určenou zadaným znakem Unicode a opakuje zadaný počet opakování.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[])

Inicializuje novou instanci String třídy na hodnotu určenou polem znaků 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)

Inicializuje novou instanci String třídy na hodnotu určenou polem znaků Unicode, počáteční polohou znaku v tomto poli a délkou.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*)

Inicializuje novou instanci String třídy na hodnotu určenou ukazatelem na pole 8bitových celých čísel se znaménkem.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)

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole 8bitové celé číslo se znaménkem, počáteční pozice v tomto poli a délku.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)

Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole 8bitových celých čísel se znaménkem, počáteční pozice v tomto poli, délka Encoding a objekt.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.

Pole

Empty Empty Empty Empty

Představuje prázdný řetězec.Represents the empty string. Toto pole je jen pro čtení.This field is read-only.

Vlastnosti

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

Získá objekt na zadané pozici v aktuálním String objektu. CharGets the Char object at a specified position in the current String object.

Length Length Length Length

Získá počet znaků v aktuálním String objektu.Gets the number of characters in the current String object.

Metody

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

Vrátí odkaz na tuto instanci 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)

Porovná podřetězce dvou zadaných String objektů a vrátí celé číslo, které určuje jejich relativní pozici v pořadí řazení.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)

Porovná podřetězce dvou zadaných String objektů, ignoruje nebo dodržuje jejich případ a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.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)

Porovná podřetězce dvou zadaných String objektů, ignoruje nebo dodržuje jejich případ a používá informace specifické pro jazykovou verzi pro ovlivnění porovnání a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.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)

Porovná podřetězce dvou zadaných String objektů pomocí zadaných možností porovnání a informací specifických pro jazykovou verzi pro ovlivnění porovnání a vrátí celé číslo, které určuje vztah mezi dvěma podřetězci na sebe navzájem v pořadí řazení.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)

Porovná podřetězce dvou zadaných String objektů pomocí zadaných pravidel a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.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)

Porovná dva String zadané objekty a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.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)

Porovná dva String zadané objekty, ignoruje nebo dodržuje jejich případ a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.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)

Porovná dva String zadané objekty, ignoruje nebo dodržuje jejich případ a používá informace specifické pro jazykovou verzi pro ovlivnění porovnání a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.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)

Porovná dva String zadané objekty pomocí zadaných možností porovnání a informací specifických pro jazykovou verzi pro ovlivnění porovnání a vrátí celé číslo, které určuje vztah mezi dvěma řetězci v pořadí řazení.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)

Porovná dva String zadané objekty pomocí zadaných pravidel a vrátí celé číslo, které určuje jejich relativní pozici v pořadí řazení.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)

Porovná podřetězce dvou zadaných String objektů vyhodnocením číselných hodnot odpovídajících Char objektů v každém podřetězci.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)

Porovná dva String zadané objekty vyhodnocením číselných hodnot odpovídajících Char objektů v každém řetězci.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)

Porovná tuto instanci se zadaným Object a indikuje, jestli tato instance předchází, následuje nebo se zobrazuje ve stejné pozici v pořadí řazení jako zadaná. ObjectCompares 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)

Porovná tuto instanci se zadaným String objektem a určí, zda tato instance předchází, následuje nebo se zobrazí ve stejné pozici v pořadí řazení jako zadaný řetězec.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>)

Zřetězí členy konstruované IEnumerable<T> kolekce typu String.Concatenates the members of a constructed IEnumerable<T> collection of type String.

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

Vytvoří řetězcovou reprezentaci zadaného objektu.Creates the string representation of a specified object.

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

Zřetězí řetězcové reprezentace dvou zadaných objektů.Concatenates the string representations of two specified objects.

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

Zřetězí řetězcové reprezentace tří zadaných objektů.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)

Zřetězí řetězcové reprezentace čtyř zadaných objektů a všech objektů zadaných v seznamu parametrů volitelné proměnné délky.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[])

Zřetězí řetězcové reprezentace prvků v zadaném Object poli.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>)

Zřetězí řetězcové reprezentace dvou určených znaků jen pro čtení.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>)

Zřetězí řetězcové reprezentace tří zadaných znaků jen pro čtení.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>)

Zřetězí řetězcové reprezentace čtyř zadaných znaků jen pro čtení.Concatenates the string representations of four specified read-only character spans.

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

Zřetězí dvě zadané instance String.Concatenates two specified instances of String.

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

Zřetězí tři zadané instance 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)

Zřetězí čtyři zadané instance String.Concatenates four specified instances of String.

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

Zřetězí prvky zadaného String pole.Concatenates the elements of a specified String array.

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

Zřetězí členy IEnumerable<T> implementace.Concatenates the members of an IEnumerable<T> implementation.

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

Vrátí hodnotu, která označuje, zda se v rámci tohoto řetězce vyskytuje zadaný znak.Returns a value indicating whether a specified character occurs within this string.

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

Vrací hodnotu určující, zda se v rámci tohoto řetězce vyskytne zadaný znak, a to pomocí zadaných pravidel porovnání.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)

Vrací hodnotu určující, zda se v rámci tohoto řetězce vyskytuje zadaný podřetězec.Returns a value indicating whether a specified substring occurs within this string.

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

Vrací hodnotu určující, zda se v rámci tohoto řetězce vyskytne zadaný řetězec, pomocí zadaných pravidel porovnání.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)

Vytvoří novou instanci String se stejnou hodnotou jako zadaná 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)

Zkopíruje zadaný počet znaků ze zadané pozice v této instanci na zadanou pozici v poli znaků 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)

Určuje, zda konec této instance řetězce odpovídá zadanému řetězci.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)

Určuje, zda konec této instance řetězce odpovídá zadanému řetězci při porovnání pomocí zadané jazykové verze.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)

Určuje, zda konec této instance řetězce odpovídá zadanému řetězci při porovnání pomocí zadané možnosti porovnání.Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.

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

Vrátí výčet Rune z tohoto řetězce.Returns an enumeration of Rune from this string.

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

Určuje, zda tato instance a zadaný objekt, který musí být String také objekt, mají stejnou hodnotu.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)

Určuje, zda má tato instance a String jiný zadaný objekt stejnou hodnotu.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)

Určuje, zda dva String zadané objekty mají stejnou hodnotu.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)

Určuje, zda dva String zadané objekty mají stejnou hodnotu.Determines whether two specified String objects have the same value. Parametr určuje pravidla jazykové verze, velikosti písmen a řazení použitá v porovnání.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)

Určuje, zda má tento řetězec a String zadaný objekt stejnou hodnotu.Determines whether this string and a specified String object have the same value. Parametr určuje pravidla jazykové verze, velikosti písmen a řazení použitá v porovnání.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)

Nahradí položku formátu nebo položky v zadaném řetězci řetězcovou reprezentací odpovídajícího objektu.Replaces the format item or items in a specified string with the string representation of the corresponding object. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.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)

Nahradí položky formátu v řetězci řetězcovou reprezentací dvou zadaných objektů.Replaces the format items in a string with the string representation of two specified objects. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.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)

Nahradí položky formátu v řetězci řetězcovou reprezentací tří zadaných objektů.Replaces the format items in a string with the string representation of three specified objects. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.An parameter supplies culture-specific formatting information.

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

Nahradí položky formátu v řetězci řetězcovými reprezentacemi odpovídajících objektů v zadaném poli.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.A parameter supplies culture-specific formatting information.

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

Nahradí jednu nebo více položek formátu v řetězci řetězcovou reprezentací zadaného objektu.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)

Nahradí položky formátu v řetězci řetězcovou reprezentací dvou zadaných objektů.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)

Nahradí položky formátu v řetězci řetězcovou reprezentací tří zadaných objektů.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[])

Nahradí položku formátu v zadaném řetězci řetězcovou reprezentací odpovídajícího objektu v zadaném poli.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

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

Načte objekt, který může iterovat přes jednotlivé znaky v tomto řetězci.Retrieves an object that can iterate through the individual characters in this string.

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

Vrátí hashový kód pro tento řetězec.Returns the hash code for this string.

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

Vrátí hodnotu hash pro zadaný rozsah znaků jen pro čtení.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)

Vrátí hodnotu hash pro zadaný rozsah znaků jen pro čtení pomocí zadaných pravidel.Returns the hash code for the provided read-only character span using the specified rules.

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

Vrátí hashový kód pro tento řetězec pomocí zadaných pravidel.Returns the hash code for this string using the specified rules.

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

Vrátí odkaz na prvek řetězce na indexu nula.Returns a reference to the element of the string at index zero.

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

Type Získá aktuální instanci.Gets the Type of the current instance.

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

Vrátí třídu TypeCode Stringfor.Returns the TypeCode for class String.

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

Sestaví index založený na nule prvního výskytu zadaného znaku Unicode v tomto řetězci.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)

Sestaví index založený na nule prvního výskytu zadaného znaku Unicode v tomto řetězci.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. Hledání začíná na zadané pozici 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)

Oznamuje index založený na nule prvního výskytu zadaného znaku v této instanci.Reports the zero-based index of the first occurrence of the specified character in this instance. Hledání začíná na zadané pozici znaku a prověřuje zadaný počet pozic znaků.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)

Sestaví index založený na nule prvního výskytu zadaného znaku Unicode v tomto řetězci.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. Parametr určuje typ hledání, které se má použít pro zadaný znak.A parameter specifies the type of search to use for the specified character.

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

Vypíše index založený na nule prvního výskytu zadaného řetězce v této instanci.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)

Vypíše index založený na nule prvního výskytu zadaného řetězce v této instanci.Reports the zero-based index of the first occurrence of the specified string in this instance. Hledání začíná na zadané pozici 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)

Vypíše index založený na nule prvního výskytu zadaného řetězce v této instanci.Reports the zero-based index of the first occurrence of the specified string in this instance. Hledání začíná na zadané pozici znaku a prověřuje zadaný počet pozic znaků.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)

Sestaví index založený na nule prvního výskytu zadaného řetězce v aktuálním String objektu.Reports the zero-based index of the first occurrence of the specified string in the current String object. Parametry určují počáteční pozici hledání v aktuálním řetězci, počet znaků v aktuálním řetězci, který se má hledat, a typ hledání, které se má použít pro zadaný řetězec.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)

Sestaví index založený na nule prvního výskytu zadaného řetězce v aktuálním String objektu.Reports the zero-based index of the first occurrence of the specified string in the current String object. Parametry určují počáteční pozici hledání v aktuálním řetězci a typ hledání, které se má použít pro zadaný řetězec.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)

Sestaví index založený na nule prvního výskytu zadaného řetězce v aktuálním String objektu.Reports the zero-based index of the first occurrence of the specified string in the current String object. Parametr určuje typ hledání, které se má použít pro zadaný řetězec.A parameter specifies the type of search to use for the specified string.

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

Sestaví index založený na nule prvního výskytu v této instanci libovolného znaku v zadaném poli znaků 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)

Sestaví index založený na nule prvního výskytu v této instanci libovolného znaku v zadaném poli znaků Unicode.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. Hledání začíná na zadané pozici 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)

Sestaví index založený na nule prvního výskytu v této instanci libovolného znaku v zadaném poli znaků Unicode.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. Hledání začíná na zadané pozici znaku a prověřuje zadaný počet pozic znaků.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)

Vrátí nový řetězec, ve kterém je zadaný řetězec vložen do zadané pozice indexu v této instanci.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)

Načte odkaz systému na zadaný String.Retrieves the system's reference to the specified String.

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

Načte odkaz na zadaný String.Retrieves a reference to a specified String.

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

Určuje, zda je tento řetězec ve formátu normalizace Unicode C.Indicates whether this string is in Unicode normalization form C.

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

Určuje, zda je tento řetězec v zadaném formuláři normalizace kódování Unicode.Indicates whether this string is in the specified Unicode normalization form.

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

Označuje, zda je null zadaný řetězec nebo prázdný řetězec ("").Indicates whether the specified string is null or an empty string ("").

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

Označuje, zda je nullzadaný řetězec, prázdný nebo se skládá pouze z prázdných znaků.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>)

Zřetězí členy konstruované IEnumerable<T> kolekce typu Stringpomocí zadaného oddělovače mezi každým členem.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[])

Zřetězí prvky pole objektu pomocí zadaného oddělovače mezi jednotlivými prvky.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[])

Zřetězí všechny prvky pole řetězců pomocí zadaného oddělovače mezi jednotlivými prvky.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)

Zřetězí zadané prvky pole řetězců pomocí zadaného oddělovače mezi jednotlivými prvky.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>)

Zřetězí členy kolekce pomocí zadaného oddělovače mezi každým členem.Concatenates the members of a collection, using the specified separator between each member.

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

Oznamuje pozici indexu na základě nuly posledního výskytu zadaného znaku Unicode v rámci této instance.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)

Oznamuje pozici indexu na základě nuly posledního výskytu zadaného znaku Unicode v rámci této instance.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. Hledání začne na určené pozici znaku a postupuje zpět na začátek řetězce.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)

Oznamuje pozici indexu na základě nuly posledního výskytu zadaného znaku Unicode v podřetězci v rámci této instance.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce pro zadaný počet pozic znaků.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)

Oznámí index (počítaný od nuly) posledního výskytu určeného řetězce v této instanci.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)

Oznámí index (počítaný od nuly) posledního výskytu určeného řetězce v této instanci.Reports the zero-based index position of the last occurrence of a specified string within this instance. Hledání začne na určené pozici znaku a postupuje zpět na začátek řetězce.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)

Oznámí index (počítaný od nuly) posledního výskytu určeného řetězce v této instanci.Reports the zero-based index position of the last occurrence of a specified string within this instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce pro zadaný počet pozic znaků.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)

Oznámí index (počítaný od nuly) posledního výskytu určeného řetězce v této instanci.Reports the zero-based index position of the last occurrence of a specified string within this instance. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce pro zadaný počet pozic znaků.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 určuje typ porovnání, které má být provedeno při hledání zadaného řetězce.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)

Oznamuje index založený na nule posledního výskytu zadaného řetězce v rámci aktuálního String objektu.Reports the zero-based index of the last occurrence of a specified string within the current String object. Hledání začne na určené pozici znaku a postupuje zpět na začátek řetězce.The search starts at a specified character position and proceeds backward toward the beginning of the string. Parametr určuje typ porovnání, které má být provedeno při hledání zadaného řetězce.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)

Oznamuje index založený na nule posledního výskytu zadaného řetězce v rámci aktuálního String objektu.Reports the zero-based index of the last occurrence of a specified string within the current String object. Parametr určuje typ hledání, které se má použít pro zadaný řetězec.A parameter specifies the type of search to use for the specified string.

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

Oznámí index (počítaný od nuly) posledního výskytu této instance jednoho nebo více znaků určených v poli 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)

Oznámí index (počítaný od nuly) posledního výskytu této instance jednoho nebo více znaků určených v poli Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. Hledání začne na určené pozici znaku a postupuje zpět na začátek řetězce.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)

Oznámí index (počítaný od nuly) posledního výskytu této instance jednoho nebo více znaků určených v poli Unicode.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. Hledání začíná na zadané pozici znaku a pokračuje zpět směrem k začátku řetězce pro zadaný počet pozic znaků.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()

Vytvoří kopii aktuálního Objectseznamu.Creates a shallow copy of the current Object.

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

Vrátí nový řetězec, jehož textová hodnota je shodná s tímto řetězcem, ale jeho binární reprezentace je ve formátu normalizace 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)

Vrátí nový řetězec, jehož textová hodnota je shodná s tímto řetězcem, ale jeho binární reprezentace je v zadaném formátu normalizace 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)

Vrátí nový řetězec, který vpravo zarovná znaky v této instanci jejich vyplněním mezerami na levé straně pro zadanou celkovou délku.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)

Vrátí nový řetězec, který vpravo zarovná znaky v této instanci jejich vyplněním na levé straně se zadaným znakem Unicode pro zadanou celkovou délku.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)

Vrátí nový řetězec, který vlevo zarovná znaky v tomto řetězci jejich vyplněním mezerami na pravé straně pro zadanou celkovou délku.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)

Vrátí nový řetězec, který zarovná znaky v tomto řetězci jejich vyplněním na pravé straně se zadaným znakem Unicode pro zadanou celkovou délku.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)

Vrátí nový řetězec, ve kterém jsou odstraněny všechny znaky v aktuální instanci počínaje zadanou pozicí a pokračováním v poslední pozici.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)

Vrátí nový řetězec, ve kterém byl odstraněn zadaný počet znaků v aktuální instanci začínající na zadané pozici.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)

Vrátí nový řetězec, ve kterém jsou všechny výskyty zadaného znaku Unicode v této instanci nahrazeny jiným zadaným znakem 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)

Vrátí nový řetězec, ve kterém jsou všechny výskyty zadaného řetězce v aktuální instanci nahrazeny jiným zadaným řetězcem.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[])

Rozdělí řetězec na podřetězce, které jsou založeny na znacích v poli.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)

Rozdělí řetězec na maximální počet podřetězců na základě znaků v poli.Splits a string into a maximum number of substrings based on the characters in an array. Zadejte také maximální počet podřetězců, které se mají vrátit.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)

Rozdělí řetězec na maximální počet podřetězců na základě znaků v poli.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)

Rozdělí řetězec na podřetězce na základě znaků v poli.Splits a string into substrings based on the characters in an array. Můžete určit, zda podřetězce obsahují prázdné prvky pole.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)

Rozdělí řetězec na maximální počet podřetězců na základě řetězců v poli.Splits a string into a maximum number of substrings based on the strings in an array. Můžete určit, zda podřetězce obsahují prázdné prvky pole.You can specify whether the substrings include empty array elements.

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

Rozdělí řetězec na podřetězce na základě řetězců v poli.Splits a string into substrings based on the strings in an array. Můžete určit, zda podřetězce obsahují prázdné prvky pole.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)

Určuje, zda začátek této instance řetězce odpovídá zadanému řetězci.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)

Určuje, zda začátek této instance řetězce odpovídá zadanému řetězci při porovnání s použitím zadané jazykové verze.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)

Určuje, zda začátek této instance řetězce odpovídá zadanému řetězci při porovnání pomocí zadané možnosti porovnání.Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.

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

Načte podřetězec z této instance.Retrieves a substring from this instance. Podřetězec začíná na zadané pozici znaku a pokračuje na konec řetězce.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)

Načte podřetězec z této instance.Retrieves a substring from this instance. Podřetězec začíná na zadané pozici znaku a má zadanou délku.The substring starts at a specified character position and has a specified length.

ToCharArray() ToCharArray() ToCharArray() ToCharArray()

Zkopíruje znaky v této instanci do pole znaků Unicode.Copies the characters in this instance to a Unicode character array.

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

Zkopíruje znaky v zadaném podřetězci v této instanci do pole znaků Unicode.Copies the characters in a specified substring in this instance to a Unicode character array.

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

Vrátí kopii tohoto řetězce převedenou na malá písmena.Returns a copy of this string converted to lowercase.

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

Vrátí kopii tohoto řetězce převedenou na malá písmena pomocí pravidel pro velká a malá písmena zadané jazykové verze.Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.

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

Vrátí kopii tohoto String objektu převedenou na malá písmena pomocí pravidel malých a velkých písmen v neutrální jazykové verzi.Returns a copy of this String object converted to lowercase using the casing rules of the invariant culture.

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

Vrátí tuto instanci String. není proveden žádný skutečný převod.Returns this instance of String; no actual conversion is performed.

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

Vrátí tuto instanci String. není proveden žádný skutečný převod.Returns this instance of String; no actual conversion is performed.

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

Vrátí kopii tohoto řetězce převedenou na velká písmena.Returns a copy of this string converted to uppercase.

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

Vrátí kopii tohoto řetězce převedenou na velká písmena pomocí pravidel pro velká a malá písmena zadané jazykové verze.Returns a copy of this string converted to uppercase, using the casing rules of the specified culture.

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

Vrátí kopii tohoto String objektu převedenou na velká písmena pomocí pravidel malých a velkých písmen v neutrální jazykové verzi.Returns a copy of this String object converted to uppercase using the casing rules of the invariant culture.

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

Odebere všechny úvodní a koncové prázdné znaky z aktuálního String objektu.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[])

Odebere všechny úvodní a koncové výskyty sady znaků zadané v poli z aktuálního String objektu.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[])

Odebere všechny koncové výskyty sady znaků zadané v poli z aktuálního String objektu.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[])

Odebere všechny úvodní výskyty sady znaků zadané v poli z aktuálního String objektu.Removes all leading occurrences of a set of characters specified in an array from the current String object.

Operátory

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

Určuje, zda dva zadané řetězce mají stejnou hodnotu.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)

Určuje, zda dva zadané řetězce mají jiné hodnoty.Determines whether two specified strings have different values.

Explicitní implementace rozhraní

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)

Popis tohoto člena naleznete v tématu ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToChar(IFormatProvider).For a description of this member, see ToChar(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToDateTime(IFormatProvider).For a description of this member, see ToDateTime(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToSingle(IFormatProvider).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)

Popis tohoto člena naleznete v tématu ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

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

Popis tohoto člena naleznete v tématu ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

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

Vrátí enumerátor, který prochází aktuálním String objektem.Returns an enumerator that iterates through the current String object.

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

Vrátí enumerátor, který prochází aktuálním String objektem.Returns an enumerator that iterates through the current String object.

Metody rozšíření

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

IEnumerable<T> DataRow T Vrátí, který obsahuje kopie DataRow objektů, a to tak, že předané vstupní objekt, kde je obecný parametr. 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)

Zkopíruje DataRow objekty do zadaného DataTables předaným vstupním IEnumerable<T> objektem, kde T je DataRowobecný parametr.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)

Zkopíruje DataRow objekty do zadaného DataTables předaným vstupním IEnumerable<T> objektem, kde T je DataRowobecný parametr.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)

Přetypování prvky IEnumerable na zadaný typ.Casts the elements of an IEnumerable to the specified type.

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

Filtruje prvky IEnumerable založené na zadaném typu.Filters the elements of an IEnumerable based on a specified type.

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

Povoluje paralelní zpracování dotazu.Enables parallelization of a query.

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

IEnumerable PřevedeIQueryablena.Converts an IEnumerable to an IQueryable.

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

Vytvoří novou ReadOnlyMemory<Char> část cílového řetězce.Creates a new ReadOnlyMemory<Char> over the portion of the target string.

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

Vytvoří novou ReadOnlyMemory<Char> část cílového řetězce počínaje zadaným indexem.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)

Vytvoří novou ReadOnlyMemory<Char> část cílového řetězce, která začíná na zadané pozici 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)

Vytvoří novou ReadOnlyMemory<Char> část cílového řetězce, který začíná na zadané pozici s délkou.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)

Vytvoří nový ReadOnlyMemory<Char> přes zadaný rozsah cílového řetězce.Creates a new ReadOnlyMemory<Char> over a specified range of the target string.

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

Vytvoří nový rozsah, který je jen pro čtení, nad část cílového řetězce ze zadané pozice pro zadaný počet znaků.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)

Vytvoří nový rozsah, který je jen pro čtení, v rámci části cílového řetězce ze zadané pozice na konec řetězce.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)

Vytvoří nový rozsah, který je jen pro čtení, přes řetězec.Creates a new read-only span over a string.

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

Určuje, zda je zadaný řetězec ve formátu normalizace Unicode C.Indicates whether the specified string is in Unicode normalization form C.

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

Označuje, zda je řetězec v zadaném formuláři normalizace kódování Unicode.Indicates whether a string is in a specified Unicode normalization form.

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

Normalizuje řetězec na formu normalizace Unicode C.Normalizes a string to a Unicode normalization form C.

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

Normalizuje řetězec na zadaný formát normalizace 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>)

Vrátí kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.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)

Vrátí filtrovanou kolekci prvků, které obsahují předchůdce všech uzlů ve zdrojové kolekci.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Do kolekce jsou zahrnuty pouze prvky XName , které mají odpovídající spárování.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>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.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>)

Vrátí kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.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)

Vrátí filtrovanou kolekci prvků, které obsahují následníky každého prvku a dokumentu ve zdrojové kolekci.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Do kolekce jsou zahrnuty pouze prvky XName , které mají odpovídající spárování.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>)

Vrátí kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci.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)

Vrátí filtrovanou kolekci podřízených prvků každého elementu a dokumentu ve zdrojové kolekci.Returns a filtered collection of the child elements of every element and document in the source collection. Do kolekce jsou zahrnuty pouze prvky XName , které mají odpovídající spárování.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>)

Vrátí kolekci uzlů, které obsahují všechny uzly ve zdrojové kolekci seřazené v pořadí dokumentů.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>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.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>)

Odebere všechny uzly ve zdrojové kolekci z nadřazeného uzlu.Removes every node in the source collection from its parent node.

Platí pro

Bezpečný přístup z více vláken

Tento typ je bezpečný pro přístup z více vláken.This type is thread safe.

Viz také