Kelas System.String

Artikel
01/08/2024

Artikel ini menyediakan keterangan tambahan untuk dokumentasi referensi untuk API ini.

String adalah kumpulan karakter berurutan yang digunakan untuk mewakili teks. Objek String adalah kumpulan System.Char objek berurutan yang mewakili string; System.Char objek sesuai dengan unit kode UTF-16. Nilai String objek adalah konten kumpulan System.Char objek berurutan, dan nilai tersebut tidak dapat diubah (yaitu baca-saja). Untuk informasi selengkapnya tentang kekekalan string, lihat bagian Kekekalan dan kelas StringBuilder. Ukuran String maksimum objek dalam memori adalah 2-GB, atau sekitar 1 miliar karakter.

Untuk informasi selengkapnya tentang Unicode, UTF-16, unit kode, titik kode, dan Char jenis dan Rune , lihat Pengenalan pengodean karakter di .NET.

Membuat instans objek String

Anda dapat membuat String instans objek dengan cara berikut:

Dengan menetapkan string harfiah ke String variabel. Ini adalah metode yang paling umum digunakan untuk membuat string. Contoh berikut menggunakan penugasan untuk membuat beberapa string. Perhatikan bahwa dalam C# dan F#, karena garis miring terbalik (\) adalah karakter escape, garis miring terbalik harfiah dalam string harus diloloskan atau seluruh string harus @-quoted.

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

Dengan memanggil String konstruktor kelas. Contoh berikut membuat instans string dengan memanggil beberapa konstruktor kelas. Perhatikan bahwa beberapa konstruktor menyertakan pointer ke array karakter atau array byte yang ditandatangani sebagai parameter. Visual Basic tidak mendukung panggilan ke konstruktor ini. Untuk informasi terperinci tentang String konstruktor, lihat String ringkasan konstruktor.

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

