System.String osztály

Megjegyzés

Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.

A sztring a szöveg ábrázolására használt karakterek szekvenciális gyűjteménye. Az String objektum egy sztringet képviselő objektumok szekvenciális gyűjteménye System.Char ; az System.Char objektum egy UTF-16 kódegységnek felel meg. Az String objektum értéke a System.Char objektumok szekvenciális gyűjteményének tartalma, és ez az érték változtathatatlan (azaz írásvédett). A sztringek nem módosíthatóságával kapcsolatos további információkért tekintse meg az Immutability és a StringBuilder osztály szakaszt. A memóriában lévő objektumok maximális mérete String 2 GB vagy körülbelül 1 milliárd karakter.

További információ a Unicode-ról, az UTF-16-ról, a kódegységekről, a kódpontokról és a Char Rune típusokról: Bevezetés a karakterkódolásba a .NET-ben.

Sztringobjektum példányosítása

Egy String objektumot a következő módokon lehet példányosítani:

Sztringkonstans változóhoz String rendelésével. Ez a sztringek létrehozásához leggyakrabban használt módszer. Az alábbi példa hozzárendeléssel hoz létre több sztringet. Vegye figyelembe, hogy c# és F# nyelven, mivel a fordított perjel (\) egy feloldó karakter, a sztringben lévő literális fordított perjeleket meg kell szökni, vagy a teljes sztringet @-idézőjellel kell megadni.

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

Az String osztálykonstruktor meghívásával. Az alábbi példa több osztálykonstruktor meghívásával példányosítja a sztringeket. Vegye figyelembe, hogy egyes konstruktorok paraméterként karaktertömbökre mutató vagy aláírt bájttömböket tartalmaznak. A Visual Basic nem támogatja a konstruktorokhoz intézett hívásokat. A konstruktorokkal kapcsolatos String részletes információkért tekintse meg a konstruktor-összegzést String.

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

