String Třída

Definice

Představuje text jako sekvenci jednotek kódu UTF-16.

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

Poznámky

Řetězec je sekvenční kolekce znaků, které se používají k vyjádření textu. Objekt String je sekvenční kolekce objektů, které představují řetězec; objekt odpovídá jednotce kódu System.Char System.Char UTF-16. Hodnota objektu je obsah sekvenční kolekce objektů a tato hodnota je neměnná (to znamená, že je jen String System.Char pro čtení). Další informace o neměnnosti řetězců najdete v části Neměnnost a třída StringBuilder. Maximální velikost objektu v String paměti je 2 GB nebo přibližně 1 miliarda znaků.

Další informace o kódování Unicode, UTF-16, jednotkách kódu, bodech kódu a typech a najdete v Char tématu Úvod do kódování znaků v rozhraní Rune .NET.

V této části:

Vytvoření instance objektu String
Objekty znaků a znaky Unicode
Řetězce a standard Unicode
Řetězce a vložené znaky null
Řetězce a indexy
Řetězce s hodnotou null a prázdné řetězce
Neměnnost a třída StringBuilder
Řadové vs. operace citlivé na jazykovou verzi
Normalizace
Operace s řetězci podle kategorie

Vytvoření instance objektu String

Instanci objektu můžete String vytvořit následujícími způsoby:

  • Přiřazením řetězcového literálu String proměnné. Toto je nejčastěji používaná metoda pro vytvoření řetězce. Následující příklad používá přiřazení k vytvoření několika řetězců. Všimněte si, že v jazyce C#, protože zpětné lomítko ( ) je řídicí znak, musí být zpětná lomítka literálů v řetězci uvozena nebo celý \ řetězec musí být @-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. Následující příklad vytvoří instanci řetězců voláním několika konstruktorů třídy. Všimněte si, že některé konstruktory zahrnují ukazatele na pole znaků nebo pole bajtů se znaménkem jako parametry. Visual Basic nepodporuje volání těchto konstruktorů. Podrobné informace o String konstruktorech najdete v String souhrnu konstruktoru.

    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ězců (+ v jazyce C# a & nebo + v Visual Basic) vytvořte jeden řetězec z jakékoli kombinace instancí a řetězcových String literálů. Následující příklad znázorňuje použití operátoru zřetězení řetězců.

    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. Následující příklad používá metody třídy String k extrakci podřetězce z většího řetězce.

    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í převedete hodnotu nebo objekt na řetězcové vyjádření. Následující příklad používá funkci složeného formátování k vložení řetězcové reprezentace dvou objektů do řetězce.

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

Každý znak v řetězci je definován skalární hodnotou Unicode, která se také nazývá bod kódu Unicode nebo pořadová (číselná) hodnota znaku Unicode. 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 .

Poznámka

Všimněte si, že vzhledem k tomu, že instance se skládá ze sekvenční kolekce jednotek kódu UTF-16, je možné vytvořit objekt, který není řetězec Unicode ve String String správném formátu. Je například možné vytvořit řetězec, který má nízkou náhradní hodnotu bez odpovídající vysoké náhradní hodnoty. I když některé metody, například metody kódování a dekódování objektů v oboru názvů, mohou provádět kontroly, aby se zajistilo, že řetězce jsou ve správném formátu, členové třídy nezaují, že je řetězec ve správném System.Text String formátu.

Jeden objekt Char obvykle představuje jeden bod kódu. To znamená, že číselná hodnota se rovná bodu Char kódu. Například bod kódu pro znak "a" je U+0061. Bod kódu však může vyžadovat více než jeden zakódovaný prvek (více než jeden Char objekt). Standard Unicode definuje dva typy znaků, které odpovídají více objektům: grafemy a body kódu unicode, které odpovídají znakům v rovinách základního kódu Char Unicode.

  • Graf je reprezentován základním znakem následovaným jedním nebo více kombinující znaky. Například znak za ním je reprezentován objektem, jehož kódový bod je U+0061 následovaný objektem, jehož kódový bod je Char Char U+0308. Tento znak může být také definován jedním Char objektem, který má bod kódu U+00E4. Jak ukazuje následující příklad, porovnání rovnosti v jazykové verzi označuje, že tyto dvě reprezentace jsou si rovny, i když běžné řadové porovnání nikoli. Pokud jsou však oba řetězce normalizovány, ordinální porovnání také označuje, že jsou si rovny. (Další informace o normalizaci řetězců najdete v části Normalizace.)

    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
    
  • Bod doplňkového kódu Unicode (náhradní pár) je reprezentován objektem, jehož kódový bod je vysoká náhradníka následovaná objektem, jehož kódový bod je nízký Char Char náhradní. Jednotky kódu s vysokými náhradními daty jsou v rozsahu od U+D800 do U+DBFF. Jednotky kódu s nízkou náhradou jsou v rozsahu od U + DC00 do U + DFFF. Náhradní páry se používají k reprezentaci znaků v 16 rovinách unicode. Následující příklad vytvoří náhradní znak a předá ho metodě k určení, zda se jedná Char.IsSurrogatePair(Char, Char) o náhradní dvojici.

    using namespace System;
    
    void main()
    {
       String^ surrogate =  L"\xD800\xDC03" ;
       for (int ctr = 0; ctr < surrogate->Length; ctr++)
          Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr]));
    
       Console::WriteLine();
       Console::WriteLine("   Is Surrogate Pair: {0}", 
                          Char::IsSurrogatePair(surrogate[0], surrogate[1]));
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       U+D800 U+DC03 
    //          Is Surrogate Pair: True
    
    string surrogate = "\uD800\uDC03";
    for (int ctr = 0; ctr < surrogate.Length; ctr++) 
       Console.Write($"U+{(ushort)surrogate[ctr]:X2} ");
    
    Console.WriteLine();
    Console.WriteLine("   Is Surrogate Pair: {0}", 
                      Char.IsSurrogatePair(surrogate[0], surrogate[1]));
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    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 Unicode

Znaky v řetězci jsou reprezentovány jednotkami kódu s kódováním UTF-16, které odpovídají Char hodnotám.

Každý znak v řetězci má přidruženou kategorii znaků Unicode, která je v rozhraní .NET reprezentována UnicodeCategory výčtem. Kategorii znaku nebo náhradní dvojice lze určit voláním CharUnicodeInfo.GetUnicodeCategory metody .

.NET udržuje svou vlastní tabulku znaků a jejich odpovídající kategorie, což zajistí, že konkrétní verze implementace .NET běžící na různých platformách vrátí stejné informace o kategorii znaků. Ve všech verzích rozhraní .NET a všech platformách operačního systému jsou informace o kategoriích znaků poskytovány v rámci databáze znaků Unicode.

V následující tabulce jsou uvedeny verze rozhraní .NET a verze standardu Unicode, na kterých jsou založeny jejich kategorie znaků.

Verze .NET Verze standardu Unicode
.NET Framework 1.1 Standard Unicode, verze 4.0.0
.NET Framework 2,0 Standard Unicode, verze 5.0.0
.NET Framework 3.5 Standard Unicode, verze 5.0.0
.NET Framework 4 Standard Unicode, verze 5.0.0
.NET Framework 4.5 Standard Unicode, verze 6.3.0
.NET Framework 4.5.1 Standard Unicode, verze 6.3.0
.NET Framework 4.5.2 Standard Unicode, verze 6.3.0
.NET Framework 4.6 Standard Unicode, verze 6.3.0
.NET Framework 4.6.1 Standard Unicode, verze 6.3.0
.NET Framework 4.6.2 a novější verze Standard Unicode, verze 8.0.0
.NET Core 2.1 Standard Unicode, verze 8.0.0
.NET Core 3.1 Standard Unicode, verze 11.0.0
.NET 5 Standard Unicode, verze 13.0.0

Kromě toho .NET podporuje porovnávání a řazení řetězců na základě standardu Unicode. .NET Framework 4 a předchozí verze udržují vlastní tabulku řetězcových dat. To platí i pro verze .NET Framework počínaje verzí .NET Framework 4.5 běžící na Windows 7. Počínaje verzí .NET Framework 4.5 běžící na Windows 8 a novějších verzích operačního systému Windows modul runtime deleguje operace porovnání a řazení řetězců na operační systém. V .NET Core a .NET 5+ poskytují informace o porovnávání a řazení řetězců v knihovnách International Components for Unicode (s výjimkou verzí Windows před Aktualizace Windows 10 z května 2019). V následující tabulce jsou uvedeny verze rozhraní .NET a verze standardu Unicode, na kterých je založeno porovnání a řazení znaků.

Verze .NET Verze standardu Unicode
.NET Framework 1.1 Standard Unicode verze 4.0.0
.NET Framework 2,0 Standard Unicode verze 5.0.0
.NET Framework 3.5 Standard Unicode verze 5.0.0
.NET Framework 4 Standard Unicode verze 5.0.0
.NET Framework 4.5 a novější Windows 7 Standard Unicode verze 5.0.0
.NET Framework 4.5 a novější Windows 8 a Windows operačních systémů Standard Unicode verze 6.3.0
.NET Core a .NET 5+ Závisí na verzi standardu Unicode podporovaném základním operačním systémem.

Řetězce a vložené znaky null

V .NET může objekt obsahovat vložené znaky null, které se počítají jako součást String délky řetězce. V některých jazycích, jako je C a C++, ale znak null označuje konec řetězce. není považován za součást řetězce a nezapočítává se jako součást délky řetězce. To znamená, že následující běžné předpoklady, které programátoři nebo knihovny C++ napsané v jazyce C nebo C++ mohou o řetězcích vytvořit, nemusí být při použití na objekty nutně String platné:

  • Hodnota vrácená strlen funkcemi nebo wcslen se nutně nerovná String.Length .

  • Řetězec vytvořený funkcemi nebo nemusí být nutně stejný jako řetězec strcpy_s wcscpy_s vytvořený metodou String.Copy .

Měli byste zajistit, aby nativní kód jazyka C a C++, který vytváří instance objektů, a kód, který je předán objektům prostřednictvím vyvolání platformy, nepoukládal, že vložený znak null označuje String String konec řetězce.

Vložené znaky null v řetězci jsou také zpracovány odlišně, pokud je řetězec seřazen (nebo porovnán) a při hledání řetězce. Při porovnávání mezi dvěma řetězci, včetně porovnání pomocí invariantní jazykové verze, jsou znaky null ignorovány. Jsou považovány pouze za řadová nebo bez rozlišení velkých a malých písmen. Na druhou stranu vložené znaky null jsou vždy zvažovány při hledání řetězce pomocí metod, jako jsou Contains StartsWith , a IndexOf .

Řetězce a indexy

Index je pozice objektu Char (nikoli znaku Unicode) v String objektu . Index je negativní číslo založené na nule, které začíná od první pozice v řetězci, což je pozice indexu nula. Řada metod vyhledávání, například a , vrací index znaku nebo IndexOf LastIndexOf podřetězce v instanci řetězce.

Vlastnost Chars[] umožňuje přístup k jednotlivým Char objektům podle jejich pozice indexu v řetězci. Vzhledem k tomu, že vlastnost je výchozí vlastnost Chars[] (v Visual Basic) nebo indexeru (v jazyce C#), můžete k jednotlivým objektům v řetězci přistupovat pomocí kódu, jako je Char následující. Tento kód hledá prázdné znaky nebo znaky interpunkce v řetězci, aby určil, kolik slov řetězec obsahuje.

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

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ím znakům Unicode, protože znak Unicode může být kódován jako více než jeden Char objekt. Konkrétně může řetězec obsahovat více znaků textových jednotek, které jsou vytvořeny základním znakem následovaný jedním nebo více kombinující znaky nebo náhradními dvojicemi. Chcete-li pracovat se znaky Unicode místo objektů, použijte třídy a nebo metodu a Char System.Globalization.StringInfo TextElementEnumerator String.EnumerateRunes Rune struktury. Následující příklad ukazuje rozdíl mezi kódem, který pracuje s Char objekty a kódem, který pracuje se znaky Unicode. Porovná počet znaků nebo textových prvků v každém slově věty. Řetězec obsahuje dvě sekvence základního znaku následované kombinující znak.

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 elementy textu pomocí metody a třídy k vytvoření výčtu všech StringInfo.GetTextElementEnumerator TextElementEnumerator textových prvků v řetězci. Voláním metody můžete také načíst pole, které obsahuje počáteční index každého textového StringInfo.ParseCombiningCharacters prvku.

Další informace o práci s jednotkami textu místo jednotlivých hodnot najdete Char v tématu Úvod do kódování znaků v .NET.

Řetězce null a prázdné řetězce

Řetězec, který byl deklarován, ale nebyl přiřazen k hodnotě , je null . Při pokusu o volání metod v tomto řetězci se vyvolá NullReferenceException . Řetězec null se liší od prázdného řetězce, což je řetězec, jehož hodnota je "" nebo String.Empty . V některých případech předání řetězce null nebo prázdného řetězce jako argumentu ve volání metody vyvolá výjimku. Například předání řetězce null metodě vyvolá výjimku a předání prázdného řetězce Int32.Parse ArgumentNullException vyvolá FormatException . V jiných případech může být argumentem metody buď řetězec null, nebo prázdný řetězec. Pokud například poskytujete implementaci pro třídu, chcete rovnovat řetězec null i prázdný řetězec se specifikátorem obecného formátu IFormattable ("G").

Třída String obsahuje následující dvě metody usnadnění, které umožňují testovat, zda je řetězec nebo null prázdný:

  • IsNullOrEmptyoznačuje, zda je řetězec buď null , nebo roven String.Empty . Tato metoda eliminuje potřebu použití kódu, jako je například následující:

    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á určuje, jestli je řetězec null , rovná se nebo se skládá výhradně z String.Empty prázdných znaků. Tato metoda eliminuje potřebu použití kódu, jako je například následující:

    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 v IFormattable.ToString implementaci vlastní Temperature třídy. Metoda podporuje formátovací řetězce "G", "C", "F" a "K". Pokud prázdný formátovací řetězec nebo formátovací řetězec, jehož hodnota je předána metodě, změní se její hodnota na řetězec formátu null "G".

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

Objekt String se nazývá neměnný (jen pro čtení), protože jeho hodnotu nelze po vytvoření upravit. Metody, které se jeví String jako úpravy objektu, ve skutečnosti vrací nový String objekt, který obsahuje úpravy.

Vzhledem k tomu, že řetězce jsou neměnné, mohou rutiny pro manipulaci s řetězci, které provádějí opakované přidávání nebo odstraňování v tom, co se zdá být jedním řetězcem, přesnou penalizaci výkonu. Například následující kód používá generátor náhodných čísel k vytvoření řetězce s 1 000 znaky v 0x0001 0x052F. I když se zdá, že kód používá zřetězení řetězců k připojení nového znaku k existujícímu řetězci s názvem , ve skutečnosti vytvoří nový objekt pro každou operaci str zřetězení. String

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

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

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

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

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

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

Třídu můžete použít StringBuilder místo třídy pro operace, které prováděly více změn String hodnoty řetězce. Na rozdíl od instancí třídy jsou objekty směšitelné. Při zřetězování, připojování nebo odstraňování podřetězců z řetězce se operace provádějí String StringBuilder s jedním řetězcem. Po dokončení úprav hodnoty objektu můžete zavolat jeho metodu a převést StringBuilder StringBuilder.ToString ji na řetězec. Následující příklad nahradí objekt použitý v předchozím příkladu ke zřetězit 1 000 náhodných znaků v rozsahu, aby 0x0001 0x052F String StringBuilder objektem .

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

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

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

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

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

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append((char)rnd.Next(1, 0x0530));
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}
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 verzi

Členové třídy provádějí s objektem operace String ordinal nebo culture-sensitive (lingvistická). String Řadová operace pracuje s číselnou hodnotou každého Char objektu. Operace citlivá na jazykovou verzi pracuje s hodnotou objektu a bere v úvahu velká a malá písmena specifická pro jazykovou verzi, řazení, formátování a String parsování pravidel. Operace citlivé na jazykovou verzi se provádí v kontextu explicitně deklarované jazykové verze nebo implicitní aktuální jazykové verze. Tyto dva druhy operací mohou při provádění ve stejném řetězci získat velmi odlišné výsledky.

.NET také podporuje operace s lingvistickými řetězci nezávislé na jazykové verzi pomocí invariantní jazykové verze ( ), která je volně založená na nastavení jazykové verze anglického jazyka nezávislého CultureInfo.InvariantCulture na oblasti. Na rozdíl od jiných nastavení je zaručeno, že nastavení invariantní jazykové verze zůstane konzistentní na jednom počítači, ze systému na systém a napříč System.Globalization.CultureInfo verzemi rozhraní .NET. Invariantní jazyková verze se může nazývat druhem černé skříňky, která zajišťuje stabilitu porovnávání a řazení řetězců ve všech kulturách.

Důležité

Pokud vaše aplikace provede bezpečnostní rozhodnutí ohledně symbolického identifikátoru, jako je název souboru nebo pojmenovaný kanál, nebo o trvalých datech, jako jsou textová data v souboru XML, měla by operace místo porovnání s jazykovou verzí používat řadové porovnání. Je to proto, že porovnání závislé na jazykové verzi může v závislosti na používané jazykové verzi přinést různé výsledky, zatímco řadové porovnání závisí výhradně na binární hodnotě porovnávaných znaků.

Důležité

Většina metod, které provádějí řetězcové operace, zahrnuje přetížení, které má parametr typu , který umožňuje určit, zda metoda provádí řadovou operaci nebo operaci citlivou StringComparison na jazykovou verzi. Obecně byste měli toto přetížení volat, aby byl záměr volání metody jasný. Osvědčené postupy a pokyny pro používání řadových operací s řetězci a operací citlivých na jazykovou verzi najdete v tématu Osvědčené postupy pro používání řetězců.

Operace pro velká a malápísmena, parsování a formátování,porovnání a řazení a testování rovnosti mohou být buď řadové, nebo na jazykové verzi. Následující části popisují jednotlivé kategorie operací.

Tip

Vždy byste měli volat přetížení metody, které záměr volání metody vymaže. Například místo volání metody k provedení porovnání dvou řetězců citlivých na jazykovou verzi pomocí konvencí aktuální jazykové verze byste měli volat metodu s hodnotou Compare(String, String) Compare(String, String, StringComparison) StringComparison.CurrentCulture comparisonType argumentu . Další informace najdete v tématu Osvědčené postupy pro používání řetězců.

Tabulky váhy řazení, sadu textových souborů, které obsahují informace o váze znaků používaných při operacích řazení a porovnání, si můžete stáhnout z následujících odkazů:

  • Windows (.NET Framework a .NET Core): Řazení tabulek váhy
  • Aktualizace Windows 10 z května 2019 nebo novější (.NET 5+) a Linux a macOS (.NET Core a .NET 5+): Výchozí tabulka elementů kolace kolace Unicode

Velikost písmen

Pravidla použití velkých a velkých písmen určují, jak změnit velká a velká písmena znaku Unicode. Například z malých písmen na velká písmena. Často se operace použití kaskády provádí před porovnáním řetězců. Řetězec může být například převeden na velká písmena, aby ho bylo možné porovnat s jiným řetězcem s velkými písmeny. Znaky v řetězci můžete převést na malá písmena voláním metody nebo a můžete je převést na velká písmena ToLower ToLowerInvariant voláním ToUpper metody nebo ToUpperInvariant . Kromě toho můžete pomocí metody TextInfo.ToTitleCase převést řetězec na velká a malá písmena nadpisu.

Poznámka

.NET Core běžící jenom v systémech Linux a MacOS: Chování kolace pro kultury C a POSIX je vždy citlivé na velká a malá písmena, protože tyto jazykové verze nepoužívají očekávané pořadí řazení Unicode. Pro provádění operací řazení bez rozlišování velkých a malých písmen doporučujeme použít jinou jazykovou verzi než C nebo POSIX.

Operace s casingem mohou být založeny na pravidlech aktuální jazykové verze, zadané jazykové verze nebo invariantní jazykové verze. Vzhledem k tomu, že se mapování případů může lišit v závislosti na použité jazykové verzi, může se výsledek operací s velikostí malá a velká písmena lišit v závislosti na jazykové verzi. Skutečné rozdíly v velikostech kaskádových velikostí jsou tři druhy:

  • Rozdíly v mapování velkých písmen LATINKY 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 (U+0131). V jazykových verzích tr-TR (turečtina (Turečtina)) a az-Latn-AZ (Jižní Amerika, Latinka) a v neutrálních jazykových verzích tr, az a az-Latn je malým ekvivalentem hlavního písmena LATINKY I MALÉ PÍSMENO LATINKY BEZ TEČKY I a velkým ekvivalentem malého písmene LATINKY I je VELKÉ PÍSMENO LATINKY I S TEČKOU VÝŠE. Ve všech ostatních kulturách, včetně invariantní jazykové verze, LATIN SMALL LETTER I a LATIN CAPITAL LETTER I jsou malá písmena a velká písmena.

    Následující příklad ukazuje, jak může porovnání řetězců navržené tak, aby zabránilo přístupu k systému souborů, selhat, pokud spoléhá na porovnání malých a malých písmen v jazykové verzi. (Měly by se použít konvence použití kaskádových kaskádových kultury.)

    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 mapování případů mezi neutrální jazykovou verzí a všemi ostatními jazykovou verzí. V těchto případech vrátí použití pravidel pro malá a velká písmena invariantní jazykové verze ke změně znaku na velká nebo malá písmena stejný znak. Pro všechny ostatní jazykové verze vrátí jiný znak. Některé ovlivněné znaky jsou uvedené v následující tabulce.

    Znak Pokud se změní na Návraty
    MICRON SIGN (U+00B5) Velká písmena VELKÉ PÍSMENO ŘEČTINY MU (U+-39C)
    VELKÉ PÍSMENO LATINKY I S TEČKOU NAD (U+0130) Malá písmena MALÉ PÍSMENO LATINKY I (U+0069)
    MALÉ PÍSMENO LATINKY BEZ TEČKY I (U+0131) Velká písmena VELKÉ PÍSMENO LATINKY I (U+0049)
    MALÉ PÍSMENO LATINKY DLOUHÉ S (U+017F) Velká písmena VELKÉ PÍSMENO LATINKY S (U+0053)
    VELKÉ PÍSMENO LATINKY D S MALÝM PÍSMENEM Z A KARONEM (U+01C5) Malá písmena MALÉ PÍSMENO LATINKY S KARONEM (U+01C6)
    KOMBINOVÁNÍ ŘEČTINY YPOGEGRAMMENI (U+0345) Velká písmena VELKÉ PÍSMENO ŘEČTINY IOTA (U+0399)
  • Rozdíly v případě mapování dvou písmen smíšených párů v rozsahu znaků ASCII Ve většině jazykových verzí se dvojice se dvěma písmeny a velkými písmeny rovná ekvivalentní dvojici s velkými nebo malými písmeny. To není pravdivé pro následující dvojice dvou písmen v následujících kulturách, protože v každém případě jsou porovnány s digrafem:

    • "lJ" a "nJ" v jazykové verzi hr-HR (Chorvatština)).

    • "cH" v kulturách cs-CZ (čeština (Česká republika)) a sk-SK (slovenština (Slovenština)).

    • "aA" v jazykové verzi da-DK (dánština (Atd.).

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" a "zS" v jazykové verzi hu-HU (maďarština (Maďarština)).

    • "cH" a "lL" v kultury es-ES_tradnl (španělština (Španělsko, tradiční řazení)).

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH" a "tR" ve jazykové verzi vi-VN (vietnamština)).

    Je však neobvyklé narazit na situaci, kdy porovnání těchto párů v jazykové verzi vytváří problémy, protože tyto páry jsou v pevných řetězcích nebo identifikátorech neobvyklé.

Následující příklad ukazuje některé rozdíly v pravidlech použití velkých a malých písmen mezi jazykovou verzí při převodu řetězců na velká písmena.

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í

Formátování a analýza jsou inverzní operace. Pravidla formátování určují, jak převést hodnotu, například datum a čas nebo číslo, na řetězcové vyjádření, zatímco pravidla analýzy určují, jak převést řetězcové vyjádření na hodnotu, jako je datum a čas. Pravidla formátování i analýzy jsou závislá na kulturní konvencích. Následující příklad znázorňuje nejednoznačnost, která může nastat při interpretaci řetězce data specifického pro jazykovou verzi. Bez znalosti konvencí jazykové verze, která byla použita k vytvoření řetězce data, není možné zjistit, jestli 03/01/2011, 3/1/2011 a 01/03/2011 představují 3. ledna 2011 nebo 1. března 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, může jeden řetězec vytvořit různá kalendářní data v závislosti na jazykové verzi, jejíž konvence se používají v operaci parsování.

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ů

Konvence pro porovnávání a řazení řetězců se liší od jazykové verze k jazykové verzi. Například pořadí řazení může být založené na telefonii nebo vizuální reprezentaci znaků. Ve východoasijských jazycích jsou znaky řazeny podle úhozů a radikálu ideografických znaků. Řazení závisí také na pořadí, které jazyky a jazykové verze používají pro abecedu. Dánský jazyk má například znak „Æ“, který se abecedně řadí za znak „Z“. Kromě toho může porovnání rozlišovat malá a velká písmena nebo rozlišovat malá a velká písmena a pravidla pro malá a velká písmena se můžou lišit podle jazykové verze. Ordinální porovnání na druhé straně používá při porovnávání a řazení řetězců body kódu Unicode jednotlivých znaků v řetězci.

Pravidla řazení určují abecední pořadí znaků Unicode a způsob, jakým se dva řetězce vzájemně porovnávají. Například metoda String.Compare(String, String, StringComparison) porovnává dva řetězce na základě StringComparison parametru . Pokud je hodnota parametru , metoda provede lingvistické porovnání, které používá konvence aktuální jazykové verze. Pokud je hodnota parametru , metoda provede StringComparison.CurrentCulture StringComparison.Ordinal řadové porovnání. Jak je vidět v následujícím příkladu, pokud je aktuální jazyková verze americké angličtiny, první volání metody (pomocí porovnání s jazykovou verzí) zvažuje "a" menší než "A", ale druhé volání stejné metody String.Compare(String, String, StringComparison) (pomocí ordinálního porovnání) považuje "a" větší než "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 řazení slov, řetězců a řad:

  • Řazení slov provádí porovnání řetězců citlivých na jazykovou verzi, ve kterých mohou určité nealfanumericky znaky Unicode mít přiřazené speciální váhy. Spojovník (-) může mít například přiřazenou velmi malou váhu, aby se spoluop a spolupráce objevily v seřazených seznamech. Seznam metod, které porovnávají dva řetězce pomocí pravidel řazení slov, najdete v části String Operace s řetězci podle kategorie.

  • Řazení řetězců také provádí porovnání citlivé na jazykovou verzi. Podobá se řazení slov s tím rozdílem, že neexistují žádné zvláštní případy a všechny nealfanumerická symboly předchytají všechny alfanumerické znaky Unicode. Dva řetězce lze porovnat pomocí pravidel řazení řetězců voláním přetížení metody, která mají parametr, který je CompareInfo.Compare options zadán jako hodnota CompareOptions.StringSort . Všimněte si, že toto je jediná metoda, kterou .NET poskytuje k porovnání dvou řetězců pomocí pravidel řazení řetězců.

  • Řadové řazení porovnává řetězce na základě číselné hodnoty každého Char objektu v řetězci. Při ordinálním porovnání se automaticky rozlišují malá a velká písmena, protože verze znaků malými a velkými písmeny mají různé body kódu. Pokud ale není case důležitý, můžete zadat řadové porovnání, které ignoruje velká a malá písmena. To je ekvivalentem k převodu řetězce na velká písmena pomocí invariantní jazykové verze a pak provedením ordinálního porovnání výsledku. Seznam metod, které porovnávají dva řetězce pomocí pravidel řadového řazení, najdete v části String Operace s řetězci podle kategorie.

Porovnání citlivé na jazykovou verzi je jakékoli porovnání, které explicitně nebo implicitně používá objekt, včetně invariantní jazykové verze, která CultureInfo je určena CultureInfo.InvariantCulture vlastností . Implicitní jazyková verze je aktuální jazyková verze, která je určena Thread.CurrentCulture vlastnostmi CultureInfo.CurrentCulture a . Pořadí řazení abecedních znaků (to znamená znaků, pro které vlastnost vrací ) v Char.IsLetter true různých jazykových verzích se výrazně kolísá. Můžete zadat porovnání citlivé na jazykovou verzi, které používá konvence konkrétní jazykové verze, zadáním objektu do metody porovnání CultureInfo řetězců, jako je Compare(String, String, CultureInfo, CompareOptions) například . Porovnání citlivé na jazykovou verzi, které používá konvence aktuální jazykové verze, můžete určit zadáním , nebo libovolného člena výčtu jiného než nebo na odpovídající přetížení StringComparison.CurrentCulture StringComparison.CurrentCultureIgnoreCase CompareOptions CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase Compare metody. Porovnání citlivé na jazykovou verzi je obecně vhodné pro řazení, zatímco ordinální porovnání nikoli. Ordinální porovnání je obecně vhodné pro určení, zda jsou dva řetězce stejné (to znamená pro určení identity), zatímco porovnání citlivé na jazykovou verzi není.

Následující příklad znázorňuje rozdíl mezi porovnáním s jazykovou verzí a řadovou verzí. Tento příklad vyhodnotí tři řetězce, Apple, Proble a AEble, pomocí ordinálního porovnání a konvencí jazykových verzí da-DK a en-US (každá z nich je výchozí jazykovou verzí v době volání Compare metody). Vzhledem k tomu, že dánština považuje znak " Za" za jednotlivá písmena a seřadí ho podle písmene "Z", je řetězec "Řble" větší než "Apple". "Ble" se ale nepovažuje za ekvivalent "AEble", takže " Polák" je také větší než "AEble". Jazyková verze en-US neobsahuje písmeno " za"", ale považuje ho za ekvivalent "AE", což vysvětluje, proč je "Ble" menší než "Apple", ale rovná se "AEble". Ordinální porovnání jinými znamená, že "Apple" je menší než " Přilna" a " Přilna" je větší než "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

Při výběru vhodné metody řazení nebo porovnání řetězců použijte následující obecné pokyny:

  • Pokud chcete, aby byly řetězce seřazeny na základě jazykové verze uživatele, měli byste je seřazení na základě konvencí aktuální jazykové verze. Pokud se jazyková verze uživatele změní, změní se také pořadí seřazených řetězců. Aplikace slovníku by například měla vždy řadit slova na základě jazykové verze uživatele.

  • Pokud chcete, aby byly řetězce seřazeny na základě konvencí konkrétní jazykové verze, měli byste je seřazení poskytnutím objektu, který představuje tuto jazykovou verzi, CultureInfo metodě porovnání. Například v aplikaci určené k učení studentů konkrétního jazyka chcete, aby se řetězce objednávaly na základě konvencí jedné z kultur, které tento jazyk předčítá.

  • Pokud chcete, aby pořadí řetězců zůstalo beze změny napříč jazykovou verzí, měli byste je sesouvat na základě konvencí invariantní jazykové verze nebo použít řadové porovnání. Můžete například použít řadové řazení k uspořádání názvů souborů, procesů, mutexů nebo pojmenovaných kanálů.

  • 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 řadový test rovnosti voláním přetížení Equals metody.

Poznámka

Pravidla řazení a použití malých a malých písmen v jazykové verzi použitá při porovnávání řetězců závisí na verzi rozhraní .NET. V .NET Core závisí porovnání řetězců na verzi standardu Unicode, kterou podporuje základní operační systém. V .NET Framework 4.5 a novějších verzích běžících na Windows 8 nebo novějších verzích odpovídají informace o řazení, použití velkých a velkých písmen, normalizaci a znakech Unicode standardu Unicode 6.0. V jiných Windows systémy odpovídají standardu Unicode 5.0.

Další informace o pravidlech řazení slov, řetězců a řad najdete v System.Globalization.CompareOptions tématu . Další doporučení, kdy jednotlivá pravidla používat, najdete v tématu Osvědčené postupy pro používání řetězců.

Obvykle nevoláte metody porovnání řetězců, jako je například přímé určení Compare pořadí řazení řetězců. Metody porovnání se místo toho nazývají metodami řazení, jako je Array.Sort nebo List<T>.Sort . Následující příklad provádí čtyři různé operace řazení (řazení slov pomocí aktuální jazykové verze, řazení slov pomocí invariantní jazykové verze, řazení řadových číslování a řazení řetězců pomocí invariantní jazykové verze) bez explicitního volání metody porovnání řetězců, i když určují typ porovnání, který se má použít. Všimněte si, že každý typ řazení vytváří jedinečné pořadí řetězců ve svém poli.

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

.NET interně používá klíče řazení pro podporu porovnání řetězců v kulturním kultury. 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. Klíč řazení reprezentovaný třídou poskytuje SortKey úložiště těchto váze pro konkrétní řetězec. Pokud vaše aplikace provádí velký počet operací vyhledávání nebo řazení ve stejné sadě řetězců, můžete zvýšit její výkon vygenerováním a uložením klíčů řazení pro všechny řetězce, které používá. Pokud se vyžaduje operace řazení nebo porovnání, použijete místo řetězců klíče řazení. Další informace najdete ve SortKey třídě .

Pokud nezadáte konvenci porovnávání řetězců, metody řazení, jako je například provádění řazení řetězců v závislosti na jazykové verzi a rozlišování malých Array.Sort(Array) a malých písmen. Následující příklad ukazuje, jak změna aktuální jazykové verze ovlivňuje pořadí seřazených řetězců v poli. Vytvoří pole tří řetězců. Nejprve je vlastnost System.Threading.Thread.CurrentThread.CurrentCulture nastavena na hodnotu en-US a je volána metoda Array.Sort(Array). Výsledné pořadí řazení je založené na konvencích řazení pro jazykovou verzi angličtiny (USA). 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. 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).

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

Upozornění

Pokud je vaším primárním účelem při porovnávání řetězců určit, zda jsou si rovny, měli byste zavolat String.Equals metodu . Obvykle byste měli použít Equals k provedení řadového porovnání. Metoda String.Compare je určená především k řazení řetězců.

Metody hledání řetězců, například a , mohou také provádět porovnání řetězců podle jazykové verze nebo String.StartsWith String.IndexOf řadových řetězců. Následující příklad znázorňuje rozdíly mezi ordinálním porovnáním a porovnáním citlivým na jazykovou verzi pomocí IndexOf metody . Hledání citlivé na jazykovou verzi, ve kterém je aktuální jazyková verze angličtina (USA), považuje podřetězec "oe" za shodu s "μ". Vzhledem k tomu, že softwarový spojovník (U+00AD) je znak s nulovou šířkou, hledání považuje tento softwarový spojovník za ekvivalentní znaku a vyhledá shodu na začátku Empty řetězce. Ordinální vyhledávání na druhé straně nenajde shodu v žádném z těchto případů.

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í v řetězcích

Metody hledání řetězců, například a , mohou také provádět porovnání řetězců v jazykové verzi nebo řadových řetězců a určit, zda je v zadaném řetězci nalezen znak nebo String.StartsWith String.IndexOf podřetězec.

Metody hledání ve třídě, které vyhledává jednotlivé znaky, například metodu , nebo jeden ze sady znaků, jako je například metoda , provádějí String IndexOf IndexOfAny řadové vyhledávání. Pokud chcete znak vyhledat v jazykové verzi, musíte volat CompareInfo metodu, jako je nebo CompareInfo.IndexOf(String, Char) CompareInfo.LastIndexOf(String, Char) . Všimněte si, že výsledky hledání znaku pomocí ordinálního porovnání a porovnání s jazykovou verzí se mohou velmi lišit. Například hledání předkomponovaných znaků Unicode, jako je například sytost "0" (U+00C6), může odpovídat libovolnému výskytu jeho součástí ve správném pořadí, například "AE" (U+041U+0045) v závislosti na jazykové verzi. Následující příklad ukazuje rozdíl mezi metodami String.IndexOf(Char) a při hledání jednotlivých CompareInfo.IndexOf(String, Char) znaků. 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í.

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 . Jedinou výjimkou je Contains , že provádí hledání pořadového čísla.

Testování rovnosti

Použijte String.Compare metodu k určení vztahu dvou řetězců v pořadí řazení. Obvykle se jedná o operaci zohledňující jazykovou verzi. Naproti tomu volejte String.Equals metodu pro otestování rovnosti. 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.

Upozornění

Je možné otestovat rovnost voláním String.Compare metody a určením, zda je návratová hodnota nulová. Tento postup se ale nedoporučuje. Chcete-li zjistit, zda jsou dva řetězce stejné, měli byste zavolat jedno z přetížení String.Equals metody. Preferované přetížení pro volání je buď Equals(String, StringComparison) Metoda instance, nebo statická Equals(String, String, StringComparison) metoda, protože obě metody obsahují System.StringComparison parametr, který explicitně určuje typ porovnání.

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. 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://". 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". V důsledku toho je přístup k systému souborů neúmyslně povolen. 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.

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.

Normalizace

Některé znaky Unicode mají více reprezentace. Například kterýkoli z následujících bodů kódu může představovat písmeno "ắ":

  • U + 1EAF

  • U + 0103 U + 0301

  • U + 0061 U + 0306 U + 0301

Více reprezentace pro jeden znak ztěžuje hledání, řazení, spárování a další řetězcové operace.

Standard Unicode definuje proces s názvem normalizace, který vrací jednu binární reprezentaci znaku Unicode pro jakékoli ekvivalentní binární reprezentace. Normalizace může použít několik algoritmů nazývaných formy normalizace, které následují různá pravidla. Rozhraní .NET podporuje formy normalizace Unicode C, D, KC a KD. Když jsou řetězce normalizovány na stejnou formu normalizace, lze je porovnat pomocí ordinálního porovnání.

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. StringTřída obsahuje několik metod, které mohou provádět ordinální porovnávání, včetně následujících:

Můžete určit, zda je řetězec normalizován na formu normalizace C voláním String.IsNormalized() metody, nebo můžete zavolat String.IsNormalized(NormalizationForm) metodu, abyste zjistili, zda je řetězec normalizován na zadaný normalizační tvar. Můžete také zavolat String.Normalize() metodu pro převod řetězce na formu normalizace C, nebo můžete zavolat String.Normalize(NormalizationForm) metodu pro převod řetězce na zadaný normalizační tvar. Podrobné informace o normalizaci a porovnávání řetězců naleznete v tématu Normalize() Normalize(NormalizationForm) metody a.

Následující jednoduchý příklad znázorňuje normalizaci řetězců. 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ů. 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. V každém případě druhý test rovnosti ukazuje, že jsou řetězce stejné.

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 += $"{(ushort)ch:X4} ";
      return result.Trim();            
   } 
   
   private static string[] NormalizeStrings(NormalizationForm nf, params string[] words)
   {
      for (int ctr = 0; ctr < words.Length; ctr++)
         if (! words[ctr].IsNormalized(nf))
            words[ctr] = words[ctr].Normalize(nf); 
      return words;   
   }
}
// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = 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 najdete v tématu System.Text.NormalizationForm a v příloze standard Unicode #15: normalizace Unicode a nejčastější dotazy na webu Unicode.org.

Operace s řetězci podle kategorie

StringTří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 normalizaci řetězce.

Porovnávání řetězců

Můžete porovnat řetězce a určit jejich relativní pozici v pořadí řazení pomocí následujících String metod:

  • Compare Vrátí celé číslo, které označuje vztah jednoho řetězce k druhému řetězci v pořadí řazení.

  • CompareOrdinal Vrá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ů.

  • CompareTo vrací celé číslo, které určuje vztah aktuální instance řetězce k druhému řetězci v pořadí řazení. CompareTo(String)Metoda poskytuje IComparable IComparable<T> implementace a pro String třídu.

Testovací řetězce pro rovnost

Voláním Equals metody určíte, zda jsou dva řetězce stejné. 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. 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í.

Hledání znaků v řetězci

StringTřída obsahuje dva druhy vyhledávacích metod:

Upozorně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. Další informace najdete v tématu regulární výrazy .NET.

Úprava řetězce

StringTřída obsahuje následující metody, které se zobrazí pro úpravu hodnoty řetězce:

  • Insert Vloží řetězec do aktuální String instance.

  • PadLeft Vloží jeden nebo více výskytů zadaného znaku na začátek řetězce.

  • PadRight Vloží jeden nebo více výskytů zadaného znaku na konci řetězce.

  • Remove odstraní podřetězec z aktuální String instance.

  • Replace Nahradí podřetězec jiným podřetězcem v aktuální String instanci.

  • ToLower a ToLowerInvariant převeďte všechny znaky v řetězci na malá písmena.

  • ToUpper a ToUpperInvariant převeďte všechny znaky v řetězci na velká písmena.

  • Trim Odebere všechny výskyty znaku ze začátku a konce řetězce.

  • TrimEnd Odebere všechny výskyty znaku z konce řetězce.

  • TrimStart Odebere všechny výskyty znaku ze začátku řetězce.

Důležité

Všechny metody změny řetězce vrací nový String objekt. Nemění hodnotu aktuální instance.

Extrahovat podřetězce z řetězce

String.SplitMetoda odděluje jeden řetězec do více řetězců. Přetížení metody umožňují zadat více oddělovačů pro omezení počtu podřetězců vypočítaných metodou, pro oříznutí prázdných znaků z podřetězců a určení, zda jsou prázdné řetězce (které se vyskytují v případě sousedících oddělovačů) zahrnuty mezi vrácené řetězce.

Kombinovat řetězce

StringPro zřetězení řetězců lze použít následující metody:

  • Concat kombinuje jeden nebo více podřetězců do jednoho řetězce.

  • Join Zřetězí jeden nebo více podřetězců do jednoho prvku a přidá oddělovač mezi každým podřetězcem.

Hodnoty formátu

String.FormatMetoda 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. FormatMetoda se často používá k následujícím akcím:

  • Pro vložení řetězcové reprezentace číselné hodnoty do řetězce.

  • Pro vložení řetězcové reprezentace hodnoty data a času v řetězci.

  • Pro vložení řetězcové reprezentace hodnoty výčtu do řetězce.

  • Pro vložení řetězcové reprezentace nějakého objektu, který podporuje IFormattable rozhraní v řetězci.

  • K pravému nebo levému bloku v poli v rámci většího řetězce.

Podrobné informace o operacích formátování a příkladech naleznete v Format souhrnu přetížení.

Zkopírování řetězce

Můžete zavolat následující String metody pro vytvoření kopie řetězce:

  • Clone Vrátí odkaz na existující String objekt.

  • Copy Vytvoří kopii existujícího řetězce.

  • CopyTo zkopíruje část řetězce do pole znaků.

Normalizovat řetězec

V kódování Unicode může mít jeden znak více kódových bodů. Normalizace převede tyto ekvivalentní znaky do stejné binární reprezentace. String.NormalizeMetoda provádí normalizaci a String.IsNormalized Metoda určuje, zda je řetězec normalizován.

Další informace a příklad najdete v části normalizace výše v tomto tématu.

Konstruktory

String(Char*)

Inicializuje novou instanci třídy na hodnotu určenou zadaným ukazatelem String na pole znaků Unicode.

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.

String(Char, Int32)

Inicializuje novou instanci String třídy na hodnotu určenou zadaným znakem Unicode a opakuje zadaný počet opakování.

String(Char[])

Inicializuje novou instanci String třídy do znaků Unicode uvedených v zadaném poli znaků.

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.

String(ReadOnlySpan<Char>)

Inicializuje novou instanci String třídy do znaků Unicode uvedených v zadaném rozsahu jen pro čtení.

String(SByte*)

Inicializuje novou instanci String třídy na hodnotu určenou ukazatelem na pole 8bitových celých čísel se znaménkem.

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.

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 a Encoding objekt.

Pole

Empty

Představuje prázdný řetězec. Toto pole je jen ke čtení.

Vlastnosti

Chars[Int32]

Získá Char objekt na zadané pozici v aktuálním String objektu.

Length

Získá počet znaků v aktuálním String objektu.

Metody

Clone()

Vrátí odkaz na tuto instanci String .

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

Porovná podřetězce dvou zadaných objektů a vrátí celé číslo, které označuje jejich String relativní pozici v pořadí řazení.

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

Porovná podřetězce dvou zadaných objektů, ignoruje nebo respektuje jejich velká a malá písmena a vrací celé číslo, které označuje jejich relativní pozici String v pořadí řazení.

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

Porovná podřetězce dvou zadaných objektů, ignoruje nebo respektuje jejich velikost a používá informace specifické pro jazykovou verzi k ovlivnění porovnání a vrátí celé číslo, které označuje jejich relativní pozici v String pořadí řazení.

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

Porovná podřetězce dvou zadaných objektů pomocí zadaných možností porovnání a informací specifických pro jazykovou verzi, aby ovlivnily porovnání, a vrátí celé číslo, které označuje vztah obou podřetězců k sobě navzájem v String pořadí řazení.

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

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

Compare(String, String)

Porovná dva zadané String objekty a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.

Compare(String, String, Boolean)

Porovná dva zadané String objekty, ignoruje nebo dodržuje jejich případ a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.

Compare(String, String, Boolean, CultureInfo)

Porovná dva zadané objekty, ignoruje nebo respektuje jejich velikost a používá informace specifické pro jazykovou verzi k ovlivnění porovnání a vrátí celé číslo, které označuje jejich relativní pozici v String pořadí řazení.

Compare(String, String, CultureInfo, CompareOptions)

Porovná dva zadané objekty pomocí zadaných možností porovnání a informací specifických pro jazykovou verzi, aby ovlivnily porovnání, a vrátí celé číslo, které označuje vzájemnou relaci dvou řetězců v String pořadí řazení.

Compare(String, String, StringComparison)

Porovná dva zadané String objekty pomocí zadaných pravidel a vrátí celé číslo, které určuje jejich relativní pozici v pořadí řazení.

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

Porovná podřetězce dvou zadaných objektů vyhodnocením číselných hodnot String odpovídajících objektů v každém Char podřetězci.

CompareOrdinal(String, String)

Porovná dva zadané String objekty vyhodnocením číselných hodnot odpovídajících objektů Char v každém řetězci.

CompareTo(Object)

Porovná tuto instanci se zadanou instancí a určuje, jestli tato instance předchází, následuje nebo se objevuje na stejné pozici v pořadí řazení Object jako zadaná Object instance .

CompareTo(String)

Porovná tuto instanci se zadaným objektem a určuje, jestli tato instance předchází, následuje nebo se objevuje na stejné pozici v pořadí řazení String jako zadaný řetězec.

Concat(IEnumerable<String>)

Zřetězí členy konstruované IEnumerable<T> kolekce typu String .

Concat(Object)

Vytvoří řetězcovou reprezentaci zadaného objektu.

Concat(Object, Object)

Zřetězí řetězcové reprezentace dvou zadaných objektů.

Concat(Object, Object, Object)

Zřetězí řetězcové reprezentace tří zadaných objektů.

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é délky proměnné.

Concat(Object[])

Zřetězí řetězcové reprezentace prvků v zadaném Object poli.

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

Zřetězí řetězcové reprezentace dvou zadaných rozsahů znaků jen pro čtení.

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

Zřetězí řetězcové reprezentace tří zadaných rozsahů znaků jen pro čtení.

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

Zřetězí řetězcové reprezentace čtyř zadaných rozsahů znaků jen pro čtení.

Concat(String, String)

Zřetězí dvě zadané instance String .

Concat(String, String, String)

Zřetězí tři zadané instance String .

Concat(String, String, String, String)

Zřetězí čtyři zadané instance String .

Concat(String[])

Zřetězí prvky zadaného String pole.

Concat<T>(IEnumerable<T>)

Zřetězí členy IEnumerable<T> implementace.

Contains(Char)

Vrátí hodnotu určující, jestli se v tomto řetězci vyskytuje zadaný znak.

Contains(Char, StringComparison)

Vrátí hodnotu určující, jestli se zadaný znak vyskytuje v tomto řetězci, pomocí zadaných pravidel porovnání.

Contains(String)

Vrátí hodnotu určující, jestli se zadaný podřetězec vyskytuje v tomto řetězci.

Contains(String, StringComparison)

Vrátí hodnotu určující, jestli se zadaný řetězec vyskytuje v tomto řetězci, pomocí zadaných pravidel porovnání.

Copy(String)
Zastaralé.

Vytvoří novou instanci se String stejnou hodnotou jako zadaná hodnota String .

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.

CopyTo(Span<Char>)

Zkopíruje obsah tohoto řetězce do cílového rozsahu.

Create(IFormatProvider, DefaultInterpolatedStringHandler)

Vytvoří nový řetězec pomocí zadaného zprostředkovatele k řízení formátování zadaného interpolovaného řetězce.

Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)

Vytvoří nový řetězec pomocí zadaného zprostředkovatele k řízení formátování zadaného interpolovaného řetězce.

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

Vytvoří nový řetězec s určitou délkou a inicializuje ho po vytvoření pomocí zadaného zpětného volání.

EndsWith(Char)

Určuje, jestli konec této instance řetězce odpovídá zadanému znaku.

EndsWith(String)

Určuje, jestli konec této instance řetězce odpovídá zadanému řetězci.

EndsWith(String, Boolean, CultureInfo)

Určuje, zda konec této instance řetězce odpovídá zadanému řetězci v porovnání se zadanou jazykovou verzí.

EndsWith(String, StringComparison)

Určuje, jestli konec této instance řetězce odpovídá zadanému řetězci v porovnání se zadanou možností porovnání.

EnumerateRunes()

Vrátí výčet z Rune tohoto řetězce.

Equals(Object)

Určuje, zda tato instance a zadaný objekt, který musí být také String objektem, mají stejnou hodnotu.

Equals(String)

Určuje, zda má tato instance a jiný zadaný String objekt stejnou hodnotu.

Equals(String, String)

Určuje, zda mají String dva zadané objekty stejnou hodnotu.

Equals(String, String, StringComparison)

Určuje, zda mají String dva zadané objekty stejnou hodnotu. Parametr určuje pravidla jazykové verze, případu a řazení použitá při porovnání.

Equals(String, StringComparison)

Určuje, jestli tento řetězec a zadaný String objekt mají stejnou hodnotu. Parametr určuje pravidla jazykové verze, případu a řazení použitá při porovnání.

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. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.

Format(IFormatProvider, String, Object, Object)

Nahradí položky formátu v řetězci řetězcovou reprezentací dvou zadaných objektů. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.

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

Nahradí položky formátu v řetězci řetězcovou reprezentací tří zadaných objektů. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.

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. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.

Format(String, Object)

Nahradí jednu nebo více položek formátu v řetězci řetězcovou reprezentací zadaného objektu.

Format(String, Object, Object)

Nahradí položky formátu v řetězci řetězcovou reprezentací dvou zadaných objektů.

Format(String, Object, Object, Object)

Nahradí položky formátu v řetězci řetězcovou reprezentací tří zadaných objektů.

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.

GetEnumerator()

Načte objekt, který může iterovat přes jednotlivé znaky v tomto řetězci.

GetHashCode()

Vrátí hashový kód pro tento řetězec.

GetHashCode(ReadOnlySpan<Char>)

Vrátí hodnotu hash pro zadaný rozsah znaků jen pro čtení.

GetHashCode(ReadOnlySpan<Char>, StringComparison)

Vrátí hodnotu hash pro zadaný rozsah znaků jen pro čtení pomocí zadaných pravidel.

GetHashCode(StringComparison)

Vrátí hashový kód pro tento řetězec pomocí zadaných pravidel.

GetPinnableReference()

Vrátí odkaz na prvek řetězce na indexu nula.

Tato metoda je určena pro podporu kompilátorů .NET a není určena pro volání uživatelským kódem.

GetType()

Type Získá aktuální instanci.

(Zděděno od Object)
GetTypeCode()

Vrátí TypeCode String třídu.

IndexOf(Char)

Sestaví index založený na nule prvního výskytu zadaného znaku Unicode v tomto řetězci.

IndexOf(Char, Int32)

Sestaví index založený na nule prvního výskytu zadaného znaku Unicode v tomto řetězci. Hledání začíná na zadané pozici znaku.

IndexOf(Char, Int32, Int32)

Hlásí index od nuly prvního výskytu zadaného znaku v této instanci. Hledání začíná na zadané pozici znaku a prozkoumá zadaný počet pozic znaků.

IndexOf(Char, StringComparison)

Sestaví index založený na nule prvního výskytu zadaného znaku Unicode v tomto řetězci. Parametr určuje typ vyhledávání, které se má použít pro zadaný znak.

IndexOf(String)

Vypíše index založený na nule prvního výskytu zadaného řetězce v této instanci.

IndexOf(String, Int32)

Hlásí index od nuly prvního výskytu zadaného řetězce v této instanci. Hledání začíná na zadané pozici znaku.

IndexOf(String, Int32, Int32)

Hlásí index od nuly prvního výskytu zadaného řetězce v této instanci. Hledání začíná na zadané pozici znaku a prozkoumá zadaný počet pozic znaků.

IndexOf(String, Int32, Int32, StringComparison)

Hlásí index od nuly prvního výskytu zadaného řetězce v aktuálním String objektu. 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á vyhledat, a typ vyhledávání, které se má použít pro zadaný řetězec.

IndexOf(String, Int32, StringComparison)

Hlásí index od nuly prvního výskytu zadaného řetězce v aktuálním String objektu. Parametry určují počáteční pozici hledání v aktuálním řetězci a typ vyhledávání, které se má použít pro zadaný řetězec.

IndexOf(String, StringComparison)

Hlásí index od nuly prvního výskytu zadaného řetězce v aktuálním String objektu. Parametr určuje typ vyhledávání, které se má použít pro zadaný řetězec.

IndexOfAny(Char[])

Hlásí index prvního výskytu v této instanci jakéhokoli znaku v zadaném poli znaků Unicode založený na nule.

IndexOfAny(Char[], Int32)

Hlásí index prvního výskytu v této instanci jakéhokoli znaku v zadaném poli znaků Unicode založený na nule. Hledání začíná na zadané pozici znaku.

IndexOfAny(Char[], Int32, Int32)

Hlásí index prvního výskytu v této instanci jakéhokoli znaku v zadaném poli znaků Unicode založený na nule. Hledání začíná na zadané pozici znaku a prozkoumá zadaný počet pozic znaků.

Insert(Int32, String)

Vrátí nový řetězec, ve kterém je zadaný řetězec vložen na určenou pozici indexu v této instanci.

Intern(String)

Načte odkaz systému na zadaný String .

IsInterned(String)

Načte odkaz na zadaný String .

IsNormalized()

Určuje, zda je tento řetězec ve formátu normalizace Unicode C.

IsNormalized(NormalizationForm)

Určuje, zda je tento řetězec v zadaném formuláři normalizace kódování Unicode.

IsNullOrEmpty(String)

Označuje, zda je zadaný řetězec null nebo prázdný řetězec ("").

IsNullOrWhiteSpace(String)

Označuje, zda je zadaný řetězec null , prázdný nebo se skládá pouze z prázdných znaků.

Join(Char, Object[])

Zřetězí řetězcové reprezentace pole objektů pomocí zadaného oddělovače mezi každým členem.

Join(Char, String[])

Zřetězí pole řetězců pomocí zadaného oddělovače mezi každým členem.

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

Zřetězí pole řetězců pomocí zadaného oddělovače mezi jednotlivými členy počínaje prvkem v value startIndex umístění a zřetězením až po count prvky.

Join(String, IEnumerable<String>)

Zřetězí členy konstruované IEnumerable<T> kolekce typu String pomocí zadaného oddělovače mezi každým členem.

Join(String, Object[])

Zřetězí prvky pole objektu pomocí zadaného oddělovače mezi jednotlivými prvky.

Join(String, String[])

Zřetězí všechny prvky pole řetězců pomocí zadaného oddělovače mezi jednotlivými prvky.

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

Zřetězí zadané prvky pole řetězců pomocí zadaného oddělovače mezi jednotlivými prvky.

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

Zřetězí členy kolekce pomocí zadaného oddělovače mezi každým členem.

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

Zřetězí členy kolekce pomocí zadaného oddělovače mezi každým členem.

LastIndexOf(Char)

Oznamuje pozici indexu na základě nuly posledního výskytu zadaného znaku Unicode v rámci této instance.

LastIndexOf(Char, Int32)

Oznamuje pozici indexu na základě nuly posledního výskytu zadaného znaku Unicode v rámci této instance. Hledání začne na určené pozici znaku a postupuje zpět na začátek řetězce.

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

LastIndexOf(String)

Oznámí index (počítaný od nuly) posledního výskytu určeného řetězce v této instanci.

LastIndexOf(String, Int32)

Oznámí index (počítaný od nuly) posledního výskytu určeného řetězce v této instanci. Hledání začne na určené pozici znaku a postupuje zpět na začátek řetězce.

LastIndexOf(String, Int32, Int32)

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

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. Hledání začíná na zadané pozici znaku a pokračuje zpět na začátek řetězce pro zadaný počet pozic znaků. Parametr určuje typ porovnání, které se má provést při hledání zadaného řetězce.

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. Hledání začne na určené pozici znaku a postupuje zpět na začátek řetězce. Parametr určuje typ porovnání, které má být provedeno při hledání zadaného řetězce.

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. Parametr určuje typ hledání, které se má použít pro zadaný řetězec.

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.

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. Hledání začne na určené pozici znaku a postupuje zpět na začátek řetězce.

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. Hledání začíná na zadané pozici znaku a pokračuje zpět na začátek řetězce pro zadaný počet pozic znaků.

MemberwiseClone()

Vytvoří použádnou kopii aktuálního souboru Object.

(Zděděno od Object)
Normalize()

Vrátí nový řetězec, jehož textová hodnota je stejná jako tento řetězec, ale jehož binární reprezentace je v normalizačním formátu Unicode ve formátu C.

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.

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.

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.

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.

PadRight(Int32, Char)

Vrátí nový řetězec, který zarovná znaky v tomto řetězci doleva tak, že je na pravé straně odsaže zadaným znakem Unicode pro zadanou celkovou délku.

Remove(Int32)

Vrátí nový řetězec, ve kterém byly odstraněny všechny znaky v aktuální instanci, počínaje zadanou pozicí a pokračováním na poslední pozici.

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.

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.

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.

Replace(String, String, Boolean, CultureInfo)

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 pomocí zadané jazykové verze a rozlišování velkých a malých písmen.

Replace(String, String, StringComparison)

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 pomocí zadaného typu porovnání.

ReplaceLineEndings()

Nahradí všechny sekvence nového řádku v aktuálním řetězci řetězcem NewLine .

ReplaceLineEndings(String)

Nahradí všechny sekvence nového řádku v aktuálním řetězci řetězcem replacementText .