Dengan menggunakan operator penggabungan string (+ di C# dan F#, dan & atau + di Visual Basic) untuk membuat string tunggal dari kombinasi String instans dan literal string apa pun. Contoh berikut mengilustrasikan penggunaan operator penggalian string.

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.

Dengan mengambil properti atau memanggil metode yang mengembalikan string. Contoh berikut menggunakan metode String kelas untuk mengekstrak substring dari string yang lebih besar.

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

Dengan memanggil metode pemformatan untuk mengonversi nilai atau objek ke representasi stringnya. Contoh berikut menggunakan fitur pemformatan komposit untuk menyematkan representasi string dari dua objek ke dalam string.

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.

Karakter objek dan karakter Unicode

Setiap karakter dalam string didefinisikan oleh nilai skalar Unicode, juga disebut titik kode Unicode atau nilai ordinal (numerik) dari karakter Unicode. Setiap titik kode dikodekan dengan menggunakan pengodean UTF-16, dan nilai numerik dari setiap elemen pengodean diwakili oleh Char objek.

Catatan

Perhatikan bahwa, karena String instans terdiri dari koleksi berurutan unit kode UTF-16, dimungkinkan untuk membuat String objek yang bukan string Unicode yang terbentuk dengan baik. Misalnya, dimungkinkan untuk membuat string yang memiliki pengganti rendah tanpa pengganti tinggi yang sesuai. Meskipun beberapa metode, seperti metode pengodean dan dekode objek di System.Text namespace layanan, dapat melakukan pemeriksaan untuk memastikan bahwa string terbentuk dengan baik, String anggota kelas tidak memastikan bahwa string terbentuk dengan baik.

Satu Char objek biasanya mewakili satu titik kode; yaitu, nilai numerik dari Char sama dengan titik kode. Misalnya, titik kode untuk karakter "a" adalah U+0061. Namun, titik kode mungkin memerlukan lebih dari satu elemen yang dikodekan (lebih dari satu Char objek). Standar Unicode mendefinisikan dua jenis karakter yang sesuai dengan beberapa Char objek: graphemes, dan titik kode tambahan Unicode yang sesuai dengan karakter di bidang tambahan Unicode.

Grafik diwakili oleh karakter dasar diikuti oleh satu atau beberapa karakter yang menggabungkan. Misalnya, karakter ä diwakili oleh Char objek yang titik kodenya adalah U+0061 diikuti oleh Char objek yang titik kodenya adalah U+0308. Karakter ini juga dapat didefinisikan oleh satu Char objek yang memiliki titik kode U+00E4. Seperti yang ditunjukkan contoh berikut, perbandingan sensitif budaya untuk kesetaraan menunjukkan bahwa kedua representasi ini sama, meskipun perbandingan biasa tidak. Namun, jika dua string dinormalisasi, perbandingan ordinal juga menunjukkan bahwa string tersebut sama. (Untuk informasi selengkapnya tentang menormalkan string, lihat Bagian normalisasi .)

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

Titik kode tambahan Unicode (pasangan pengganti) diwakili oleh Char objek yang titik kodenya adalah pengganti tinggi diikuti oleh Char objek yang titik kodenya adalah pengganti rendah. Unit kode pengganti tinggi berkisar dari U+D800 hingga U+DBFF. Unit kode pengganti rendah berkisar dari U+DC00 hingga U+DFFF. Pasangan pengganti digunakan untuk mewakili karakter dalam 16 bidang tambahan Unicode. Contoh berikut membuat karakter pengganti dan meneruskannya ke Char.IsSurrogatePair(Char, Char) metode untuk menentukan apakah itu pasangan pengganti.

string surrogate = "\uD800\uDC03";
for (int ctr = 0; ctr < surrogate.Length; ctr++) 
   Console.Write($"U+{(ushort)surrogate[ctr]:X2} ");

Console.WriteLine();
Console.WriteLine("   Is Surrogate Pair: {0}", 
                  Char.IsSurrogatePair(surrogate[0], surrogate[1]));
// The example displays the following output:
//       U+D800 U+DC03
//          Is Surrogate Pair: True

open System

let surrogate = "\uD800\uDC03"
for i = 0 to surrogate.Length - 1 do
    printf $"U+{uint16 surrogate[i]:X2} "

printfn $"\n   Is Surrogate Pair: {Char.IsSurrogatePair(surrogate[0], surrogate[1])}"
// The example displays the following output:
//       U+D800 U+DC03
//          Is Surrogate Pair: True

Module 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

Standar Unicode

Karakter dalam string diwakili oleh unit kode yang dikodekan UTF-16, yang sesuai dengan Char nilai.

Setiap karakter dalam string memiliki kategori karakter Unicode terkait, yang diwakili dalam .NET oleh UnicodeCategory enumerasi. Kategori karakter atau pasangan pengganti dapat ditentukan dengan memanggil CharUnicodeInfo.GetUnicodeCategory metode .

.NET mempertahankan tabel karakternya sendiri dan kategori yang sesuai, yang memastikan bahwa versi tertentu dari implementasi .NET yang berjalan pada platform yang berbeda mengembalikan informasi kategori karakter yang identik. Pada semua versi .NET dan di semua platform OS, informasi kategori karakter disediakan oleh Database Karakter Unicode.

Tabel berikut mencantumkan versi .NET dan versi Standar Unicode tempat kategori karakternya didasarkan.

Versi .NET	Versi Standar Unicode
.NET Framework 1.1	Unicode Standard, Versi 4.0.0
.NET Framework 2.0	Unicode Standard, versi 5.0.0
.NET Framework 3,5	Unicode Standard, versi 5.0.0
.NET Framework 4	Unicode Standard, versi 5.0.0
.NET Framework 4.5	Unicode Standard, Versi 6.3.0
.NET Framework 4.5.1	Unicode Standard, Versi 6.3.0
.NET Framework 4.5.2	Unicode Standard, Versi 6.3.0
.NET Framework 4.6	Unicode Standard, Versi 6.3.0
.NET Framework 4.6.1	Unicode Standard, Versi 6.3.0
.NET Framework 4.6.2 dan versi yang lebih baru	Unicode Standard, versi 8.0.0
.NET Core 2.1	Unicode Standard, versi 8.0.0
.NET Core 3.1	Unicode Standard, versi 11.0.0
.NET 5	Unicode Standard, versi 13.0.0

Selain itu, .NET mendukung perbandingan string dan pengurutan berdasarkan standar Unicode. Dimulai dengan .NET Framework 4.5 yang berjalan pada Windows 8 dan versi yang lebih baru dari sistem operasi Windows, runtime mendelegasikan perbandingan string dan operasi pengurutan ke sistem operasi. Pada .NET Core dan .NET 5+, perbandingan string dan informasi pengurutan disediakan oleh Komponen Internasional untuk pustaka Unicode (kecuali pada versi Windows sebelum Pembaruan Windows 10 Mei 2019). Tabel berikut mencantumkan versi .NET dan versi Standar Unicode tempat perbandingan dan pengurutan karakter didasarkan.

Versi .NET	Versi Standar Unicode
.NET Framework 4.5 dan yang lebih baru di Windows 7	Unicode Standard, versi 5.0.0
.NET Framework 4.5 dan yang lebih baru pada sistem operasi Windows 8 dan yang lebih baru	Unicode Standard, Versi 6.3.0
.NET Core dan .NET 5+	Tergantung pada versi Standar Unicode yang didukung oleh sistem operasi yang mendasar.

Karakter null yang disematkan

Di .NET, String objek dapat menyertakan karakter null yang disematkan, yang dihitung sebagai bagian dari panjang string. Namun, dalam beberapa bahasa seperti C dan C++, karakter null menunjukkan akhir string; ini tidak dianggap sebagai bagian dari string dan tidak dihitung sebagai bagian dari panjang string. Ini berarti bahwa asumsi umum berikut bahwa pemrogram atau pustaka C dan C++ yang ditulis dalam C atau C++ mungkin membuat tentang string tidak selalu valid saat diterapkan ke String objek:

Nilai yang strlen dikembalikan oleh fungsi atau wcslen tidak selalu sama dengan String.Length.
String yang strcpy_s dibuat oleh fungsi atau wcscpy_s belum tentu identik dengan string yang String.Copy dibuat oleh metode .

Anda harus memastikan bahwa kode C dan C++ asli yang membuat instans String objek, dan kode yang diteruskan String objek melalui pemanggilan platform, jangan asumsikan bahwa karakter null yang disematkan menandai akhir string.

Karakter null yang disematkan dalam string juga diperlakukan secara berbeda saat string diurutkan (atau dibandingkan) dan saat string dicari. Karakter null diabaikan saat melakukan perbandingan sensitif budaya antara dua string, termasuk perbandingan menggunakan budaya invarian. Mereka dianggap hanya untuk perbandingan ordinal atau tidak peka huruf besar/kecil. Di sisi lain, karakter null yang disematkan selalu dipertimbangkan saat mencari string dengan metode seperti Contains, , StartsWithdan IndexOf.

String dan indeks

Indeks adalah posisi Char objek (bukan karakter Unicode) dalam String. Indeks adalah angka nonnegatif berbasis nol yang dimulai dari posisi pertama dalam string, yang merupakan nol posisi indeks. Sejumlah metode pencarian, seperti IndexOf dan LastIndexOf, mengembalikan indeks karakter atau substring dalam instans string.

Properti Chars[] memungkinkan Anda mengakses objek individual Char berdasarkan posisi indeksnya dalam string. Chars[] Karena properti adalah properti default (di Visual Basic) atau pengindeks (di C# dan F#), Anda dapat mengakses objek individual Char dalam string dengan menggunakan kode seperti berikut ini. Kode ini mencari spasi kosong atau karakter tanda baca dalam string untuk menentukan berapa banyak kata yang dikandung string.

string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
for (int ctr = 0; ctr < s1.Length; ctr++) {
   if (Char.IsPunctuation(s1[ctr]) | Char.IsWhiteSpace(s1[ctr]))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

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

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

String Karena kelas mengimplementasikan IEnumerable antarmuka, Anda juga dapat melakukan iterasi melalui Char objek dalam string dengan menggunakan foreach konstruksi, seperti yang ditunjukkan contoh berikut.

string s1 = "This string consists of a single short sentence.";
int nWords = 0;

s1 = s1.Trim();      
foreach (var ch in s1) {
   if (Char.IsPunctuation(ch) | Char.IsWhiteSpace(ch))
      nWords++;              
}
Console.WriteLine("The sentence\n   {0}\nhas {1} words.",
                  s1, nWords);                                                                     
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

let s1 = "This string consists of a single short sentence."
let mutable nWords = 0

for ch in s1 do
    if Char.IsPunctuation ch || Char.IsWhiteSpace ch then
        nWords <- nWords + 1
printfn $"The sentence\n   {s1}\nhas {nWords} words."
// The example displays the following output:
//       The sentence
//          This string consists of a single short sentence.
//       has 8 words.

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

Nilai indeks berturut-turut mungkin tidak sesuai dengan karakter Unicode berturut-turut, karena karakter Unicode mungkin dikodekan sebagai lebih dari satu Char objek. Secara khusus, string mungkin berisi unit teks multi-karakter yang dibentuk oleh karakter dasar diikuti oleh satu atau beberapa karakter gabungan atau dengan pasangan pengganti. Untuk bekerja dengan karakter Unicode alih-alih Char objek, gunakan System.Globalization.StringInfo kelas dan TextElementEnumerator , atau String.EnumerateRunes metode dan Rune struktur . Contoh berikut mengilustrasikan perbedaan antara kode yang berfungsi dengan Char objek dan kode yang berfungsi dengan karakter Unicode. Ini membandingkan jumlah karakter atau elemen teks di setiap kata kalimat. String mencakup dua urutan karakter dasar diikuti dengan karakter penggambungan.

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

Contoh ini berfungsi dengan elemen teks dengan menggunakan StringInfo.GetTextElementEnumerator metode dan TextElementEnumerator kelas untuk menghitung semua elemen teks dalam string. Anda juga dapat mengambil array yang berisi indeks awal setiap elemen teks dengan memanggil StringInfo.ParseCombiningCharacters metode .

Untuk informasi selengkapnya tentang bekerja dengan unit teks daripada nilai individual Char , lihat Pengantar pengodean karakter di .NET.

String null dan string kosong

String yang telah dideklarasikan tetapi belum ditetapkan nilainya adalah null. Mencoba memanggil metode pada string tersebut melempar .NullReferenceException String null berbeda dari string kosong, yang merupakan string yang nilainya adalah "" atau String.Empty. Dalam beberapa kasus, meneruskan string null atau string kosong sebagai argumen dalam panggilan metode melemparkan pengecualian. Misalnya, meneruskan string null ke Int32.Parse metode melempar ArgumentNullException, dan meneruskan string kosong melempar FormatException. Dalam kasus lain, argumen metode dapat berupa string null atau string kosong. Misalnya, jika Anda menyediakan IFormattable implementasi untuk kelas, Anda ingin menyamakan string null dan string kosong dengan penentu format umum ("G").

Kelas String ini mencakup dua metode kenyamanan berikut yang memungkinkan Anda menguji apakah string atau null kosong:

IsNullOrEmpty, yang menunjukkan apakah string adalah atau null sama dengan String.Empty. Metode ini menghilangkan kebutuhan untuk menggunakan kode seperti berikut:
```
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, yang menunjukkan apakah string adalah null, sama dengan String.Empty, atau terdiri secara eksklusif dari karakter spasi putih. Metode ini menghilangkan kebutuhan untuk menggunakan kode seperti berikut:

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

Contoh berikut menggunakan IsNullOrEmpty metode dalam IFormattable.ToString implementasi kelas kustom Temperature . Metode ini mendukung string format "G", "C", "F", dan "K". Jika string format kosong atau string format yang nilainya null diteruskan ke metode , nilainya diubah ke string format "G".

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

Kekekalan dan kelas StringBuilder

Objek String disebut tidak dapat diubah (baca-saja), karena nilainya tidak dapat diubah setelah dibuat. Metode yang tampaknya mengubah String objek benar-benar mengembalikan objek baru String yang berisi modifikasi.

Karena string tidak dapat diubah, rutinitas manipulasi string yang melakukan penambahan atau penghapusan berulang ke apa yang tampaknya merupakan string tunggal dapat menentukan penalti performa yang signifikan. Misalnya, kode berikut menggunakan generator angka acak untuk membuat string dengan 1000 karakter dalam rentang 0x0001 untuk 0x052F. Meskipun kode tampaknya menggunakan perangkaian string untuk menambahkan karakter baru ke string yang ada bernama str, kode tersebut benar-benar membuat objek baru String untuk setiap operasi perangkaian.

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

Anda dapat menggunakan StringBuilder kelas alih-alih String kelas untuk operasi yang membuat beberapa perubahan pada nilai string. Tidak seperti instans String kelas, StringBuilder objek dapat diubah; ketika Anda menggabungkan, menambahkan, atau menghapus substring dari string, operasi dilakukan pada satu string. Setelah selesai memodifikasi nilai StringBuilder objek, Anda dapat memanggil metodenya StringBuilder.ToString untuk mengonversinya menjadi string. Contoh berikut menggantikan String yang digunakan dalam contoh sebelumnya untuk menggabungkan 1000 karakter acak dalam rentang ke 0x0001 untuk 0x052F dengan StringBuilder objek.

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

Operasi ordinal vs. sensitif terhadap budaya

Anggota String kelas melakukan operasi ordinal atau peka budaya (linguistik) pada objek String . Operasi ordinal bertindak pada nilai numerik setiap Char objek. Operasi sensitif budaya bertindak berdasarkan nilai String objek, dan mempertimbangkan aturan casing, pengurutan, pemformatan, dan penguraian khusus budaya. Operasi sensitif budaya dijalankan dalam konteks budaya yang dinyatakan secara eksplisit atau budaya implisit saat ini. Dua jenis operasi dapat menghasilkan hasil yang sangat berbeda ketika dilakukan pada string yang sama.

.NET juga mendukung operasi string linguistik yang tidak sensitif budaya dengan menggunakan budaya invarian (CultureInfo.InvariantCulture), yang secara longgar didasarkan pada pengaturan budaya bahasa Inggris yang independen dari wilayah. Tidak seperti pengaturan lain System.Globalization.CultureInfo , pengaturan budaya invarian dijamin tetap konsisten pada satu komputer, dari sistem ke sistem, dan di seluruh versi .NET. Budaya invarian dapat dilihat sebagai semacam kotak hitam yang memastikan stabilitas perbandingan string dan pemesanan di semua budaya.

Penting

Jika aplikasi Anda membuat keputusan keamanan tentang pengidentifikasi simbolis seperti nama file atau pipa bernama, atau tentang data yang bertahan seperti data berbasis teks dalam file XML, operasi harus menggunakan perbandingan ordinal alih-alih perbandingan yang sensitif terhadap budaya. Ini karena perbandingan sensitif budaya dapat menghasilkan hasil yang berbeda tergantung pada budaya yang berlaku, sedangkan perbandingan ordinal hanya tergantung pada nilai biner dari karakter yang dibandingkan.

Penting

Sebagian besar metode yang melakukan operasi string mencakup kelebihan beban yang memiliki parameter jenis StringComparison, yang memungkinkan Anda menentukan apakah metode melakukan operasi ordinal atau sensitif terhadap budaya. Secara umum, Anda harus memanggil kelebihan beban ini untuk membuat niat panggilan metode Anda jelas. Untuk praktik dan panduan terbaik untuk menggunakan operasi ordinal dan peka budaya pada string, lihat Praktik Terbaik untuk Menggunakan String.

Operasi untuk casing, penguraian dan pemformatan, perbandingan dan pengurutan, dan pengujian untuk kesetaraan dapat berupa ordinal atau sensitif terhadap budaya. Bagian berikut membahas setiap kategori operasi.

Tip

Anda harus selalu memanggil metode kelebihan beban yang membuat niat panggilan metode Anda jelas. Misalnya, alih-alih memanggil metode untuk melakukan perbandingan Compare(String, String)StringComparison.CurrentCulture sensitif budaya dari dua string dengan menggunakan konvensi budaya saat ini, Anda harus memanggil Compare(String, String, StringComparison) metode dengan nilai untuk comparisonType argumen. Untuk informasi selengkapnya, lihat Praktik Terbaik untuk Menggunakan String.

Anda dapat mengunduh tabel berat pengurutan, sekumpulan file teks yang berisi informasi tentang bobot karakter yang digunakan dalam operasi pengurutan dan perbandingan, dari tautan berikut:

Windows (.NET Framework dan .NET Core): Mengurutkan Tabel Berat
Pembaruan Windows 10 Mei 2019 atau yang lebih baru (.NET 5+) dan Linux dan macOS (.NET Core dan .NET 5+): Tabel Elemen Kolas Unicode Default

Kapitalisasi

Aturan casing menentukan cara mengubah kapitalisasi karakter Unicode; misalnya, dari huruf kecil ke huruf besar. Seringkali, operasi casing dilakukan sebelum perbandingan string. Misalnya, string mungkin dikonversi menjadi huruf besar sehingga dapat dibandingkan dengan string huruf besar lainnya. Anda dapat mengonversi karakter dalam string menjadi huruf kecil dengan memanggil ToLower metode atau ToLowerInvariant , dan Anda dapat mengonversinya menjadi huruf besar dengan memanggil ToUpper metode atau ToUpperInvariant . Selain itu, Anda dapat menggunakan TextInfo.ToTitleCase metode untuk mengonversi string ke huruf besar/kecil.

Catatan

.NET Core hanya berjalan pada sistem Linux dan macOS: Perilaku kolatasi untuk budaya C dan Posix selalu peka huruf besar/kecil karena budaya ini tidak menggunakan urutan kolae Unicode yang diharapkan. Kami menyarankan agar Anda menggunakan budaya selain C atau Posix untuk melakukan operasi pengurutan yang peka terhadap budaya dan tidak peka huruf besar/kecil.

Operasi casing dapat didasarkan pada aturan budaya saat ini, budaya tertentu, atau budaya invarian. Karena pemetaan kasus dapat bervariasi tergantung pada budaya yang digunakan, hasil operasi casing dapat bervariasi berdasarkan budaya. Perbedaan aktual dalam casing adalah tiga jenis:

Perbedaan dalam pemetaan kasus HURUF LATIN KAPITAL I (U+0049), HURUF KECIL LATIN I (U+0069), HURUF LATIN KAPITAL I DENGAN TITIK DI ATAS (U+0130), dan HURUF KECIL LATIN DOTLESS I (U+0131). Dalam tr-TR (Turki)) dan az-Latn-AZ (Azerbaijan, Budaya Latin), dan dalam budaya netral tr, az, dan az-Latn, huruf kecil yang setara dengan HURUF LATIN KAPITAL I adalah HURUF KECIL LATIN DOTLESS I, dan huruf besar yang setara dengan HURUF KECIL LATIN I adalah HURUF LATIN KAPITAL I DENGAN TITIK DI ATAS. Dalam semua budaya lainnya, termasuk budaya invarian, HURUF KECIL LATIN I dan HURUF LATIN MODAL I adalah huruf kecil dan huruf besar yang setara.

Contoh berikut menunjukkan bagaimana perbandingan string yang dirancang untuk mencegah akses sistem file dapat gagal jika bergantung pada perbandingan casing yang sensitif terhadap budaya. (Konvensi casing dari budaya invarian harus telah digunakan.)

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: {0}", CultureInfo.CurrentCulture.DisplayName);
         Console.WriteLine(resource);
         Console.WriteLine("Access allowed: {0}", 
                           ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
         Console.WriteLine();
      }   
   }
}
// The example displays the following output:
//       Culture: English (United States)
//       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
//       Access allowed: False
//       
//       Culture: Turkish (Turkey)
//       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
//       Access allowed: True

open System
open System.Globalization
open System.Threading

let disallowed = "file"

let isAccessAllowed (resource: string) =
    let cultures = 
        [| CultureInfo.CreateSpecificCulture "en-US"
           CultureInfo.CreateSpecificCulture "tr-TR" |]
    let index = resource.IndexOfAny [| '\\'; '/' |]
    let scheme =
        if index > 0 then
            resource.Substring(0, index - 1)
        else 
            null

    // Change the current culture and perform the comparison.
    for culture in cultures do
        Thread.CurrentThread.CurrentCulture <- culture
        printfn $"Culture: {CultureInfo.CurrentCulture.DisplayName}"
        printfn $"{resource}"
        printfn $"Access allowed: {String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase) |> not}"
        printfn ""
        
isAccessAllowed @"FILE:\\\c:\users\user001\documents\FinancialInfo.txt"
// The example displays the following output:
//       Culture: English (United States)
//       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
//       Access allowed: False
//
//       Culture: Turkish (Turkey)
//       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
//       Access allowed: True

Imports System.Globalization
Imports System.Threading

Module 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

Perbedaan dalam kasus pemetaan antara budaya invarian dan semua budaya lainnya. Dalam kasus ini, menggunakan aturan kasing budaya invarian untuk mengubah karakter menjadi huruf besar atau huruf kecil mengembalikan karakter yang sama. Untuk semua budaya lainnya, mengembalikan karakter yang berbeda. Beberapa karakter yang terpengaruh tercantum dalam tabel berikut.

karakter	Jika diubah menjadi	Kembali
MICRON SIGN (U+00B5)	Uppercase	HURUF KAPITAL YUNANI MU (U+-39C)
HURUF LATIN KAPITAL I DENGAN TITIK DI ATAS (U+0130)	Huruf kecil	HURUF LATIN KECIL I (U+0069)
HURUF LATIN KECIL DOTLESS I (U+0131)	Uppercase	HURUF LATIN KAPITAL I (U+0049)
HURUF LATIN KECIL PANJANG S (U+017F)	Uppercase	HURUF LATIN KAPITAL S (U+0053)
HURUF LATIN KAPITAL D DENGAN HURUF KECIL Z DENGAN CARON (U+01C5)	Huruf kecil	HURUF LATIN KECIL DZ DENGAN CARON (U+01C6)
MENGGABUNGKAN YPOGEGRAMMENI YUNANI (U+0345)	Uppercase	HURUF KAPITAL YUNANI IOTA (U+0399)

Perbedaan dalam kasus pemetaan pasangan kasus campuran dua huruf dalam rentang karakter ASCII. Di sebagian besar budaya, pasangan huruf campuran dua huruf sama dengan pasangan huruf besar atau huruf kecil dua huruf yang setara. Ini tidak berlaku untuk pasangan dua huruf berikut dalam budaya berikut, karena dalam setiap kasus mereka dibandingkan dengan grafik:
- "lJ" dan "nJ" dalam budaya SDM (Kroasia (Kroasia)."
- "cH" dalam budaya cs-CZ (Ceko (Republik Ceko)) dan sk-SK (Slowakia)).
- "aA" dalam budaya da-DK (Denmark)).
- "cS", "dZ", "dZS", "nY", "sZ", "tY", dan "zS" dalam budaya hu-HU (Hungaria (Hongaria)."
- "cH" dan "lL" dalam budaya es-ES_tradnl (Spanyol, Jenis Tradisional)).
- "cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", dan "tR" dalam budaya vi-VN (Vietnam)).
Namun, tidak biasa untuk mengalami situasi di mana perbandingan pasangan ini yang sensitif terhadap budaya menciptakan masalah, karena pasangan ini jarang dalam string atau pengidentifikasi tetap.

Contoh berikut mengilustrasikan beberapa perbedaan dalam aturan casing antara budaya saat mengonversi string menjadi huruf besar.

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

Penguraian dan pemformatan

Pemformatan dan penguraian adalah operasi terbalik. Aturan pemformatan menentukan cara mengonversi nilai, seperti tanggal dan waktu atau angka, ke representasi stringnya, sedangkan aturan penguraian menentukan cara mengonversi representasi string ke nilai seperti tanggal dan waktu. Aturan pemformatan dan penguraian tergantung pada konvensi budaya. Contoh berikut menggambarkan ambiguitas yang dapat muncul saat menafsirkan string tanggal khusus budaya. Tanpa mengetahui konvensi budaya yang digunakan untuk menghasilkan string tanggal, tidak mungkin untuk mengetahui apakah 03/01/2011, 3/1/2011, dan 01/03/2011 mewakili 3 Januari 2011 atau 1 Maret 2011.

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

Demikian pula, seperti yang ditunjukkan contoh berikut, satu string dapat menghasilkan tanggal yang berbeda tergantung pada budaya yang konvensinya digunakan dalam operasi penguraian.

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

Perbandingan dan pengurutan string

Konvensi untuk membandingkan dan mengurutkan string bervariasi dari budaya ke budaya. Misalnya, urutan pengurutan mungkin didasarkan pada fonetik atau pada representasi visual karakter. Dalam bahasa Asia Timur, karakter diurutkan berdasarkan goresan dan radikal ideograf. Pengurutan juga tergantung pada bahasa dan budaya pesanan yang digunakan untuk alfabet. Misalnya, bahasa Denmark memiliki karakter "Æ" yang diurutkannya setelah "Z" dalam alfabet. Selain itu, perbandingan dapat peka huruf besar/kecil atau tidak peka huruf besar/kecil, dan aturan casing mungkin berbeda menurut budaya. Perbandingan ordinal, di sisi lain, menggunakan titik kode Unicode dari karakter individual dalam string saat membandingkan dan mengurutkan string.

Aturan pengurutan menentukan urutan alfabet karakter Unicode dan bagaimana dua string dibandingkan satu sama lain. Misalnya, metode membandingkan String.Compare(String, String, StringComparison) dua string berdasarkan StringComparison parameter . Jika nilai parameter adalah StringComparison.CurrentCulture, metode melakukan perbandingan linguistik yang menggunakan konvensi budaya saat ini; jika nilai parameter adalah StringComparison.Ordinal, metode melakukan perbandingan ordinal. Akibatnya, seperti yang ditunjukkan oleh contoh berikut, jika budaya saat ini adalah bahasa Inggris AS, panggilan pertama ke String.Compare(String, String, StringComparison) metode (menggunakan perbandingan sensitif budaya) mempertimbangkan "a" kurang dari "A", tetapi panggilan kedua ke metode yang sama (menggunakan perbandingan ordinal) mempertimbangkan "a" lebih besar dari "A".

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

.NET mendukung aturan pengurutan kata, string, dan ordinal:

Pengurutan kata melakukan perbandingan string yang sensitif terhadap budaya di mana karakter Unicode non-phanumeric tertentu mungkin memiliki bobot khusus yang ditetapkan untuk mereka. Misalnya, tanda hubung (-) mungkin memiliki bobot yang sangat kecil yang ditetapkan untuk itu sehingga "coop" dan "co-op" muncul di samping satu sama lain dalam daftar yang diurutkan. Untuk daftar String metode yang membandingkan dua string menggunakan aturan pengurutan kata, lihat bagian Operasi string menurut kategori .
Pengurutan string juga melakukan perbandingan yang sensitif terhadap budaya. Ini mirip dengan pengurutan kata, kecuali bahwa tidak ada kasus khusus, dan semua simbol non-alfanumerik datang sebelum semua karakter Unicode alfanumerik. Dua string dapat dibandingkan menggunakan aturan pengurutan CompareInfo.Compare CompareOptions.StringSortstring dengan memanggil metode kelebihan beban yang memiliki options parameter yang diberikan nilai . Perhatikan bahwa ini adalah satu-satunya metode yang disediakan .NET untuk membandingkan dua string menggunakan aturan pengurutan string.
Pengurutan ordinal membandingkan string berdasarkan nilai numerik setiap Char objek dalam string. Perbandingan ordinal secara otomatis peka huruf besar/kecil karena versi huruf kecil dan huruf besar karakter memiliki titik kode yang berbeda. Namun, jika kasus tidak penting, Anda dapat menentukan perbandingan ordinal yang mengabaikan kasus. Ini setara dengan mengonversi string menjadi huruf besar dengan menggunakan budaya invarian dan kemudian melakukan perbandingan ordinal pada hasilnya. Untuk daftar String metode yang membandingkan dua string menggunakan aturan pengurutan ordinal, lihat bagian Operasi string menurut kategori .

Perbandingan sensitif budaya adalah perbandingan apa pun yang secara eksplisit atau implisit CultureInfo menggunakan objek, termasuk budaya invarian yang ditentukan oleh CultureInfo.InvariantCulture properti. Budaya implisit adalah budaya saat ini, yang ditentukan oleh Thread.CurrentCulture properti dan CultureInfo.CurrentCulture . Ada variasi yang cukup besar dalam urutan urutan karakter alfabet (yaitu, karakter yang Char.IsLetter dikembalikan properti true) di seluruh budaya. Anda dapat menentukan perbandingan sensitif budaya yang menggunakan konvensi budaya tertentu dengan menyediakan objek ke metode perbandingan CultureInfo string seperti Compare(String, String, CultureInfo, CompareOptions). Anda dapat menentukan perbandingan sensitif budaya yang menggunakan konvensi budaya saat ini dengan memasok StringComparison.CurrentCulture, , StringComparison.CurrentCultureIgnoreCaseatau anggota CompareOptions enumerasi selain CompareOptions.Ordinal atau CompareOptions.OrdinalIgnoreCase ke kelebihan Compare metode yang sesuai. Perbandingan sensitif budaya umumnya sesuai untuk pengurutan sedangkan perbandingan ordinal tidak. Perbandingan ordinal umumnya sesuai untuk menentukan apakah dua string sama (yaitu, untuk menentukan identitas) sedangkan perbandingan yang sensitif terhadap budaya tidak.

Contoh berikut menggambarkan perbedaan antara perbandingan peka budaya dan ordinal. Contoh mengevaluasi tiga string, "Apple", "Æble", dan "AEble", menggunakan perbandingan ordinal dan konvensi budaya da-DK dan en-US (masing-masing adalah budaya default pada saat Compare metode dipanggil). Karena bahasa Denmark memperlakukan karakter "Æ" sebagai huruf individu dan mengurutkannya setelah "Z" dalam alfabet, string "Æble" lebih besar dari "Apple". Namun, "Æble" tidak dianggap setara dengan "AEble", sehingga "Æble" juga lebih besar dari "AEble". Budaya en-AS tidak termasuk huruf "Æ" tetapi memperlakukannya setara dengan "AE", yang menjelaskan mengapa "Æble" kurang dari "Apple" tetapi sama dengan "AEble". Perbandingan ordinal, di sisi lain, menganggap "Apple" kurang dari "Æble", dan "Æble" lebih besar dari "AEble".

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

public class CompareStringSample
{
   public static void Main()
   {
      string str1 = "Apple";
      string str2 = "Æble"; 
      string str3 = "AEble";
      
      // Set the current culture to Danish in Denmark.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Set the current culture to English in the U.S.
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      Console.WriteLine("Current culture: {0}", 
                        CultureInfo.CurrentCulture.Name);
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, String.Compare(str1, str2));
      Console.WriteLine("Comparison of {0} with {1}: {2}\n", 
                        str2, str3, String.Compare(str2, str3));
      
      // Perform an ordinal comparison.
      Console.WriteLine("Ordinal comparison");
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str1, str2, 
                        String.Compare(str1, str2, StringComparison.Ordinal));
      Console.WriteLine("Comparison of {0} with {1}: {2}", 
                        str2, str3, 
                        String.Compare(str2, str3, StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       Current culture: da-DK
//       Comparison of Apple with Æble: -1
//       Comparison of Æble with AEble: 1
//       
//       Current culture: en-US
//       Comparison of Apple with Æble: 1
//       Comparison of Æble with AEble: 0
//       
//       Ordinal comparison
//       Comparison of Apple with Æble: -133
//       Comparison of Æble with AEble: 133

open System
open System.Globalization
open System.Threading

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

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

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

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

Imports System.Globalization
Imports System.Threading

Public Module 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

Gunakan panduan umum berikut untuk memilih metode pengurutan atau perbandingan string yang sesuai:

Jika Anda ingin string dipesan berdasarkan budaya pengguna, Anda harus memesannya berdasarkan konvensi budaya saat ini. Jika budaya pengguna berubah, urutan string yang diurutkan juga akan berubah. Misalnya, aplikasi tesaurus harus selalu mengurutkan kata-kata berdasarkan budaya pengguna.
Jika Anda ingin string diurutkan berdasarkan konvensi budaya tertentu, Anda harus memesannya dengan menyediakan objek yang mewakili budaya tersebut dengan metode perbandingan CultureInfo . Misalnya, dalam aplikasi yang dirancang untuk mengajar siswa bahasa tertentu, Anda ingin string dipesan berdasarkan konvensi salah satu budaya yang berbicara bahasa tersebut.
Jika Anda ingin urutan string tetap tidak berubah di seluruh budaya, Anda harus memesannya berdasarkan konvensi budaya yang invarian atau menggunakan perbandingan ordinal. Misalnya, Anda akan menggunakan pengurutan ordinal untuk mengatur nama file, proses, mutex, atau pipa bernama.
Untuk perbandingan yang melibatkan keputusan keamanan (seperti apakah nama pengguna valid), Anda harus selalu melakukan pengujian ordinal untuk kesetaraan dengan memanggil kelebihan metode Equals .

Catatan

Aturan pengurutan dan casing yang sensitif terhadap budaya yang digunakan dalam perbandingan string bergantung pada versi .NET. Pada .NET Core, perbandingan string tergantung pada versi Standar Unicode yang didukung oleh sistem operasi yang mendasarinya. Di .NET Framework 4.5 dan versi yang lebih baru yang berjalan pada Windows 8 atau yang lebih baru, pengurutan, casing, normalisasi, dan informasi karakter Unicode sesuai dengan standar Unicode 6.0. Pada sistem operasi Windows lainnya, mereka sesuai dengan standar Unicode 5.0.

Untuk informasi selengkapnya tentang aturan pengurutan kata, string, dan ordinal, lihat topik tersebut System.Globalization.CompareOptions . Untuk rekomendasi tambahan tentang kapan menggunakan setiap aturan, lihat Praktik Terbaik untuk Menggunakan String.

Biasanya, Anda tidak memanggil metode perbandingan string seperti Compare secara langsung untuk menentukan urutan urutan string. Sebagai gantinya, metode perbandingan dipanggil dengan metode pengurutan seperti Array.Sort atau List<T>.Sort. Contoh berikut melakukan empat operasi pengurutan yang berbeda (pengurutan kata menggunakan budaya saat ini, pengurutan kata menggunakan kultur yang invarian, urutan ordinal, dan pengurutan string menggunakan budaya invarian) tanpa secara eksplisit memanggil metode perbandingan string, meskipun mereka menentukan jenis perbandingan yang akan digunakan. Perhatikan bahwa setiap jenis jenis menghasilkan urutan string yang unik dalam arraynya.

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

Tip

Secara internal, .NET menggunakan kunci pengurutan untuk mendukung perbandingan string yang sensitif secara budaya. Setiap karakter dalam string diberikan beberapa kategori berat sortir, termasuk alfabet, huruf besar/kecil, dan diakritik. Kunci pengurutan, yang diwakili oleh SortKey kelas, menyediakan repositori bobot ini untuk string tertentu. Jika aplikasi Anda melakukan sejumlah besar operasi pencarian atau pengurutan pada serangkaian string yang sama, Anda dapat meningkatkan performanya dengan menghasilkan dan menyimpan kunci pengurutan untuk semua string yang digunakannya. Saat operasi pengurutan atau perbandingan diperlukan, Anda menggunakan tombol pengurutan alih-alih string. Untuk informasi selengkapnya, lihat SortKey kelas.

Jika Anda tidak menentukan konvensi perbandingan string, metode pengurutan seperti Array.Sort(Array) melakukan pengurutan peka terhadap budaya dan peka huruf besar/kecil pada string. Contoh berikut menggambarkan bagaimana mengubah budaya saat ini memengaruhi urutan string yang diurutkan dalam array. Ini membuat array tiga string. Pertama, ini mengatur System.Threading.Thread.CurrentThread.CurrentCulture properti ke en-US dan memanggil Array.Sort(Array) metode . Urutan pengurutan yang dihasilkan didasarkan pada konvensi pengurutan untuk budaya Bahasa Inggris (Amerika Serikat). Selanjutnya, contoh mengatur System.Threading.Thread.CurrentThread.CurrentCulture properti ke da-DK dan memanggil Array.Sort metode lagi. Perhatikan bagaimana urutan pengurutan yang dihasilkan berbeda dari hasil en-US karena menggunakan konvensi pengurutan untuk Denmark (Denmark).

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

public class ArraySort
{
   public static void Main(String[] args)
   {
      // Create and initialize a new array to store the strings.
      string[] stringArray = { "Apple", "Æble", "Zebra"};

      // Display the values of the array.
      Console.WriteLine( "The original string array:");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "en-US".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US");
      // Sort the values of the array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"en-US\":");
      PrintIndexAndValues(stringArray);

      // Set the CurrentCulture to "da-DK".
      Thread.CurrentThread.CurrentCulture = new CultureInfo("da-DK");
      // Sort the values of the Array.
      Array.Sort(stringArray);

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray);
   }
   public static void PrintIndexAndValues(string[] myArray)
   {
      for (int i = myArray.GetLowerBound(0); i <=
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble

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

Peringatan

Jika tujuan utama Anda dalam membandingkan string adalah untuk menentukan apakah mereka sama, Anda harus memanggil metode .String.Equals Biasanya, Anda harus menggunakan Equals untuk melakukan perbandingan ordinal. Metode String.Compare ini dimaksudkan terutama untuk mengurutkan string.

Metode pencarian string, seperti String.StartsWith dan String.IndexOf, juga dapat melakukan perbandingan string yang sensitif terhadap budaya atau ordinal. Contoh berikut menggambarkan perbedaan antara perbandingan ordinal dan peka budaya menggunakan metode .IndexOf Pencarian sensitif budaya di mana budaya saat ini adalah bahasa Inggris (Amerika Serikat) mempertimbangkan "oe" substring untuk mencocokkan ligatur "œ". Karena tanda hubung lunak (U+00AD) adalah karakter lebar nol, pencarian memperlakukan tanda hubung lunak setara dengan dan menemukan kecocokan String.Empty di awal string. Pencarian ordinal, di sisi lain, tidak menemukan kecocokan dalam kedua kasus.

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("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '' found in cooperative at position 0
//       '' found in cooperative at position 2

open System

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

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

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

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

Module 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

Mencari dalam string

Metode pencarian string, seperti String.StartsWith dan String.IndexOf, juga dapat melakukan perbandingan string sensitif budaya atau ordinal untuk menentukan apakah karakter atau substring ditemukan dalam string tertentu.

Metode pencarian di String kelas yang mencari karakter individual, seperti IndexOf metode , atau salah satu dari satu set karakter, seperti IndexOfAny metode , semuanya melakukan pencarian ordinal. Untuk melakukan pencarian karakter yang sensitif terhadap budaya, Anda harus memanggil CompareInfo metode seperti CompareInfo.IndexOf(String, Char) atau CompareInfo.LastIndexOf(String, Char). Perhatikan bahwa hasil pencarian karakter menggunakan perbandingan ordinal dan peka budaya bisa sangat berbeda. Misalnya, pencarian untuk karakter Unicode yang telah dikomposisikan sebelumnya seperti ligatur "Æ" (U+00C6) mungkin cocok dengan kemunculan komponennya dalam urutan yang benar, seperti "AE" (U+041U+0045), tergantung pada budaya. Contoh berikut mengilustrasikan perbedaan antara String.IndexOf(Char) metode dan CompareInfo.IndexOf(String, Char) saat mencari karakter individual. Ligatur "æ" (U+00E6) ditemukan dalam string "udara" saat menggunakan konvensi budaya en-AS, tetapi tidak ketika menggunakan konvensi budaya da-DK atau ketika melakukan perbandingan ordinal.

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 '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));
      
      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0

open System.Globalization

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

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

Imports System.Globalization

Module 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

Di sisi lain, String metode kelas yang mencari string daripada karakter melakukan pencarian sensitif budaya jika opsi pencarian tidak ditentukan secara eksplisit oleh parameter jenis StringComparison. Satu-satunya pengecualian adalah Contains, yang melakukan pencarian ordinal.

Uji kesetaraan

String.Compare Gunakan metode untuk menentukan hubungan dua string dalam urutan pengurutan. Biasanya, ini adalah operasi yang sensitif terhadap budaya. Sebaliknya, panggil String.Equals metode untuk menguji kesetaraan. Karena pengujian untuk kesetaraan biasanya membandingkan input pengguna dengan beberapa string yang diketahui, seperti nama pengguna yang valid, kata sandi, atau jalur sistem file, biasanya merupakan operasi ordinal.

Peringatan

Dimungkinkan untuk menguji kesetaraan String.Compare dengan memanggil metode dan menentukan apakah nilai yang dikembalikan adalah nol. Namun, praktik ini tidak disarankan. Untuk menentukan apakah dua string sama, Anda harus memanggil salah satu kelebihan beban String.Equals metode. Kelebihan beban yang disukai untuk dipanggil adalah metode instans Equals(String, StringComparison) atau metode statis Equals(String, String, StringComparison) , karena kedua metode menyertakan System.StringComparison parameter yang secara eksplisit menentukan jenis perbandingan.

Contoh berikut menggambarkan bahaya melakukan perbandingan sensitif budaya untuk kesetaraan ketika ordinal harus digunakan sebagai gantinya. Dalam hal ini, niat kode adalah untuk melarang akses sistem file dari URL yang dimulai dengan "FILE://" atau "file://" dengan melakukan perbandingan yang tidak peka huruf besar/kecil dari awal URL dengan string "FILE://". Namun, jika perbandingan sensitif budaya dilakukan menggunakan budaya Turki (Turki) pada URL yang dimulai dengan "file://", perbandingan untuk kesetaraan gagal, karena huruf besar Turki yang setara dengan huruf kecil "i" adalah "İ" alih-alih "I". Akibatnya, akses sistem file secara tidak sengaja diizinkan. Di sisi lain, jika perbandingan ordinal dilakukan, perbandingan untuk kesetaraan berhasil, dan akses sistem file ditolak.

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

   private static bool TestForEquality(string str, StringComparison cmp)
   {
      int position = str.IndexOf("://");
      if (position < 0) return false;

      string substring = str.Substring(0, position);  
      return substring.Equals("FILE", cmp);
   }
}
// The example displays the following output:
//       Culture-sensitive test for equality:
//       Access to file://c:/notes.txt is allowed.
//       
//       Ordinal test for equality:
//       Access to file://c:/notes.txt is not allowed.

open System
open System.Globalization
open System.Threading

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

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

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

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

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

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

Imports System.Globalization
Imports System.Threading

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

Normalisasi kasus

Beberapa karakter Unicode memiliki beberapa representasi. Misalnya, salah satu poin kode berikut dapat mewakili huruf "ắ":

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

Beberapa representasi untuk satu karakter mempersulit pencarian, pengurutan, pencocokan, dan operasi string lainnya.

Standar Unicode mendefinisikan proses yang disebut normalisasi yang mengembalikan satu representasi biner dari karakter Unicode untuk salah satu representasi biner yang setara. Normalisasi dapat menggunakan beberapa algoritma, yang disebut formulir normalisasi, yang mengikuti aturan yang berbeda. .NET mendukung formulir normalisasi Unicode C, D, KC, dan KD. Ketika string telah dinormalisasi ke bentuk normalisasi yang sama, string dapat dibandingkan dengan menggunakan perbandingan ordinal.

Perbandingan ordinal adalah perbandingan biner dari nilai skalar Unicode dari objek yang Char sesuai di setiap string. Kelas ini String mencakup sejumlah metode yang dapat melakukan perbandingan ordinal, termasuk yang berikut:

Setiap kelebihan beban Comparemetode , , StartsWith Equals, EndsWith, IndexOf, dan LastIndexOf yang mencakup StringComparison parameter . Metode ini melakukan perbandingan ordinal jika Anda menyediakan nilai StringComparison.Ordinal atau OrdinalIgnoreCase untuk parameter ini.
Kelebihan beban CompareOrdinal metode.
Metode yang menggunakan perbandingan ordinal secara default, seperti Contains, , Replacedan Split.
Metode yang mencari Char nilai atau untuk elemen dalam Char array dalam instans string. Metode tersebut termasuk IndexOf(Char) dan Split(Char[]).

Anda dapat menentukan apakah string dinormalisasi ke formulir normalisasi C dengan memanggil String.IsNormalized() metode , atau Anda dapat memanggil String.IsNormalized(NormalizationForm) metode untuk menentukan apakah string dinormalisasi ke formulir normalisasi tertentu. Anda juga dapat memanggil String.Normalize() metode untuk mengonversi string ke formulir normalisasi C, atau Anda dapat memanggil String.Normalize(NormalizationForm) metode untuk mengonversi string ke formulir normalisasi tertentu. Untuk informasi langkah demi langkah tentang menormalkan dan membandingkan string, lihat Normalize() metode dan Normalize(NormalizationForm) .

Contoh sederhana berikut mengilustrasikan normalisasi string. Ini mendefinisikan huruf "ố" dengan tiga cara berbeda dalam tiga string yang berbeda, dan menggunakan perbandingan ordinal untuk kesetaraan untuk menentukan bahwa setiap string berbeda dari dua string lainnya. Kemudian mengonversi setiap string ke formulir normalisasi yang didukung, dan sekali lagi melakukan perbandingan ordinal dari setiap string dalam bentuk normalisasi tertentu. Dalam setiap kasus, pengujian kedua untuk kesetaraan menunjukkan bahwa string sama.

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

Untuk informasi selengkapnya tentang formulir normalisasi dan normalisasi, lihat System.Text.NormalizationForm, serta Lampiran Standar Unicode #15: Formulir Normalisasi Unicode dan FAQ Normalisasi di situs web unicode.org.

Operasi string menurut kategori

Kelas ini String menyediakan anggota untuk membandingkan string, menguji string untuk kesetaraan, menemukan karakter atau substring dalam string, memodifikasi string, mengekstrak substring dari string, menggabungkan string, memformat nilai, menyalin string, dan menormalkan string.

Membandingkan string

Anda dapat membandingkan string untuk menentukan posisi relatifnya dalam urutan pengurutan dengan menggunakan metode berikut String :

Compare mengembalikan bilangan bulat yang menunjukkan hubungan satu string ke string kedua dalam urutan pengurutan.
CompareOrdinal mengembalikan bilangan bulat yang menunjukkan hubungan satu string ke string kedua berdasarkan perbandingan titik kodenya.
CompareTo mengembalikan bilangan bulat yang menunjukkan hubungan instans string saat ini ke string kedua dalam urutan pengurutan. Metode ini CompareTo(String) menyediakan IComparable implementasi dan IComparable<T> untuk String kelas .

Menguji string untuk kesetaraan

Anda memanggil Equals metode untuk menentukan apakah dua string sama. Instans Equals(String, String, StringComparison) dan kelebihan beban statis Equals(String, StringComparison) memungkinkan Anda menentukan apakah perbandingan peka terhadap budaya atau ordinal, dan apakah kasus dianggap atau diabaikan. Sebagian besar pengujian untuk kesetaraan adalah ordinal, dan perbandingan untuk kesetaraan yang menentukan akses ke sumber daya sistem (seperti objek sistem file) harus selalu ordinal.

Menemukan karakter dalam string

Kelas ini String mencakup dua jenis metode pencarian:

Metode yang mengembalikan Boolean nilai untuk menunjukkan apakah substring tertentu ada dalam instans string. Ini termasuk Containsmetode , EndsWith, dan StartsWith .
Metode yang menunjukkan posisi awal substring dalam instans string. Ini termasuk IndexOfmetode , IndexOfAny, LastIndexOf, dan LastIndexOfAny .

Peringatan

Jika Anda ingin mencari string untuk pola tertentu daripada substring tertentu, Anda harus menggunakan ekspresi reguler. Untuk informasi selengkapnya, lihat .NET Regular Expressions.

Mengubah string

Kelas String ini mencakup metode berikut yang tampaknya mengubah nilai string:

Insert menyisipkan string ke dalam instans saat ini String .
PadLeft menyisipkan satu atau beberapa kemunculan karakter tertentu di awal string.
PadRight menyisipkan satu atau beberapa kemunculan karakter tertentu di akhir string.
Remove menghapus substring dari instans saat ini String .
Replace mengganti substring dengan substring lain dalam instans saat ini String .
ToLower dan ToLowerInvariant konversi semua karakter dalam string menjadi huruf kecil.
ToUpper dan ToUpperInvariant konversi semua karakter dalam string menjadi huruf besar.
Trim menghapus semua kemunculan karakter dari awal dan akhir string.
TrimEnd menghapus semua kemunculan karakter dari akhir string.
TrimStart menghapus semua kemunculan karakter dari awal string.

Penting

Semua metode modifikasi string mengembalikan objek baru String . Mereka tidak mengubah nilai instans saat ini.

Mengekstrak substring dari string

Metode ini String.Split memisahkan satu string menjadi beberapa string. Kelebihan beban metode memungkinkan Anda menentukan beberapa pemisah, untuk membatasi jumlah substring yang diekstrak metode, untuk memangkas spasi putih dari substring, dan untuk menentukan apakah string kosong (yang terjadi ketika pembatas berdekatan) disertakan di antara string yang dikembalikan.

Menggabungkan string

Metode berikut String dapat digunakan untuk penggalian string:

Concat menggabungkan satu atau beberapa substring ke dalam satu string.
Join menggabungkan satu atau beberapa substring ke dalam satu elemen dan menambahkan pemisah di antara setiap substring.

Format nilai

Metode ini String.Format menggunakan fitur pemformatan komposit untuk mengganti satu atau beberapa tempat penampung dalam string dengan representasi string dari beberapa objek atau nilai. Metode Format ini sering digunakan untuk melakukan hal berikut:

Untuk menyematkan representasi string dari nilai numerik dalam string.
Untuk menyematkan representasi string dari nilai tanggal dan waktu dalam string.
Untuk menyematkan representasi string dari nilai enumerasi dalam string.
Untuk menyematkan representasi string dari beberapa objek yang mendukung IFormattable antarmuka dalam string.
Untuk membenarkan kanan atau membenarkan substring di bidang dalam string yang lebih besar.

Untuk informasi terperinci tentang operasi dan contoh pemformatan, lihat Format ringkasan kelebihan beban.

Menyalin string

Anda dapat memanggil metode berikut String untuk membuat salinan string:

Clone mengembalikan referensi ke objek yang sudah ada String .
Copy membuat salinan string yang ada.
CopyTo menyalin sebagian string ke array karakter.

Menormalkan string

Di Unicode, satu karakter dapat memiliki beberapa titik kode. Normalisasi mengonversi karakter yang setara ini menjadi representasi biner yang sama. Metode String.Normalize ini melakukan normalisasi, dan String.IsNormalized metode menentukan apakah string dinormalisasi.

Untuk informasi selengkapnya dan contohnya, lihat bagian Normalisasi sebelumnya di artikel ini.

Kelas System.String

Membuat instans objek String

Karakter objek dan karakter Unicode

Standar Unicode

Karakter null yang disematkan

String dan indeks

String null dan string kosong

Kekekalan dan kelas StringBuilder

Operasi ordinal vs. sensitif terhadap budaya

Kapitalisasi

Penguraian dan pemformatan

Perbandingan dan pengurutan string

Mencari dalam string

Uji kesetaraan

Normalisasi kasus

Operasi string menurut kategori

Membandingkan string

Menguji string untuk kesetaraan

Menemukan karakter dalam string

Mengubah string

Mengekstrak substring dari string

Menggabungkan string

Format nilai

Menyalin string

Menormalkan string

Saran dan Komentar

Sumber Daya Tambahan: