String Třída

Definice

Představuje text jako posloupnost 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é slouží k reprezentaci textu. Objekt String je sekvenční kolekce System.Char objektů, které představují řetězec; System.Char objekt odpovídá jednotce kódu UTF-16. Hodnota String objektu je obsah sekvenční kolekce System.Char objektů a tato hodnota je neměnná (to znamená jen pro čtení). Další informace o neměnnosti řetězců naleznete v části Immutability a StringBuilder třídy . Maximální velikost objektu String v paměti je 2 GB nebo přibližně 1 miliard znaků.

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

V této části:

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

Vytvoření instance objektu String

Objekt můžete vytvořit pomocí String následujících způsobů:

  • Přiřazením řetězcového literálu String k proměnné Toto je nejčastěji použitá 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# a F#, protože zpětné lomítko (\) je řídicí znak, musí být zpětné lomítka literálu v řetězci řídicí 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
    
    let string1 = "This is a string created by assignment."
    printfn "%s" string1
    let string2a = "The path is C:\\PublicDocuments\\Report1.doc"
    printfn "%s" string2a
    let string2b = @"The path is C:\PublicDocuments\Report1.doc"
    printfn "%s" string2b
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc
    
    Dim string1 As String = "This is a string created by assignment."
    Console.WriteLine(string1)
    Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc"
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       This is a string created by assignment.
    '       The path is C:\PublicDocuments\Report1.doc
    
  • Voláním konstruktoru String 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 obsahují ukazatele na pole znaků nebo podepsané bajtové pole jako parametry. Visual Basic nepodporuje volání těchto konstruktorů. Podrobné informace o String konstruktorech najdete v souhrnu konstruktoru String .

    using namespace System;
    
    void main()
    {
       wchar_t chars[5] = L"word";
       char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
       // Create a string from a character array. 
       String^ string1 = gcnew String(chars);
       Console::WriteLine(string1);
    
       // Create a string that consists of a character repeated 20 times. 
       String^ string2 = gcnew String('c', 20);
       Console::WriteLine(string2);
    
       String^ stringFromBytes = nullptr;
       String^ stringFromChars = nullptr;
    
       char * pbytes = &bytes[0];
       // Create a string from a pointer to a signed byte array.
       stringFromBytes = gcnew String(pbytes);
    
       wchar_t* pchars =  &chars[0];
       // Create a string from a pointer to a character array.
       stringFromChars = gcnew String(pchars);
    
       Console::WriteLine(stringFromBytes);
       Console::WriteLine(stringFromChars);
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       word 
    //       cccccccccccccccccccc 
    //       ABCDE 
    //       word
    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word
    
    let chars = [| 'w'; 'o'; 'r'; 'd' |]
    let bytes = [| 0x41y; 0x42y; 0x43y; 0x44y; 0x45y; 0x00y |]
    
    // Create a string from a character array.
    let string1 = String chars
    printfn "%s" string1
    
    // Create a string that consists of a character repeated 20 times.
    let string2 = String('c', 20)
    printfn "%s" string2
    
    let stringFromBytes =
        // Create a string from a pointer to a signed byte array.
        use pbytes = fixed bytes
        String pbytes
    let stringFromChars = 
        // Create a string from a pointer to a character array.
        use pchars = fixed chars
        String pchars
    
    printfn $"{stringFromBytes}"
    printfn $"{stringFromChars}"
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word
    
    Dim chars() As Char = { "w"c, "o"c, "r"c, "d"c }
    
    ' Create a string from a character array.
    Dim string1 As New String(chars)
    Console.WriteLine(string1)
    
    ' Create a string that consists of a character repeated 20 times.
    Dim string2 As New String("c"c, 20)
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       word
    '       cccccccccccccccccccc
    
  • Pomocí operátoru zřetězení řetězců (+ v jazyce C# a F# a & nebo + v Visual Basic) vytvořte jeden řetězec z libovolné kombinace String instancí a řetězcových 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.
    
    let string1 = "Today is " + DateTime.Now.ToString("D") + "."
    printfn $"{string1}"
    
    let string2 = "This is one sentence. " + "This is a second. "
    let string2 = string2 + "This is a third sentence."
    printfn $"{string2}"
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    Dim string1 As String = "Today is " + Date.Now.ToString("D") + "."  
    Console.WriteLine(string1)
    Dim string2 As String = "This is one sentence. " + "This is a second. "
    string2 += "This is a third sentence."
    Console.WriteLine(string2)      
    ' The example displays output like the following:
    '    Today is Tuesday, July 06, 2011.
    '    This is one sentence. This is a second. This is a third sentence.
    
  • Načtením vlastnosti nebo voláním metody, která vrací řetězec. Následující příklad používá metody String třídy k extrahování 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
    
    let sentence = "This sentence has five words."
    // Extract the second word.
    let startPosition = sentence.IndexOf " " + 1
    let word2 = 
        sentence.Substring(startPosition, sentence.IndexOf(" ", startPosition) - startPosition)
    printfn $"Second word: {word2}"
    // The example displays the following output:
    //       Second word: sentence
    
    Dim sentence As String = "This sentence has five words."
    ' Extract the second word.
    Dim startPosition As Integer = sentence.IndexOf(" ") + 1
    Dim word2 As String = sentence.Substring(startPosition, 
                                             sentence.IndexOf(" ", startPosition) - startPosition) 
    Console.WriteLine("Second word: " + word2)
    ' The example displays the following output:
    '       Second word: sentence
    
  • Voláním metody formátování převeďte hodnotu nebo objekt na jeho řetězcovou reprezentaci. Následující příklad používá složenou funkci 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.
    
    let dateAndTime = DateTime(2011, 7, 6, 7, 32, 0)
    let temperature = 68.3
    String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.", dateAndTime, temperature)
    |> printfn "%s"
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.
    
    Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM#
    Dim temperature As Double = 68.3
    Dim result As String = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                         dateAndTime, temperature)
    Console.WriteLine(result)
    ' The example displays the following output:
    '       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.
    

Objekty znaků a znaky kódování Unicode

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

Poznámka

Všimněte si, že protože String instance se skládá z sekvenční kolekce jednotek kódu UTF-16, je možné vytvořit String objekt, který není dobře formátovaný řetězec Unicode. Například je možné vytvořit řetězec, který má nízký náhradník bez odpovídajícího vysokého náhradního příkazu. I když některé metody, jako jsou například metody kódování a dekódování objektů v System.Text oboru názvů, mohou provádět kontroly, aby se zajistilo, že řetězce jsou dobře vytvořené, členové třídy nezajistí, String že řetězec je dobře vytvořený.

Jeden Char objekt obvykle představuje jeden kódový bod, tj. číselná hodnota Char rovná se bodu kódu. Například bod kódu znaku "a" je U+0061. Bod kódu však může vyžadovat více než jeden kódovaný prvek (více než jeden Char objekt). Standard Unicode definuje dva typy znaků, které odpovídají více Char objektům: grafemes a doplňkovým bodům kódu Unicode, které odpovídají znakům v doplňkových rovině Unicode.

  • Grafeme je reprezentován základním znakem následovaným jedním nebo více kombinačními znaky. Znak ä je například reprezentován objektem Char , jehož kódový bod je U+0061 následovaný Char objektem, jehož kódový bod je U+0308. Tento znak lze také definovat jedním Char objektem, který má bod kódu U+00E4. Jak ukazuje následující příklad, porovnání citlivé na jazykovou verzi pro rovnost označuje, že tyto dvě reprezentace jsou stejné, i když běžné pořadové porovnání není. Pokud jsou však tyto dva řetězce normalizovány, pořadové porovnání také značí, že jsou stejné. (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
    
    open System
    open System.IO
    
    do
        use sw = new StreamWriter(@".\graphemes.txt")
        let grapheme = "\u0061\u0308"
        sw.WriteLine grapheme
    
        let singleChar = "\u00e4"
        sw.WriteLine singleChar
    
        sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                    String.Equals(grapheme, singleChar,
                                    StringComparison.CurrentCulture))
        sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar,
                    String.Equals(grapheme, singleChar,
                                    StringComparison.Ordinal))
        sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar,
                    String.Equals(grapheme.Normalize(),
                                    singleChar.Normalize(),
                                    StringComparison.Ordinal))
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    Imports System.Globalization
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\graphemes.txt")
          Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308)
          sw.WriteLine(grapheme)
          
          Dim singleChar As String = ChrW(&h00e4)
          sw.WriteLine(singleChar)
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture))
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal))
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal))
          sw.Close() 
       End Sub
    End Module
    ' The example produces the following output:
    '       ä
    '       ä
    '       ä = ä (Culture-sensitive): True
    '       ä = ä (Ordinal): False
    '       ä = ä (Normalized Ordinal): True
    
  • Doplňkový kód Unicode (náhradní dvojice) je reprezentován objektem Char , jehož kódový bod je vysoký náhradník následovaný objektem Char , jehož kódový bod je nízký náhradní. Jednotky kódu vysokých náhrad se liší od U+D800 do U+DBFF. Jednotky kódu nízkých náhrad se liší od U+DC00 do U+DFFF. Náhradní dvojice se používají k reprezentaci znaků v doplňkových rovinách 16 Unicode. Následující příklad vytvoří náhradní znak a předá ho Char.IsSurrogatePair(Char, Char) metodě k určení, zda je náhradní pár.

    using namespace System;
    
    void main()
    {
       String^ surrogate =  L"\xD800\xDC03" ;
       for (int ctr = 0; ctr < surrogate->Length; ctr++)
          Console::Write("U+{0:X4} ", Convert::ToUInt16(surrogate[ctr]));
    
       Console::WriteLine();
       Console::WriteLine("   Is Surrogate Pair: {0}", 
                          Char::IsSurrogatePair(surrogate[0], surrogate[1]));
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       U+D800 U+DC03 
    //          Is Surrogate Pair: True
    
    string surrogate = "\uD800\uDC03";
    for (int ctr = 0; ctr < surrogate.Length; ctr++) 
       Console.Write($"U+{(ushort)surrogate[ctr]:X2} ");
    
    Console.WriteLine();
    Console.WriteLine("   Is Surrogate Pair: {0}", 
                      Char.IsSurrogatePair(surrogate[0], surrogate[1]));
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    open System
    
    let surrogate = "\uD800\uDC03"
    for i = 0 to surrogate.Length - 1 do
        printf $"U+{uint16 surrogate[i]:X2} "
    
    printfn $"\n   Is Surrogate Pair: {Char.IsSurrogatePair(surrogate[0], surrogate[1])}"
    // The example displays the following output:
    //       U+D800 U+DC03
    //          Is Surrogate Pair: True
    
    Module Example
       Public Sub Main()
          Dim surrogate As String = ChrW(&hD800) + ChrW(&hDC03)
          For ctr As Integer = 0 To surrogate.Length - 1
             Console.Write("U+{0:X2} ", Convert.ToUInt16(surrogate(ctr)))
          Next   
          Console.WriteLine()
          Console.WriteLine("   Is Surrogate Pair: {0}", 
                            Char.IsSurrogatePair(surrogate(0), surrogate(1)))
       End Sub
    End Module
    
    ' The example displays the following output:
    '       U+D800 U+DC03
    '          Is Surrogate Pair: True
    

Řetězce a standard Unicode

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

Každý znak v řetězci má přidruženou kategorii znaků Unicode, která je reprezentována v .NET výčtem UnicodeCategory . Kategorie 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í řetězců a řazení na základě standardu Unicode. .NET Framework 4 a předchozí verze udržují vlastní tabulku řetězcových dat. Platí to také o verzích .NET Framework počínaje .NET Framework 4.5 spuštěnými na Windows 7. Počínaje .NET Framework 4.5 spuštěnými na Windows 8 a novějších verzích operačního systému Windows modul runtime deleguje operace porovnání řetězců a řazení do operačního systému. V rozhraní .NET Core a .NET 5+ poskytuje informace o porovnávání řetězců a řazení mezinárodních komponent pro knihovny Unicode (s výjimkou verzí Windows před Aktualizace Windows 10 z května 2019). V následující tabulce jsou uvedeny verze .NET a verze sady Unicode Standard, na kterých jsou založeny porovnání znaků a řazení.

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ších Windows 8 a novějších operačních systémech Windows Standard Unicode verze 6.3.0
.NET Core a .NET 5+ Závisí na verzi standardu Unicode podporované základním operačním systémem.

Řetězce a vložené znaky null

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

  • Hodnota vrácené funkcemi strlen wcslen se nemusí nutně rovnat String.Length.

  • Řetězec vytvořený strcpy_s pomocí nebo wcscpy_s funkce není nutně identický s řetězcem vytvořeným metodou String.Copy .

Měli byste zajistit, aby nativní kód jazyka C a C++, který vytvoří instanci objektů, a kód předaný String objekty prostřednictvím vyvolání platformy, nepředpokládáString, že vložený znak null označí konec řetězce.

Vložené znaky null v řetězci se také zachází jinak, když je řetězec seřazen (nebo porovnán) a při hledání řetězce. Při porovnávání citlivých na jazykovou verzi mezi dvěma řetězci se ignorují znaky null, včetně porovnání pomocí invariantní jazykové verze. Považují se pouze za pořadové nebo pořadové porovnání nerozlišující velká a velká písmena. Na druhé straně se vložené znaky null vždy považují za hledání řetězce pomocí metod, jako jsou Contains, StartsWitha IndexOf.

Řetězce a indexy

Index je pozice objektu Char (nikoli znaku Unicode) v objektu String. Index je nulové nenegativní číslo, které začíná od první pozice v řetězci, což je pozice indexu nula. Řada metod hledání, například IndexOf a LastIndexOf, vrátí index znaku nebo podřetězce v instanci řetězce.

Vlastnost Chars[] umožňuje přístup k jednotlivým Char objektům podle jejich umístění indexu v řetězci. Vzhledem k tomu, že Chars[] vlastnost je výchozí vlastnost (v Visual Basic) nebo indexer (v jazyce C# a F#), můžete k jednotlivým Char objektům v řetězci přistupovat pomocí kódu, jako je následující. Tento kód vyhledá prázdné znaky nebo interpunkční znaky v řetězci a určí, 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.
let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

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

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

Vzhledem k tomu, že String třída implementuje IEnumerable rozhraní, můžete také iterovat Char objekty v řetězci pomocí konstruktoru foreach , jak ukazuje následující 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.
let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

for ch in s1 do
    if Char.IsPunctuation ch || Char.IsWhiteSpace ch then
        nWords <- nWords + 1
printfn $"The sentence\n   {s1}\nhas {nWords} words."
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.
Module Example
   Public Sub Main()
      Dim s1 As String = "This string consists of a single short sentence."
      Dim nWords As Integer = 0

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

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 objektů Char . Konkrétně řetězec může obsahovat víceznakové jednotky textu, které jsou tvořeny základním znakem následovaným jedním nebo více kombinačními znaky nebo náhradními páry. Pokud chcete místo objektů pracovat se znaky Char Unicode, použijte třídy System.Globalization.StringInfo a TextElementEnumerator String.EnumerateRunes metody a Rune strukturu. Následující příklad znázorňuje rozdíl mezi kódem, který funguje s objekty a kódem, který funguje s Char 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é kombinačním znakem.

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
open System
open System.Globalization

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

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

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

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

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

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

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

Tento příklad pracuje s textovými prvky pomocí StringInfo.GetTextElementEnumerator metody a TextElementEnumerator třídy k výčtu všech textových prvků v řetězci. Můžete také načíst pole, které obsahuje počáteční index každého textového prvku voláním StringInfo.ParseCombiningCharacters metody.

Další informace o práci s jednotkami textu, nikoli s jednotlivými Char hodnotami, najdete 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, je nullhodnota . Pokus o volání metod v daném řetězci 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 vyvolá výjimka předání řetězce null nebo prázdného řetězce jako argumentu ve volání metody. Například předání řetězce null metodě Int32.Parse vyvolá ArgumentNullExceptionhodnotu a předání prázdného FormatExceptionřetězce vyvolá hodnotu . V jiných případech může být argument metody buď řetězec null, nebo prázdný řetězec. Pokud například poskytujete IFormattable implementaci třídy, chcete shodovat řetězec null i prázdný řetězec se specifikátorem obecného formátu ("G").

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

  • IsNullOrEmpty, který označuje, zda je řetězec buď null nebo je roven String.Empty. Tato metoda eliminuje potřebu používat kód, například následující:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    if str = null || str.Equals String.Empty then
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace, který označuje, zda je nullřetězec , rovná String.Emptyse nebo se skládá výhradně z prázdných znaků. Tato metoda eliminuje potřebu používat kód, 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 = null || str.Equals String.Empty || str.Trim().Equals String.Empty then
    
    If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

Následující příklad používá metodu IsNullOrEmpty IFormattable.ToString v implementaci vlastní Temperature třídy. Metoda podporuje řetězce formátu "G", "C", "F" a "K". Pokud je prázdný formátovací řetězec nebo formátovací řetězec, jehož hodnota je null předána metodě, jeho hodnota se změní na řetězec formátu "G".

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

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

Neměnitelnost a třída StringBuilder

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

Vzhledem k tomu, že řetězce jsou neměnné, rutiny manipulace s řetězci, které provádějí opakované sčítání nebo odstranění k tomu, co se zdá být jedním řetězcem, mohou přesnou významné snížení výkonu. Následující kód například používá generátor náhodných čísel k vytvoření řetězce s 1000 znaky v oblasti 0x0001 k 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 str, ve skutečnosti vytvoří nový String objekt pro každou operaci zřetězení.

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

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

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

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

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

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

do
    let rnd = Random()

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

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

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

Třídu můžete použít StringBuilder místo String třídy pro operace, které dělají více změn hodnoty řetězce. Na rozdíl od instancí String třídy StringBuilder jsou objekty ztlumitelné; při zřetězení, připojení nebo odstranění podřetězců z řetězce se operace provádějí na jednom řetězci. Po dokončení úpravy hodnoty objektu StringBuilder můžete volat jeho StringBuilder.ToString metodu, která ji převede na řetězec. Následující příklad nahrazuje String použitý v předchozím příkladu ke zřetězení 1000 náhodných znaků v oblasti tak, aby 0x0001 0x052F objektem StringBuilder .

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

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

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

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

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

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

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

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

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

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

Řádové operace vs. operace zohledňující jazykovou verzi

String Členové třídy provádějí na objektu ordinální operace nebo operace citlivé na jazykovou verzi (lingvistickéString). Pořadová operace funguje na číselnou hodnotu každého Char objektu. Operace citlivá na jazykovou verzi funguje na hodnotě objektu String a bere v úvahu pravidla specifické pro jazykovou verzi, řazení, formátování a parsování pravidel. Operace citlivé na jazykovou verzi se provádějí v kontextu explicitně deklarované jazykové verze nebo implicitní aktuální jazykové verze. Tyto dva druhy operací můžou při provádění stejného řetězce vytvářet velmi odlišné výsledky.

.NET také podporuje operace jazykových řetězců nerozlišující jazykovou verzi jazyka pomocí invariantní jazykové verze (CultureInfo.InvariantCulture), která je volně založená na nastavení jazykové verze anglického jazyka nezávislého na oblasti. Na rozdíl od jiných System.Globalization.CultureInfo nastavení je zaručeno, že nastavení invariantní jazykové verze zůstane konzistentní na jednom počítači, od systému po systém a napříč verzemi .NET. Invariantní jazykovou verzi lze považovat za druh černého rámečku, který zajišťuje stabilitu porovnání řetězců a řazení napříč všemi jazykovými verzemi.

Důležité

Pokud vaše aplikace rozhodne o symbolickém 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í citlivého na jazykovou verzi použít pořadové porovnání. Důvodem je to, že porovnání citlivé na jazykovou verzi může přinést různé výsledky v závislosti na použité jazykové verzi, zatímco poř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, zahrnují přetížení, které má parametr typu StringComparison, který umožňuje určit, zda metoda provádí ordinální nebo jazykovou verzi citlivou operaci. Obecně byste měli volat toto přetížení, aby záměr volání metody bylo jasné. Osvědčené postupy a pokyny pro použití operací citlivých na pořadové a jazykové verze u řetězců najdete v tématu Osvědčené postupy pro používání řetězců.

Operace pro vkládání, parsování a formátování, porovnání a řazení a testování rovnosti mohou být buď pořadové, nebo jazykové verze citlivé. Následující části probírají jednotlivé kategorie operací.

Tip

Vždy byste měli volat přetížení metody, která zjasní záměr volání metody. Například místo volání Compare(String, String) metody k provedení porovnání dvou řetězců citlivých na jazykovou verzi pomocí konvencí aktuální jazykové verze byste měli volat Compare(String, String, StringComparison) metodu s hodnotou argumentu StringComparison.CurrentCulture comparisonType . 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 hmotnostech znaků použitých při operacích řazení a porovnání, si můžete stáhnout z následujících odkazů:

Velikost písmen

Pravidla psaní písmen určují, jak změnit velká písmena znaku Unicode; Například z malých písmen na velká písmena. Často se provádí operace dělení před porovnáním řetězců. Řetězec se například může převést na velká písmena, aby se dal porovnat s jiným velkým řetězcem. Znaky v řetězci můžete převést na malá písmena voláním ToLower nebo ToLowerInvariant metodou a můžete je převést na velká písmena voláním nebo ToUpperInvariant metodouToUpper. Kromě toho můžete metodu použít k převodu TextInfo.ToTitleCase řetězce na případ názvu.

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 casingu mohou být založeny na pravidlech aktuální jazykové verze, zadané jazykové verze nebo invariantní jazykové verze. Vzhledem k tomu, že mapování případů se můžou lišit v závislosti na použité jazykové verzi, může se výsledek operací vkládání písmen lišit v závislosti na jazykové verzi. Skutečné rozdíly v pouzdrech jsou tři druhy:

  • Rozdíly v mapování velkých písmen latinky I (U+0049), MALÉ PÍSMENO LATINKY (U+0069), VELKÉ PÍSMENO LATINKY I S TEČKOU NAD (U+0130) a LATIN SMALL LETTER DOTLESS I (U+0131). V kulturách tr-TR (Turečtina (Turecko)) a az-Latn-AZ (Ázerbájdžán, latinka) a v tr, az-Latn neutrální jazykové verze, malá písmena ekvivalent LATIN CAPITAL LETTER I je LATIN SMALL LETTER I( LATIN SMALL LETTER DOTLESS I) a velká písmena LATIN SMALL LETTER I je LATIN CAPITAL LETTER I with dot above. Ve všech ostatních jazykových verzích, včetně invariantní jazykové verze, jsou malá písmena LATIN SMALL LETTER I a LATIN CAPITAL LETTER I malá a velká písmena ekvivalenty.

    Následující příklad ukazuje, jak porovnání řetězců navržené tak, aby zabránilo selhání přístupu k systému souborů, pokud spoléhá na porovnání písmen citlivých na jazykovou verzi. (Měly by se použít konvence casingu invariantní jazykové verze.)

    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
       
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    open System
    open System.Globalization
    open System.Threading
    
    let disallowed = "file"
    
    let isAccessAllowed (resource: string) =
        let cultures = 
            [| CultureInfo.CreateSpecificCulture "en-US"
               CultureInfo.CreateSpecificCulture "tr-TR" |]
        let index = resource.IndexOfAny [| '\\'; '/' |]
        let scheme =
            if index > 0 then
                resource.Substring(0, index - 1)
            else 
                null
    
        // Change the current culture and perform the comparison.
        for culture in cultures do
            Thread.CurrentThread.CurrentCulture <- culture
            printfn $"Culture: {CultureInfo.CurrentCulture.DisplayName}"
            printfn $"{resource}"
            printfn $"Access allowed: {String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase) |> not}"
            printfn ""
            
    isAccessAllowed @"FILE:\\\c:\users\user001\documents\FinancialInfo.txt"
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    Imports System.Globalization
    Imports System.Threading
    
    Module Example
       Const disallowed = "file"
       
       Public Sub Main()
          IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt")
       End Sub
    
       Private Sub IsAccessAllowed(resource As String)
          Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"),
                                            CultureInfo.CreateSpecificCulture("tr-TR") }
          Dim scheme As String = Nothing
          Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c })
          If index > 0 Then scheme = resource.Substring(0, index - 1)
    
          ' Change the current culture and perform the comparison.
          For Each culture In cultures
             Thread.CurrentThread.CurrentCulture = culture
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
             Console.WriteLine(resource)
             Console.WriteLine("Access allowed: {0}", 
                               Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase))      
             Console.WriteLine()
          Next   
       End Sub      
    End Module
    ' The example displays the following output:
    '       Culture: English (United States)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: False
    '       
    '       Culture: Turkish (Turkey)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: True
    
  • Rozdíly v mapování případů mezi invariantní jazykovou verzí a všemi ostatními jazykovými verzemi. V těchto případech se pomocí pravidel velikostí písmen invariantní jazykové verze změní znak na velká nebo malá písmena, vrátí 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
    SIGN MICRON (U+00B5) Velká písmena ŘECKÉ VELKÉ PÍSMENO 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 TEČKA I (U+0131) Velká písmena VELKÉ PÍSMENO LATINKY I (U+0049)
    MALÉ PÍSMENO LATINKY (U+017F) Velká písmena VELKÉ PÍSMENO LATINKY (U+0053)
    VELKÉ PÍSMENO LATINKY D S MALÝM PÍSMENEM Z S CARON (U+01C5) Malá písmena MALÉ PÍSMENO LATINKY DZ S CARON (U+01C6)
    KOMBINOVÁNÍ ŘECKÉ YPOGEGRAMMENI (U+0345) Velká písmena ŘECKÉ VELKÉ PÍSMENO IOTA (U+0399)
  • Rozdíly v mapování dvou písmen smíšených párů písmen v oblasti znaků ASCII Ve většině jazykových verzí se dvojice dvou písmen smíšeného písmena rovná ekvivalentní dvoumísmenné velké nebo malé dvojici. To neplatí pro následující dvojice dvou písmen v následujících jazykových verzích, protože v každém případě se porovnávají s digrafem:

    • "lJ" a "nJ" v jazykové verzi hr-HR (Chorvatsko)).

    • "cH" v kulturách cs-CZ (Česká republika)) a sk-SK (Slovensko)).

    • "aA" v jazykové verzi da-DK (Dánsko)

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

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

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

    Je však neobvyklé narazit na situaci, kdy porovnání těchto dvojic citlivých na jazykovou 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 pro velká písmena mezi jazykovými verzemi 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