Split(Char, Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaného znaku oddělovače a volitelně možností. Rozdělí řetězec na maximální počet podřetězců na základě poskytnutého oddělovače znaků a volitelně vypouští prázdné podřetězce z výsledku.

Split(Char, StringSplitOptions)

Rozdělí řetězec na podřetězce na základě zadaného znaku oddělovače a volitelně možnosti.

Split(Char[])

Rozdělí řetězec na podřetězce na základě zadaných oddělovacích znaků.

Split(Char[], Int32)

Rozdělí řetězec na maximální počet podřetězců na základě zadaných oddělovacích znaků.

Split(Char[], Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaných oddělovacích znaků a volitelně možností.

Split(Char[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě zadaných znaků oddělovače a možností.

Split(String, Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaného řetězce oddělovače a volitelně možností.

Split(String, StringSplitOptions)

Rozdělí řetězec na podřetězce založené na zadaném oddělovači řetězců.

Split(String[], Int32, StringSplitOptions)

Rozdělí řetězec na maximální počet podřetězců na základě zadaných oddělovacích řetězců a volitelně možností.

Split(String[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě zadaného řetězce s oddělovači a volitelně možností.

StartsWith(Char)

Určuje, zda tato instance řetězce začíná zadaným znakem.

StartsWith(String)

Určuje, jestli začátek této instance řetězce odpovídá zadanému řetězci.

StartsWith(String, Boolean, CultureInfo)

Určuje, zda začátek této instance řetězce odpovídá zadanému řetězci v porovnání se zadanou jazykovou verzí.

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

Substring(Int32)

Načte podřetězec z této instance. Podřetězec začíná na zadané pozici znaku a pokračuje na konec řetězce.

Substring(Int32, Int32)

Načte podřetězec z této instance. Podřetězec začíná na zadané pozici znaku a má zadanou délku.

ToCharArray()

Zkopíruje znaky v této instanci do pole znaků Unicode.

ToCharArray(Int32, Int32)

Zkopíruje znaky v zadaném podřetězci v této instanci do pole znaků Unicode.

ToLower()

Vrátí kopii tohoto řetězce převedenou na malá písmena.

ToLower(CultureInfo)

Vrátí kopii tohoto řetězce převedenou na malá písmena s použitím pravidel velikostí písmen zadané jazykové verze.

ToLowerInvariant()

Vrátí kopii tohoto objektu převedenou na malá písmena s použitím pravidel pro malá a velká písmena String invariantní jazykové verze.

ToString()

Vrátí tuto instanci String typu ; není proveden žádný skutečný převod.

ToString(IFormatProvider)

Vrátí tuto instanci String typu ; není proveden žádný skutečný převod.

ToUpper()

Vrátí kopii tohoto řetězce převedenou na velká písmena.

ToUpper(CultureInfo)

Vrátí kopii tohoto řetězce převedenou na velká písmena s použitím pravidel pro velká a malá písmena zadané jazykové verze.

ToUpperInvariant()

Vrátí kopii tohoto objektu převedenou na velká písmena pomocí pravidel použití velkých a malých písmen String invariantní jazykové verze.

Trim()

Odebere z aktuálního řetězce všechny úvodní a koncové prázdné znaky.

Trim(Char)

Odebere všechny počáteční a koncové instance znaku z aktuálního řetězce.

Trim(Char[])

Odebere všechny počáteční a koncové výskyty sady znaků zadané v poli z aktuálního řetězce.

TrimEnd()

Odebere všechny koncové prázdné znaky z aktuálního řetězce.

TrimEnd(Char)

Odebere všechny koncové výskyty znaku z aktuálního řetězce.

TrimEnd(Char[])

Odebere všechny koncové výskyty sady znaků zadané v poli z aktuálního řetězce.

TrimStart()

Odebere všechny úvodní prázdné znaky z aktuálního řetězce.

TrimStart(Char)

Odebere všechny úvodní výskyty zadaného znaku z aktuálního řetězce.

TrimStart(Char[])

Odebere všechny úvodní výskyty sady znaků zadané v poli z aktuálního řetězce.

TryCopyTo(Span<Char>)

Zkopíruje obsah tohoto řetězce do cílového rozsahu.

Operátory

Equality(String, String)

Určuje, zda dva zadané řetězce mají stejnou hodnotu.

Implicit(String to ReadOnlySpan<Char>)

Definuje implicitní převod daného řetězce na rozsah znaků, který je jen pro čtení.

Inequality(String, String)

Určuje, zda dva zadané řetězce mají jiné hodnoty.

Explicitní implementace rozhraní

IComparable.CompareTo(Object)

Porovná tuto instanci se zadanou instancí a určuje, jestli tato instance předchází, následuje nebo se objevuje na stejné pozici v pořadí řazení Object jako zadaná Object instance .

IConvertible.GetTypeCode()

Vrátí TypeCode String třídu.

IConvertible.ToBoolean(IFormatProvider)

Popis tohoto člena naleznete v tématu ToBoolean(IFormatProvider) .

IConvertible.ToByte(IFormatProvider)

Popis tohoto člena naleznete v tématu ToByte(IFormatProvider) .

IConvertible.ToChar(IFormatProvider)

Popis tohoto člena naleznete v tématu ToChar(IFormatProvider) .

IConvertible.ToDateTime(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDateTime(IFormatProvider) .

IConvertible.ToDecimal(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDecimal(IFormatProvider) .

IConvertible.ToDouble(IFormatProvider)

Popis tohoto člena naleznete v tématu ToDouble(IFormatProvider) .

IConvertible.ToInt16(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt16(IFormatProvider) .

IConvertible.ToInt32(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt32(IFormatProvider) .

IConvertible.ToInt64(IFormatProvider)

Popis tohoto člena naleznete v tématu ToInt64(IFormatProvider) .

IConvertible.ToSByte(IFormatProvider)

Popis tohoto člena naleznete v tématu ToSByte(IFormatProvider) .

IConvertible.ToSingle(IFormatProvider)

Popis tohoto člena naleznete v tématu ToSingle(IFormatProvider) .

IConvertible.ToString(IFormatProvider)

Popis tohoto člena naleznete v tématu ToString(IFormatProvider) .

IConvertible.ToType(Type, IFormatProvider)

Popis tohoto člena naleznete v tématu ToType(Type, IFormatProvider) .

IConvertible.ToUInt16(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt16(IFormatProvider) .

IConvertible.ToUInt32(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt32(IFormatProvider) .

IConvertible.ToUInt64(IFormatProvider)

Popis tohoto člena najdete v tématu ToUInt64(IFormatProvider) .

IEnumerable.GetEnumerator()

Vrátí enumerátor, který prochází aktuálním String objektem.

IEnumerable<Char>.GetEnumerator()

Vrátí enumerátor, který prochází aktuálním String objektem.

Metody rozšíření

ToImmutableArray<TSource>(IEnumerable<TSource>)

Vytvoří neměnné pole ze zadané kolekce.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Vytvoří neměnný slovník z existující kolekce prvků a použije transformační funkci na zdrojové klíče.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Vytvoří neměnný slovník na základě určité transformace sekvence.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Vytvoří výčet a transformaci sekvence a vytvoří neměnný slovník jeho obsahu.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)

Vytvoří výčet a transformaci sekvence a vytvoří neměnný slovník jeho obsahu pomocí zadaného porovnávače klíčů.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

Vytvoří výčet a transformaci sekvence a vytvoří neměnný slovník jeho obsahu pomocí zadaných klíčových a hodnotových porovnávačů.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvence a vytvoří neměnnou sadu hodnot hash jejího obsahu.

ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří výčet sekvence, vytvoří neměnnou sadu hodnot hash jejího obsahu a použije zadaný porovnávač rovnosti pro typ sady.

ToImmutableList<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvence a vytvoří neměnný seznam jeho obsahu.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Vytvoří výčet a transformaci sekvence a vytvoří neměnný seřazený slovník jeho obsahu.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)

Vytvoří výčet a transformaci sekvence a vytvoří neměnný seřazený slovník jeho obsahu pomocí zadaného porovnávače klíčů.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

Vytvoří výčet a transformaci sekvence a vytvoří neměnný seřazený slovník jeho obsahu pomocí zadaných porovnávacích klíčů a hodnot.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Vytvoří výčet sekvence a vytvoří neměnnou seřazenou sadu jeho obsahu.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Vytvoří výčet sekvence, vytvoří neměnnou seřazenou sadu jeho obsahu a použije zadaný porovnávací modul.

CopyToDataTable<T>(IEnumerable<T>)

DataTable Vrátí hodnotu, která obsahuje kopie DataRow objektů, vzhledem k vstupnímu IEnumerable<T> objektu, kde je DataRowobecný parametr T .

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

Zkopíruje DataRow objekty do zadaného DataTableobjektu , vzhledem k vstupnímu IEnumerable<T> objektu, kde je DataRowobecný parametr T .

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

Zkopíruje DataRow objekty do zadaného DataTableobjektu , vzhledem k vstupnímu IEnumerable<T> objektu, kde je DataRowobecný parametr T .

Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)

Použije funkci akumulátoru na sekvenci.

Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)

Použije funkci akumulátoru na sekvenci. Zadaná počáteční hodnota akumulátoru se používá jako počáteční hodnota akumulátoru.

Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)

Použije funkci akumulátoru na sekvenci. Zadaná počáteční hodnota se používá jako počáteční hodnota akumulátoru a zadaná funkce slouží k výběru výsledné hodnoty.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Určuje, zda všechny prvky sekvence splňují podmínku.

Any<TSource>(IEnumerable<TSource>)

Určuje, zda sekvence obsahuje všechny prvky.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Určuje, zda některý prvek sekvence splňuje podmínku.

Append<TSource>(IEnumerable<TSource>, TSource)

Připojí hodnotu na konec sekvence.

AsEnumerable<TSource>(IEnumerable<TSource>)

Vrátí vstup zadaný jako IEnumerable<T>.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vypočítá průměr posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vypočítá průměr posloupnosti Double hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vypočítá průměr posloupnosti Int32 hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vypočítá průměr posloupnosti Int64 hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vypočítá průměr posloupnosti hodnot null, Decimal které jsou získány vyvoláním transformační funkce pro každý prvek vstupní sekvence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vypočítá průměr posloupnosti hodnot null, Double které jsou získány vyvoláním transformační funkce pro každý prvek vstupní sekvence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vypočítá průměr posloupnosti hodnot null, Int32 které jsou získány vyvoláním transformační funkce pro každý prvek vstupní sekvence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vypočítá průměr posloupnosti hodnot null, Int64 které jsou získány vyvoláním transformační funkce pro každý prvek vstupní sekvence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vypočítá průměr posloupnosti hodnot null, Single které jsou získány vyvoláním transformační funkce pro každý prvek vstupní sekvence.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vypočítá průměr posloupnosti Single hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Cast<TResult>(IEnumerable)

Přetypuje prvky zadaného IEnumerable typu.

Chunk<TSource>(IEnumerable<TSource>, Int32)

Rozdělí prvky sekvence na bloky velikosti nejvíce size.

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Zřetězí dvě sekvence.

Contains<TSource>(IEnumerable<TSource>, TSource)

Určuje, zda sekvence obsahuje zadaný prvek pomocí výchozího porovnávače rovnosti.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Určuje, zda sekvence obsahuje zadaný prvek pomocí zadané IEqualityComparer<T>.

Count<TSource>(IEnumerable<TSource>)

Vrátí počet prvků v posloupnosti.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí číslo, které představuje, kolik prvků v zadané sekvenci splňuje podmínku.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Vrátí prvky zadané sekvence nebo výchozí hodnotu parametru typu v jednotonové kolekci, pokud je sekvence prázdná.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

Vrátí prvky zadané sekvence nebo zadanou hodnotu v jednotonové kolekci, pokud je sekvence prázdná.

Distinct<TSource>(IEnumerable<TSource>)

Vrátí jedinečné prvky ze sekvence pomocí výchozího porovnávače rovnosti k porovnání hodnot.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Vrátí odlišné prvky ze sekvence pomocí zadané IEqualityComparer<T> hodnoty k porovnání hodnot.

DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Vrátí odlišné prvky ze sekvence podle zadané funkce selektoru klíče.

DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Vrátí odlišné prvky ze sekvence podle zadané funkce selektoru klíčů a pomocí zadaného porovnávacího nástroje k porovnání klíčů.

ElementAt<TSource>(IEnumerable<TSource>, Index)

Vrátí prvek v zadaném indexu v posloupnosti.

ElementAt<TSource>(IEnumerable<TSource>, Int32)

Vrátí prvek v zadaném indexu v posloupnosti.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)

Vrátí prvek v zadaném indexu v posloupnosti nebo výchozí hodnotě, pokud je index mimo rozsah.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)

Vrátí prvek v zadaném indexu v posloupnosti nebo výchozí hodnotě, pokud je index mimo rozsah.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Vytvoří množinu dvou sekvencí pomocí výchozího porovnávače rovnosti k porovnání hodnot.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří množinu dvou sekvencí pomocí zadaného IEqualityComparer<T> k porovnání hodnot.

ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Vytvoří množinu dvou sekvencí podle zadané funkce selektoru klíče.

ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Vytvoří množinu dvou sekvencí podle zadané funkce selektoru klíče.

First<TSource>(IEnumerable<TSource>)

Vrátí první prvek sekvence.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí první prvek v sekvenci, která splňuje zadanou podmínku.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Vrátí první prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.

FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)

Vrátí první prvek sekvence nebo zadanou výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí první prvek sekvence, která splňuje podmínku nebo výchozí hodnotu, pokud se nenajde žádný takový prvek.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Vrátí první prvek sekvence, která splňuje podmínku, nebo zadanou výchozí hodnotu, pokud se nenajde žádný takový prvek.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíčů.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíčů a porovná klíče pomocí zadaného porovnávače.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Seskupí prvky sekvence podle zadané funkce selektoru klíčů a zadává prvky pro každou skupinu pomocí zadané funkce.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Seskupí prvky sekvence podle funkce selektoru klíčů. Klíče se porovnávají pomocí porovnávače a prvky jednotlivých skupin se projektují pomocí zadané funkce.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Klíče se porovnávají pomocí zadaného porovnávače.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Prvky každé skupiny se projektují pomocí zadané funkce.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

Seskupí prvky sekvence podle zadané funkce selektoru klíčů a vytvoří výslednou hodnotu z každé skupiny a jejího klíče. Klíčové hodnoty se porovnávají pomocí zadaného porovnávače a prvky každé skupiny se projektují pomocí zadané funkce.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)

Koreluje prvky dvou sekvencí na základě rovnosti klíčů a seskupuje výsledky. Výchozí porovnávač rovnosti se používá k porovnání klíčů.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

Koreluje prvky dvou sekvencí na základě klíčové rovnosti a seskupuje výsledky. Zadaný IEqualityComparer<T> klíč se používá k porovnání klíčů.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Vytvoří průnik dvou sekvencí pomocí výchozího porovnávače rovnosti k porovnání hodnot.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří průsečík dvou sekvencí pomocí zadaného IEqualityComparer<T> porovnání hodnot.

IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Vytvoří množinou průsečík dvou sekvencí podle zadané funkce selektoru klíče.

IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Vytvoří množinou průsečík dvou sekvencí podle zadané funkce selektoru klíče.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

Koreluje prvky dvou sekvencí na základě odpovídajících klíčů. Výchozí porovnávač rovnosti se používá k porovnání klíčů.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

Koreluje prvky dvou sekvencí na základě odpovídajících klíčů. Zadaný IEqualityComparer<T> se používá k porovnání klíčů.

Last<TSource>(IEnumerable<TSource>)

Vrátí poslední prvek sekvence.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí poslední prvek sekvence, která splňuje zadanou podmínku.

LastOrDefault<TSource>(IEnumerable<TSource>)

Vrátí poslední prvek sekvence nebo výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.

LastOrDefault<TSource>(IEnumerable<TSource>, TSource)

Vrátí poslední prvek sekvence nebo zadanou výchozí hodnotu, pokud sekvence neobsahuje žádné prvky.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí poslední prvek sekvence, která splňuje podmínku nebo výchozí hodnotu, pokud se nenajde žádný takový prvek.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Vrátí poslední prvek sekvence, která splňuje podmínku, nebo zadanou výchozí hodnotu, pokud se nenajde žádný takový prvek.

LongCount<TSource>(IEnumerable<TSource>)

Vrátí hodnotu Int64 , která představuje celkový počet prvků v posloupnosti.

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí hodnotu Int64 , která představuje, kolik prvků v sekvenci splňuje podmínku.

Max<TSource>(IEnumerable<TSource>)

Vrátí maximální hodnotu v obecné sekvenci.

Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Vrátí maximální hodnotu v obecné sekvenci.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Decimal hodnotu.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Double hodnotu.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vyvolá transformační funkci na každém prvku sekvence a vrátí maximální Int32 hodnotu.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vyvolá transformační funkci na každém prvku sekvence a vrátí maximální Int64 hodnotu.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu nullable Decimal .

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu nullable Double .

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu nullable Int32 .

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu nullable Int64 .

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu nullable Single .

Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vyvolá transformační funkci na každém prvku sekvence a vrátí maximální Single hodnotu.

Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Vyvolá transformační funkci pro každý prvek obecné sekvence a vrátí maximální výslednou hodnotu.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Vrátí maximální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Vrátí maximální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů a porovnávače klíčů.

Min<TSource>(IEnumerable<TSource>)

Vrátí minimální hodnotu v obecné sekvenci.

Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Vrátí minimální hodnotu v obecné sekvenci.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Decimal hodnotu.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Double hodnotu.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int32 hodnotu.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Int64 hodnotu.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vyvolá transformační funkci na každém prvku sekvence a vrátí minimální hodnotu nullable Decimal .

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vyvolá transformační funkci na každém prvku sekvence a vrátí minimální hodnotu nullable Double .

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vyvolá transformační funkci na každém prvku sekvence a vrátí minimální hodnotu nullable Int32 .

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vyvolá transformační funkci na každém prvku sekvence a vrátí minimální hodnotu nullable Int64 .

Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vyvolá transformační funkci na každém prvku sekvence a vrátí minimální hodnotu nullable Single .

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální Single hodnotu.

Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Vyvolá transformační funkci pro každý prvek obecné sekvence a vrátí minimální výslednou hodnotu.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Vrátí minimální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Vrátí minimální hodnotu v obecné sekvenci podle zadané funkce selektoru klíčů a porovnávače klíčů.

OfType<TResult>(IEnumerable)

Filtruje prvky IEnumerable založené na zadaném typu.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Seřadí prvky sekvence vzestupně podle klíče.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Seřadí prvky sekvence ve vzestupném pořadí pomocí zadaného porovnávače.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Seřadí prvky sekvence v sestupném pořadí podle klíče.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Seřadí prvky sekvence v sestupném pořadí pomocí zadaného porovnávače.

Prepend<TSource>(IEnumerable<TSource>, TSource)

Přidá hodnotu na začátek sekvence.

Reverse<TSource>(IEnumerable<TSource>)

Invertuje pořadí prvků v posloupnosti.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)

Prodá jednotlivé prvky sekvence do nového formuláře.

Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)

Začlení každý prvek sekvence do nového formuláře zahrnutím indexu prvku.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)

Prodá jednotlivé prvky sekvence na IEnumerable<T> sekvenci a zploštějí výsledné sekvence do jedné sekvence.

SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)