A sztringösszefűzési operátorral (C# és F# esetében +, illetve Visual Basicben & vagy +) egyetlen sztringet hozhat létre a példányok és a sztringkonstansok tetszőleges kombinációjából. Az alábbi példa a sztringösszefűzési operátor használatát mutatja be.

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.

Egy tulajdonság beolvasásával vagy egy sztringet visszaadó metódus meghívásával. Az alábbi példa a String osztály metódusaival nyer ki egy részsztringet egy nagyobb sztringből.

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

Egy érték vagy objektum sztring-ábrázolására szolgáló formázási metódus meghívásával. Az alábbi példa az összetett formázási funkcióval ágyazza be két objektum sztringbe való ábrázolását.

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.

Karakterobjektumok és Unicode-karakterek

A sztring minden karakterét Unicode skaláris érték határozza meg, más néven Unicode-kódpont vagy Unicode-karakter sorszámértéke (numerikus). Minden kódpont kódolása UTF-16 kódolással történik, a kódolás egyes elemeinek numerikus értékét pedig egy Char objektum jelöli.

Megjegyzés

Vegye figyelembe, hogy mivel egy String példány UTF-16 kódegységek szekvenciális gyűjteményéből áll, létrehozhat egy String olyan objektumot, amely nem egy jól formázott Unicode-sztring. Létrehozhat például egy olyan sztringet, amely alacsony helyettessel rendelkezik, de nem rendelkezik megfelelő magas helyettessel. Bár egyes metódusok, például a névtérben lévő System.Text objektumok kódolásának és dekódolásának módjai, ellenőrzésekkel gondoskodhatnak arról, hogy a sztringek megfelelően formázva legyenek, String az osztálytagok nem biztosítják, hogy a sztringek megfelelően legyenek formázva.

Char Egy objektum általában egyetlen kódpontot jelöl, azaz a kódpont numerikus értéke Char egyenlő. Az "a" karakter kódpontja például U+0061. Egy kódponthoz azonban több kódolt elemre is szükség lehet (egynél Char több objektumra). A Unicode szabvány két karaktertípust határoz meg, amelyek több Char objektumnak felelnek meg: gráfok és Unicode kiegészítő kódpontok, amelyek a Unicode kiegészítő síkjaiban szereplő karaktereknek felelnek meg.

A gráfokat egy alap karakter jelöli, amelyet egy vagy több egyesítési karakter követ. Az ä karaktert például egy Char olyan objektum jelöli, amelynek kódpontja U+0061, majd egy Char olyan objektum, amelynek kódpontja U+0308. Ezt a karaktert egyetlen Char objektum is definiálhatja, amely U+00E4 kódponttal rendelkezik. Ahogy az alábbi példa is mutatja, az egyenlőség kultúraérzékeny összehasonlítása azt jelzi, hogy ez a két ábrázolás egyenlő, noha egy ordinális összehasonlítás nem. Ha azonban a két sztring normalizálva van, az ordinális összehasonlítás azt is jelzi, hogy egyenlőek. (További információ a sztringek normalizálásáról: Normalizálási szakasz.)

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

public class Example5
{
   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 Example9
    Public Sub Main()
        Dim sw As New StreamWriter(".\graphemes.txt")
        Dim grapheme As String = ChrW(&H61) + ChrW(&H308)
        sw.WriteLine(grapheme)

        Dim singleChar As String = ChrW(&HE4)
        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

A Unicode kiegészítő kódpontokat (helyettesítő párokat) egy Char olyan objektum jelöli, amelynek kódpontja egy magas helyettesítő, amelyet egy Char olyan objektum követ, amelynek a kódpontja alacsony helyettesítő. A magas helyettesítők kódegységei U+D800 és U+DBFF között mozognak. Az alacsony helyettesítők kódegységei U+DC00 és U+DFFF között mozognak. A helyettesítő párok a 16 Unicode kiegészítő síkban lévő karaktereket jelölik. Az alábbi példa létrehoz egy helyettesítő karaktert, és átadja a Char.IsSurrogatePair(Char, Char) metódusnak annak megállapításához, hogy helyettesítő pár-e.

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: {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 Example20
    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

A Unicode szabvány

A sztringek karaktereit UTF-16 kódolt kódegységek jelölik, amelyek megfelelnek a Char értékeknek.

A sztring minden karaktere rendelkezik Unicode-karakterkategóriával, amelyet a .NET-ben az UnicodeCategory enumerálás jelöl. A karakter vagy helyettesítő pár kategóriája a metódus meghívásával CharUnicodeInfo.GetUnicodeCategory határozható meg.

A .NET saját karaktertáblát és a hozzájuk tartozó kategóriákat tart fenn, amely biztosítja, hogy a különböző platformokon futó .NET-implementáció egy adott verziója azonos karakterkategória-információkat adjon vissza. Az összes .NET-verzióban és minden operációsrendszer-platformon a unicode karakteradatbázis adja meg a karakterkategória adatait.

Az alábbi táblázat a .NET-verziókat és a Unicode Standard azon verzióit sorolja fel, amelyeken a karakterkategóriák alapulnak.

.NET-verzió	A Unicode Standard verziója
.NET-keretrendszer 1.1	A Unicode Standard 4.0.0-s verziója
.NET-keretrendszer 2.0	A Unicode Standard 5.0.0-s verziója
.NET keretrendszer 3.5-ös verziója	A Unicode Standard 5.0.0-s verziója
.NET-keretrendszer 4	A Unicode Standard 5.0.0-s verziója
.NET-keretrendszer 4.5	A Unicode Standard 6.3.0-s verziója
.NET-keretrendszer 4.5.1	A Unicode Standard 6.3.0-s verziója
.NET-keretrendszer 4.5.2	A Unicode Standard 6.3.0-s verziója
.NET-keretrendszer 4.6	A Unicode Standard 6.3.0-s verziója
.NET-keretrendszer 4.6.1-es verziója	A Unicode Standard 6.3.0-s verziója
.NET-keretrendszer 4.6.2-s és újabb verziók	A Unicode Standard 8.0.0-s verziója
.NET Core 2.1	A Unicode Standard 8.0.0-s verziója
.NET Core 3.1	A Unicode Standard, 11.0.0-s verzió
.NET 5	A Unicode Standard, 13.0.0-s verzió

A .NET emellett támogatja a Karakterláncok összehasonlítását és rendezését a Unicode szabvány alapján. A Windows operációs rendszer Windows 8-on és újabb verzióin futó .NET-keretrendszer 4.5-ös verziójától kezdve a futtatókörnyezet sztring-összehasonlítási és rendezési műveleteket delegál az operációs rendszerre. A .NET Core-on és a .NET 5+-on a karakterlánc-összehasonlítási és rendezési információkat a Unicode-kódtárakhoz készült nemzetközi összetevők biztosítják (kivéve a Windows Windows 10 2019. májusi frissítése előtti verzióit). Az alábbi táblázat a .NET verzióit és a Unicode Standard azon verzióit sorolja fel, amelyeken a karakter-összehasonlítás és -rendezés alapul.

.NET-verzió	A Unicode Standard verziója
.NET-keretrendszer 4.5-ös és újabb verziók Windows 7 rendszeren	A Unicode Standard 5.0.0-s verziója
.NET-keretrendszer 4.5-ös és újabb verziók Windows 8 és újabb Windows operációs rendszereken	A Unicode Standard 6.3.0-s verziója
.NET Core és .NET 5+	Az alapul szolgáló operációs rendszer által támogatott Unicode Standard verziótól függ.

Beágyazott null karakterek

A .NET-ben az String objektumok tartalmazhatnak beágyazott null karaktereket, amelyek a sztring hosszának részét képezik. Egyes nyelvekben, például a C és a C++ nyelvben azonban a null karakter egy sztring végét jelzi; nem tekinthető a sztring részének, és nem számít bele a sztring hosszába. Ez azt jelenti, hogy a C és C++ programozók vagy C++ nyelven írt kódtárak által a sztringekre vonatkozó alábbi gyakori feltételezések nem feltétlenül érvényesek String objektumokra vonatkoztatva.

A strlen vagy a wcslen függvények által visszaadott értékek nem feltétlenül egyenlőek String.Length-vel.
A strcpy_s vagy wcscpy_s függvények által létrehozott sztring nem feltétlenül azonos a másolt sztringgel.

Győződjön meg arról, hogy a natív C és C++ kód, amely String objektumokat példányosít, valamint a platformhíváson keresztül String objektumokat kapó kód ne feltételezzék, hogy egy beágyazott null karakter jelöli a sztring végét.

A beágyazott null karakterek a sztringek rendezésekor (vagy összehasonlításakor) és a sztringek keresésekor is másképp lesznek kezelve. A null karaktereket figyelmen kívül hagyjuk két karakterlánc kultúraérzékeny összehasonlításai során, beleértve az invariáns kultúra alkalmazásával történő összehasonlításokat is. Ezek csak a sorszámos vagy a kis- és nagybetűket nem érzékelyítő ordinális összehasonlítások esetében tekinthetők meg. Másfelől a beágyazott null karaktereket mindig figyelembe veszik, amikor sztringeket olyan módszerekkel keresnek, mint például Contains, StartsWith és IndexOf.

Sztringek és indexek

Az index egy Char objektum (nem Unicode-karakter) pozíciója valamelyik String-ben. Az index egy nulla alapú, nem negatív szám, amely a karaktersorozat első pozíciójától indul, vagyis az index pozíciója nulla. Számos keresési módszer, például IndexOf és LastIndexOf, visszaadja egy karakter vagy alsztring indexét a sztringpéldányban.

A Chars[Int32] tulajdonság lehetővé teszi az egyes Char objektumok elérését a sztring indexpozíciója alapján. Mivel a Chars[Int32] tulajdonság az alapértelmezett tulajdonság (a Visual Basicben) vagy az indexelő (C# és F# nyelven), a sztring egyes Char objektumait az alábbi kóddal érheti el. Ez a kód üres szóközt vagy írásjeleket keres egy sztringben annak meghatározásához, hogy a sztring hány szót tartalmaz.

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
   {s1}
 has {nWords} words.
 """);                                                                     
// 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 Example12
    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)) 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.

Mivel az String osztály implementálja az IEnumerable interfészt, iterálhat a sztringben lévő Char objektumokon egy foreach szerkezettel, ahogy az alábbi példában látható.

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
   {s1}
 has {nWords} words.
 """);
// 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 Example13
    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.

Előfordulhat, hogy az egymást követő indexértékek nem felelnek meg az egymást követő Unicode-karaktereknek, mivel egy Unicode-karakter több Char objektumként is kódolható. A sztringek tartalmazhatnak több karakterből álló szöveges egységeket, amelyeket alapkarakterek alkotnak, amelyeket egy vagy több egyesítő karakter vagy helyettesítő pár követ. Ha objektumok helyett Unicode-karaktereket szeretne használni, használja az Char és System.Globalization.StringInfo osztályokat, valamint a TextElementEnumerator metódust és a String.EnumerateRunes struktúrát. Az alábbi példa a Unicode-karaktereket használó objektumokkal és kódokkal Char működő kódok közötti különbséget mutatja be. Összehasonlítja a mondatok egyes szavaiban szereplő karakterek vagy szövegelemek számát. A karakterlánc két sorozatot tartalmaz: egy alapkaraktert, amelyet egy összevonó karakter követ.

// 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 Example14
    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(&H27) 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(&H27) Then Continue Do
            If String.IsNullOrEmpty(s.Trim()) Or (s.Length = 1 AndAlso Char.IsPunctuation(Convert.ToChar(s))) Then
                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

Ez a példa a StringInfo.GetTextElementEnumerator metódus és a TextElementEnumerator osztály használatával dolgozik, hogy felsorolja a karakterlánc összes szöveges elemét. A metódus meghívásával olyan tömböt is lekérhet, amely tartalmazza az egyes szövegelemek kezdő indexét StringInfo.ParseCombiningCharacters .

Az egyes Char értékek helyett a szövegegységek használatával kapcsolatos további információkért lásd : Bevezetés a karakterkódolásba a .NET-ben.

Null karaktersorok és üres karaktersorok

Az a sztring, amely deklarálva van, de nincs hozzárendelve értékhez, az .null Ha megpróbál metódusokat meghívni a sztringen, egy NullReferenceException kivételt okoz. A null sztring eltér az üres sztringtől, amely egy olyan karakterlánc, amelynek értéke "" vagy String.Empty. Bizonyos esetekben egy metódushívás argumentumaként null sztring vagy üres sztring átadása kivételt eredményez. Ha például null sztringet ad át a Int32.Parse metódusnak, az kivált egy ArgumentNullException kivételt, míg ha egy üres sztringet ad át, akkor egy FormatException kivételt vált ki. Más esetekben a metódusargumentum lehet null vagy üres sztring. Ha például egy osztályhoz biztosít implementációt IFormattable , akkor egy nullértékű és egy üres stringet is azonosítania kell az általános ("G") formátumkijelölővel.

Az String osztály a következő két kényelmi metódust tartalmazza, amelyek lehetővé teszik, hogy tesztelje, a sztring üres-e vagy sem:

IsNullOrEmpty, amely azt jelzi, hogy egy sztring vagy null, vagy egyenlő String.Empty-vel. Ez a módszer szükségtelenné teszi a következő kódhoz hasonló kód használatát:
```
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, amely azt jelzi, hogy egy nullsztring egyenlő-e String.Empty, vagy kizárólag szóköz karakterekből áll. Ez a módszer szükségtelenné teszi a következő kódhoz hasonló kód használatát:

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

Az alábbi példa egy IsNullOrEmpty egyéni IFormattable.ToString osztály implementálásában használja a Temperature metódust. A metódus támogatja a "G", "C", "F" és "K" formátumú sztringeket. Ha egy üres formátumsztringet vagy egy olyan formátumsztringet adnak át a metódusnak, amelynek értéke null, az értéke "G" formátumsztringre változik.

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

A nem módosíthatóság és a StringBuilder osztály

Az String objektumokat nem módosíthatónak (írásvédettnek) nevezzük, mert az értéke a létrehozás után nem módosítható. Azok a metódusok, amelyek úgy tűnik, hogy módosítanak egy objektumot String , valójában egy új String objektumot ad vissza, amely tartalmazza a módosítást.

Mivel a sztringek nem módosíthatók, a sztringmanipulálási rutinok, amelyek ismétlődő kiegészítéseket vagy törléseket hajtanak végre az egyetlen sztringhez, jelentős teljesítménybeli büntetést vonhatnak maga után. Az alábbi kód például egy véletlenszám-generátort használ, hogy létrehozzon egy 1000 karakter hosszú sztringet az 0x0001 és 0x052F közötti tartományban. Bár úgy tűnik, hogy a kód sztringösszefűzést használ egy új karakter hozzáfűzéséhez a meglévő, elnevezett strsztringhez, valójában létrehoz egy új String objektumot minden egyes összefűzési művelethez.

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

public class Example6
{
   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 Example10
    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, &H530))
            If str.Length Mod 60 = 0 Then str += vbCrLf
        Next
        sw.Write(str)
        sw.Close()
    End Sub
End Module

A StringBuilder osztályt használhatja az String osztály helyett olyan műveletekhez, amelyek többször módosítják egy sztring értékét. Az osztály String példányaival ellentétben az StringBuilder objektumok nem módosíthatók; ha egy sztringből összefűz, hozzáfűz vagy töröl részsztringeket, a műveletek egyetlen sztringen lesznek végrehajtva. Ha befejezte egy objektum értékének StringBuilder módosítását, meghívhatja annak metódusát StringBuilder.ToString , hogy sztringgé konvertálja. Az alábbi példa az előző példában használt String helyett egy StringBuilder objektumot alkalmaz 1000 véletlenszerű karakter összefűzésére a 0x0001 és 0x052F tartományban.

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

public class Example10
{
   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 Example11
    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, &H530)))
            If sb.Length Mod 60 = 0 Then sb.AppendLine()
        Next
        sw.Write(sb.ToString())
        sw.Close()
    End Sub
End Module

Sorrendi vs. kultúraérzékeny műveletek

Az String osztály tagjai sorszám vagy kultúraérzékeny (nyelvi) műveleteket hajtanak végre egy String objektumon. Az ordinális művelet az egyes Char objektumok numerikus értékére hat. A kultúraérzékeny művelet az objektum értékére hat, és figyelembe veszi a String kultúraspecifikus burkolati, rendezési, formázási és elemzési szabályokat. A kultúraérzékeny műveletek explicit módon deklarált vagy implicit aktuális kultúra kontextusában hajthatók végre. A két művelettípus nagyon eltérő eredményeket hozhat, ha ugyanazon a sztringen hajtják végre őket.

A .NET támogatja a kultúraérzékeny nyelvi sztringműveleteket is az invariáns kultúra (CultureInfo.InvariantCulture) használatával, amely lazán alapul az angol nyelv régiótól független kulturális beállításain. A többi System.Globalization.CultureInfo beállítástól eltérően az invariáns kultúra beállításai garantáltan egységesek maradnak egyetlen számítógépen, rendszerről rendszerre és a .NET különböző verzióira. Az invariáns kultúra egyfajta fekete dobozként tekinthető, amely biztosítja a szövegelemek összehasonlításának és rendezésének stabilitását minden kultúra esetén.

Fontos

Ha az alkalmazás biztonsági döntést hoz egy szimbolikus azonosítóról, például egy fájlnévről vagy egy elnevezett csőről, vagy a tárolt adatokról, például egy XML-fájl szövegalapú adatairól, a műveletnek a kultúraérzékeny összehasonlítás helyett egy sorszámos összehasonlítást kell használnia. Ennek az az oka, hogy a kultúraérzékeny összehasonlítás a hatályos kultúrától függően eltérő eredményeket hozhat, míg a sorszámok összehasonlítása kizárólag az összehasonlított karakterek bináris értékétől függ.

Fontos

A karakterláncműveleteket végrehajtó legtöbb metódus tartalmaz egy metódus túlterhelést, amelynek van egy StringComparison típusú paramétere, amely lehetővé teszi annak megadását, hogy a metódus ordinalis vagy kultúraérzékeny műveletet hajt-e végre. Általában ezt a túlterhelést kell meghívnia, hogy egyértelmű legyen a metódushívás szándéka. A sztringek sorszám- és kultúraérzékeny műveleteinek használatára vonatkozó ajánlott eljárásokért és útmutatásért tekintse meg a sztringek használatának ajánlott eljárásait.

A casing, az elemzés és a formázás, az összehasonlítás és a rendezés, valamint az egyenlőség tesztelésének műveletei sorrendi vagy kulturális szempontból érzékenyek lehetnek. A következő szakaszok a művelet egyes kategóriáiról szólnak.

Tipp.

Mindig egy olyan metódustúlterhelést kell hívnia, amely egyértelművé teszi a metódushívás szándékát. Például, ahelyett hogy meghívná a Compare(String, String) metódust, hogy az aktuális kultúra konvenciói szerint hajtson végre két sztring kultúraérzékeny összehasonlítását, hívja meg a Compare(String, String, StringComparison) metódust azzal, hogy StringComparison.CurrentCulture értéket adjon meg az comparisonType argumentumnál. További információ: Ajánlott eljárások sztringek használatához.

A rendezési és összehasonlító műveletekben használt karaktersúlyokra vonatkozó információkat tartalmazó szövegfájlok sorát az alábbi hivatkozásokról töltheti le:

Windows (.NET-keretrendszer és .NET Core): Súlytáblák rendezése
Windows 10 2019. májusi frissítése vagy újabb (.NET 5+) és Linux és macOS (.NET Core és .NET 5+): Alapértelmezett Unicode-rendezési elem táblázata

Betűméret

A nagybetűsítési szabályok határozzák meg, hogyan változtatható meg egy Unicode karakter nagybetűsítése, például kisbetűből nagybetűvé. A rendszer gyakran sztring-összehasonlítás előtt hajt végre egy burkolati műveletet. Például egy karakterlánc nagybetűssé alakítható, hogy összehasonlítható legyen egy másik nagybetűs karakterlánccal. A sztringben lévő karaktereket kisbetűssé alakíthatja a ToLower metódus meghívásával ToLowerInvariant , és a metódus meghívásával ToUpper ToUpperInvariant nagybetűssé alakíthatja őket. Emellett a TextInfo.ToTitleCase metódussal címsor esetre alakíthat egy karakterláncot.

Megjegyzés

Csak Linux és macOS rendszereken futó .NET Core: A C- és Posix-kultúrák rendezési viselkedése mindig megkülönbözteti a kis- és nagybetűket, mivel ezek a kultúrák nem a megszokott Unicode rendezési sorrendet használják. Azt javasoljuk, hogy a C vagy a Posixtól eltérő kultúrát használjon a kultúraérzékeny, kis- és nagybetűkre nem érzékeny rendezési műveletek végrehajtásához.

A burkolási műveletek alapulhatnak a jelenlegi kultúra, egy megadott kultúra, vagy az invariáns kultúra szabályain. Mivel az esetleképezések a használt kultúrától függően eltérőek lehetnek, a burkolati műveletek eredménye a kultúrától függően változhat. A burkolatok tényleges különbségei háromféleek:

Különbségek a LATIN NAGY I (U+0049), a LATIN KIS I (U+0069), a LATIN NAGY I PONT FELETT (U+0130) és a LATIN KIS I PONT NÉLKÜL (U+0131) esetleképezésében. A tr-TR (török (Törökország)) és az-Latn-AZ (azerbajdzsáni, latin) kultúrákban, valamint a tr, az és az-Latn semleges kultúrákban a LATIN NAGYBETŰS I betű kisbetűje a LATIN KISBETŰ DOTLESS I, a latin kisbetűs I betű nagybetűs megfelelője pedig a LATIN NAGYBETŰS I PONTTAL. Minden más kultúrában, beleértve az invariáns kultúrát, a LATIN KISBETŰS I és a LATIN NAGYBETŰS I kis- és nagybetűs megfelelői.

Az alábbi példa bemutatja, hogyan hiúsulhat meg a fájlrendszer hozzáférésének megakadályozására tervezett sztring-összehasonlítás, ha kultúraérzékeny burkolat-összehasonlításra támaszkodik. (Az invariáns kultúra burkolati konvencióit kellett volna használni.)

using System;
using System.Globalization;
using System.Threading;

public class Example1
{
   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: {CultureInfo.CurrentCulture.DisplayName}");
         Console.WriteLine(resource);
         Console.WriteLine($"Access allowed: {! 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 Example2
    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

Eltérések az invariáns kultúra és az összes többi kultúra közötti esetleképezésekben. Ezekben az esetekben az invariáns kultúra kis- és nagybetűsítési szabályaival egy karaktert nagy- vagy kisbetűssé alakítva ugyanazt a karaktert kapjuk vissza. Minden más kultúrában egy másik karaktert ad vissza. Az érintett karakterek némelyike az alábbi táblázatban látható.

Karakter	Ha megváltozik	Visszaküldések
MIKRON JEL (U+00B5)	Nagybetű	GÖRÖG NAGYBETŰ MU (U+-39C)
LATIN NAGYBETŰ I FÖLÖTTI PONTTAL (U+0130)	Kisbetűs	LATIN KIS I BETŰ (U+0069)
LATIN KIS BETŰ PONT NÉLKÜLI I (U+0131)	Nagybetű	LATIN NAGYBETŰS I (U+0049)
LATIN KIS BETŰ HOSSZÚ S (U+017F)	Nagybetű	LATIN NAGYBETŰS S (U+0053)
LATIN NAGY D BETŰ KIS Z BETŰVEL CARON (U+01C5)	Kisbetűs	LATIN KIS DZ BETŰ KARONNAL (U+01C6)
GÖRÖG YPOGEGRAMMENI ÖSSZEHANGOLÁSA (U+0345)	Nagybetű	GÖRÖG NAGYBETŰS IOTA (U+0399)

Kétbetűs vegyes kis- és nagybetűpárok esetleképezéseinek különbségei az ASCII karaktertartományban. A legtöbb kultúrában a kétbetűs vegyes kis- és nagybetűs pár egyenlő az egyenértékű kétbetűs nagybetűs vagy kisbetűs párral. Ez nem igaz a következő kétbetűs párokra a következő kultúrákban, mert minden esetben egy digráfhoz hasonlítják őket:
- "lJ" és "nJ" a hr-HR (horvát (Horvátország)) kultúrában.
- "cH" a cs-CZ (Cseh Köztársaság)) és az sk-SK (szlovák (Szlovákia)) kultúrákban.
- "aA" a da-DK (dán (Dánia)) kultúrában.
- "cS", "dZ", "dZS", "nY", "sZ", "tY" és "zS" a hu-HU (magyar (Magyarország)) kultúrában.
- "cH" és "lL" az es-ES_tradnl (spanyol (Spanyolország, hagyományos rendezés)) kultúrában.
- "cH", "gI", "kH", "nG", "nH", "pH", "qU'", "tH" és "tR" a vi-VN (vietnami (Vietnam)) kultúrában.
Szokatlan azonban olyan helyzet, amikor a párok kultúraérzékeny összehasonlítása problémákat okoz, mivel ezek a párok nem gyakoriak rögzített sztringekben vagy azonosítókban.

Az alábbi példa a karakterláncok nagybetűkre alakításakor a kultúrák közötti betűformázási szabályok néhány különbségét szemlélteti.

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

Elemzés és formázás

A formázás és az elemzés inverz művelet. A formázási szabályok határozzák meg, hogyan alakíthatók át egy érték (például dátum és idő vagy szám) sztring-ábrázolására, míg az elemzési szabályok határozzák meg, hogyan alakíthatók át sztring-ábrázolások értékké, például dátummá és idővé. A formázási és elemzési szabályok a kulturális konvencióktól függnek. Az alábbi példa azt a kétértelműséget szemlélteti, amely egy kultúraspecifikus dátumsztring értelmezésekor merülhet fel. Anélkül, hogy ismernénk a dátum formátumát előállító kultúra konvencióit, nem tudhatjuk, hogy a 03/01/2011, a 3/1/2011, és az 01/03/2011 a 2011. január 3.-át vagy a 2011. március 1.-jét jelenti-e.

using System;
using System.Globalization;

public class Example9
{
   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 Example8
    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

Hasonlóképpen, ahogy az alábbi példa is mutatja, egyetlen sztring különböző dátumokat hozhat létre attól függően, hogy melyik kultúrát használják az elemzési műveletben.

using System;
using System.Globalization;

public class Example15
{
   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 Example18
    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

Sztringek összehasonlítása és rendezése

A sztringek összehasonlítására és rendezésére vonatkozó konvenciók kultúránként eltérőek. A rendezési sorrend például a fonetika vagy a karakterek vizuális ábrázolása alapján történhet. A kelet-ázsiai nyelvekben a karaktereket az ideográfiák vonalai és gyöke rendezi. A rendezés attól is függ, hogy a nyelvek és a kultúrák milyen sorrendben használják az ábécét. A dán nyelv például egy "Æ" karaktert tartalmaz, amelyet az ábécé "Z" betűje után rendez. Emellett az összehasonlítások megkülönböztethetik a kis- és nagybetűs írásmódot, és a kis- és nagybetűs szabályok kultúránként eltérhetnek. Az ordinális összehasonlítás viszont a sztringek egyes karaktereinek Unicode-kódpontjait használja a sztringek összehasonlítása és rendezése során.

A rendezési szabályok határozzák meg a Unicode-karakterek betűrendjét, valamint azt, hogy két sztring hogyan viszonyul egymáshoz. Például a String.Compare(String, String, StringComparison) metódus két karakterláncot hasonlít össze a StringComparison paraméter alapján. Ha a paraméter értéke az StringComparison.CurrentCulture, a metódus az aktuális kultúra konvencióit használó nyelvi összehasonlítást végez; ha a paraméter értéke, StringComparison.Ordinala metódus egy sorszámos összehasonlítást hajt végre. Következésképpen, ahogy az alábbi példa is mutatja, ha a jelenlegi kulturális beállítás amerikai angol, akkor a metódus első hívása String.Compare(String, String, StringComparison) (a kultúraérzékeny összehasonlítás használatával) az "a"-t kisebbnek tekinti, mint az "A"-t, de a második hívás ugyanahhoz a metódushoz (az ordinális összehasonlítás használatával) az "a"-t nagyobbnak tekinti, mint az "A"-t.

using System;
using System.Globalization;
using System.Threading;

public class Example2
{
   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 Example3
    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

A .NET támogatja a szó-, sztring- és ordinalszerinti rendezési szabályokat.

A szórendezés olyan karakterláncok kultúraérzékeny összehasonlítását hajtja végre, amelyben bizonyos nem alfanumerikus Unicode-karakterekhez speciális súlyok vannak rendelve. Előfordulhat például, hogy a kötőjel (-) nagyon kis súlyt tartalmaz, így a "coop" és a "co-op" egymás mellett jelenik meg egy rendezett listában. Azoknak a metódusoknak a String listáját, amelyek két sztringet hasonlítanak össze szó szerinti rendezési szabályokkal, tekintse meg a Karakterláncműveletek kategória szerint című szakaszt.
A karakterlánc rendezés szintén kulturális szempontból érzékeny összehasonlítást végez. Hasonló a szórendezéshez, kivéve, hogy nincsenek speciális esetek, és az összes nonalphanumerikus szimbólum megelőzi az alfanumerikus Unicode-karaktereket. Két karakterlánc összehasonlítható a karakterlánc rendezési szabályok alkalmazásával a CompareInfo.Compare metódus túlterheléseinek meghívásával, amelyek options paramétere CompareOptions.StringSort értékkel van ellátva. Vegye figyelembe, hogy ez az egyetlen módszer, amellyel a .NET két sztringet hasonlít össze karakterlánc-rendezési szabályokkal.
Az ordinális rendezés a sztringek karakterláncait hasonlítja össze a sztring egyes Char objektumainak numerikus értéke alapján. A sorrendi összehasonlítás automatikusan megkülönbözteti a kis- és nagybetűket, mivel a karakter kis- és nagybetűs verziói eltérő kódpontokkal rendelkeznek. Ha azonban az eset nem fontos, megadhat egy olyan sorszámos összehasonlítást, amely figyelmen kívül hagyja az esetet. Ez egyenértékű azzal, hogy a karakterláncot nagybetűssé alakítja az invariáns kultúra használatával, majd végrehajt egy ordinalis összehasonlítást az eredményen. Azoknak a metódusoknak a String listáját, amelyek két sztringet hasonlítanak össze ordinalis rendezési szabályokkal, lásd a Karakterláncműveletek kategória szerint című szakaszt.

A kultúraérzékeny összehasonlítás olyan összehasonlítás, amely explicit módon vagy implicit módon használ objektumot CultureInfo , beleértve a tulajdonság által CultureInfo.InvariantCulture megadott invariáns kultúrát is. Az implicit kultúra az aktuális kultúra, amelyet a Thread.CurrentCulture és CultureInfo.CurrentCulture tulajdonságok határoznak meg. A különböző kultúrákban jelentős eltérések vannak a betűrendben szereplő karakterek (azaz a metódus által Char.IsLetter visszaadott truekarakterek) sorrendjében. Végezhet kultúraérzékeny összehasonlítást, amely egy adott kultúra konvencióit használja, ha egy CultureInfo objektumot ad meg egy sztring-összehasonlítási módszerhez, például Compare(String, String, CultureInfo, CompareOptions). Megadhat egy kultúraérzékeny összehasonlítást, amely a jelenlegi kultúra konvencióit követi, ha StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase értéket, vagy a CompareOptions felsorolás bármelyik tagját megadja, kivéve a CompareOptions.Ordinal vagy CompareOptions.OrdinalIgnoreCase, a Compare metódus megfelelő túlterhelésénél. A kultúra szempontjából érzékeny összehasonlítás általában megfelelő a rendezéshez, míg a sorrendi összehasonlítás nem. Általában a sorszám szerinti összehasonlítás alkalmas annak meghatározására, hogy két karakterlánc megegyezik-e (vagyis az azonosság meghatározására), míg a kultúrafüggő összehasonlítás nem.

Az alábbi példa a kultúra-érzékeny és az ordinális összehasonlítás közötti különbséget mutatja be. A példa három sztringet értékel ki: "Apple", "Æble" és "AEble", az ordinális összehasonlítást és a da-DK és az en-US kultúrák konvencióit használva (amelyek mindegyike az alapértelmezett kultúra a Compare metódus meghívásának időpontjában). Mivel a dán nyelv az "Æ" karaktert egyéni betűként kezeli, és a "Z" után rendezi az ábécében, a "Æble" sztring nagyobb, mint az "Apple". A "Æble" azonban nem egyenértékű az "AEble"-sel, így az "Æble" is nagyobb, mint az "AEble". Az USA-beli kultúra nem tartalmazza az "Æ" betűt, hanem az "AE" betűvel egyenértékűként kezeli, ami megmagyarázza, hogy az "Æble" miért kisebb, mint az "Apple", de egyenlő az "AEble"-sel. A rendezési összehasonlítás viszont az "Apple"-t kisebbnek tekinti, mint az "Æble"-t, míg az "Æble"-t nagyobbnak az "AEble"-nél.

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: {CultureInfo.CurrentCulture.Name}");
      Console.WriteLine($"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}");
      Console.WriteLine($"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n");
      
      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine($"Current culture: {CultureInfo.CurrentCulture.Name}");
      Console.WriteLine($"Comparison of {str1} with {str2}: {String.Compare(str1, str2)}");
      Console.WriteLine($"Comparison of {str2} with {str3}: {String.Compare(str2, str3)}\n");
      
      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine($"Comparison of {str1} with {str2}: {String.Compare(str1, str2, StringComparison.Ordinal)}");
      Console.WriteLine($"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

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

A megfelelő rendezési vagy sztring-összehasonlító módszer kiválasztásához használja az alábbi általános irányelveket:

Ha azt szeretné, hogy a sztringek a felhasználó kultúrája alapján legyenek rendezve, akkor azokat a jelenlegi kultúra konvenciói alapján kell rendeznie. Ha a felhasználó kultúrája megváltozik, a rendezett sztringek sorrendje is ennek megfelelően változik. Egy szinonimaszótár-alkalmazásnak például mindig a felhasználó kultúrája alapján kell rendeznie a szavakat.
Ha azt szeretné, hogy a karakterláncok egy adott kultúra konvenciói alapján legyenek rendezve, akkor azokat úgy kell rendezni, hogy egy CultureInfo objektumot ad meg, amely az adott kultúrát képviseli egy összehasonlítási módszerhez. Például egy olyan alkalmazásban, amely egy adott nyelvet tanít a diákoknak, karaktersorokat szeretne rendezni az adott nyelvet beszélő kultúrák egyikének konvenciói alapján.
Ha azt szeretné, hogy a sztringek sorrendje a kultúrák között változatlan maradjon, akkor az invariáns kultúra konvenciói szerinti rendezést alkalmazzon, vagy használjon sorrendi összehasonlítást. A fájlok, folyamatok, mutexek vagy elnevezett csövek nevének rendszerezéséhez például egy sorrendi osztályozást használna.
Biztonsági döntéssel járó összehasonlításhoz (például hogy a felhasználónév érvényes-e) mindig végezzen egy sorszámos tesztet az egyenlőség érdekében a Equals metódus túlterhelésének meghívásával.

Megjegyzés

A sztring-összehasonlításban használt kulturális szempontból érzékeny rendezési és burkolati szabályok a .NET verziójától függenek. A .NET Core-on a sztringek összehasonlítása az alapul szolgáló operációs rendszer által támogatott Unicode Standard verziójától függ. A Windows 8 vagy újabb rendszeren futó .NET-keretrendszer 4.5-ös és újabb verzióiban a rendezés, a burkolat, a normalizálás és a Unicode karakteradatok megfelelnek a Unicode 6.0 szabványnak. Más Windows operációs rendszereken megfelelnek a Unicode 5.0 szabványnak.

A szavak, karakterláncok és sorrendi szabályokkal kapcsolatos további információkért tekintse meg a System.Globalization.CompareOptions témakört. Az egyes szabályok használatára vonatkozó további javaslatokért tekintse meg a sztringek használatának ajánlott eljárásait.

Általában nem hívhat sztring-összehasonlító módszereket, például Compare közvetlenül a sztringek rendezési sorrendjének meghatározásához. Ehelyett az összehasonlítási metódusokat olyan rendezési módszerekkel hívjuk meg, mint a Array.Sort vagy List<T>.Sorta . Az alábbi példa négy különböző rendezési műveletet hajt végre (szórendezés az aktuális kultúrával, szórendezés az invariáns kultúrával, sorrendi rendezés és sztringsorrendezés az invariáns kultúrával) anélkül, hogy explicit módon meghívna egy sztring-összehasonlító módszert, bár megadják a használni kívánt összehasonlítás típusát. Vegye figyelembe, hogy minden rendezési típus egyedi sorrendet hoz létre a sztringek között a tömbben.

using System;
using System.Collections;
using System.Collections.Generic;
using System.Globalization;
 
public class Example3
{
   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 Example4
    Public Sub Main()
        Dim strings() As String = {"coop", "co-op", "cooperative",
                                  "co" + ChrW(&HAD) + "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

Tipp.

A .NET a rendezési kulcsokat használja belsőleg a kulturálisan érzékeny karakterláncok összehasonlításának támogatására. A karakterlánc minden egyes karaktere több kategóriájú rendezési súlyozást kap, beleértve az ábécé, a kis- és nagybetű, valamint a diakritikus jellemzőket. Az osztály által SortKey képviselt rendezési kulcs adattárat biztosít a súlyok számára egy adott karakterlánchoz. Ha az alkalmazás nagy számú keresési vagy rendezési műveletet hajt végre ugyanazon a sztringkészleten, javíthatja a teljesítményét, ha rendezési kulcsokat hoz létre és tárol az összes használt sztringhez. Ha rendezési vagy összehasonlító műveletre van szükség, a sztringek helyett a rendezési kulcsokat kell használnia. További információért lásd a SortKey osztályt.

Ha nem ad meg sztringösszehasonlító konvenciót, olyan rendezési módszerek, mint például a Array.Sort(Array), kultúraérzékenyen és kis- és nagybetű érzékenyen rendezik a sztringeket. Az alábbi példa bemutatja, hogy az aktuális kultúra módosítása hogyan befolyásolja a tömb rendezett szövegeinek sorrendjét. Három karakterláncból álló tömböt hoz létre. Először az en-US értékre állítja a System.Threading.Thread.CurrentThread.CurrentCulture tulajdonságot, és meghívja a metódust Array.Sort(Array) . Az eredményként kapott rendezési sorrend az angol (Egyesült Államok) kultúra rendezési konvenciókon alapul. A példa ezután da-DK-ra állítja a System.Threading.Thread.CurrentThread.CurrentCulture tulajdonságot, és újra meghívja a metódust Array.Sort . Figyelje meg, hogy az eredményként kapott rendezési sorrend miben különbözik az USA-beli eredményektől, mivel a dán (Dánia) rendezési konvencióit használja.

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($"[{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

Figyelmeztetés

Ha a sztringek összehasonlításának elsődleges célja annak meghatározása, hogy egyenlőek-e, akkor hívja meg a metódust String.Equals . Általában a Equals használata ajánlott, ha rendezési sorrend összehasonlítást kell végezni. A String.Compare metódus elsősorban sztringek rendezésére szolgál.

A sztringkeresési metódusok, például String.StartsWith és String.IndexOf, kulturális szempontból érzékeny vagydinális sztring-összehasonlításokat is végezhetnek. Az alábbi példa a IndexOf módszer használatával bemutatja a sorszám szerinti és a kultúraérzékeny összehasonlítások közötti különbségeket. Egy kultúraérzékeny keresés, amelyben a jelenlegi kultúra angol (Egyesült Államok), úgy tekinti, hogy az "oe" részsztring megfelel az "œ" ligatúrának. Mivel a helyreállítható kötőjel (U+00AD) nulla szélességű karakter, a keresés a helyreállítható kötőjelet egyenértékűként String.Empty kezeli, és a sztring elején talál egyezést. A sorszámos keresés azonban egyik esetben sem talál egyezést.

using System;

public class Example8
{
   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($"'{substring}' found in {s} at position {result}");
      else
         Console.WriteLine($"'{substring}' not found in {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 Example5
    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(&HAD)
        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 Then
            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

Keresés sztringekben

A sztringkeresési módszerek( például String.StartsWith és String.IndexOf) kultúraérzékeny vagy sorszámú sztring-összehasonlításokat is végezhetnek annak megállapításához, hogy egy karakter vagy alsztring található-e egy adott sztringben.

Az String osztály keresési módszerei, amelyek egyedi karaktereket keresnek, mint például a IndexOf metódus, vagy karakterek egy csoportját, mint például a IndexOfAny metódus, mind ordális keresést hajtanak végre. Egy karakter kultúraérzékeny kereséséhez meg kell hívnia egy metódust CompareInfo, például CompareInfo.IndexOf(String, Char) vagy CompareInfo.LastIndexOf(String, Char). Vegye figyelembe, hogy a karakter sorszám- és kultúraérzékeny összehasonlítást használó keresésének eredményei nagyon eltérőek lehetnek. Egy előre összeállított Unicode-karakter, például az "Æ" ligatúra (U+00C6) keresése az adott kultúrától függően megfelelhet annak összetevői helyes sorrendben történő előfordulásának, például az "AE" (U+0041 U+0045). Az alábbi példa bemutatja az String.IndexOf(Char) és CompareInfo.IndexOf(String, Char) metódusok közötti különbséget, amikor egyetlen karaktert keresünk. Az "æ" betűkapcsolat (U+00E6) megtalálható a "aerial" sztringben, amikor az en-US kultúra konvencióit használjuk, de nem található meg sem a da-DK kultúra konvencióit használva, sem sorszám-összehasonlítás végrehajtásakor.

using System;
using System.Globalization;

public class Example17
{
   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 '{ch}' in {str}: {str.IndexOf(ch)}");
      
      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine($"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

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

A String osztálymódszerek, amelyek karakterláncot keresnek a karakter helyett, kulturális szempontból érzékeny keresést hajtanak végre, ha a keresési beállításokat nem adják meg explicit módon egy StringComparison típusú paraméter által. Az egyetlen kivétel az Contains, amely egy sorszámos keresést hajt végre.

Egyenlőség tesztelése

A String.Compare metódus segítségével meghatározhatja két karakterlánc kapcsolatát a rendezési sorrendben. Ez általában egy kultúraérzékeny művelet. Ezzel szemben hívja meg az String.Equals metódust az egyenlőség tesztelésére. Mivel az egyenlőségi teszt általában összehasonlítja a felhasználói bemenetet valamilyen ismert sztringgel, például érvényes felhasználónévvel, jelszóval vagy fájlrendszer elérési úttal, ez általában egy sorszámú művelet.

Figyelmeztetés

Az egyenlőséget tesztelni lehet a String.Compare metódus meghívásával és annak meghatározásával, hogy a visszatérési érték nulla-e. Ez a gyakorlat azonban nem ajánlott. Annak megállapításához, hogy két karakterlánc egyenlő-e, meg kell hívnia a String.Equals metódus egyik túlterhelését. A hívás elsődleges túlterhelése a példány Equals(String, StringComparison) metódus vagy a statikus Equals(String, String, StringComparison) metódus legyen, mivel mindkét metódus tartalmaz egy System.StringComparison paramétert, amely explicit módon meghatározza az összehasonlítás típusát.

Az alábbi példa szemlélteti a veszélyt, amely abból adódik, ha az egyenlőség vizsgálatakor kulturális szempontból érzékeny összehasonlítást végzünk, amikor inkább sorszám szerinti összehasonlítást kellene alkalmazni. Ebben az esetben a kód célja, hogy megtiltsa a fájlrendszer hozzáférését a "FILE://" vagy a "file://" kezdetű URL-címekről az URL-cím elejének kis- és nagybetűs összehasonlításával a "FILE://" sztringgel. Ha azonban a "file://" kezdetű URL-címen a török (törökországi) kultúra használatával végeznek kultúraérzékeny összehasonlítást, az egyenlőségre vonatkozó összehasonlítás meghiúsul, mivel az "i" kisbetűs török nagybetűs megfelelője "I" helyett "İ". Ennek eredményeképpen a fájlrendszerhez való hozzáférés akaratlanul engedélyezett. Másrészről, ha sorszám szerinti összehasonlítást végez, az egyenlőség vizsgálata sikeres, és a fájlrendszerhez való hozzáférés megtagadásra kerül.

using System;
using System.Globalization;
using System.Threading;

public class Example4
{
   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 {filePath} is allowed.");
      else
         Console.WriteLine($"Access to {filePath} is not allowed.");
      
      Console.WriteLine("\nOrdinal test for equality:");
      if (! TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine($"Access to {filePath} is allowed.");
      else
         Console.WriteLine($"Access to {filePath} is not allowed.");
   }

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

Normalizálás

Egyes Unicode-karakterek több reprezentációval rendelkeznek. Az alábbi kódpontok bármelyike például a "ắ" betűt jelölheti:

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

Egyetlen karakter több ábrázolása bonyolítja a keresést, a rendezést, az egyeztetést és az egyéb sztringműveleteket.

A Unicode szabvány egy normalizálás nevű folyamatot határoz meg, amely egy Unicode-karakter egy bináris reprezentációját adja vissza a megfelelő bináris reprezentációkhoz. A normalizálás több algoritmust, úgynevezett normalizálási űrlapot is használhat, amelyek különböző szabályokat követnek. A .NET támogatja a C, D, KC és KD Unicode normalizálási űrlapokat. Ha a szövegláncok azonos normalizálási formára történő normalizálása megtörtént, akkor ordinális összehasonlítással hasonlíthatók össze.

Az ordinális összehasonlítás az egyes sztringekben lévő megfelelő Char objektumok Unicode skaláris értékének bináris összehasonlítása. Az String osztály számos olyan metódust tartalmaz, amelyek képesek a sorszámok összehasonlítására, beleértve a következőket:

Olyan Compare, Equals, StartsWith, EndsWith, IndexOf és LastIndexOf metódusok túlterhelése, amelyek tartalmazzák a StringComparison paramétert. A metódus sorszámalapú összehasonlítást hajt végre, ha ennél a paraméternél StringComparison.Ordinal vagy OrdinalIgnoreCase értéket ad meg.
A módszer túlterhelései CompareOrdinal .
A sorszám-összehasonlítást alapértelmezés szerint használó metódusok, például Contains: , Replaceés Split.
Olyan metódusok, amelyek egy Char értéket vagy egy Char tömb elemeit keresik egy karakterláncpéldányban. Az ilyen módszerek közé tartoznak IndexOf(Char) és Split(Char[]).

A metódus meghívásával String.IsNormalized() meghatározhatja, hogy egy sztring normalizálva van-e a C normalizálási űrlapra, vagy meghívhatja a String.IsNormalized(NormalizationForm) metódust annak megállapításához, hogy a sztring egy adott normalizálási űrlapra van-e normalizálva. Meghívhatja azt a String.Normalize() metódust is, amely egy sztringet c normalizálási űrlapmá alakít, vagy meghívhatja a String.Normalize(NormalizationForm) metódust, hogy egy sztringet egy megadott normalizálási űrlapmá alakítson. A sztringek normalizálásával és összehasonlításával kapcsolatos részletes információkért tekintse meg a Normalize() és a Normalize(NormalizationForm) metódust.

Az alábbi egyszerű példa a sztring normalizálását szemlélteti. A "ố" betűt három különböző módon határozza meg három különböző sztringben, és egy sorszámos összehasonlítást használ az egyenlőséghez annak megállapításához, hogy az egyes sztringek eltérnek a másik két sztringtől. Ezután átalakítja az egyes sztringeket a támogatott normalizálási űrlapokra, és ismét végrehajtja az egyes sztringek sorszám szerinti összehasonlítását egy megadott normalizálási űrlapon. Minden esetben a második egyenlőségi teszt azt mutatja, hogy a karakterláncok egyenlőek.

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

public class Example13
{
   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 Example16
    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(&HF4) + ChrW(&H301) + "ng"
        Dim s3 As String = "so" + ChrW(&H302) + ChrW(&H301) + "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

A normalizálási és normalizálási űrlapokkal kapcsolatos további információkért lásd System.Text.NormalizationForm a Unicode Standard 15. mellékletét: Unicode Normalization Forms and the Normalization FAQ on the unicode.org website.

Sztringműveletek kategória szerint

Az String osztály lehetővé teszi a tagok számára a sztringek összehasonlítását, a sztringek egyenlőségének tesztelését, a karakterláncok karaktereinek vagy alsztringjeinek keresését, a sztringek módosítását, a sztringek részsztringjeinek kinyerését, a sztringek kombinálását, az értékek formázását, a sztringek másolását és a sztring normalizálását.

Sztringek összehasonlítása

A sztringeket a következő String módszerekkel hasonlíthatja össze a rendezési sorrendben elfoglalt relatív pozíciójuk meghatározásához:

Compare Egy egész számot ad vissza, amely egy sztring és egy második sztring viszonyát jelzi a rendezési sorrendben.
CompareOrdinal egy egész számot ad vissza, amely egy sztring és egy második sztring kapcsolatát jelzi a kódpontok összehasonlítása alapján.
CompareTo Egy egész számot ad vissza, ami az aktuális sztring és a rendezési sorrend egy második sztringjének kapcsolatát jelzi. A CompareTo(String) metódus biztosítja az IComparable osztályhoz tartozó IComparable<T> implementációkat és String megvalósításokat.

Sztringek egyenlőségének tesztelése

A Equals metódus meghívásával megállapíthatja, hogy két karakterlánc egyenlő-e. A példány Equals(String, String, StringComparison) és a statikus Equals(String, StringComparison) túlterhelések segítségével meghatározhatja, hogy az összehasonlítás kulturális szempontból érzékeny-e vagy sem, és hogy az esetet figyelembe veszik-e vagy figyelmen kívül hagyják-e. A legtöbb egyenlőségi teszt sorszámmal rendelkezik, és a rendszererőforráshoz (például fájlrendszerobjektumhoz) való hozzáférést meghatározó egyenlőség összehasonlításának mindig sorszámmal kell rendelkeznie.

Karakterek keresése sztringben

Az String osztály kétféle keresési módszert tartalmaz:

Metódusok, amelyek visszatérnek egy Boolean értékkel annak jelzésére, hogy egy adott részkarakterlánc jelen van-e egy karakterlánc-példányban. Ezek közé tartoznak a Contains, EndsWithés StartsWith a metódusok.
Metódusok, amelyek egy karakterlánc példányban lévő részkarakterlánc kezdő pozícióját jelzik. Ezek közé tartoznak a IndexOf, IndexOfAny, LastIndexOfés LastIndexOfAny a metódusok.

Figyelmeztetés

Ha egy adott minta sztringben szeretne keresni egy adott részstring helyett, használjon reguláris kifejezéseket. További információ: .NET Regular Expressions.

Sztring módosítása

Az String osztály a következő metódusokat tartalmazza, amelyek úgy tűnik, hogy módosítják egy sztring értékét:

Insert karakterláncot szúr be az aktuális String példányba.
PadLeft Egy megadott karakter egy vagy több előfordulását beszúrja egy karakterlánc elejére.
PadRight Egy adott karakter egy vagy több előfordulását szúrja be egy sztring végére.
Remove az aktuális String példányból töröl egy részsztringet.
Replace Egy alsztringet egy másik alsztringre cserél az aktuális String példányban.
ToLower és ToLowerInvariant a karakterlánc összes karakterét kisbetűssé alakítja.
ToUpper és ToUpperInvariant konvertálják a karakterláncban lévő összes karaktert nagybetűvé.
Trim Eltávolítja egy karakter összes előfordulását egy karakterlánc elejétől és végétől.
TrimEnd Eltávolítja egy karakter összes előfordulását egy karakterlánc végéről.
TrimStart Eltávolítja egy karakter összes előfordulását egy sztring elejéről.

Fontos

Minden sztringmódosítási módszer új String objektumot ad vissza. Nem módosítják az aktuális példány értékét.

Részsztringek kinyerése sztringből

A String.Split metódus egyetlen sztringet több sztringre választ el. A metódus túlterhelései lehetővé teszik több elválasztó karakter megadását, a metódus által kinyert részsztringek számának korlátozását, a térközök alsztringekből való levágását, valamint annak megadását, hogy az üres sztringek (amelyek határolójelek szomszédosak) szerepeljenek-e a visszaadott sztringek között.

Sztringek egyesítése

A sztringösszefűzéshez a következő String módszerek használhatók:

Concat egy vagy több részsztringet egyesít egyetlen sztringben.
Join összefűz egy vagy több részsztringet egyetlen elembe, és elválasztójelet ad az egyes részsztringek közé.

Értékek formázása

A String.Format metódus az összetett formázási funkcióval egy sztring egy vagy több helyőrzőjét lecseréli egy objektum vagy érték sztringképére. A Format módszert gyakran használják a következők végrehajtására:

Numerikus érték sztringképének beágyazása egy sztringbe.
Dátum- és időérték szöveges formájának beágyazása szövegbe.
Az enumerálási érték sztringképének beágyazása egy sztringbe.
Egy olyan objektum sztringképének beágyazásához, amely támogatja a IFormattable felületet egy sztringben.
Egy nagyobb karakterláncon belüli mezőt jobbra vagy balra igazíthat.

A formázási műveletekről és példákról részletes információt a túlterhelés összegzésében Format talál.

Karakterlánc másolása

A sztring másolatának készítéséhez a következő String metódusokat hívhatja meg:

Clone egy meglévő String objektumra mutató hivatkozást ad vissza.
CopyTo a sztringből egy részt egy karaktertömbbe másol.

Sztring normalizálása

Unicode-ban egyetlen karakter több kódponttal is rendelkezhet. A normalizálás ezeket az egyenértékű karaktereket ugyanazzal a bináris ábrázolással alakítja át. A String.Normalize metódus végrehajtja a normalizálást, és a String.IsNormalized metódus meghatározza, hogy egy sztring normalizálva van-e.

További információt és egy példát a cikk korábbi, Normalizálás szakaszában talál.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2026-02-12

System.String osztály

Sztringobjektum példányosítása

Karakterobjektumok és Unicode-karakterek

A Unicode szabvány

Beágyazott null karakterek

Sztringek és indexek

Null karaktersorok és üres karaktersorok

A nem módosíthatóság és a StringBuilder osztály

Sorrendi vs. kultúraérzékeny műveletek

Betűméret

Elemzés és formázás

Sztringek összehasonlítása és rendezése

Keresés sztringekben

Egyenlőség tesztelése

Normalizálás

Sztringműveletek kategória szerint

Sztringek összehasonlítása

Sztringek egyenlőségének tesztelése

Karakterek keresése sztringben

Sztring módosítása

Részsztringek kinyerése sztringből

Sztringek egyesítése

Értékek formázása

Karakterlánc másolása

Sztring normalizálása

Visszajelzés

További források