open System
open System.Globalization
open System.IO

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

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

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

// The example displays the following output:
//    file:
//        Invariant:    FILE               00 46 00 49 00 4C 00 45
//            en-US:    FILE               00 46 00 49 00 4C 00 45
//            tr-TR:    FİLE               00 46 01 30 00 4C 00 45
//
//    sıfır:
//        Invariant:   SıFıR         00 53 01 31 00 46 01 31 00 52
//            en-US:   SIFIR         00 53 00 49 00 46 00 49 00 52
//            tr-TR:   SIFIR         00 53 00 49 00 46 00 49 00 52
//
//    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ězcovou reprezentaci na hodnotu, jako je datum a čas. Formátování i parsování pravidel závisí na kulturních 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 kalendářního data, není možné zjistit, zda 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
open System
open System.Globalization

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

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

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

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

Podobně jako v následujícím příkladu ukazuje, že jeden řetězec může vytvořit různá data v závislosti na jazykové verzi, jejíž konvence se používají v operaci analýzy.

using namespace System;
using namespace System::Globalization;

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

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

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

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

Porovnávání a řazení řetězců

Konvence pro porovnávání a řazení řetězců se liší od jazykové verze po jazykovou verzi. Pořadí řazení může být například založené na fonetice nebo na 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“. Porovnání navíc můžou být malá a velká a malá písmena nerozlišující a pravidla pro velká písmena se můžou lišit podle jazykové verze. Pořadové porovnání používá naopak body kódu Unicode jednotlivých znaků v řetězci při porovnávání a řazení řetězců.