Prodá jednotlivé prvky sekvence na sekvenci IEnumerable<T>a zploštějí výsledné sekvence do jedné sekvence. Index každého zdrojového elementu se používá v projektované podobě tohoto prvku.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Zarovná jednotlivé prvky sekvence na IEnumerable<T>sekvenci , zploštějí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků u každého prvku v něm.

SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)

Zarovná jednotlivé prvky sekvence na IEnumerable<T>sekvenci , zploštějí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků u každého prvku v něm. Index každého zdrojového prvku se používá v přechodném projektované podobě tohoto prvku.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Určuje, zda jsou dvě sekvence stejné porovnáním prvků pomocí výchozího porovnávače rovnosti pro jejich typ.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Určuje, zda jsou dvě sekvence stejné porovnáním jejich prvků pomocí zadaného IEqualityComparer<T>.

Single<TSource>(IEnumerable<TSource>)

Vrátí jediný prvek sekvence a vyvolá výjimku, pokud v sekvenci není přesně jeden prvek.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí jediný prvek sekvence, která splňuje zadanou podmínku, a vyvolá výjimku, pokud existuje více než jeden takový prvek.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Vrátí jediný prvek sekvence nebo výchozí hodnotu, pokud je sekvence prázdná; tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek.

SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)

Vrátí jediný prvek sekvence nebo zadanou výchozí hodnotu, pokud je sekvence prázdná; tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí jediný prvek sekvence, která splňuje zadanou podmínku nebo výchozí hodnotu, pokud takový prvek neexistuje; tato metoda vyvolá výjimku, pokud podmínku splňuje více než jeden prvek.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Vrátí jediný prvek sekvence, která splňuje zadanou podmínku, nebo zadanou výchozí hodnotu, pokud neexistuje žádný takový prvek; tato metoda vyvolá výjimku, pokud podmínku splňuje více než jeden prvek.

Skip<TSource>(IEnumerable<TSource>, Int32)

Obchází zadaný počet prvků v posloupnosti a potom vrátí zbývající prvky.

SkipLast<TSource>(IEnumerable<TSource>, Int32)

Vrátí novou výčtovou kolekci, která obsahuje prvky z source posledního count prvku zdrojové kolekce vynechána.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Obchází prvky v posloupnosti, pokud je zadaná podmínka pravdivá a vrátí zbývající prvky.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Obchází prvky v posloupnosti, pokud je zadaná podmínka pravdivá a vrátí zbývající prvky. Index elementu se používá v logice predikátové funkce.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Vypočítá součet posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)

Vypočítá součet posloupnosti Double hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)

Vypočítá součet posloupnosti Int32 hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)

Vypočítá součet posloupnosti Int64 hodnot, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Vypočítá součet posloupnosti hodnot s možnou Decimal hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)

Vypočítá součet posloupnosti hodnot s možnou Double hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Vypočítá součet posloupnosti hodnot s možnou Int32 hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Vypočítá součet posloupnosti hodnot s možnou Int64 hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Vypočítá součet posloupnosti hodnot s možnou Single hodnotou null, které jsou získány vyvoláním transformační funkce na každém prvku vstupní sekvence.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Vypočítá součet posloupnosti Single hodnot, které jsou získány vyvoláním transformační funkce u každého prvku vstupní sekvence.

Take<TSource>(IEnumerable<TSource>, Int32)

Vrátí zadaný počet souvislých prvků od začátku sekvence.

Take<TSource>(IEnumerable<TSource>, Range)

Vrátí zadanou oblast souvislých prvků ze sekvence.

TakeLast<TSource>(IEnumerable<TSource>, Int32)

Vrátí novou výčtovou kolekci, která obsahuje poslední count prvky z source.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Vrátí prvky z posloupnosti, pokud je zadaná podmínka pravdivá.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Vrátí prvky z posloupnosti, pokud je zadaná podmínka pravdivá. Index prvku se používá v logice predikátové funkce.

ToArray<TSource>(IEnumerable<TSource>)

Vytvoří pole z objektu IEnumerable<T>.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Dictionary<TKey,TValue> Vytvoří ze zadané funkce selektoru klíčů z IEnumerable<T> závislosti na zadané funkci selektoru klíčů.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Dictionary<TKey,TValue> Vytvoří ze zadané funkce selektoru klíčů a porovnávače klíčů z IEnumerable<T> závislosti na zadané funkci selektoru klíčů.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Dictionary<TKey,TValue> Vytvoří ze zadaného selektoru IEnumerable<T> klíče a funkce selektoru prvků.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Dictionary<TKey,TValue> Vytvoří ze IEnumerable<T> zadané funkce selektoru klíčů, porovnávače a funkce selektoru prvků.

ToHashSet<TSource>(IEnumerable<TSource>)

HashSet<T> Vytvoří z objektu IEnumerable<T>.

ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

HashSet<T> Vytvoří z porovnání IEnumerable<T> klíčů pomocí klávesycomparer.

ToList<TSource>(IEnumerable<TSource>)

List<T> Vytvoří z objektu IEnumerable<T>.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Lookup<TKey,TElement> Vytvoří z funkce IEnumerable<T> selektoru klíčů podle zadané funkce selektoru klíčů.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Lookup<TKey,TElement> Vytvoří ze zadané funkce selektoru klíčů a porovnávače klíčů ze IEnumerable<T> zadané funkce.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Lookup<TKey,TElement> Vytvoří ze zadaného selektoru IEnumerable<T> klíče a funkce selektoru prvků.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Lookup<TKey,TElement> Vytvoří ze IEnumerable<T> zadané funkce selektoru klíče, porovnávače a funkce selektoru prvků.

TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)

Pokusí se určit počet prvků v sekvenci bez vynucení výčtu.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Vytvoří sjednocovací sadu dvou sekvencí pomocí výchozího porovnávače rovnosti.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Vytvoří sjednocovací sadu dvou sekvencí pomocí zadaného IEqualityComparer<T>.

UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)

Vytvoří sjednocování dvou sekvencí podle zadané funkce selektoru klíče.

UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)

Vytvoří sjednocování dvou sekvencí podle zadané funkce selektoru klíče.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Filtruje posloupnost hodnot na základě predikátu.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Filtruje posloupnost hodnot na základě predikátu. Index každého prvku se používá v logice predikátové funkce.

Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

Vytvoří sekvenci řazených členů s prvky ze dvou zadaných sekvencí.

Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)

Vytvoří sekvenci řazených členů s prvky ze tří zadaných sekvencí.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Použije zadanou funkci na odpovídající prvky dvou sekvencí a vytvoří sekvenci výsledků.

AsParallel(IEnumerable)

Umožňuje paralelizaci dotazu.

AsParallel<TSource>(IEnumerable<TSource>)

Umožňuje paralelizaci dotazu.

AsQueryable(IEnumerable)

Převede na IEnumerable IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Převede obecný IEnumerable<T> na obecný IQueryable<T>.

AsMemory(String)

Vytvoří novou ReadOnlyMemory<Char> část cílového řetězce.

AsMemory(String, Index)

Vytvoří novou ReadOnlyMemory<Char> část cílového řetězce začínající na zadaném indexu.

AsMemory(String, Int32)

Vytvoří novou ReadOnlyMemory<Char> část cílového řetězce začínající na zadané pozici znaku.

AsMemory(String, Int32, Int32)

Vytvoří novou ReadOnlyMemory<Char> část cílového řetězce začínající na zadané pozici s délkou.

AsMemory(String, Range)

Vytvoří novou ReadOnlyMemory<Char> v zadané oblasti cílového řetězce.

AsSpan(String)

Vytvoří nový rozsah jen pro čtení přes řetězec.

AsSpan(String, Int32)

Vytvoří nový rozsah jen pro čtení přes část cílového řetězce z zadané pozice na konec řetězce.

AsSpan(String, Int32, Int32)

Vytvoří nový rozsah jen pro čtení přes část cílového řetězce ze zadané pozice pro zadaný počet znaků.

IsNormalized(String)

Určuje, zda je zadaný řetězec ve formátu normalizace Unicode C.

IsNormalized(String, NormalizationForm)

Určuje, zda je řetězec v zadaném formátu normalizace Unicode.

Normalize(String)

Normalizuje řetězec na normalizační formulář Unicode C.

Normalize(String, NormalizationForm)

Normalizuje řetězec do zadaného formuláře normalizace Unicode.

Ancestors<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují předky každého uzlu ve zdrojové kolekci.

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

Vrátí filtrovanou kolekci prvků, která obsahuje nadřazené prvky každého uzlu ve zdrojové kolekci. V kolekci jsou zahrnuty pouze prvky, které mají shodu XName .

DescendantNodes<T>(IEnumerable<T>)

Vrátí kolekci následnických uzlů každého dokumentu a elementu ve zdrojové kolekci.

Descendants<T>(IEnumerable<T>)

Vrátí kolekci prvků, které obsahují následné prvky každého prvku a dokumentu ve zdrojové kolekci.

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

Vrátí filtrovanou kolekci prvků, která obsahuje následné prvky každého prvku a dokumentu ve zdrojové kolekci. V kolekci jsou zahrnuty pouze prvky, které mají shodu XName .

Elements<T>(IEnumerable<T>)

Vrátí kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci.

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

Vrátí filtrovanou kolekci podřízených prvků každého prvku a dokumentu ve zdrojové kolekci. V kolekci jsou zahrnuty pouze prvky, které mají shodu XName .

InDocumentOrder<T>(IEnumerable<T>)

Vrátí kolekci uzlů, která obsahuje všechny uzly ve zdrojové kolekci seřazené v pořadí dokumentů.

Nodes<T>(IEnumerable<T>)

Vrátí kolekci podřízených uzlů každého dokumentu a elementu ve zdrojové kolekci.

Remove<T>(IEnumerable<T>)

Odebere každý uzel ve zdrojové kolekci z nadřazeného uzlu.

Platí pro

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

Tento typ je bezpečný pro přístup z více vláken.

Viz také