String Třída

Reference

Definice

Obor názvů:: System

Sestavení:: System.Runtime.dll

Sestavení:: mscorlib.dll

Sestavení:: netstandard.dll

Důležité

Některé informace platí pro předběžně vydaný produkt, který se může zásadně změnit, než ho výrobce nebo autor vydá. Microsoft neposkytuje žádné záruky, výslovné ani předpokládané, týkající se zde uváděných informací.

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: Object
String

Atributy: SerializableAttribute ComVisibleAttribute

Implementuje: IEnumerable<Char> IEnumerable IComparable IComparable<String> IConvertible IEquatable<String> ICloneable

Poznámky

Řetězec je sekvenční kolekce znaků, která se používá 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 objektu String je obsah sekvenční kolekce System.Char objektů a tato hodnota je neměnná (to znamená, že je 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, neboli asi 1 miliarda znaků.

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

V této části:

Vytvoření instance objektu String
Objekty znaků a znaky kódování 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ěnitelnost a třída StringBuilder
Řádové operace vs. operace zohledňující jazykovou verzi
Normalizace
Operace s řetězci podle kategorie

Vytvoření instance objektu String

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

Přiřazením řetězcového literálu String k proměnné. Toto je nejčastěji používaná metoda pro vytvoření řetězce. Následující příklad používá přiřazení k vytvoření několika řetězců. Všimněte si, že v jazyce C# a F# a vzhledem k tomu, že zpětné lomítko (\) je řídicí znak, musí být zpětná lomítka literálu v řetězci řídicí nebo musí být celý řetězec @-uvozován.

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á pole bajtů 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 jazyce Visual Basic) vytvoříte jeden řetězec z libovolné kombinace instancí a řetězcových String literálů. Následující příklad ukazuje 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řevést hodnotu nebo objekt na její řetězcovou reprezentaci. Následující příklad používá funkci složeného formátování k vložení řetězcové reprezentace dvou objektů do řetězce.

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

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

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, která se označuje také jako bod kódu Unicode nebo řadová (číselná) hodnota znaku Unicode. Každý bod kódu je kódován pomocí kódování UTF-16 a číselná hodnota každého prvku kódování je reprezentována objektem Char .

Poznámka

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

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

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

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

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

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

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

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

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

open System
open System.IO

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

    let singleChar = "\u00e4"
    sw.WriteLine singleChar

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

Imports System.Globalization
Imports System.IO

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

Doplňkový kódový bod unicode (náhradní pár) je reprezentován objektem Char , jehož kódovým bodem je vysoká náhrada následovaná objektem Char , jehož kódový bod je nízký náhradník. Jednotky kódu s vysokou náhradou jsou v rozsahu od U+D800 do U+DBFF. Jednotky kódu s nízkými náhradami jsou v rozsahu od U+DC00 do U+DFFF. Náhradní páry se používají k reprezentaci znaků v 16 doplňkových rovinách Unicode. Následující příklad vytvoří náhradní znak a předá ho Char.IsSurrogatePair(Char, Char) metodě k určení, zda se jedná o náhradní pár.

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ódový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 v .NET reprezentována výčtem UnicodeCategory . Kategorie znaku nebo náhradní dvojice lze určit voláním CharUnicodeInfo.GetUnicodeCategory metody.

.NET udržuje vlastní tabulku znaků a jejich odpovídající kategorie, což zajišťuje, že konkrétní verze implementace .NET spuštěné na různých platformách vrací stejné informace o kategoriích znaků. Ve všech verzích .NET a na všech platformách operačního systému poskytuje znaková databáze Unicode informace o kategoriích znaků.

Následující tabulka uvádí verze rozhraní .NET a verze standardu Unicode, na kterých jsou založeny jejich kategorie znaků.

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

Kromě toho .NET podporuje porovnávání a řazení řetězců na základě standardu Unicode. Rozhraní .NET Framework 4 a předchozí verze udržují vlastní tabulku řetězcových dat. To platí i pro verze rozhraní .NET Framework počínaje rozhraním .NET Framework 4.5 ve Windows 7. Počínaje rozhraním .NET Framework 4.5 spuštěným v Windows 8 a novějších verzích operačního systému Windows deleguje modul runtime operace porovnání a řazení řetězců do operačního systému. V systémech .NET Core a .NET 5+ poskytují informace o porovnání a řazení řetězců mezinárodní součásti pro knihovny Unicode (s výjimkou verzí windows před Aktualizace Windows 10 z května 2019). Následující tabulka uvádí verze rozhraní .NET a verze standardu Unicode, na kterých je založeno porovnávání a řazení znaků.

Verze .NET	Verze standardu Unicode
.NET Framework 1.1	Standard Unicode, verze 4.0.0
.NET Framework 2,0	Standard Unicode, verze 5.0.0
.NET Framework 3.5	Standard Unicode, verze 5.0.0
.NET Framework 4	Standard Unicode, verze 5.0.0
.NET Framework 4.5 a novější ve Windows 7	Standard Unicode, verze 5.0.0
.NET Framework 4.5 a novější v 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. Nicméně, v některých jazycích, jako je C a C++, znak null označuje konec řetězce; nepovažuje se za součást řetězce a nezapočítává se jako součást délky řetězce. To znamená, že následující běžné předpoklady, které programátoři jazyka C a C++ nebo knihovny napsané v jazyce C nebo C++ můžou vytvářet o řetězcích, nemusí být při použití na String objekty nutně platné:

Hodnota vrácená funkcemi strlen nebo wcslen se nemusí nutně rovnat String.Lengthhodnotě .
Řetězec vytvořený funkcemi strcpy_s nebo wcscpy_s nemusí být nutně identický s řetězcem vytvořeným metodou String.Copy .

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

Vložené znaky null v řetězci se také zpracovávají odlišně při řazení (nebo porovnání) řetězce a při hledání řetězce. Při porovnávání dvou řetězců, včetně porovnání pomocí invariantní jazykové verze, se znaky null ignorují. Považují se pouze za pořadové nebo malá a velká písmena. Na druhou stranu, vložené znaky null se vždy zvažují při prohledávání řetězce pomocí metod, jako Containsjsou , StartsWitha IndexOf.

Řetězce a indexy

Index je umístění objektu Char (nikoli znaku Unicode) v objektu String. Index je nulové, nezánětné číslo, které začíná od první pozice v řetězci, což je pozice indexu nula. Řada vyhledávacích metod, například IndexOf a LastIndexOf, vrací 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 jazyce 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 hledá prázdné znaky nebo interpunkční znamény v řetězci, aby zjistil, 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 objekty Char 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.

Hodnoty po sobě jdoucích indexů nemusí odpovídat po sobě jdoucím znakům Unicode, protože znak Unicode může být zakódován jako více než jeden Char objekt. Řetězec může zejména 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 pracovat se znaky Unicode místo Char objektů, použijte System.Globalization.StringInfo třídy a TextElementEnumerator nebo metodu String.EnumerateRunes Rune a strukturu. Následující příklad znázorňuje rozdíl mezi kódem, který pracuje s Char objekty, a kódem, který pracuje se znaky Unicode. Porovnává počet znaků nebo textových prvků v jednotlivých slovech 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 émotion que "+
                     L"je commence à raconter ici les aventures " +
                     L"extraordinaires de Joseph Rouletabille."; 
  
   // Character counters. 
   int nChars = 0;
   // Objects to store word count.
   List<int>^ chars = gcnew List<int>();
   List<int>^ elements = gcnew List<int>();

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

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

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

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

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

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

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

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