Pravidla řazení určují abecední pořadí znaků Unicode a způsob, jakým se dva řetězce vzájemně porovnávají. Metoda například String.Compare(String, String, StringComparison) porovnává dva řetězce na základě parametru StringComparison . Pokud je StringComparison.CurrentCulturehodnota parametru , metoda provede lingvistické porovnání, které používá konvence aktuální jazykové verze; pokud je StringComparison.Ordinalhodnota parametru , metoda provede pořadové porovnání. Jak ukazuje následující příklad, pokud je aktuální jazyková verze angličtina v USA, první volání metody (pomocí porovnání citlivé na String.Compare(String, String, StringComparison) jazykovou verzi) považuje za "a" menší než "A", ale druhé volání stejné metody (pomocí pořadové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
open System
open System.Globalization
open System.Threading

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

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

.NET 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 mít určité neosamocené znaky Unicode přiřazené speciální váhy. Například spojovník (-) může mít přiřazenou velmi malou hmotnost, aby se vedle sebe zobrazovaly "coop" a "co-op" v seřazeném seznamu. Seznam String metod, které porovnávají dva řetězce pomocí pravidel řazení slov, najdete v části Operace řetězce podle kategorií .

  • Ř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 neosamocené symboly přicházejí před všechny alfanumerické znaky Unicode. Dva řetězce lze porovnat pomocí pravidel řazení řetězců voláním CompareInfo.Compare přetížení metody, které mají options parametr, který je zadán hodnotu 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ů.

  • Pořadové řazení porovnává řetězce na základě číselné hodnoty každého Char objektu v řetězci. Pořadové porovnání se automaticky rozlišuje malá a velká písmena, protože malé a velké verze znaku mají různé body kódu. Pokud ale případ není důležitý, můžete zadat pořadové porovnání, které ignoruje případ. Jedná se o ekvivalent převodu řetězce na velká písmena pomocí invariantní jazykové verze a následného porovnání pořadového výsledku. Seznam String metod, které porovnávají dva řetězce pomocí pořadových pravidel řazení, najdete v části Operace řetězce podle kategorií .

Porovnání citlivé na jazykovou verzi je jakékoli porovnání, které explicitně nebo implicitně používá CultureInfo objekt, včetně invariantní jazykové verze, která je určena vlastností CultureInfo.InvariantCulture . Implicitní jazyková verze je aktuální jazyková verze, která je určena vlastnostmi a CultureInfo.CurrentCulture vlastnostmiThread.CurrentCulture. V pořadí řazení abecedních znaků (tj. znaků, pro které Char.IsLetter se vlastnost vrací true) napříč jazykovými verzemi je značná variace. Můžete zadat porovnání citlivé na jazykovou verzi, které používá konvence konkrétní jazykové verze zadáním CultureInfo objektu do metody porovnání řetězců, jako Compare(String, String, CultureInfo, CompareOptions)je . Můžete zadat porovnání citlivé na jazykovou verzi, které používá konvence aktuální jazykové verze zadáním StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCasenebo libovolného člena výčtu CompareOptions jiné než CompareOptions.Ordinal nebo CompareOptions.OrdinalIgnoreCase k příslušné přetížení Compare metody. Porovnání citlivé na jazykovou verzi je obecně vhodné pro řazení, zatímco pořadové porovnání není. Pořadové porovnání je obecně vhodné pro určení, zda jsou dva řetězce stejné (tj. pro určení identity), zatímco porovnání citlivé na jazykovou verzi není.

Následující příklad znázorňuje rozdíl mezi jazykovou verzí a pořadovým porovnáním. Příklad vyhodnocuje tři řetězce, "Apple", "Æble" a "AEble", pomocí pořadového porovnání a konvencí jazykových verzí da-DK a en-US (každá z nich je výchozí jazykovou verzí v době Compare , kdy se metoda volá). Vzhledem k tomu, že dánský jazyk považuje znak "Æ" za samostatné písmeno a seřadí ho za "Z" v abecedě, řetězec "Æble" je větší než "Apple". "Æble" se však nepovažuje za ekvivalent "AEble", takže "Æble" je také větší než "AEble". Jazyk en-US neobsahuje písmeno "Æ", ale považuje ho za ekvivalent "AE", což vysvětluje, proč "Æble" je menší než "Apple", ale rovná se "AEble". Pořadové porovnání, na druhé straně považuje "Apple" za menší než "Æble" a "Æble" být 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
open System
open System.Globalization
open System.Threading

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

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

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

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

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

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

  • Pokud chcete, aby se řetězce uspořádaly na základě jazykové verze uživatele, měli byste je uspořádat na základě konvencí aktuální jazykové verze. Pokud se změní jazyková verze uživatele, pořadí seřazených řetězců se také odpovídajícím způsobem změní. Aplikace tesaurus by například měla vždy řadit slova na základě jazykové verze uživatele.

  • Pokud chcete, aby se řetězce uspořádaly na základě konvencí konkrétní jazykové verze, měli byste je uspořádat tak CultureInfo , že zadáte objekt, který představuje tuto jazykovou verzi pro metodu porovnání. Například v aplikaci navržené pro výuku studentů určitého jazyka chcete řetězce uspořádat na základě konvencí jedné z jazykových verzí, které tento jazyk mluví.

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

  • Pro porovnání, které zahrnuje bezpečnostní rozhodnutí (například jestli je uživatelské jméno platné), byste měli vždy provést pořadový test rovnosti voláním přetížení Equals metody.

Poznámka

Pravidla řazení a písmen citlivá na jazykovou verzi, která se používají při porovnávání řetězců, závisí na verzi rozhraní .NET. Porovnání řetězců na platformě .NET Core závisí na verzi standardu Unicode podporovaném základním operačním systémem. V .NET Framework 4.5 a novějších verzích spuštěných na Windows 8 nebo novějších verzích, řazení, velikostí písmen, normalizace a informací o znakech Unicode odpovídají standardu Unicode 6.0. V jiných Windows operačních systémech odpovídají standardu Unicode 5.0.

Další informace o pravidlech řazení slov, řetězců a pořadových řádů najdete v System.Globalization.CompareOptions tématu. Další doporučení týkající se použití jednotlivých pravidel najdete v tématu Osvědčené postupy pro používání řetězců.

Obvykle nezavoláte metody porovnání řetězců, například Compare přímo k určení pořadí řazení řetězců. Místo toho se metody porovnání volají pomocí metod řazení, jako je nebo Array.Sort 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, pořadového řazení 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ů v jeho 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
open System
open System.Collections.Generic
open System.Globalization

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

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

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

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

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

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

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

// The example displays the following output:
//         Original     Word Sort  Invariant Word  Ordinal Sort   String Sort
//
//             coop          cœur            cœur         co-op         co-op
//            co-op         coeur           coeur         coeur          cœur
//      cooperative          coop            coop          coop         coeur
//     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

Rozhraní .NET interně používá klíče řazení k podpoře porovnání řetězců s kulturní citlivostí. 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ý SortKey třídou poskytuje úložiště těchto hmotností pro určitý řetězec. Pokud vaše aplikace provádí velké množství operací vyhledávání nebo řazení ve stejné sadě řetězců, můžete zvýšit jeho výkon generováním a uložením klíčů řazení pro všechny řetězce, které používá. Pokud je požadována operace řazení nebo porovnání, použijte místo řetězců klíče řazení. Další informace najdete v předmětu SortKey .

Pokud neurčíte konvenci porovnání řetězců, metody řazení, jako Array.Sort(Array) je provádění řazení v jazykové verzi, řazení s rozlišováním velkých a malých písmen u řetězců. 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
open System
open System.Globalization
open System.Threading

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

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

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

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

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

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

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

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

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

Upozornění

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

Metody prohledávání řetězců, například String.StartsWith a String.IndexOf, mohou také provádět porovnání řetězců citlivých na jazykovou verzi nebo pořadové řetězce. Následující příklad znázorňuje rozdíly mezi pořadovými a jazykovými porovnáními, které používají metodu IndexOf . Hledání citlivé na jazykovou verzi, ve kterém je aktuální jazyková verze angličtina (USA), považuje podřetězce "oe" za odpovídající ligaturu "œ". Vzhledem k tomu, že měkký spojovník (U+00AD) je znak nulové šířky, hledání považuje měkké pomlčky za Empty ekvivalentní a najde shodu na začátku řetězce. Pořadové hledání na druhé straně nenajde shodu v obou případech.

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

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

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

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

// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//
//       '­' found in 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 vyhledávání řetězců, například String.StartsWith a String.IndexOf, mohou také provádět porovnání řetězců citlivých na jazykovou verzi nebo pořadové řetězce, aby bylo možné určit, zda je znak nebo podřetězce nalezen v zadaném řetězci.

Vyhledávací metody ve String třídě, které hledají jednotlivé znaky, například metodu IndexOf , nebo jednu ze sady znaků, například metodu IndexOfAny , provádějí všechna pořadové vyhledávání. Chcete-li provést vyhledávání v jazykové verzi znaku, je nutné volat metodu CompareInfo , jako je nebo CompareInfo.IndexOf(String, Char) CompareInfo.LastIndexOf(String, Char). Všimněte si, že výsledky hledání znaku pomocí pořadového a jazykového porovnání mohou být velmi odlišné. Například hledání předkomposovaného znaku Unicode, jako je ligatura "Æ" (U+00C6), může v závislosti na jazykové verzi odpovídat jakémukoli výskytu jeho součástí ve správném pořadí, například "AE" (U+041U+0045). Následující příklad znázorňuje rozdíl mezi znaky String.IndexOf(Char) a CompareInfo.IndexOf(String, Char) metodami při hledání jednotlivých znaků. Ligatura "æ" (U+00E6) se nachází v řetězci "letecký" při použití konvencí jazykové verze en-US, ale ne při použití konvencí jazykové verze da-DK nebo při provádění pořadové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
open System.Globalization

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

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

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

Na druhé straně třídy metody, které hledají řetězec místo znaku, provádějí vyhledávání citlivé na jazykovou verzi, String pokud možnosti hledání nejsou explicitně zadány parametrem typu StringComparison. Jedinou výjimkou je Contains, která provádí pořadové vyhledávání.

Testování rovnosti

String.Compare Pomocí metody určete relaci dvou řetězců v pořadí řazení. Obvykle se jedná o operaci citlivou na jazykovou verzi. Naproti tomu volejte metodu String.Equals , která testuje rovnost. Vzhledem k tomu, že test rovnosti obvykle porovnává vstup uživatele s určitým známým řetězcem, jako je platné uživatelské jméno, heslo nebo cesta k systému souborů, obvykle se jedná o pořadovou operaci.

Upozornění

Rovnost je možné otestovat voláním String.Compare metody a určením, zda je vrácená hodnota nula. Tento postup se však nedoporučuje. Chcete-li zjistit, zda jsou dva řetězce stejné, měli byste volat jeden z přetížení String.Equals metody. Upřednostňované přetížení pro volání je metoda instance Equals(String, StringComparison) nebo statická Equals(String, String, StringComparison) metoda, protože obě metody zahrnují System.StringComparison parametr, který explicitně určuje typ porovnání.

Následující příklad znázorňuje nebezpečí, že je vhodné místo toho použít pořadové porovnání pro rovnost citlivou na jazykovou verzi. V tomto případě je záměrem kódu zakázat přístup systému souborů z adres URL začínajících na "FILE://" nebo "file://" provedením porovnání začátku adresy URL s řetězcem "FILE://". Pokud je však porovnání citlivé na jazykovou verzi provedeno pomocí turecké jazykové verze (Turecko) na adrese URL, která začíná na "file://", porovnání rovnosti selže, protože turecké velké písmeno "i" je "İ" místo "I". V důsledku toho je přístup k systému souborů neúmyslně povolený. Na druhé straně, pokud je provedeno pořadové porovnání, porovnání rovnosti proběhne úspěšně a přístup k systému souborů je 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.
open System
open System.Globalization
open System.Threading

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

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

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

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

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

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

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

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

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

Normalizace

Některé znaky Unicode mají více reprezentací. Například některý 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 reprezentací jednoho znaku komplikuje vyhledávání, řazení, porovnávání a další řetězcové operace.

Standard Unicode definuje proces označovaný jako normalizace, který vrací jednu binární reprezentaci znaku Unicode pro libovolnou z ekvivalentních binárních reprezentací. Normalizace může používat několik algoritmů, označovaných jako normalizační formuláře, které se řídí různými pravidly. .NET podporuje normalizaci unicode formulářů C, D, KC a KD. Pokud byly řetězce normalizovány do stejného formátu normalizace, lze je porovnat pomocí pořadového porovnání.

Pořadové porovnání je binární porovnání skalární hodnoty Unicode odpovídajících Char objektů v každém řetězci. Třída String obsahuje řadu metod, které mohou provádět pořadové porovnání, včetně následujících:

Můžete určit, zda je řetězec normalizován na normalizaci formuláře C voláním String.IsNormalized() metody, nebo můžete volat metodu String.IsNormalized(NormalizationForm) k určení, zda je řetězec normalizován na zadaný normalizační formulář. Můžete také volat metodu String.Normalize() pro převod řetězce na normalizaci formuláře C, nebo můžete volat metodu String.Normalize(NormalizationForm) pro převod řetězce na zadaný normalizační formulář. Podrobné informace o normalizaci a porovnávání řetězců najdete v tématech Normalize() a Normalize(NormalizationForm) metodách.

Následující jednoduchý příklad znázorňuje normalizaci řetězců. Definuje písmeno "ố" třemi různými způsoby třemi různými řetězci a pomocí pořadového porovnání rovnosti určí, že každý řetězec se liší od ostatních dvou řetězců. Potom převede každý řetězec na podporované formuláře normalizace a znovu provede pořadové porovnání každého řetězce v zadaném normalizačním formuláři. V každém případě druhý test rovnosti ukazuje, že řetězce jsou 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
open System
open System.IO
open System.Text

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

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

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

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

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

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

// The example displays the following output:
//       sống (0073 1ED1 006E 0067) = sống (0073 00F4 0301 006E 0067): False
//       sống (0073 1ED1 006E 0067) = 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 normalizaci formulářů naleznete v článku System.Text.NormalizationForm, stejně jako standardní příloha Unicode č. 15: Formuláře normalizace Unicode a nejčastější dotazy k normalizaci na unicode.org webu.

Operace s řetězci podle kategorie

Třída String 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ů

Řetězce můžete porovnat 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 relaci jednoho řetězce k druhému řetězci v pořadí řazení.

  • CompareOrdinal vrátí celé číslo, které označuje relaci jednoho řetězce k druhému řetězci na základě porovnání jejich bodů kódu.

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

Testování řetězců pro rovnost

Zavoláte metodu Equals , která určí, 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ání citlivé na jazykovou verzi nebo pořadové číslo a zda je případ považován za nebo ignorován. Většina testů rovnosti je ordinální a porovnání rovnosti, které určují přístup k systémovému prostředku (například objektu systému souborů), by měly být vždy pořadové.

Vyhledání znaků v řetězci

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

Upozornění

Pokud chcete vyhledat řetězec pro určitý vzor místo konkrétního podřetězce, měli byste použít regulární výrazy. Další informace naleznete v tématu Regulární výrazy .NET.

Úprava řetězce

Třída String obsahuje následující metody, které se zdá upravit hodnotu řetězce:

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

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

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

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

  • Replace nahradí podřetětce jiným podřetětcem 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 od začátku a konce řetězce.

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

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

Důležité

Všechny metody úprav řetězců vrací nový String objekt. Neupravují hodnotu aktuální instance.

Extrahování podřetězců z řetězce

Metoda String.Split odděluje jeden řetězec do více řetězců. Přetížení metody umožňují určit více oddělovačů, omezit počet podřetězců, které metoda extrahuje, oříznout prázdné místo z podřetězců a určit, zda jsou prázdné řetězce (které se vyskytují při sousedních oddělovačů) jsou zahrnuty mezi vrácenými řetězci.

Kombinování řetězců

Pro zřetězení řetězců lze použít následující String 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ý podřetězce.

Formátování hodnot

Metoda String.Format používá složenou funkci formátování k nahrazení jednoho nebo více zástupných symbolů v řetězci řetězcovou reprezentací některého objektu nebo hodnoty. Metoda Format se často používá k provedení následujících kroků:

  • Vložení řetězcové reprezentace číselné hodnoty do řetězce

  • Vložení řetězcové reprezentace hodnoty data a času do řetězce

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

  • Chcete-li vložit řetězcovou reprezentaci některého objektu, který podporuje IFormattable rozhraní v řetězci.

  • Zarovnání do bloku doprava nebo doleva do bloku podřetězce v poli ve větším řetězci.

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

Zkopírování řetězce

K vytvoření kopie řetězce můžete volat následující String metody:

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

Normalizace řetězce

V kódování Unicode může mít jeden znak více bodů kódu. Normalizace převede tyto ekvivalentní znaky na stejnou binární reprezentaci. Metoda String.Normalize 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 String třídy na hodnotu označenou zadaným ukazatelem na pole znaků Unicode.

String(Char*, Int32, Int32)

Inicializuje novou instanci String třídy na hodnotu označ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 označenou zadaným znakem Unicode opakuje zadaný početkrát.

String(Char[])

Inicializuje novou instanci String třídy na znaky Unicode uvedené v zadaném poli znaků.

String(Char[], Int32, Int32)

Inicializuje novou instanci String třídy na hodnotu označenou polem znaků Unicode, počátečním umístěním znaku v tomto poli a délkou.

String(ReadOnlySpan<Char>)

Inicializuje novou instanci String třídy na znaky Unicode uvedené v zadaném rozsahu jen pro čtení.

String(SByte*)

Inicializuje novou instanci String třídy na hodnotu označenou ukazatelem na pole 8bitové znaménka celá čísla.

String(SByte*, Int32, Int32)

Inicializuje novou instanci String třídy na hodnotu označenou zadaným ukazatelem na pole 8bitové znaménka celé číslo, počáteční pozici v tomto poli a délku.

String(SByte*, Int32, Int32, Encoding)

Inicializuje novou instanci String třídy na hodnotu označenou zadaným ukazatelem na pole 8bitové znaménka celé číslo, počáteční pozici v této matici, délku a Encoding objekt.

Pole

Empty

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

Vlastnosti

Chars[Int32]

Char Získá 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 String objektů a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.

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

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

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

Porovnává podřetězce dvou zadaných String objektů, ignoruje nebo respektuje jejich případ 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 pořadí řazení.

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

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

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

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

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 respektuje 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é String objekty, ignoruje nebo respektuje jejich případ a pomocí informací specifických pro jazykovou verzi ovlivní porovnání a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.

Compare(String, String, CultureInfo, CompareOptions)

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

Compare(String, String, StringComparison)

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

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

Porovnává podřetětěce dvou zadaných String objektů vyhodnocením číselných hodnot odpovídajících Char objektů v jednotlivých podřetěžcích.

CompareOrdinal(String, String)

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

CompareTo(Object)

Porovná tuto instanci se zadaným Object a určuje, zda tato instance předchází, následuje nebo se zobrazí ve stejné pozici v pořadí řazení jako zadaná Object.

CompareTo(String)

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

Concat(IEnumerable<String>)

Zřetězí členy vytvořené 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 volitelných parametrů 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 znaků jen pro čtení.

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

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

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

Zřetězí řetězcové reprezentace čtyř zadaných 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 označující, zda se v tomto řetězci vyskytuje zadaný znak.

Contains(Char, StringComparison)

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

Contains(String)

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

Contains(String, StringComparison)

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

Copy(String)
Zastaralé.

Vytvoří novou instanci String se stejnou hodnotou jako zadaná 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 konkrétní délkou a inicializuje ho po vytvoření pomocí zadaného zpětného volání.

EndsWith(Char)

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

EndsWith(String)

Určuje, zda 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 při porovnání se zadanou jazykovou verzí.

EndsWith(String, StringComparison)

Určuje, zda konec této instance řetězce odpovídá zadanému řetězci při porovnání pomocí zadané možnosti porovnání.

EnumerateRunes()

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

Equals(Object)

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

Equals(String)

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

Equals(String, String)

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

Equals(String, String, StringComparison)

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

Equals(String, StringComparison)

Určuje, zda má tento řetězec a zadaný String objekt stejnou hodnotu. Parametr určuje jazykovou verzi, malá a velká písmena a pravidla řazení použitá v 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ězcovou reprezentací 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 jednotlivé znaky v tomto řetězci.

GetHashCode()

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

GetHashCode(ReadOnlySpan<Char>)

Vrátí kód hash zadaného rozsahu znaků jen pro čtení.

GetHashCode(ReadOnlySpan<Char>, StringComparison)

Vrátí kód hash zadaného znaku jen pro čtení pomocí zadaných pravidel.

GetHashCode(StringComparison)

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

GetPinnableReference()

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

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

GetType()

Type Získá aktuální instanci.

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

TypeCode Vrátí hodnotu pro String třídu.

IndexOf(Char)

Hlásí nulový index prvního výskytu zadaného znaku Unicode v tomto řetězci.

IndexOf(Char, Int32)

Hlásí nulový index 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í nulový index prvního výskytu zadaného znaku v této instanci. Hledání začíná na zadané pozici znaku a zkoumá zadaný počet pozic znaků.

IndexOf(Char, StringComparison)

Hlásí nulový index prvního výskytu zadaného znaku Unicode v tomto řetězci. Parametr určuje typ hledání, který se má použít pro zadaný znak.

IndexOf(String)

Hlásí nulový index prvního výskytu zadaného řetězce v této instanci.

IndexOf(String, Int32)

Hlásí nulový index 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í nulový index prvního výskytu zadaného řetězce v této instanci. Hledání začíná na zadané pozici znaku a zkoumá zadaný počet pozic znaků.

IndexOf(String, Int32, Int32, StringComparison)

Hlásí nulový index 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 k hledání a typ hledání, který se má použít pro zadaný řetězec.

IndexOf(String, Int32, StringComparison)

Hlásí nulový index 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 hledání, který se má použít pro zadaný řetězec.

IndexOf(String, StringComparison)

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

IndexOfAny(Char[])

Hlásí nulový index prvního výskytu v této instanci libovolného znaku v zadaném poli znaků Unicode.

IndexOfAny(Char[], Int32)

Hlásí nulový index prvního výskytu v této instanci libovolného znaku v zadaném poli znaků Unicode. Hledání začíná na zadané pozici znaku.

IndexOfAny(Char[], Int32, Int32)

Hlásí nulový index prvního výskytu v této instanci libovolného znaku v zadaném poli znaků Unicode. Hledání začíná na zadané pozici znaku a zkoumá zadaný počet pozic znaků.

Insert(Int32, String)

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

Intern(String)

Načte odkaz Stringna zadaný systém .

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 formátu normalizace Unicode.

IsNullOrEmpty(String)

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

IsNullOrWhiteSpace(String)

Určuje, zda je nullzadaný řetězec , 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 umístěným na value startIndex pozici a zřetězením až k count prvkům.

Join(String, IEnumerable<String>)

Zřetězí členy vytvořené IEnumerable<T> kolekce typu Stringpomocí zadaného oddělovače mezi jednotlivými členy.

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

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

Zřetězí zadané prvky řetězce 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)

Hlásí pozici indexu založeného na nule posledního výskytu zadaného znaku Unicode v této instanci.

LastIndexOf(Char, Int32)

Hlásí pozici indexu založeného na nule posledního výskytu zadaného znaku Unicode v této instanci. Hledání začne na určené pozici znaku a postupuje zpět na začátek řetězce.

LastIndexOf(Char, Int32, Int32)

Hlásí pozici indexu založeného na nule posledního výskytu zadaného znaku Unicode v podřetězení 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)

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 směrem k začátku ř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)

Hlásí nulový index 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ý se má provést při hledání zadaného řetězce.

LastIndexOf(String, StringComparison)

Hlásí nulový index 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 směrem k začátku ř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 ve formátu normalizace Unicode C.

Normalize(NormalizationForm)

Vrátí nový řetězec, jehož textová hodnota je stejná jako tento řetězec, ale jehož binární reprezentace je v zadaném formátu normalizace Unicode.

PadLeft(Int32)

Vrátí nový řetězec, který zarovná znaky v této instanci tak, že je odsadí mezerami vlevo pro zadanou celkovou délku.

PadLeft(Int32, Char)

Vrátí nový řetězec, který zarovná znaky v této instanci tak, že je odsadí nalevo se zadaným znakem Unicode pro zadanou celkovou délku.