open System
open System.Globalization

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

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

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

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

Imports System.Collections.Generic
Imports System.Globalization

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

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

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

Tento příklad pracuje s textovými elementy pomocí StringInfo.GetTextElementEnumerator metody a TextElementEnumerator třídy pro výčet všech textových elementů 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 místo 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 nemá přiřazenou hodnotu, je null. Pokus o volání metod pro tento řetězec vyvolá .NullReferenceException Řetězec null se liší od prázdného řetězce, což je řetězec, jehož hodnota je "" nebo String.Empty. V některých případech předání řetězce null nebo prázdného řetězce jako argumentu ve volání metody vyvolá výjimku. Například předání řetězce null metodě Int32.Parse vyvolá ArgumentNullExceptiona předání prázdného řetězce vyvolá FormatException. V jiných případech může být argumentem metody řetězec null nebo prázdný řetězec. Pokud například poskytujete IFormattable implementaci pro třídu, chcete rovnítku řetězec null i prázdný řetězec se specifikátorem obecného formátu ("G").

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

IsNullOrEmpty, která označuje, jestli se řetězec rovná nullString.Emptynebo . Tato metoda eliminuje potřebu používat kód, jako je 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, jestli se řetězec rovná nullString.Emptynebo se skládá výhradně z prázdných znaků. Tato metoda eliminuje potřebu používat kód, jako je například následující:

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

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

if str = 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 v implementaci IFormattable.ToString vlastní Temperature třídy. Metoda podporuje řetězce formátu "G", "C", "F" a "K". Pokud je metodě předán prázdný formátovací řetězec nebo formátovací řetězec, jehož hodnota je null předána, změní se jeho hodnota na formátovací řetězec "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é zdánlivě String upravují objekt, 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é přidání nebo odstranění toho, co se zdá být jedním řetězcem, mohou provést 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 se 1000 znaky v rozsahu 0x0001 0x052F. I když se zdá, že kód používá zřetězení řetězců k připojení nového znaku k existujícímu řetězci s názvem 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 proměnlivé. Když zřetězíte, připojíte nebo odstraníte podřetězce z řetězce, operace se provádějí s jedním řetězcem. Po dokončení úprav hodnoty objektu StringBuilder můžete volat jeho StringBuilder.ToString metodu a převést ji na řetězec. Následující příklad nahradí String objekt použitý v předchozím příkladu ke zřetězení 1 000 náhodných znaků v rozsahu, aby se 0x0001 0x052F s 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í ordinální operace nebo operace závislé na jazykové verzi (lingvistické) objektuString. Pořadová operace funguje na číselnou hodnotu každého Char objektu. Operace citlivá na jazykovou verzi působí na hodnotu objektu String a bere v úvahu pravidla pro velká a malá písmena, řazení, formátování a parsování specifická pro jazykovou verzi. 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í se stejným řetězcem vést k velmi odlišným výsledkům.

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

Důležité

Pokud vaše aplikace učiní bezpečnostní rozhodnutí 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í závislého na jazykové verzi použít pořadové porovnání. Důvodem je to, že porovnání závislé na jazykové verzi může přinést různé výsledky v závislosti na použité jazykové verzi, zatímco řadové porovnání závisí výhradně na binární hodnotě porovnávaných znaků.

Důležité

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

Operace pro vytváření velkých a malých písmen, parsování a formátování, porovnání a řazení a testování rovnosti můžou být buď pořadové, nebo závislé na jazykové verzi. Následující části popisují 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ů závislých na jazykové verzi pomocí konvencí aktuální jazykové verze byste měli volat metodu Compare(String, String, StringComparison) s hodnotou StringComparison.CurrentCulture argumentu comparisonType . Další informace najdete v tématu Osvědčené postupy pro používání řetězců.

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

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

Velikost písmen

Pravidla pro velká písmena určují, jak změnit velká písmena znaku Unicode; Například od malých písmen k velkým písmenům. Operace vytváření malých a malých písmen se často provádí před porovnáním řetězců. Řetězec může být například převeden na velká písmena, aby se dal porovnat s jiným řetězcem velkými písmeny. Znaky v řetězci můžete převést voláním metody nebo ToLowerInvariant na malá písmena a voláním metody nebo ToUpperInvariant je můžete převést na velká písmenaToUpper.ToLower Kromě toho můžete použít metodu k převodu TextInfo.ToTitleCase řetězce na velká písmena názvu.

Poznámka

.NET Core běžící pouze v systémech Linux a macOS: Chování kolace pro jazykové verze jazyka C a Posix vždy rozlišuje velká a malá písmena, protože tyto jazykové verze nepoužívají očekávané pořadí řazení Unicode. K provádění operací řazení, které rozlišují jazykovou verzi a nerozlišují malá a velká písmena, doporučujeme používat jinou jazykovou verzi než jazyk C nebo Posix.

Operace s velikostí a velikostí 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ůže lišit v závislosti na použité jazykové verzi, může se výsledek operací s velikostí písmen lišit v závislosti na jazykové verzi. Skutečné rozdíly v velikostech jsou tři druhy:

Rozdíly v mapování velkých písmen latinky I (U+0049), MALÉ PÍSMENO LATINKY I (U+0069), VELKÉ PÍSMENO LATINKY I S TEČKOU NAD (U+0130) a MALÉ PÍSMENO LATINKY I (U+0131). V jazykových verzích tr-TR (turečtina (Turecko)) a az-Latn-AZ (Ázerbájdžán, latinka) a v neutrálních kulturách tr, az a az-Latn je ekvivalent velkého písmene LATINKY I malými písmeny latinky MALÉ PÍSMENO BEZ TEČKY I a ekvivalentem velkého písmena MALÉ PÍSMENO LATINKY I je VELKÉ PÍSMENO LATINKY I S TEČKOU NAHOŘE. Ve všech ostatních jazykových verzích, včetně neutrální jazykové verze, malé písmeno latinky I a VELKÉ PÍSMENO LATINKY I jsou ekvivalenty malých a velkých písmen.