PadRight(Int32)

Vrátí nový řetězec, který zarovná znaky v tomto řetězci tak, že je odsadí mezerami vpravo pro zadanou celkovou délku.

PadRight(Int32, Char)

Vrátí nový řetězec, který zarovná znaky v tomto řetězci tak, že je odsadí na pravé straně se 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 po 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 se všechny výskyty zadaného znaku Unicode v této instanci nahradí jiným zadaným znakem Unicode.

Replace(String, String)

Vrátí nový řetězec, ve kterém se všechny výskyty zadaného řetězce v aktuální instanci nahradí jiným zadaným řetězcem.

Replace(String, String, Boolean, CultureInfo)

Vrátí nový řetězec, ve kterém se všechny výskyty zadaného řetězce v aktuální instanci nahradí jiným zadaným řetězcem pomocí zadané jazykové verze a citlivosti velkých a malých písmen.

Replace(String, String, StringComparison)

Vrátí nový řetězec, ve kterém se všechny výskyty zadaného řetězce v aktuální instanci nahradí jiným zadaným řetězcem pomocí zadaného typu porovnání.

ReplaceLineEndings()

Nahradí všechny sekvence newline v aktuálním řetězci znakem NewLine.

ReplaceLineEndings(String)

Nahradí všechny sekvence newline v aktuálním řetězci 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ě zadaného oddělovače znaků, volitelně vynechá 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ě i možností.