Následující příklad ukazuje, jak porovnání řetězců navržené tak, aby zabránilo přístupu k systému souborů může selhat, pokud se spoléhá na porovnání velkých a malých verzí citlivé na jazykovou verzi. (Měly by být použity konvence vytváření malých a malých písmen 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 použití pravidel velikosti písmen invariantní jazykové verze ke změně znaku na velká nebo malá písmena vrátí stejný znak. Pro všechny ostatní jazykové verze vrátí jiný znak. Některé z ovlivněných znaků jsou uvedeny v následující tabulce.

Znak	Pokud se změní na	Návraty
ZNAMÉNKO 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 BEZ TEČKY I (U+0131)	Velká písmena	VELKÉ PÍSMENO LATINKY I (U+0049)
MALÉ PÍSMENO LATINKY S (U+017F)	Velká písmena	VELKÉ PÍSMENO LATINKY S (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)
KOMBINACE ŘECKÉHO YPOGEGRAMMENI (U+0345)	Velká písmena	ŘECKÉ VELKÉ PÍSMENO IOTA (U+0399)

Rozdíly v mapování případů dvoumísmenných párů malých a velkých písmen v rozsahu znaků ASCII. Ve většině jazykových verzí se dvoumísmenná dvojice s malými a malými písmeny rovná ekvivalentnímu dvoumísmenné dvojici velkých a malých písmen. 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 hr-HR (chorvatština (Chorvatsko)) kultura.
- "cH" v kulturách cs-CZ (česká (Česká republika)) a sk-SK (slovenština (Slovensko)).
- "aA" v jazykové verzi da-DK (dánština (Dánsko)).
- "cS", "dZ", "dZS", "nY", "sZ", "tY" a "zS" v kultuře hu-HU (maďarština (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 kultuře vi-VN (vietnamština(Vietnam)).
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 velkých písmen 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"ǅenana" };
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"),  
                                                               gcnew CultureInfo("tr-TR") };

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

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

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

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

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

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

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

open System
open System.Globalization
open System.IO

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

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

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

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

Imports System.Globalization
Imports System.IO

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

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

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

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ězcovou reprezentaci, zatímco pravidla analýzy určují, jak převést řetězcovou reprezentaci na hodnotu, jako je datum a čas. Pravidla formátování i parsování jsou závislá 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 data, není možné zjistit, jestli 03/01/2011, 3.3.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ě, jak ukazuje následující příklad, jeden řetězec může vytvořit různá data v závislosti na jazykové verzi, jejíž konvence se používají v operaci parsování.

using namespace System;
using namespace System::Globalization;

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

using System;
using System.Globalization;

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

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 k jazykové verzi. Pořadí řazení může být například založené na fonetice nebo na vizuálním znázornění znaků. Ve východoasijských jazycích jsou znaky řazeny podle úhozů a radikálu ideografických znaků. Řazení závisí také na pořadí, které jazyky a jazykové verze používají pro abecedu. Dánský jazyk má například znak „Æ“, který se abecedně řadí za znak „Z“. Kromě toho můžou být porovnávání rozlišovat malá a malá písmena nebo nerozlišovat velká a malá písmena a pravidla pro malá písmena se můžou lišit podle jazykové verze. Porovnání řad na druhé straně používá 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 porovnání dvou řetězců. 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 jazykové porovnání, které používá konvence aktuální jazykové verze; pokud je StringComparison.Ordinalhodnota parametru , metoda provede porovnání řad. V důsledku toho, jak ukazuje následující příklad, pokud je aktuální jazyková verze americká angličtina, první volání String.Compare(String, String, StringComparison) metody (pomocí porovnání s jazykovou verzí) považuje "a" za menší než "A", ale druhé volání stejné metody (pomocí porovnání řad) považuje "a" za 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 řadových řad:

Řazení slov provádí porovnání řetězců citlivých na jazykovou verzi, ve kterých některé nefanumerické znaky Unicode mohou mít přiřazené zvláštní váhy. Například spojovník (-) může mít přiřazenou velmi malou váhu, aby se vedle sebe v seřadeném seznamu zobrazovaly "coop" a "co-op". Seznam String metod, které porovnávají dva řetězce pomocí pravidel řazení slov, najdete v části Operace řetězců 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 neafanumerické symboly mají před všemi alfanumerickými 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 zadaný hodnotou CompareOptions.StringSort. Všimněte si, že toto je jediná metoda, kterou .NET poskytuje pro porovnání dvou řetězců pomocí pravidel řazení řetězců.
Řadové řazení porovnává řetězce na základě číselné hodnoty každého Char objektu v řetězci. Při porovnávání řad se automaticky rozlišují malá a velká písmena, protože verze znaku s malými a velkými písmeny mají různé body kódu. Pokud ale velikost písmen není důležitá, můžete zadat porovnání řad, které ignoruje malá a velká písmena. To je ekvivalentem převodu řetězce na velká písmena pomocí invariantní jazykové verze a následného porovnání řad s výsledkem. Seznam String metod, které porovnávají dva řetězce pomocí pravidel řazení řad, najdete v části Operace řetězců podle kategorie .

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 CultureInfo.InvariantCulture vlastností. Implicitní jazyková verze je aktuální jazyková verze, která je určena vlastnostmi Thread.CurrentCulture a CultureInfo.CurrentCulture . Pořadí řazení abecedních znaků (tj. znaků, pro které Char.IsLetter vlastnost vrací true) je značně proměnlivé napříč jazykovými verzemi. Porovnání citlivé na jazykovou verzi, které používá konvence konkrétní jazykové verze, můžete určit zadáním objektu CultureInfo do metody porovnání řetězců, jako Compare(String, String, CultureInfo, CompareOptions)je . Můžete určit 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 odpovídající přetížení Compare metody. Porovnání citlivé na jazykovou verzi je obecně vhodné pro řazení, zatímco řadové porovnání není. Porovnání řadových řad 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 porovnáním s jazykovou verzí a řadovým porovnáním. Příklad vyhodnocuje tři řetězce, "Apple", "Æble" a "AEble", pomocí porovnání řad a konvencí jazykových verzí da-DK a en-US (z nichž každý je výchozí jazykovou verzí v době, kdy Compare je metoda volána). Vzhledem k tomu, že dánština považuje znak "Æ" za samostatné písmeno a řadí ho v abecedě za "Z", ř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". Jazyková verze en-US neobsahuje písmeno "Æ", ale považuje ho za ekvivalent "AE", což vysvětluje, proč je "Æble" menší než "Apple", ale rovná se "AEble". Naproti tomu ordinální porovnání považuje "Jablko" za menší než "Æble" a "Æble" za 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

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

Pokud chcete, aby se řetězce seřadily podle jazykové verze uživatele, měli byste je seřadit na základě konvencí aktuální jazykové verze. Pokud se změní jazyková verze uživatele, odpovídajícím způsobem se změní i pořadí seřazených řetězců. Například aplikace tesaurus by měla vždy řadit slova na základě jazykové verze uživatele.
Pokud chcete, aby řetězce byly seřazeny na základě konvencí konkrétní jazykové verze, měli byste je uspořádat tak, že do metody porovnání zadáte CultureInfo objekt, který představuje tuto jazykovou verzi. Například v aplikaci navržené tak, aby učila studenty určitému jazyku, chcete, aby řetězce byly seřazeny na základě konvencí jedné z jazykových verzí, které tímto jazykem 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 řadové porovnání. Například pomocí řadového řazení můžete uspořádat názvy souborů, procesů, mutexů nebo pojmenovaných kanálů.
Pro porovnání, které zahrnuje rozhodnutí o zabezpečení (například jestli je uživatelské jméno platné), byste vždy měli provést ordinální test rovnosti voláním přetížení Equals metody.

Poznámka

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Tip

Rozhraní .NET interně používá klíče řazení k podpoře porovnání kulturně citlivých řetězců. 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 vah pro konkrétní řetězec. Pokud vaše aplikace provádí velké množství operací vyhledávání nebo řazení ve stejné sadě řetězců, můžete její výkon zlepšit generováním a ukládáním klíčů řazení pro všechny řetězce, které používá. Pokud se vyžaduje operace řazení nebo porovnání, použijete místo řetězců klíče řazení. Další informace najdete ve SortKey třídě.

Pokud nezadáte konvenci porovnání řetězců, metody řazení, jako Array.Sort(Array) jsou například jazykové verze a velká písmena, seřadí řetězce. 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 anglickou jazykovou verzi (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 zjistit, zda jsou si rovny, měli byste metodu String.Equals volat. Obvykle byste měli použít Equals k provedení porovnání řad. Metoda String.Compare je určena primárně k řazení řetězců.

Metody vyhledávání řetězců, jako String.StartsWith jsou a String.IndexOf, také můžou provádět porovnání řetězců s jazykovou verzí nebo řadovými řetězci. Následující příklad znázorňuje rozdíly mezi porovnáními řadových a jazykových verzí pomocí IndexOf metody . Hledání citlivé na jazykovou verzi, ve kterém je aktuální jazyková verze angličtina (USA), považuje podřetězc "oe" za odpovídající ligaturu "œ". Vzhledem k tomu, že měkký spojovník (U+00AD) je znak s nulovou šířkou, hledání považuje měkké spojovníky za ekvivalent Empty a najde shodu na začátku řetězce. Naproti tomu řadové vyhledávání 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 cooperative at position 0
//       '' found in cooperative at position 2

open System

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

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

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

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

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

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

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ů s jazykovou verzí nebo řadovými řetězci a určit, zda se v zadaném řetězci nachází znak nebo podřetězcec.

Vyhledávací metody ve String třídě, které hledají jednotlivé znaky, jako IndexOf je například metoda, nebo jeden ze sady znaků, jako IndexOfAny je metoda, provádějí ordinální vyhledávání. Pokud chcete pro znak vyhledat jazykovou verzi, musíte volat metodu CompareInfo , jako CompareInfo.IndexOf(String, Char) je nebo CompareInfo.LastIndexOf(String, Char). Všimněte si, že výsledky hledání znaku pomocí porovnání řad a jazykových verzí se můžou velmi lišit. Například hledání předkompilovaného znaku Unicode, jako je ligatura "Æ" (U+00C6), může v závislosti na jazykové verzi odpovídat jakémukoli výskytu jeho komponent ve správném pořadí, například "AE" (U+041U+0045). Následující příklad znázorňuje rozdíl mezi String.IndexOf(Char) metodami a CompareInfo.IndexOf(String, Char) při hledání jednotlivých znaků. Ligatura "æ" (U+00E6) se nachází v řetězci "aerial" při použití konvencí jazykové verze en-US, ale ne při použití konvencí jazyka da-DK nebo při provádění porovnání pořadových řad.

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ě metody tříd, String které vyhledávají řetězec místo znaku, provádějí vyhledávání citlivé na jazykovou verzi, pokud nejsou možnosti hledání explicitně určeny parametrem typu StringComparison. Jedinou výjimkou je Contains, který provádí ř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 voláním String.Equals metody otestujte rovnost. Vzhledem k tomu, že test rovnosti obvykle porovnává vstup uživatele s nějakým známým řetězcem, jako je platné uživatelské jméno, heslo nebo cesta systému souborů, jedná se obvykle o ř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 rovny, měli byste volat jedno z přetížení String.Equals metody. Upřednostňované přetížení, které se má volat, je buď metoda instance Equals(String, StringComparison) , nebo statická Equals(String, String, StringComparison) metoda, protože obě metody obsahují System.StringComparison parametr, který explicitně určuje typ porovnání.

Následující příklad znázorňuje nebezpečí provedení porovnání rovnosti citlivého na jazykovou verzi, pokud by se místo toho měla použít řadová. V tomto případě je záměrem kódu zakázat přístup k systému souborů z adres URL, které začínají na "FILE://" nebo "file://", provedením porovnání začátku adresy URL bez rozlišování velkých a malých písmen 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 ekvivalentu malého písmena "i" je "İ" místo "I". V důsledku toho je přístup k systému souborů neúmyslně povolen. Na druhou stranu, pokud je provedeno porovnání řad, porovnání rovnosti je ú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 kterýkoli z následujících bodů kódu může představovat písmeno "ắ":

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

Více reprezentací pro jeden znak komplikuje vyhledávání, řazení, porovnávání a další řetězcové operace.

Standard Unicode definuje proces s názvem normalizace, který vrací jednu binární reprezentaci znaku Unicode pro libovolné jeho ekvivalentní binární reprezentace. 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 normalizační formuláře Unicode C, D, KC a KD. Pokud jsou řetězce normalizovány do stejné normalizační formy, lze je porovnat pomocí porovnání řad.

Ordinální 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 porovnání řad, včetně následujících:

Jakékoli přetížení Comparemetod , Equals, StartsWith, EndsWith, IndexOfa LastIndexOf , které obsahují StringComparison parametr. Metoda provede porovnání pořadových řad, pokud zadáte hodnotu StringComparison.Ordinal nebo OrdinalIgnoreCase pro tento parametr.
Přetížení CompareOrdinal metody.
Metody, které ve výchozím nastavení používají porovnání řad, například Contains, Replacea Split.
Metody, které vyhledávají Char hodnotu nebo prvky v Char poli v instanci řetězce. Mezi tyto metody patří IndexOf(Char) a Split(Char[]).

Můžete zjistit, zda je řetězec normalizován na normalizační formulář C voláním String.IsNormalized() metody, nebo můžete voláním String.IsNormalized(NormalizationForm) metody určit, zda je řetězec normalizován do zadaného normalizačního formuláře. Můžete také volat metodu String.Normalize() pro převod řetězce na normalizační formulář 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 Normalize() tématu metody a Normalize(NormalizationForm) .

Následující jednoduchý příklad znázorňuje normalizaci řetězců. Definuje písmeno "ố" třemi různými způsoby ve třech různých řetězcích a pomocí porovnání řad pro rovnost určí, že se každý řetězec liší od ostatních dvou řetězců. Potom převede každý řetězec na podporované normalizační formuláře a znovu provede ordinální porovnání každého řetězce v zadané normalizační formě. V každém případě druhý test rovnosti ukazuje, že řetězce jsou si rovny.

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

public ref class Example
{
private:
   StreamWriter^ sw;

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

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

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

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

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

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

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

      sw->Close(); 
   }
};

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

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

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

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

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

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

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

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

open System
open System.IO
open System.Text

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Další informace o normalizačních a normalizačních formulářích najdete v tématech System.Text.NormalizationForm, a standardní příloha Unicode č. 15: Formuláře normalizace unicode a nejčastější dotazy k normalizaci na webu unicode.org.

Operace s řetězci podle kategorie

Třída String poskytuje členy pro porovnávání řetězců, testování řetězců z hlediska rovnosti, vyhledání znaků nebo podřetězcec v řetězci, úpravu řetězce, extrahování podřetězcec 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ů

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

Compare vrátí celé číslo, které označuje vztah jednoho řetězce k druhému řetězci v pořadí řazení.
CompareOrdinal vrátí celé číslo, které označuje vztah jednoho řetězce k druhému řetězci na základě porovnání jejich bodů kódu.
CompareTo vrátí celé číslo, které označuje vztah instance aktuálního řetězce k druhému řetězci v pořadí řazení. Metoda CompareTo(String) poskytuje IComparable implementace a IComparable<T> pro String třídu.

Testování řetězců z hlediska rovnosti

Voláním Equals metody určíte, zda jsou dva řetězce rovny. 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 řadové a zda je zvažována nebo ignorována velká a velká písmena. Většina testů rovnosti je pořadových a porovnání rovnosti, která určují přístup k systémovému prostředku (například k objektu systému souborů), by měla být vždy řadová.

Vyhledání znaků v řetězci

Třída String obsahuje dva druhy metod vyhledávání:

Metody, které vracejí Boolean hodnotu označující, zda určitý podřetězc je přítomen v instanci řetězce. Patří mezi ně Containsmetody , EndsWitha StartsWith .
Metody označující počáteční pozici podřetězce v instanci řetězce. Patří mezi ně IndexOfmetody , IndexOfAny, LastIndexOfa LastIndexOfAny .

Upozornění

Pokud chcete v řetězci hledat konkrétní vzor místo konkrétního podřetězce, měli byste použít regulární výrazy. Další informace najdete v tématu Regulární výrazy .NET.

Úprava řetězce

Třída String obsahuje následující metody, které se zdají 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čátek řetězce.
PadRight vloží jeden nebo více výskytů zadaného znaku na konec řetězce.
Remove odstraní podřetěžce z aktuální String instance.
Replace nahradí podřetětce jiným podřetěžcem 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 úpravy řetězců vrátí nový String objekt. Neupravují hodnotu aktuální instance.

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

Metoda String.Split rozdělí jeden řetězec do více řetězců. Přetížení metody umožňují zadat více oddělovačů, omezit počet podřetězců, které metoda extrahuje, oříznout prázdné znaky z podřetězců a určit, zda jsou prázdné řetězce (ke kterým dochází, když jsou oddělovače sousední) zahrnuty mezi vrácené řetězce.

Kombinování řetězců

Pro zřetězení řetězců je možné 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ězí do jednoho prvku a přidá oddělovač mezi každý podřetěc.

Formátování hodnot

Metoda String.Format používá funkci složeného 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 se Format často používá k následujícímu:

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 IFormattable , který podporuje rozhraní v řetězci.
K zarovnání podřetězce doprava nebo doleva do podřetězce v poli ve větším řetězci.

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

Kopírování řetězce

Pokud chcete vytvořit kopii ř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 do stejné binární reprezentace. Metoda String.Normalize provádí normalizaci a metoda String.IsNormalized 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 určenou zadaným ukazatelem na pole znaků Unicode, počáteční pozici znaku v této matici a délku.
String(Char, Int32)	Inicializuje novou instanci String třídy na hodnotu označenou zadaným znakem Unicode opakovaným zadaným počtem opakování.
String(Char[])	Inicializuje novou instanci String třídy na znaky Unicode uvedené v zadané znakové pole.
String(Char[], Int32, Int32)	Inicializuje novou instanci String třídy na hodnotu označenou polem znaků Unicode, počáteční pozici znaku v této matici a délku.
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ých celých čísel se znaménkem.
String(SByte*, Int32, Int32)	Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole 8bitových celých čísel se znaménkem, počáteční pozici v rámci tohoto pole a délku.
String(SByte*, Int32, Int32, Encoding)	Inicializuje novou instanci String třídy na hodnotu určenou zadaným ukazatelem na pole 8bitových celých čísel se znaménkem, počáteční pozici v rámci tohoto pole, délky a objektu Encoding .

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 objektu String.
Compare(String, Int32, String, Int32, Int32)	Porovná podřetězce dva zadané String objekty 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ězcec 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á podřetězcec dvou zadaných String objektů, ignoruje nebo dodržuje jejich velikost a používá informace specifické pro jazykovou verzi k ovlivnění porovnání a vrátí celé číslo, které označuje jejich relativní pozici v pořadí řazení.
Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)	Porovná podřetěcece 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 vzájemný vztah mezi dvěma podřetětětci v pořadí řazení.
Compare(String, Int32, String, Int32, Int32, StringComparison)	Porovná podřetězce dva zadané String objekty 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 velikost 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 velikost a použije 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, String, CultureInfo, CompareOptions)	Porovná dva zadané String objekty pomocí zadaných možností porovnání a informací specifických pro jazykovou verzi, aby ovlivnily porovnání, a vrátí celé číslo, které označuje vzájemný vztah mezi dvěma řetězci 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ěžce dvou zadaných String objektů vyhodnocením číselných hodnot odpovídajících Char objektů v každém podřetěžci.
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 zobrazuje 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 zobrazuje na stejné pozici 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 znakových rozsahů jen pro čtení.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Zřetězí řetězcové reprezentace tří zadaných znakových rozsahů jen pro čtení.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Zřetězí řetězcové reprezentace čtyř zadaných znakových rozsahů jen pro čtení.
Concat(String, String)	Zřetězí dvě zadané instance objektu String.
Concat(String, String, String)	Zřetězí tři zadané instance objektu String.
Concat(String, String, String, String)	Zřetězí čtyři zadané instance objektu 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 určující, zda se zadaný znak vyskytuje v tomto řetězci pomocí zadaných porovnávacích pravidel.
Contains(String)	Vrátí hodnotu označující, zda se v tomto řetězci vyskytuje zadaný podřetězcec.
Contains(String, StringComparison)	Vrátí hodnotu označující, zda se zadaný řetězec vyskytuje v rámci tohoto řetězce pomocí zadaných porovnávacích pravidel.
Copy(String)	Zastaralé. Vytvoří novou instanci objektu se String 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 určitou 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í pomocí zadané jazykové verze.
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 z Rune tohoto řetězce.
Equals(Object)	Určuje, zda tato instance a zadaný objekt, který musí být String také objektem, mají stejnou hodnotu.
Equals(String)	Určuje, zda tato instance a jiný zadaný String objekt mají 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 jazykovou verzi, případ a pravidla řazení použitá při porovnání.
Equals(String, StringComparison)	Určuje, zda tento řetězec a zadaný String objekt mají stejnou hodnotu. Parametr určuje jazykovou verzi, případ a pravidla řazení použitá při porovnání.
Format(IFormatProvider, CompositeFormat, Object[])	Představuje text jako posloupnost jednotek kódu UTF-16.
Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)	Představuje text jako posloupnost jednotek kódu UTF-16.
Format(IFormatProvider, String, Object)	Nahradí formátovanou položku nebo položky v zadaném řetězci řetězcovou reprezentací odpovídajícího objektu. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.
Format(IFormatProvider, String, Object, Object)	Nahradí položky formátu v řetězci řetězcovou reprezentací dvou zadaných objektů. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.
Format(IFormatProvider, String, Object, Object, Object)	Nahradí položky formátu v řetězci řetězcovou reprezentací tří zadaných objektů. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.
Format(IFormatProvider, String, Object[])	Nahradí položky formátu v řetězci řetězcovými reprezentacemi odpovídajících objektů v zadaném poli. Parametr poskytuje informace o formátování specifické pro jazykovou verzi.
Format(String, Object)	Nahradí jednu nebo více položek formátu v řetězci řetězcovou reprezentací zadaného objektu.
Format(String, Object, Object)	Nahradí položky formátu v řetězci řetězcovou reprezentací dvou zadaných objektů.
Format(String, Object, Object, Object)	Nahradí položky formátu v řetězci řetězcovou reprezentací tří zadaných objektů.
Format(String, Object[])	Nahradí položku formátu v zadaném řetězci řetězcovou reprezentací odpovídajícího objektu v zadaném poli.
Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)	Představuje text jako posloupnost jednotek kódu UTF-16.
Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)	Představuje text jako posloupnost jednotek kódu UTF-16.
Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)	Představuje text jako posloupnost jednotek kódu UTF-16.
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 pro zadaný rozsah znaků jen pro čtení.
GetHashCode(ReadOnlySpan<Char>, StringComparison)	Vrátí kód hash pro zadaný rozsah znaků 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 v indexu nula. Tato metoda je určena pro podporu kompilátorů .NET a není určena k vyvolání uživatelským kódem.
GetType()	Získá aktuální Type instanci. (Zděděno od Object)
GetTypeCode()	Vrátí hodnotu TypeCode 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 prozkoumá 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 vyhledává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 prozkoumá zadaný počet pozic znaků.
IndexOf(String, Int32, Int32, StringComparison)	Hlásí index založený na nule prvního výskytu zadaného řetězce v aktuálním String objektu. Parametry určují počáteční pozici hledání v aktuálním řetězci, počet znaků v aktuálním řetězci, který se má hledat, a typ hledání, který se má použít pro zadaný řetězec.
IndexOf(String, Int32, StringComparison)	Hlásí index založený na nule 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í index založený na nule 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 prozkoumá 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 systému na zadaný String.
IsInterned(String)	Načte odkaz na zadaný String.
IsNormalized()	Určuje, zda je tento řetězec ve formátu normalizace unicode C.
IsNormalized(NormalizationForm)	Určuje, zda je tento řetězec v zadaném formátu normalizace unicode.
IsNullOrEmpty(String)	Označuje, jestli je `null` zadaný řetězec nebo prázdný řetězec ("").
IsNullOrWhiteSpace(String)	Určuje, zda zadaný řetězec je `null`, prázdný nebo se skládá pouze z prázdných znaků.
Join(Char, Object[])	Zřetězí řetězcové reprezentace pole objektů pomocí zadaného oddělovače mezi jednotlivými členy.
Join(Char, String[])	Zřetězí pole řetězců pomocí zadaného oddělovače mezi jednotlivými členy.
Join(Char, String[], Int32, Int32)	Zřetězí pole řetězců pomocí zadaného oddělovače mezi jednotlivými členy, počínaje elementem v `value` umístění a `startIndex` zřetězením až k prvkům `count` .
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 objektů pomocí zadaného oddělovače mezi jednotlivými prvky.
Join(String, String[])	Zřetězí všechny prvky pole řetězců pomocí zadaného oddělovače mezi jednotlivými elementy.
Join(String, String[], Int32, Int32)	Zřetězí zadané prvky pole řetězců pomocí zadaného oddělovače mezi jednotlivými elementy.
Join<T>(Char, IEnumerable<T>)	Zřetězí členy kolekce pomocí zadaného oddělovače mezi jednotlivými členy.
Join<T>(String, IEnumerable<T>)	Zřetězí členy kolekce pomocí zadaného oddělovače mezi jednotlivými členy.
LastIndexOf(Char)	Hlásí nulovou pozici indexu posledního výskytu zadaného znaku Unicode v této instanci.
LastIndexOf(Char, Int32)	Hlásí nulovou pozici indexu 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í nulovou pozici indexu 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 na začátek řetězce pro zadaný počet pozic znaků. Parametr určuje typ porovnání, který se má provést při hledání zadaného řetězce.
LastIndexOf(String, Int32, StringComparison)	Hlásí nulový index posledního výskytu zadaného řetězce v aktuálním 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 aktuálním 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ří mělkou kopii aktuálního Objectsouboru . (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 doprava tím, že je odsadí mezerami na levé straně pro zadanou celkovou délku.
PadLeft(Int32, Char)	Vrátí nový řetězec, který zarovná znaky v této instanci doprava tím, že je nalevo odsadí zadaným znakem Unicode pro zadanou celkovou délku.
PadRight(Int32)	Vrátí nový řetězec, který zarovná znaky v tomto řetězci doleva 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 doleva tím, že je vpravo odsadí 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 na zadané pozici a pokračováním až do poslední pozice.
Remove(Int32, Int32)	Vrátí nový řetězec, ve kterém byl odstraněn zadaný počet znaků v aktuální instanci začínající na zadané pozici.
Replace(Char, Char)	Vrátí nový řetězec, ve kterém jsou všechny výskyty zadaného znaku Unicode v této instanci nahrazeny jiným zadaným znakem Unicode.
Replace(String, String)	Vrátí nový řetězec, ve kterém jsou všechny výskyty zadaného řetězce v aktuální instanci nahrazeny jiným zadaným řetězcem.
Replace(String, String, Boolean, CultureInfo)	Vrátí nový řetězec, ve kterém jsou všechny výskyty zadaného řetězce v aktuální instanci nahrazeny jiným zadaným řetězcem pomocí zadané jazykové verze a rozlišování velkých a malých písmen.
Replace(String, String, StringComparison)	Vrátí nový řetězec, ve kterém jsou všechny výskyty zadaného řetězce v aktuální instanci nahrazeny jiným zadaným řetězcem pomocí zadaného typu porovnání.
ReplaceLineEndings()	Nahradí všechny sekvence nového řetězce v aktuálním řetězci řetězcem NewLine.
ReplaceLineEndings(String)	Nahradí všechny sekvence nového řetězce v aktuálním řetězci řetězcem `replacementText`.
Split(Char, Int32, StringSplitOptions)	Rozdělí řetězec na maximální počet podřetězc na základě zadaného znaku oddělovače a volitelně i možností. Rozdělí řetězec na maximální počet podřetězc na základě zadaného oddělovače znaků a volitelně vynechá prázdné podřetězcece 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 oddělovacích znaků.
Split(Char[], Int32)	Rozdělí řetězec na maximální počet podřetězc na základě zadaných oddělovacích znaků.
Split(Char[], Int32, StringSplitOptions)	Rozdělí řetězec na maximální počet podřetězc na základě zadaných oddělovacích znaků a volitelně i 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, které jsou založené na zadaném oddělovači řetězců.
Split(String[], Int32, StringSplitOptions)	Rozdělí řetězec na maximální počet podřetězc na základě zadaných oddělovacích řetězců a volitelně 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í pomocí zadané jazykové verze.
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ězc začíná na zadané pozici znaku a pokračuje na konec řetězce.
Substring(Int32, Int32)	Načte podřetězec z této instance. Podřetě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 velká písmena zadané jazykové verze.
ToLowerInvariant()	Vrátí kopii tohoto String objektu převedenou na malá písmena pomocí pravidel pro vytváření velkých 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řevedenou na velká písmena.
ToUpper(CultureInfo)	Vrátí kopii tohoto řetězce převedeného na velká písmena pomocí pravidel pro velká písmena zadané jazykové verze.
ToUpperInvariant()	Vrátí kopii tohoto String objektu převedenou na velká písmena pomocí pravidel pro vytváření velkých písmen invariantní jazykové verze.
Trim()	Odebere z aktuálního řetězce všechny počáteční a koncové prázdné znaky.
Trim(Char)	Odebere všechny počáteční a koncové instance znaku z aktuálního řetězce.
Trim(Char[])	Odebere všechny počáteční a koncové výskyty sady znaků zadané v poli z aktuálního řetězce.
TrimEnd()	Odebere z aktuálního řetězce všechny koncové prázdné znaky.
TrimEnd(Char)	Odebere všechny koncové výskyty znaku z aktuálního řetězce.
TrimEnd(Char[])	Odebere všechny koncové výskyty sady znaků zadané v poli z aktuálního řetězce.
TrimStart()	Odebere všechny počáteční prázdné znaky z aktuálního řetězce.
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é 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 určuje, zda tato instance předchází, následuje nebo se zobrazuje ve stejné pozici v pořadí řazení jako zadaný Object.
IConvertible.GetTypeCode()	Vrátí hodnotu TypeCode 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 najdete v tématu ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Popis tohoto člena najdete v tématu ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Popis tohoto člena najdete v tématu ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Popis tohoto člena najdete v tématu ToUInt64(IFormatProvider).
IEnumerable.GetEnumerator()	Vrátí enumerátor, který iteruje aktuální String objekt.
IEnumerable<Char>.GetEnumerator()	Vrátí enumerátor, který iteruje aktuální String objekt.

Metody rozšíření

ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Představuje text jako posloupnost jednotek kódu UTF-16.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Představuje text jako posloupnost jednotek kódu UTF-16.
ToFrozenSet<T>(IEnumerable<T>, Boolean)	Představuje text jako posloupnost jednotek kódu UTF-16.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	Představuje text jako posloupnost jednotek kódu UTF-16.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>, Boolean)	Představuje text jako posloupnost jednotek kódu UTF-16.
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 založený na určité transformaci sekvence.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník jejího obsahu.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Vytvoří výčet a transformuje sekvenci a vytvoří neměnný slovník jejího 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 transformuje sekvenci a vytvoří neměnný slovník jejího obsahu pomocí zadaných porovnávačů klíčů a hodnot.
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 jejího obsahu.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Vytvoří výčet a transformuje sekvenci a vytvoří neměnný seřazený slovník jejího obsahu.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Vytvoří výčet a transformuje sekvenci a vytvoří neměnný seřazený slovník jejího 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 transformuje sekvenci a vytvoří neměnný slovník seřazeného obsahu pomocí zadaných porovnávačů klíčů a hodnot.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Vytvoří výčet sekvence a vytvoří neměnnou seřazenou sadu jejího obsahu.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Vytvoří výčet sekvence, vytvoří neměnnou seřazenou sadu jejího obsahu a použije zadaný porovnávač.
CopyToDataTable<T>(IEnumerable<T>)	Vrátí hodnotuDataTable, která obsahuje kopie DataRow objektů vzhledem ke vstupnímu IEnumerable<T> objektu, kde je DataRowobecný parametr `T` .
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Zkopíruje DataRow objekty do zadaného DataTableobjektu s ohledem na vstupní IEnumerable<T> objekt, kde obecný parametr `T` je DataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Zkopíruje DataRow objekty do zadaného DataTableobjektu s ohledem na vstupní IEnumerable<T> objekt, kde obecný parametr `T` je DataRow.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Použije funkci akumulátoru na sekvenci.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Použije funkci akumulátoru na sekvenci. Zadaná počáteční hodnota se použije jako počáteční hodnota akumulátoru.
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Použije funkci akumulátoru na sekvenci. Zadaná počáteční hodnota se použije jako počáteční hodnota akumulátoru a zadaná funkce se použije 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í vstup zadaný jako IEnumerable<T>.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Vypočítá průměr posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce u každého 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 u každého 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 u každého 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 u každého 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 u každého prvku 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 u každého prvku 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 u každého prvku 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 u každého prvku 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 u každého prvku 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 u každého prvku vstupní sekvence.
Cast<TResult>(IEnumerable)	Přetypuje prvky objektu na IEnumerable zadaný typ.
Chunk<TSource>(IEnumerable<TSource>, Int32)	Rozdělí prvky sekvence na bloky o 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é IEqualityComparer<T>.
Count<TSource>(IEnumerable<TSource>)	Vrátí počet prvků v sekvenci.
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 jednoúčelové kolekci, pokud je sekvence prázdná.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Vrátí prvky zadané sekvence nebo zadanou hodnotu v jednoúčelové kolekci, pokud je sekvence prázdná.
Distinct<TSource>(IEnumerable<TSource>)	Vrátí odliš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> pro porovnání hodnot.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Vrátí odlišné prvky ze sekvence podle zadané funkce selektoru klíčů.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Vrátí odlišné prvky ze sekvence podle zadané funkce voliče klíčů a pomocí zadaného porovnávače k porovnání klíčů.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Vrátí element v zadaném indexu v sekvenci.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Vrátí element v zadaném indexu v sekvenci.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Vrátí prvek v zadaném indexu v sekvenci nebo výchozí hodnotu, pokud je index mimo rozsah.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Vytvoří rozdíl sady dvou sekvencí pomocí výchozího porovnávače rovnosti k porovnání hodnot.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Vytvoří rozdíl sady dvou sekvencí pomocí zadané IEqualityComparer<T> k porovnání hodnot.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Vytvoří rozdíl sady dvou sekvencí podle zadané funkce selektoru klíčů.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Vytvoří rozdíl sady dvou sekvencí podle zadané funkce selektoru klíčů.
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 takový prvek nenajde.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Vrátí první prvek sekvence, který splňuje podmínku, nebo zadanou výchozí hodnotu, pokud není nalezen žá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 voliče 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 promítne elementy 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 každé skupiny se promítnou 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 jsou promítány 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 promítnou 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. K porovnání klíčů se používá výchozí porovnávače rovnosti.
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ě rovnosti klíčů a seskupuje výsledky. Zadaná IEqualityComparer<T> hodnota se používá k porovnání klíčů.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Vytvoří množinu průniku dvou sekvencí pomocí výchozího porovnávače rovnosti k porovnání hodnot.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Vytvoří množinu průniku dvou sekvencí pomocí zadané IEqualityComparer<T> k porovnání hodnot.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Vytvoří množinu průniku dvou sekvencí podle zadané funkce selektoru klíčů.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Vytvoří množinu průniku 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íčů. K porovnání klíčů se používá výchozí porovnávače rovnosti.
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> hodnota 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 žádný takový prvek nenajde.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Vrátí poslední prvek sekvence, která splňuje podmínku, nebo zadanou výchozí hodnotu, pokud není nalezen žádný takový prvek.
LongCount<TSource>(IEnumerable<TSource>)	Vrátí hodnotu Int64 , která představuje celkový počet prvků v sekvenci.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí hodnotu Int64 , která představuje, kolik prvků v sekvenci splňuje podmínku.
Max<TSource>(IEnumerable<TSource>)	Vrátí maximální hodnotu v obecné sekvenci.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Vrátí maximální hodnotu v obecné sekvenci.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Decimal hodnotu.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální Double hodnotu.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Vyvolá transformační funkci 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 s možnou Decimal hodnotou null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Double hodnotou null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Int32 hodnotou null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Int64 hodnotou null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí maximální hodnotu s možnou Single hodnotou null.
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 voliče 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 s možnou Decimal hodnotou null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Double hodnotou null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Int32 hodnotou null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Int64 hodnotou null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Vyvolá transformační funkci pro každý prvek sekvence a vrátí minimální hodnotu s možnou Single hodnotou null.
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 voliče klíčů a porovnávače klíčů.
OfType<TResult>(IEnumerable)	Filtruje prvky objektu IEnumerable na základě zadaného typu.
Order<T>(IEnumerable<T>)	Seřadí prvky sekvence ve vzestupném pořadí.
Order<T>(IEnumerable<T>, IComparer<T>)	Seřadí prvky sekvence ve vzestupném pořadí.
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.
OrderDescending<T>(IEnumerable<T>)	Seřadí prvky sekvence v sestupném pořadí.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	Seřadí prvky sekvence v sestupném pořadí.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Přidá hodnotu na začátek sekvence.
Reverse<TSource>(IEnumerable<TSource>)	Invertuje pořadí prvků v sekvenci.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Promítá každý prvek sekvence do nového formuláře.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Promítá každý prvek sekvence do nové podoby začleněním indexu elementu.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Promítá každý prvek sekvence na a IEnumerable<T> zploštějí výsledné sekvence do jedné sekvence.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Promítá každý prvek sekvence na IEnumerable<T>a zploštěluje výsledné sekvence do jedné sekvence. Index každého zdrojového elementu se používá v projektované formě tohoto elementu.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Promítne každý prvek sekvence na IEnumerable<T>, zploštějí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků pro každý prvek v této sekvenci.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Promítne každý prvek sekvence na IEnumerable<T>, zploštějí výsledné sekvence do jedné sekvence a vyvolá funkci selektoru výsledků pro každý prvek v této sekvenci. 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 rovny 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 si dvě sekvence rovny, porovnáním jejich prvků pomocí zadaného IEqualityComparer<T>.
Single<TSource>(IEnumerable<TSource>)	Vrátí jediný prvek sekvence a vyvolá výjimku, pokud v sekvenci není přesně jeden prvek.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí jediný prvek sekvence, který splňuje zadanou podmínku, a vyvolá výjimku, pokud existuje více než jeden takový prvek.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Vrátí jediný prvek sekvence, nebo výchozí hodnotu, pokud je sekvence prázdná; tato metoda vyvolá výjimku, pokud je v sekvenci více než jeden prvek.
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)	Vrátí jediný prvek sekvence nebo zadanou výchozí hodnotu, pokud je posloupnost 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 žádný 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 žádný 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 sekvenci a vrátí zbývající prvky.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Vrátí novou výčtovou kolekci, která obsahuje elementy z `source` , přičemž poslední `count` prvky zdrojové kolekce jsou vynechány.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Obchází prvky v sekvenci, pokud je zadaná podmínka pravdivá, a pak vrátí zbývající prvky.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Obchází prvky v sekvenci, pokud je zadaná podmínka pravdivá, a pak vrátí zbývající prvky. Index elementu se používá v logice predikátové funkce.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Vypočítá součet posloupnosti Decimal hodnot, které jsou získány vyvoláním transformační funkce u každého 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 u každého 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 u každého 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 u každého 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 pro každý prvek 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 pro každý prvek 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 pro každý prvek 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 pro každý prvek 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 pro každý prvek 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` elementy z `source`.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Vrátí prvky ze sekvence, pokud je zadaná podmínka pravdivá.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Vrátí prvky ze sekvence, pokud je zadaná podmínka pravdivá. Index elementu 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ří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů a porovnávače klíčů.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadaného selektoru klíčů a funkcí selektoru prvků.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Dictionary<TKey,TValue> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů, porovnávače a funkce selektoru prvků.
ToHashSet<TSource>(IEnumerable<TSource>)	Vytvoří z HashSet<T> objektu IEnumerable<T>.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	HashSet<T> Vytvoří z objektu IEnumerable<T> pomocí `comparer` příkazu k porovnání klíčů.
ToList<TSource>(IEnumerable<TSource>)	Vytvoří z List<T> objektu IEnumerable<T>.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů a porovnávače klíčů.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadaného selektoru klíčů a funkcí selektoru prvků.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Lookup<TKey,TElement> Vytvoří z objektu IEnumerable<T> podle zadané funkce selektoru klíčů, 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ří sadu sjednocení dvou sekvencí pomocí výchozího porovnávače rovnosti.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Vytvoří sjednocení sady dvou sekvencí pomocí zadané IEqualityComparer<T>.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Vytvoří sjednocení sady dvou sekvencí podle zadané funkce selektoru klíčů.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Vytvoří sjednocení sady dvou sekvencí podle zadané funkce selektoru klíčů.
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ří posloupnost řazených kolekcí členů s prvky ze dvou zadaných sekvencí.
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)	Vytvoří sekvenci řazených kolekcí č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 objekt 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ří nový `ReadOnlyMemory<Char>` přes část cílového řetězce začínající na zadaném indexu.
AsMemory(String, Int32)	Vytvoří nový `ReadOnlyMemory<Char>` přes část cílového řetězce začínající na zadané pozici znaku.
AsMemory(String, Int32, Int32)	Vytvoří nový `ReadOnlyMemory<Char>` přes čá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í části 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 do formátu normalizace unicode C.
Normalize(String, NormalizationForm)	Normalizuje řetězec do zadaného formuláře normalizace unicode.
Ancestors<T>(IEnumerable<T>)	Vrátí kolekci prvků, která obsahuje nadřazené součásti všech uzlů ve zdrojové kolekci.
Ancestors<T>(IEnumerable<T>, XName)	Vrátí filtrovanou kolekci prvků, která obsahuje nadřazené součásti všech uzlů ve zdrojové kolekci. V kolekci jsou zahrnuty pouze prvky, které mají odpovídající 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á obsahuje 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í odpovídající 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í odpovídající XName .
InDocumentOrder<T>(IEnumerable<T>)	Vrátí kolekci uzlů, která obsahuje všechny uzly ve zdrojové kolekci seřazené podle 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 všechny uzly 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.

String Třída

Definice

Poznámky

Vytvoření instance objektu String

Objekty znaků a znaky kódování 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ěnitelnost a třída StringBuilder

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

Velikost písmen

Analýza a formátování

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

Hledání v řetězcích

Testování rovnosti

Normalizace

Operace s řetězci podle kategorie

Porovnávání řetězců

Testování řetězců z hlediska rovnosti

Vyhledání znaků v řetězci

Úprava řetězce

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

Kombinování řetězců

Formátování hodnot

Kopírování řetězce

Normalizace řetězce

Konstruktory

Pole

Vlastnosti

Metody

Operátory

Explicitní implementace rozhraní

Metody rozšíření

Platí pro

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

Viz také

Další materiály