Split(Char[])

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

Split(Char[], Int32)

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

Split(Char[], Int32, StringSplitOptions)

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

Split(Char[], StringSplitOptions)

Rozdělí řetězec na podřetězce na základě zadaných oddělovacích znaků 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ě i 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 řetězců s oddělovači a volitelně i možností.

Split(String[], StringSplitOptions)

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

StartsWith(Char)

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

StartsWith(String)

Určuje, zda 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 při 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ězce začíná na zadané pozici znaku a pokračuje na konci řetězce.

Substring(Int32, Int32)

Načte podřetězec z této instance. Podřetězení 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ěžci 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 pomocí pravidel pro velikost písmen zadané jazykové verze.

ToLowerInvariant()

Vrátí kopii tohoto String objektu převedenou na malá písmena pomocí pravidel písmen invariantní jazykové verze.

ToString()

Vrátí tuto instanci ; Stringneprovádí se žádný skutečný převod.

ToString(IFormatProvider)

Vrátí tuto instanci ; Stringneprovádí se žádný skutečný převod.

ToUpper()

Vrátí kopii tohoto řetězce převedeného na velká písmena.

ToUpper(CultureInfo)

Vrátí kopii tohoto řetězce převedeného na velká písmena pomocí pravidel velikostí písmen zadané jazykové verze.

ToUpperInvariant()

Vrátí kopii tohoto String objektu převedenou na velká písmena pomocí pravidel pro vložení invariantní jazykové verze.

Trim()

Odebere z aktuálního řetězce všechny počáteční a koncové znaky prázdných znaků.

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 z aktuálního řetězce všechny počáteční prázdné znaky.

TrimStart(Char)

Odebere všechny počáteční výskyty zadaného znaku z aktuálního řetězce.

TrimStart(Char[])

Odebere všechny počáteční výskyty sady znaků zadaných 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ů jen pro čtení.

Inequality(String, String)

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

Explicitní implementace rozhraní

IComparable.CompareTo(Object)

Porovná tuto instanci se zadaným Object a označuje, zda tato instance předchází, následuje nebo se zobrazí ve stejném pořadí řazení jako zadaná Object.

IConvertible.GetTypeCode()

TypeCode Vrátí hodnotu pro String třídu.

IConvertible.ToBoolean(IFormatProvider)

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

IConvertible.ToByte(IFormatProvider)

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

IConvertible.ToChar(IFormatProvider)

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

IConvertible.ToDateTime(IFormatProvider)

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

IConvertible.ToDecimal(IFormatProvider)

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

IConvertible.ToDouble(IFormatProvider)

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

IConvertible.ToInt16(IFormatProvider)

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

IConvertible.ToInt32(IFormatProvider)

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

IConvertible.ToInt64(IFormatProvider)

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

IConvertible.ToSByte(IFormatProvider)

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

IConvertible.ToSingle(IFormatProvider)

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

IConvertible.ToString(IFormatProvider)

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

IConvertible.ToUInt32(IFormatProvider)

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

IConvertible.ToUInt64(IFormatProvider)

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

IEnumerable.GetEnumerator()

Vrátí výčet, který iteruje prostřednictvím aktuálního String objektu.

IEnumerable<Char>.GetEnumerator()

Vrátí výčet, který iteruje prostřednictvím aktuálního String objektu.

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

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

Použije funkci akumulátoru pro sekvenci. Zadaná počáteční hodnota 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 pro 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 nějaké 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í zadaný vstup 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 s možnou Decimal hodnotou null, 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 s možnou Double hodnotou null, 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 s možnou Int32 hodnotou null, 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 s možnou Int64 hodnotou null, 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 s možnou Single hodnotou null, 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 maximálně 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ého 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 kolekci singleton, 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ří průnik dvou sekvencí podle zadané funkce selektoru klíčů.

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

Vytvoří průnik dvou sekvencí podle zadané funkce selektoru klíčů.

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> klíč 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 na každém prvku sekvence a vrátí maximální Decimal hodnotu.

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

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

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

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

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

Vyvolá transformační funkci pro každý prvek 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 pro každý prvek 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 pro každý prvek sekvence a vrátí minimální hodnotu nullable Decimal .

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

Vyvolá transformační funkci pro každý prvek 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>)

Prodá jednotlivé prvky sekvence do nového formuláře začleněním indexu prvku.

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

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

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

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

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

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

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

Prodá každý prvek sekvence na IEnumerable<T>, zploštějí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků na každém prvku v něm. Index každého zdrojového prvku se používá v přechodné projektované formě 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 rovny porovnáním jejich prvků pomocí zadané IEqualityComparer<T>.

Single<TSource>(IEnumerable<TSource>)

Vrátí jediný prvek sekvence a vyvolá výjimku, pokud v sekvenci není právě 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 více než jeden prvek splňuje podmínku.

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 takový prvek neexistuje; tato metoda vyvolá výjimku, pokud více než jeden prvek splňuje podmínku.

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

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

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

Vrátí novou výčtovou kolekci, která obsahuje prvky z source posledních count prvků zdrojové kolekce, která není 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 prvku 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ří nový ReadOnlyMemory<Char> v zadaném rozsahu 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 ze 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é