String Kelas

Definisi

Ruang nama:

System

Rakitan:

netstandard.dll, System.Runtime.dll

Sumber:

String.cs

Mewakili teks sebagai urutan unit kode UTF-16.

public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, IParsable<System::String ^>, ISpanParsable<System::String ^>, System::Collections::Generic::IEnumerable<char>

public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, IParsable<string>, ISpanParsable<string>, System.Collections.Generic.IEnumerable<char>

type string = class
    interface seq<char>
    interface IEnumerable
    interface ICloneable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
    interface IParsable<string>
    interface ISpanParsable<string>

Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String), IParsable(Of String), ISpanParsable(Of String)

Warisan

Object

String

Penerapan

IEnumerable<Char> IEnumerable IComparable IComparable<String> IConvertible IEquatable<String> ICloneable IParsable<String> IParsable<TSelf> ISpanParsable<String>

Keterangan

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 jenis Char serta Rune, lihat Pengenalan pengodean karakter di .NET.

Menginstansiasi objek String

Anda dapat membuat objek String 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, karakter garis miring terbalik dalam string harus diloloskan atau seluruh string harus menggunakan tanda @ di depan string.

  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 satu string dari kombinasi instans String dan string literal apa pun. Contoh berikut mengilustrasikan penggunaan operator penggabungan 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.
  

Objek karakter 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.

Note

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, dapat memeriksa untuk memastikan bahwa string terbentuk dengan baik, anggota kelas String 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 objek Char: grafem, dan titik kode tambahan Unicode yang sesuai dengan karakter di bidang tambahan Unicode.

• Grafem diwakili oleh karakter dasar yang diikuti oleh satu atau lebih karakter penggabung. 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 dalam contoh berikut, perbandingan yang peka terhadap budaya untuk kesetaraan nilai menunjukkan bahwa kedua representasi ini sama, meskipun perbandingan ordinal biasa tidak demikian. 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 Example
  {
     public static void Main()
     {
        StreamWriter sw = new StreamWriter(@".\graphemes.txt");
        string grapheme = "\u0061\u0308";
        sw.WriteLine(grapheme);
        
        string singleChar = "\u00e4";
        sw.WriteLine(singleChar);
              
        sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                     String.Equals(grapheme, singleChar, 
                                   StringComparison.CurrentCulture));
        sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                     String.Equals(grapheme, singleChar, 
                                   StringComparison.Ordinal));
        sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                     String.Equals(grapheme.Normalize(), 
                                   singleChar.Normalize(), 
                                   StringComparison.Ordinal));
        sw.Close(); 
     }
  }
  // The example produces the following output:
  //       ä
  //       ä
  //       ä = ä (Culture-sensitive): True
  //       ä = ä (Ordinal): False
  //       ä = ä (Normalized Ordinal): True
  

  open System
  open System.IO
  
  do
      use sw = new StreamWriter(@".\graphemes.txt")
      let grapheme = "\u0061\u0308"
      sw.WriteLine grapheme
  
      let singleChar = "\u00e4"
      sw.WriteLine singleChar
  
      sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                  String.Equals(grapheme, singleChar,
                                  StringComparison.CurrentCulture))
      sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar,
                  String.Equals(grapheme, singleChar,
                                  StringComparison.Ordinal))
      sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar,
                  String.Equals(grapheme.Normalize(),
                                  singleChar.Normalize(),
                                  StringComparison.Ordinal))
  // The example produces the following output:
  //       ä
  //       ä
  //       ä = ä (Culture-sensitive): True
  //       ä = ä (Ordinal): False
  //       ä = ä (Normalized Ordinal): True
  

  Imports System.Globalization
  Imports System.IO
  
  Module 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:
  '       ä
  '       ä
  '       ä = ä (Culture-sensitive): True
  '       ä = ä (Ordinal): False
  '       ä = ä (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
Kerangka Kerja .NET 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. Informasi perbandingan dan pengurutan string disediakan oleh komponen International untuk pustaka Unicode (kecuali pada versi Windows sebelum pembaruan Windows 10 Mei 2019).

Karakter nol 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-asumsi umum berikut mengenai string, yang mungkin dibuat oleh pemrogram atau pustaka C dan C++ yang ditulis dalam C atau C++, tidak selalu valid saat diterapkan pada objek String.

• Nilai yang dikembalikan oleh fungsi strlen atau wcslen, tidak selalu sama dengan String.Length.

• String yang dibuat oleh fungsi strcpy_s atau wcscpy_s belum tentu identik dengan string yang sedang disalin.

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 terhadap perbedaan huruf besar dan 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, yaitu posisi indeks nol. Sejumlah metode pencarian, seperti IndexOf dan LastIndexOf, mengembalikan indeks karakter atau substring dalam instans string.

Properti Chars[Int32] memungkinkan Anda mengakses objek individual Char berdasarkan posisi indeksnya dalam string. Chars[Int32] 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.

Karena kelas String mengimplementasikan antarmuka IEnumerable, Anda juga dapat melakukan iterasi melalui objek Char dalam string dengan menggunakan konstruk foreach, seperti yang ditunjukkan oleh 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 kelas System.Globalization.StringInfo dan TextElementEnumerator, atau metode String.EnumerateRunes dan struktur Rune. 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 émotion que "+
                 "je commence à raconter ici les aventures " +
                 "extraordinaires de Joseph Rouletabille."; 
// Character counters.
int nChars = 0;
// Objects to store word count.
List<int> chars = new List<int>();
List<int> elements = new List<int>();

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

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

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

open System
open System.Globalization

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

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

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

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

Imports System.Collections.Generic
Imports System.Globalization

Module 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 émotion que " +
                              "je commence à raconter ici les aventures " +
                              "extraordinaires de Joseph Rouletabille."
        ' Character counters.
        Dim nChars As Integer = 0
        ' Objects to store word count.
        Dim chars As New List(Of Integer)()
        Dim elements As New List(Of Integer)()

        For Each ch In opening
            ' Skip the ' character.
            If ch = ChrW(&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 akan mengakibatkan melemparkan 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 pemanggilan metode dapat memunculkan 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 praktis berikut yang memungkinkan Anda menguji apakah string adalah null atau kosong:

• IsNullOrEmpty, yang menunjukkan apakah string tersebut adalah null atau 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 metode IsNullOrEmpty dalam implementasi IFormattable.ToString dari kelas khusus 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 Example
{
   public static void Main()
   {
      Random rnd = new Random();
      
      string str = String.Empty;
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                           false, Encoding.Unicode);

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

open System
open System.IO
open System.Text

do
    let rnd = Random()

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

Imports System.IO
Imports System.Text

Module 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 dari kelas String, objek StringBuilder bersifat mutable; ketika Anda menggabungkan, menambahkan, atau menghapus substring dari suatu 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 Example
{
   public static void Main()
   {
      Random rnd = new Random();
      StringBuilder sb = new StringBuilder();
      StreamWriter sw = new StreamWriter(@".\StringFile.txt", 
                                         false, Encoding.Unicode);

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

open System
open System.IO
open System.Text

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

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

Imports System.IO
Imports System.Text

Module 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. operasi yang peka 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 yang peka terhadap budaya bertindak berdasarkan nilai objek String, dan mempertimbangkan aturan kapitalisasi, pengurutan, pemformatan, dan penguraian yang khusus untuk 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 konstan dapat dilihat sebagai semacam kotak hitam yang memastikan stabilitas perbandingan string teks dan pengurutan di semua budaya.

Important

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.

Important

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 Compare(String, String) untuk melakukan perbandingan dua string yang peka budaya dengan menggunakan konvensi budaya saat ini, Anda harus memanggil metode Compare(String, String, StringComparison) dengan nilai StringComparison.CurrentCulture untuk argumen comparisonType. 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 Tabel Elemen Kolase Unicode Default.

Pelindung

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 metode TextInfo.ToTitleCase untuk mengonversi string ke bentuk huruf kapital judul.

Note

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

Operasi casing dapat didasarkan pada aturan budaya saat ini, budaya yang ditentukan, 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 huruf besar-kecil 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 I TANPA TITIK (U+0131). Dalam budaya tr-TR (Turki) dan az-Latn-AZ (Azerbaijan, Latin), serta dalam skrip netral tr, az, dan az-Latn, huruf kecil yang setara dengan HURUF LATIN KAPITAL I adalah HURUF LATIN KECIL I TANPA TITIK, dan huruf besar yang setara dengan HURUF LATIN KECIL I adalah HURUF LATIN KAPITAL I BERTITIK ATAS. Dalam semua budaya lainnya, termasuk budaya invarian, HURUF KECIL LATIN I dan HURUF BESAR LATIN I adalah setara dalam bentuk huruf kecil dan huruf besar.

  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 Example
  {
     const string disallowed = "file";
     
     public static void Main()
     {
        IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
     }
  
     private static void IsAccessAllowed(String resource)
     {
        CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                   CultureInfo.CreateSpecificCulture("tr-TR") };
        String scheme = null;
        int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
        if (index > 0) 
           scheme = resource.Substring(0, index - 1);
  
        // Change the current culture and perform the comparison.
        foreach (var culture in cultures) {
           Thread.CurrentThread.CurrentCulture = culture;
           Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
           Console.WriteLine(resource);
           Console.WriteLine("Access allowed: {0}", 
                             ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
           Console.WriteLine();
        }   
     }
  }
  // The example displays the following output:
  //       Culture: English (United States)
  //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
  //       Access allowed: False
  //       
  //       Culture: Turkish (Turkey)
  //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
  //       Access allowed: True
  

  open System
  open System.Globalization
  open System.Threading
  
  let disallowed = "file"
  
  let isAccessAllowed (resource: string) =
      let cultures = 
          [| CultureInfo.CreateSpecificCulture "en-US"
             CultureInfo.CreateSpecificCulture "tr-TR" |]
      let index = resource.IndexOfAny [| '\\'; '/' |]
      let scheme =
          if index > 0 then
              resource.Substring(0, index - 1)
          else 
              null
  
      // Change the current culture and perform the comparison.
      for culture in cultures do
          Thread.CurrentThread.CurrentCulture <- culture
          printfn $"Culture: {CultureInfo.CurrentCulture.DisplayName}"
          printfn $"{resource}"
          printfn $"Access allowed: {String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase) |> not}"
          printfn ""
          
  isAccessAllowed @"FILE:\\\c:\users\user001\documents\FinancialInfo.txt"
  // The example displays the following output:
  //       Culture: English (United States)
  //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
  //       Access allowed: False
  //
  //       Culture: Turkish (Turkey)
  //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
  //       Access allowed: True
  

  Imports System.Globalization
  Imports System.Threading
  
  Module 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 penulisan huruf budaya invarian untuk mengubah karakter menjadi huruf besar atau huruf kecil mengembalikan karakter yang sama. Pada semua budaya lainnya, menghasilkan karakter yang berbeda. Beberapa karakter yang terpengaruh tercantum dalam tabel berikut.

  karakter	Jika diubah menjadi	Returns
  TANDA MIKRON (U+00B5)	Huruf Kapital	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 I TANPA TITIK (U+0131)	Huruf Kapital	HURUF LATIN KAPITAL I (U+0049)
  HURUF LATIN KECIL PANJANG S (U+017F)	Huruf Kapital	HURUF LATIN KAPITAL S (U+0053)
  HURUF BESAR LATIN D DENGAN HURUF KECIL Z DENGAN CARON (U+01C5)	Huruf kecil	HURUF LATIN KECIL DZ DENGAN CARON (U+01C6)
  MENGGABUNGKAN YPOGEGRAMMENI YUNANI (U+0345)	Huruf Kapital	HURUF KAPITAL YUNANI IOTA (U+0399)

• Perbedaan dalam pemetaan kasus pasangan dua huruf dengan campuran huruf besar dan kecil 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 hr-HR (Kroasia)."
  • "cH" dalam budaya cs-CZ (Ceko (Republik Ceko)) dan budaya sk-SK (Slowakia).
  • "aA" dalam kebudayaan 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, jarang sekali menemui situasi di mana perbandingan pasangan ini yang peka terhadap perbedaan budaya menciptakan masalah, karena pasangan ini jarang dalam string tetap atau pengidentifikasi konstan.

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", "Dženana" };
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"),  
                                 new CultureInfo("tr-TR") };

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

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

open System
open System.Globalization
open System.IO

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

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

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

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

Imports System.Globalization
Imports System.IO

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

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

            Next
            sw.WriteLine()
        Next
        sw.Close()
    End Sub

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

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 Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

      foreach (var culture in cultures)
         Console.WriteLine("{0,-12} {1}", String.IsNullOrEmpty(culture.Name) ?
                           "Invariant" : culture.Name, 
                           date.ToString("d", culture));                                    
   }
}
// The example displays the following output:
//       Invariant    03/01/2011
//       en-US        3/1/2011
//       fr-FR        01/03/2011

open System
open System.Globalization

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

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

Imports System.Globalization

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

open System
open System.Globalization

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

Imports System.Globalization

Module 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 urutan yang digunakan oleh bahasa dan budaya 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 String.Compare(String, String, StringComparison) ini membandingkan dua string berdasarkan parameter StringComparison. 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 Amerika Serikat, panggilan pertama ke metode String.Compare(String, String, StringComparison) (menggunakan perbandingan sensitif budaya) membandingkan "a" lebih kecil dari "A", tetapi panggilan kedua ke metode yang sama (menggunakan perbandingan ordinal) membandingkan "a" lebih besar dari "A".

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

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("en-US");
      Console.WriteLine(String.Compare("A", "a", StringComparison.CurrentCulture));
      Console.WriteLine(String.Compare("A", "a", StringComparison.Ordinal));
   }
}
// The example displays the following output:
//       1
//       -32

open System
open System.Globalization
open System.Threading

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

Imports System.Globalization
Imports System.Threading

Module 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 diberikan bobot yang sangat kecil, sehingga "coop" dan "co-op" dapat muncul berdekatan 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 string dengan memanggil metode overload yang memiliki parameter yang diberikan nilai CompareInfo.Compare. 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 aksara karena versi huruf kecil dan huruf besar dari 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 yang secara eksplisit atau implisit menggunakan objek CultureInfo, termasuk budaya invarian yang ditentukan oleh properti CultureInfo.InvariantCulture. Budaya implisit adalah budaya saat ini, yang ditentukan oleh properti Thread.CurrentCulture dan CultureInfo.CurrentCulture. Ada variasi yang cukup besar dalam urutan karakter alfabet (yaitu, karakter yang untuknya metode Char.IsLetter mengembalikan true) di seluruh budaya. Anda dapat menentukan perbandingan yang peka terhadap budaya yang menggunakan konvensi budaya tertentu dengan menyediakan objek CultureInfo ke metode perbandingan 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-US tidak termasuk huruf "Æ" tetapi memperlakukannya setara dengan "AE", yang menjelaskan mengapa "Æble" dianggap lebih rendah daripada "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 berurutan ordinal untuk mengatur nama file, proses, mutex, atau named pipe.

• Untuk perbandingan yang melibatkan keputusan keamanan (seperti apakah nama pengguna valid), Anda harus selalu melakukan pengujian ordinal untuk kesetaraan dengan memanggil overload dari metode Equals.

Note

Aturan pengurutan dan casing yang sensitif terhadap budaya yang digunakan dalam perbandingan string bergantung pada versi Standar Unicode yang didukung oleh sistem operasi yang mendasarinya.

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 Example
{
   public static void Main()
   {
      string[] strings = { "coop", "co-op", "cooperative", 
                           "co\u00ADoperative", "cœur", "coeur" };

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Module 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
'     co­operative         co-op           co-op   cooperative          coop
'             cœur   cooperative     cooperative  co­operative   cooperative
'            coeur  co­operative    co­operative          cœur  co­operative

Tip

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 kelas SortKey.

Jika Anda tidak menentukan konvensi perbandingan string, metode pengurutan seperti Array.Sort(Array) melakukan pengurutan sensitif terhadap budaya dan sensitif terhadap huruf besar/kecil pada string. Contoh berikut menggambarkan bagaimana mengubah budaya saat ini memengaruhi urutan string yang diurutkan dalam array. Ini membuat sebuah array yang terdiri dari tiga string. Pertama, properti System.Threading.Thread.CurrentThread.CurrentCulture diatur ke en-US dan metode Array.Sort(Array) dipanggil. Urutan pengurutan yang dihasilkan didasarkan pada konvensi pengurutan untuk budaya Bahasa Inggris (Amerika Serikat). Selanjutnya, contoh ini mengatur properti System.Threading.Thread.CurrentThread.CurrentCulture ke da-DK dan memanggil metode Array.Sort 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

Warning

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 yang sensitif terhadap budaya di mana budaya saat ini menggunakan bahasa Inggris (Amerika Serikat) menganggap potongan teks "oe" sesuai dengan 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 Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();
      
      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

   private static void FindInString(string s, string substring, StringComparison options)
   {
      int result = s.IndexOf(substring, options);
      if (result != -1)
         Console.WriteLine("'{0}' found in {1} at position {2}", 
                           substring, s, result);
      else
         Console.WriteLine("'{0}' not found in {1}", 
                           substring, s);                                                  
   }
}
// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//       
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2

open System

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

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

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

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

Module 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 co­operative at position 0
'       '­' found in co­operative 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 metode CompareInfo 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 "aerial" saat menggunakan konvensi budaya en-US, tetapi tidak ketika menggunakan konvensi budaya da-DK atau ketika melakukan perbandingan ordinal.

using System;
using System.Globalization;

public class Example
{
   public static void Main()
   {
      String[] cultureNames = { "da-DK", "en-US" };
      CompareInfo ci;
      String str = "aerial";
      Char ch = 'æ';  // U+00E6
      
      Console.Write("Ordinal comparison -- ");
      Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                        str.IndexOf(ch));
      
      foreach (var cultureName in cultureNames) {
         ci = CultureInfo.CreateSpecificCulture(cultureName).CompareInfo;
         Console.Write("{0} cultural comparison -- ", cultureName);
         Console.WriteLine("Position of '{0}' in {1}: {2}", ch, str,
                           ci.IndexOf(str, ch));
      }
   }
}
// The example displays the following output:
//       Ordinal comparison -- Position of 'æ' in aerial: -1
//       da-DK cultural comparison -- Position of 'æ' in aerial: -1
//       en-US cultural comparison -- Position of 'æ' in aerial: 0

open System.Globalization

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

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

Imports System.Globalization

Module 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 akan melakukan pencarian yang peka terhadap budaya jika opsi pencarian tidak secara eksplisit ditentukan oleh parameter dari 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 metode String.Equals 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.

Warning

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 overload metode String.Equals. Overload yang diutamakan untuk dipanggil adalah metode instance Equals(String, StringComparison) atau metode statik Equals(String, String, StringComparison), karena kedua metode menyertakan System.StringComparison parameter yang secara jelas menentukan jenis perbandingan.

Contoh berikut menggambarkan bahaya melakukan perbandingan sensitif budaya untuk kesetaraan, yang seharusnya menggunakan perbandingan ordinal. Dalam hal ini, tujuan kode adalah untuk melarang akses sistem file dari URL yang dimulai dengan "FILE://" atau "file://" dengan melakukan perbandingan tanpa memperhatikan huruf besar/kecil dari bagian 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 ke sistem file diizinkan tanpa sengaja. Di sisi lain, jika perbandingan ordinal dilakukan, perbandingan kesetaraan berhasil, dan akses ke sistem file ditolak.

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

public class Example
{
   public static void Main()
   {
      Thread.CurrentThread.CurrentCulture = CultureInfo.CreateSpecificCulture("tr-TR");      

      string filePath = "file://c:/notes.txt";
      
      Console.WriteLine("Culture-sensitive test for equality:");
      if (!TestForEquality(filePath, StringComparison.CurrentCultureIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
      
      Console.WriteLine("\nOrdinal test for equality:");
      if (!TestForEquality(filePath, StringComparison.OrdinalIgnoreCase))
         Console.WriteLine("Access to {0} is allowed.", filePath);
      else
         Console.WriteLine("Access to {0} is not allowed.", filePath);
   }

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

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

open System
open System.Globalization
open System.Threading

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

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

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

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

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

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

Imports System.Globalization
Imports System.Threading

Module 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

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 overload dari metode Compare, Equals, StartsWith, EndsWith, IndexOf, dan LastIndexOf yang mencakup parameter StringComparison. 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 nilai Char atau elemen dalam array Char di dalam instance 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 Example
{
   private static StreamWriter sw;
   
   public static void Main()
   {
      sw = new StreamWriter(@".\TestNorm1.txt");

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

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

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

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

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

open System
open System.IO
open System.Text

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

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

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

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

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

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

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

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

Module 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) = sống (0073 006F 0302 0301 006E 0067): False
'       sống (0073 00F4 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): False
'       
'       Normalization FormC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       
'       
'       Normalization FormKC:
'       
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       sống (0073 1ED1 006E 0067) = sống (0073 1ED1 006E 0067): True
'       
'       
'       Normalization FormKD:
'       
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True
'       sống (0073 006F 0302 0301 006E 0067) = sống (0073 006F 0302 0301 006E 0067): True

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 CompareTo(String) menyediakan IComparable dan IComparable<T> implementasi untuk kelas String.

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 Contains, EndsWith, dan metode StartsWith.

• Metode yang menunjukkan posisi awal substring dalam instans string. Ini termasuk IndexOf metode, IndexOfAny, LastIndexOf, dan LastIndexOfAny.

Warning

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.

Important

Semua metode modifikasi string mengembalikan objek baru String . Mereka tidak memodifikasi nilai instance yang sekarang.

Ekstrak substring dari sebuah string

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

Menggabungkan string

Metode berikut String dapat digunakan untuk penggabungan 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 String.Format menggunakan fitur pemformatan komposit untuk mengganti placeholder dalam string dengan representasi string dari objek atau nilai tertentu. 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 meratakan ke kanan atau meratakan ke kiri sebuah substring di dalam sebuah 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 .
• CopyTo menyalin sebagian string ke array karakter.

Menormalkan teks

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.

Konstruktor

Nama	Deskripsi
String(Char, Int32)	Menginisialisasi instans String baru kelas ke nilai yang ditunjukkan oleh karakter Unicode tertentu yang mengulangi beberapa kali.
String(Char[], Int32, Int32)	Menginisialisasi instans String baru kelas ke nilai yang ditunjukkan oleh array karakter Unicode, posisi karakter awal dalam array tersebut, dan panjangnya.
String(Char[])	Menginisialisasi instans String baru kelas ke karakter Unicode yang ditunjukkan dalam array karakter yang ditentukan.
String(Char*, Int32, Int32)	Menginisialisasi instans String baru kelas ke nilai yang ditunjukkan oleh penunjuk tertentu ke array karakter Unicode, posisi karakter awal dalam array tersebut, dan panjangnya.
String(Char*)	Menginisialisasi instans String baru kelas ke nilai yang ditunjukkan oleh penunjuk tertentu ke array karakter Unicode.
String(ReadOnlySpan<Char>)	Menginisialisasi instans String baru kelas ke karakter Unicode yang ditunjukkan dalam rentang baca-saja yang ditentukan.
String(SByte*, Int32, Int32, Encoding)	Menginisialisasi instans String baru kelas ke nilai yang ditunjukkan oleh penunjuk tertentu ke array bilangan bulat bertanda tangan 8-bit, posisi awal dalam array tersebut, panjang, dan Encoding objek.
String(SByte*, Int32, Int32)	Menginisialisasi instans String baru kelas ke nilai yang ditunjukkan oleh penunjuk tertentu ke array bilangan bulat bertanda tangan 8-bit, posisi awal dalam array tersebut, dan panjangnya.
String(SByte*)	Menginisialisasi instans String baru kelas ke nilai yang ditunjukkan oleh penunjuk ke array bilangan bulat bertanda tangan 8-bit.

Bidang

Nama	Deskripsi
Empty	Mewakili string kosong. Bidang ini hanya dapat dibaca.

Properti

Nama	Deskripsi
Chars[Int32]	Mendapatkan objek pada Char posisi yang ditentukan dalam objek saat ini String .
Length	Mendapatkan jumlah karakter dalam objek saat ini String .

Metode

Nama	Deskripsi
Clone()	Mengembalikan referensi ke instans ini dari String.
Compare(String, Int32, String, Int32, Int32, Boolean, CultureInfo)	Membandingkan substring dari dua objek tertentu, mengabaikan atau menghormati kasusnya dan menggunakan informasi khusus budaya untuk memengaruhi perbandingan String , dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, Int32, String, Int32, Int32, Boolean)	Membandingkan substring dari dua objek tertentu String , mengabaikan atau menghormati kasusnya, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, Int32, String, Int32, Int32, CultureInfo, CompareOptions)	Membandingkan substring dari dua objek tertentu menggunakan opsi perbandingan yang ditentukan dan informasi khusus budaya untuk memengaruhi perbandingan String , dan mengembalikan bilangan bulat yang menunjukkan hubungan dua substring satu sama lain dalam urutan pengurutan.
Compare(String, Int32, String, Int32, Int32, StringComparison)	Membandingkan substring dari dua objek tertentu String menggunakan aturan yang ditentukan, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, Int32, String, Int32, Int32)	Membandingkan substring dari dua objek tertentu String dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, String, Boolean, CultureInfo)	Membandingkan dua objek tertentu, mengabaikan atau menghormati kasusnya, dan menggunakan informasi khusus budaya untuk memengaruhi perbandingan String , dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, String, Boolean)	Membandingkan String dua objek tertentu, mengabaikan atau menghormati kasusnya, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, String, CultureInfo, CompareOptions)	Membandingkan dua objek tertentu menggunakan opsi perbandingan yang ditentukan dan informasi khusus budaya untuk memengaruhi perbandingan String , dan mengembalikan bilangan bulat yang menunjukkan hubungan kedua string satu sama lain dalam urutan pengurutan.
Compare(String, String, StringComparison)	Membandingkan String dua objek tertentu menggunakan aturan yang ditentukan, dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
Compare(String, String)	Membandingkan dua objek yang ditentukan String dan mengembalikan bilangan bulat yang menunjukkan posisi relatifnya dalam urutan pengurutan.
CompareOrdinal(String, Int32, String, Int32, Int32)	Membandingkan substring dari dua objek tertentu String dengan mengevaluasi nilai numerik objek yang Char sesuai di setiap substring.
CompareOrdinal(String, String)	Membandingkan dua objek yang ditentukan String dengan mengevaluasi nilai numerik objek yang Char sesuai di setiap string.
CompareTo(Object)	Membandingkan instans ini dengan yang ditentukan Object dan menunjukkan apakah instans ini mendahului, mengikuti, atau muncul dalam posisi yang sama dalam urutan pengurutan seperti yang ditentukan Object.
CompareTo(String)	Membandingkan instans ini dengan objek tertentu String dan menunjukkan apakah instans ini mendahului, mengikuti, atau muncul dalam posisi yang sama dalam urutan pengurutan sebagai string yang ditentukan.
Concat(IEnumerable<String>)	Menggabungkan anggota koleksi jenis IEnumerable<T>yang dibangun String .
Concat(Object, Object, Object)	Menggabungkan representasi string dari tiga objek yang ditentukan.
Concat(Object, Object)	Menggabungkan representasi string dari dua objek tertentu.
Concat(Object)	Membuat representasi string dari objek tertentu.
Concat(Object[])	Menggabungkan representasi string elemen dalam array tertentu Object .
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Menggabungkan representasi string dari empat rentang karakter baca-saja yang ditentukan.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Menggabungkan representasi string dari tiga rentang karakter baca-saja yang ditentukan.
Concat(ReadOnlySpan<Char>, ReadOnlySpan<Char>)	Menggabungkan representasi string dari dua rentang karakter baca-saja yang ditentukan.
Concat(ReadOnlySpan<Object>)	Menggabungkan representasi string elemen dalam rentang objek tertentu.
Concat(ReadOnlySpan<String>)	Menggabungkan elemen rentang tertentu dari String.
Concat(String, String, String, String)	Menggabungkan empat instans tertentu dari String.
Concat(String, String, String)	Menggabungkan tiga instans tertentu dari String.
Concat(String, String)	Menggabungkan dua instans tertentu dari String.
Concat(String[])	Menggabungkan elemen array tertentu String .
Concat<T>(IEnumerable<T>)	Menggabungkan anggota implementasi IEnumerable<T> .
Contains(Char, StringComparison)	Mengembalikan nilai yang menunjukkan apakah karakter tertentu terjadi dalam string ini, menggunakan aturan perbandingan yang ditentukan.
Contains(Char)	Mengembalikan nilai yang menunjukkan apakah karakter tertentu terjadi dalam string ini.
Contains(String, StringComparison)	Mengembalikan nilai yang menunjukkan apakah string tertentu terjadi dalam string ini, menggunakan aturan perbandingan yang ditentukan.
Contains(String)	Mengembalikan nilai yang menunjukkan apakah substring tertentu terjadi dalam string ini.
Copy(String)	Kedaluwarsa. Membuat instans String baru dengan nilai yang sama dengan yang ditentukan String.
CopyTo(Int32, Char[], Int32, Int32)	Menyalin jumlah karakter tertentu dari posisi tertentu dalam instans ini ke posisi tertentu dalam array karakter Unicode.
CopyTo(Span<Char>)	Menyalin isi string ini ke dalam rentang tujuan.
Create(IFormatProvider, DefaultInterpolatedStringHandler)	Membuat string baru dengan menggunakan penyedia yang ditentukan untuk mengontrol pemformatan string terinterpolasi yang ditentukan.
Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)	Membuat string baru dengan menggunakan penyedia yang ditentukan untuk mengontrol pemformatan string terinterpolasi yang ditentukan.
Create<TState>(Int32, TState, SpanAction<Char,TState>)	Membuat string baru dengan panjang tertentu dan menginisialisasinya setelah dibuat dengan menggunakan panggilan balik yang ditentukan.
EndsWith(Char)	Menentukan apakah akhir instans string ini cocok dengan karakter yang ditentukan.
EndsWith(String, Boolean, CultureInfo)	Menentukan apakah akhir instans string ini cocok dengan string yang ditentukan jika dibandingkan menggunakan budaya yang ditentukan.
EndsWith(String, StringComparison)	Menentukan apakah akhir instans string ini cocok dengan string yang ditentukan jika dibandingkan menggunakan opsi perbandingan yang ditentukan.
EndsWith(String)	Menentukan apakah akhir instans string ini cocok dengan string yang ditentukan.
EnumerateRunes()	Mengembalikan enumerasi dari Rune string ini.
Equals(Object)	Menentukan apakah instans ini dan objek tertentu, yang juga harus menjadi String objek, memiliki nilai yang sama.
Equals(String, String, StringComparison)	Menentukan apakah dua objek yang ditentukan String memiliki nilai yang sama. Parameter menentukan budaya, kasus, dan aturan pengurutan yang digunakan dalam perbandingan.
Equals(String, String)	Menentukan apakah dua objek yang ditentukan String memiliki nilai yang sama.
Equals(String, StringComparison)	Menentukan apakah string ini dan objek tertentu String memiliki nilai yang sama. Parameter menentukan budaya, kasus, dan aturan pengurutan yang digunakan dalam perbandingan.
Equals(String)	Menentukan apakah instans ini dan objek lain yang ditentukan String memiliki nilai yang sama.
Format(IFormatProvider, CompositeFormat, Object[])	Mengganti item format atau item dalam CompositeFormat dengan representasi string objek terkait dalam format yang ditentukan.
Format(IFormatProvider, CompositeFormat, ReadOnlySpan<Object>)	Mengganti item format atau item dalam CompositeFormat dengan representasi string objek terkait dalam format yang ditentukan.
Format(IFormatProvider, String, Object, Object, Object)	Mengganti item format dalam string dengan representasi string dari tiga objek yang ditentukan. Parameter memasok informasi pemformatan khusus budaya.
Format(IFormatProvider, String, Object, Object)	Mengganti item format dalam string dengan representasi string dari dua objek yang ditentukan. Parameter memasok informasi pemformatan khusus budaya.
Format(IFormatProvider, String, Object)	Mengganti item format atau item dalam string tertentu dengan representasi string objek yang sesuai. Parameter memasok informasi pemformatan khusus budaya.
Format(IFormatProvider, String, Object[])	Mengganti item format dalam string dengan representasi string objek terkait dalam array tertentu. Parameter memasok informasi pemformatan khusus budaya.
Format(IFormatProvider, String, ReadOnlySpan<Object>)	Mengganti item format dalam string dengan representasi string objek terkait dalam rentang tertentu. Parameter memasok informasi pemformatan khusus budaya.
Format(String, Object, Object, Object)	Mengganti item format dalam string dengan representasi string dari tiga objek yang ditentukan.
Format(String, Object, Object)	Mengganti item format dalam string dengan representasi string dari dua objek yang ditentukan.
Format(String, Object)	Mengganti satu atau beberapa item format dalam string dengan representasi string dari objek tertentu.
Format(String, Object[])	Mengganti item format dalam string tertentu dengan representasi string objek terkait dalam array tertentu.
Format(String, ReadOnlySpan<Object>)	Mengganti item format dalam string tertentu dengan representasi string objek terkait dalam rentang yang ditentukan.
Format<TArg0,TArg1,TArg2>(IFormatProvider, CompositeFormat, TArg0, TArg1, TArg2)	Mengganti item format atau item dalam CompositeFormat dengan representasi string objek terkait dalam format yang ditentukan.
Format<TArg0,TArg1>(IFormatProvider, CompositeFormat, TArg0, TArg1)	Mengganti item format atau item dalam CompositeFormat dengan representasi string objek terkait dalam format yang ditentukan.
Format<TArg0>(IFormatProvider, CompositeFormat, TArg0)	Mengganti item format atau item dalam CompositeFormat dengan representasi string objek terkait dalam format yang ditentukan.
GetEnumerator()	Mengambil objek yang dapat melakukan iterasi melalui karakter individual dalam string ini.
GetHashCode()	Mengembalikan kode hash untuk string ini.
GetHashCode(ReadOnlySpan<Char>, StringComparison)	Mengembalikan kode hash untuk rentang karakter baca-saja yang disediakan menggunakan aturan yang ditentukan.
GetHashCode(ReadOnlySpan<Char>)	Mengembalikan kode hash untuk rentang karakter baca-saja yang disediakan.
GetHashCode(StringComparison)	Mengembalikan kode hash untuk string ini menggunakan aturan yang ditentukan.
GetPinnableReference()	Mengembalikan referensi ke elemen string pada nol indeks. Metode ini dimaksudkan untuk mendukung pengkompilasi .NET dan tidak dimaksudkan untuk dipanggil oleh kode pengguna.
GetType()	Mendapatkan Type instans saat ini. (Diperoleh dari Object)
GetTypeCode()	Mengembalikan TypeCode untuk String kelas .
IndexOf(Char, Int32, Int32)	Melaporkan indeks berbasis nol dari kemunculan pertama karakter yang ditentukan dalam instans ini. Pencarian dimulai pada posisi karakter tertentu dan memeriksa jumlah posisi karakter tertentu.
IndexOf(Char, Int32)	Melaporkan indeks berbasis nol dari kemunculan pertama karakter Unicode yang ditentukan dalam string ini. Pencarian dimulai pada posisi karakter tertentu.
IndexOf(Char, StringComparison)	Melaporkan indeks berbasis nol dari kemunculan pertama karakter Unicode yang ditentukan dalam string ini. Parameter menentukan jenis pencarian yang akan digunakan untuk karakter yang ditentukan.
IndexOf(Char)	Melaporkan indeks berbasis nol dari kemunculan pertama karakter Unicode yang ditentukan dalam string ini.
IndexOf(String, Int32, Int32, StringComparison)	Melaporkan indeks berbasis nol dari kemunculan pertama string yang ditentukan dalam objek saat ini String . Parameter menentukan posisi pencarian awal dalam string saat ini, jumlah karakter dalam string saat ini untuk dicari, dan jenis pencarian yang akan digunakan untuk string yang ditentukan.
IndexOf(String, Int32, Int32)	Melaporkan indeks berbasis nol dari kemunculan pertama string yang ditentukan dalam instans ini. Pencarian dimulai pada posisi karakter tertentu dan memeriksa jumlah posisi karakter tertentu.
IndexOf(String, Int32, StringComparison)	Melaporkan indeks berbasis nol dari kemunculan pertama string yang ditentukan dalam objek saat ini String . Parameter menentukan posisi pencarian awal dalam string saat ini dan jenis pencarian yang akan digunakan untuk string yang ditentukan.
IndexOf(String, Int32)	Melaporkan indeks berbasis nol dari kemunculan pertama string yang ditentukan dalam instans ini. Pencarian dimulai pada posisi karakter tertentu.
IndexOf(String, StringComparison)	Melaporkan indeks berbasis nol dari kemunculan pertama string yang ditentukan dalam objek saat ini String . Parameter menentukan jenis pencarian yang akan digunakan untuk string yang ditentukan.
IndexOf(String)	Melaporkan indeks berbasis nol dari kemunculan pertama string yang ditentukan dalam instans ini.
IndexOfAny(Char[], Int32, Int32)	Melaporkan indeks berbasis nol dari kemunculan pertama dalam contoh karakter apa pun ini dalam array karakter Unicode tertentu. Pencarian dimulai pada posisi karakter tertentu dan memeriksa jumlah posisi karakter tertentu.
IndexOfAny(Char[], Int32)	Melaporkan indeks berbasis nol dari kemunculan pertama dalam contoh karakter apa pun ini dalam array karakter Unicode tertentu. Pencarian dimulai pada posisi karakter tertentu.
IndexOfAny(Char[])	Melaporkan indeks berbasis nol dari kemunculan pertama dalam contoh karakter apa pun ini dalam array karakter Unicode tertentu.
Insert(Int32, String)	Mengembalikan string baru di mana string tertentu disisipkan pada posisi indeks tertentu dalam instans ini.
Intern(String)	Mengambil referensi sistem ke yang ditentukan String.
IsInterned(String)	Mengambil referensi ke String.
IsNormalized()	Menunjukkan apakah string ini berada dalam formulir normalisasi Unicode C.
IsNormalized(NormalizationForm)	Menunjukkan apakah string ini berada dalam formulir normalisasi Unicode yang ditentukan.
IsNullOrEmpty(String)	Menunjukkan apakah string yang ditentukan adalah null atau string kosong ("").
IsNullOrWhiteSpace(String)	Menunjukkan apakah string yang ditentukan adalah null, kosong, atau hanya terdiri dari karakter spasi putih.
Join(Char, Object[])	Menggabungkan representasi string dari array objek, menggunakan pemisah yang ditentukan antara setiap anggota.
Join(Char, ReadOnlySpan<Object>)	Menggabungkan representasi string dari rentang objek, menggunakan pemisah yang ditentukan antara setiap anggota.
Join(Char, ReadOnlySpan<String>)	Menggabungkan rentang string, menggunakan pemisah yang ditentukan antara setiap anggota.
Join(Char, String[], Int32, Int32)	Menggabungkan array string, menggunakan pemisah yang ditentukan antara setiap anggota, dimulai dengan elemen di value yang terletak di startIndex posisi, dan menggabungkan hingga count elemen.
Join(Char, String[])	Menggabungkan array string, menggunakan pemisah yang ditentukan antara setiap anggota.
Join(String, IEnumerable<String>)	Menggabungkan anggota kumpulan jenis IEnumerable<T>yang dibangun String , menggunakan pemisah yang ditentukan antara setiap anggota.
Join(String, Object[])	Menggabungkan elemen array objek, menggunakan pemisah yang ditentukan di antara setiap elemen.
Join(String, ReadOnlySpan<Object>)	Menggabungkan representasi string dari rentang objek, menggunakan pemisah yang ditentukan antara setiap anggota.
Join(String, ReadOnlySpan<String>)	Menggabungkan rentang string, menggunakan pemisah yang ditentukan antara setiap anggota.
Join(String, String[], Int32, Int32)	Menggabungkan elemen array string yang ditentukan, menggunakan pemisah yang ditentukan di antara setiap elemen.
Join(String, String[])	Menggabungkan semua elemen array string, menggunakan pemisah yang ditentukan di antara setiap elemen.
Join<T>(Char, IEnumerable<T>)	Menggabungkan anggota koleksi, menggunakan pemisah yang ditentukan antara setiap anggota.
Join<T>(String, IEnumerable<T>)	Menggabungkan anggota koleksi, menggunakan pemisah yang ditentukan antara setiap anggota.
LastIndexOf(Char, Int32, Int32)	Melaporkan posisi indeks berbasis nol dari kemunculan terakhir karakter Unicode yang ditentukan dalam substring dalam instans ini. Pencarian dimulai pada posisi karakter yang ditentukan dan melanjutkan mundur ke awal string untuk sejumlah posisi karakter yang ditentukan.
LastIndexOf(Char, Int32)	Melaporkan posisi indeks berbasis nol dari kemunculan terakhir karakter Unicode tertentu dalam instans ini. Pencarian dimulai pada posisi karakter yang ditentukan dan melanjutkan mundur ke awal string.
LastIndexOf(Char)	Melaporkan posisi indeks berbasis nol dari kemunculan terakhir karakter Unicode tertentu dalam instans ini.
LastIndexOf(String, Int32, Int32, StringComparison)	Melaporkan posisi indeks berbasis nol dari kemunculan terakhir string yang ditentukan dalam instans ini. Pencarian dimulai pada posisi karakter yang ditentukan dan melanjutkan mundur ke awal string untuk jumlah posisi karakter yang ditentukan. Parameter menentukan jenis perbandingan yang harus dilakukan saat mencari string yang ditentukan.
LastIndexOf(String, Int32, Int32)	Melaporkan posisi indeks berbasis nol dari kemunculan terakhir string yang ditentukan dalam instans ini. Pencarian dimulai pada posisi karakter yang ditentukan dan melanjutkan mundur ke awal string untuk sejumlah posisi karakter yang ditentukan.
LastIndexOf(String, Int32, StringComparison)	Melaporkan indeks berbasis nol dari kemunculan terakhir string tertentu dalam objek saat ini String . Pencarian dimulai pada posisi karakter yang ditentukan dan melanjutkan mundur ke awal string. Parameter menentukan jenis perbandingan yang harus dilakukan saat mencari string yang ditentukan.
LastIndexOf(String, Int32)	Melaporkan posisi indeks berbasis nol dari kemunculan terakhir string yang ditentukan dalam instans ini. Pencarian dimulai pada posisi karakter yang ditentukan dan melanjutkan mundur ke awal string.
LastIndexOf(String, StringComparison)	Melaporkan indeks berbasis nol dari kemunculan terakhir string tertentu dalam objek saat ini String . Parameter menentukan jenis pencarian yang akan digunakan untuk string yang ditentukan.
LastIndexOf(String)	Melaporkan posisi indeks berbasis nol dari kemunculan terakhir string yang ditentukan dalam instans ini.
LastIndexOfAny(Char[], Int32, Int32)	Melaporkan posisi indeks berbasis nol dari kemunculan terakhir dalam contoh ini dari satu atau beberapa karakter yang ditentukan dalam array Unicode. Pencarian dimulai pada posisi karakter yang ditentukan dan melanjutkan mundur ke awal string untuk sejumlah posisi karakter yang ditentukan.
LastIndexOfAny(Char[], Int32)	Melaporkan posisi indeks berbasis nol dari kemunculan terakhir dalam contoh ini dari satu atau beberapa karakter yang ditentukan dalam array Unicode. Pencarian dimulai pada posisi karakter yang ditentukan dan melanjutkan mundur ke awal string.
LastIndexOfAny(Char[])	Melaporkan posisi indeks berbasis nol dari kemunculan terakhir dalam contoh ini dari satu atau beberapa karakter yang ditentukan dalam array Unicode.
MemberwiseClone()	Membuat salinan dangkal dari Objectsaat ini. (Diperoleh dari Object)
Normalize()	Mengembalikan string baru yang nilai tekstualnya sama dengan string ini, tetapi yang representasi binernya berada dalam formulir normalisasi Unicode C.
Normalize(NormalizationForm)	Mengembalikan string baru yang nilai tekstualnya sama dengan string ini, tetapi yang representasi binernya dalam bentuk normalisasi Unicode yang ditentukan.
PadLeft(Int32, Char)	Mengembalikan string baru yang meratakan kanan karakter dalam instans ini dengan mengayuhnya di sebelah kiri dengan karakter Unicode tertentu, untuk panjang total yang ditentukan.
PadLeft(Int32)	Mengembalikan string baru yang meratakan kanan karakter dalam instans ini dengan mengayuhnya dengan spasi di sebelah kiri, untuk panjang total yang ditentukan.
PadRight(Int32, Char)	Mengembalikan string baru yang meratakan kiri karakter dalam string ini dengan mengayuhnya di sebelah kanan dengan karakter Unicode tertentu, untuk panjang total yang ditentukan.
PadRight(Int32)	Mengembalikan string baru yang meratakan kiri karakter dalam string ini dengan mengayuhnya dengan spasi di sebelah kanan, untuk panjang total yang ditentukan.
Remove(Int32, Int32)	Mengembalikan string baru di mana jumlah karakter tertentu dalam instans saat ini yang dimulai pada posisi tertentu telah dihapus.
Remove(Int32)	Mengembalikan string baru di mana semua karakter dalam instans saat ini, dimulai pada posisi yang ditentukan dan melanjutkan melalui posisi terakhir, telah dihapus.
Replace(Char, Char)	Mengembalikan string baru di mana semua kemunculan karakter Unicode tertentu dalam instans ini diganti dengan karakter Unicode lain yang ditentukan.
Replace(String, String, Boolean, CultureInfo)	Mengembalikan string baru di mana semua kemunculan string tertentu dalam instans saat ini diganti dengan string lain yang ditentukan, menggunakan budaya dan sensitivitas kasus yang disediakan.
Replace(String, String, StringComparison)	Mengembalikan string baru di mana semua kemunculan string tertentu dalam instans saat ini diganti dengan string lain yang ditentukan, menggunakan jenis perbandingan yang disediakan.
Replace(String, String)	Mengembalikan string baru di mana semua kemunculan string tertentu dalam instans saat ini diganti dengan string lain yang ditentukan.
ReplaceLineEndings()	Mengganti semua urutan baris baru dalam string saat ini dengan NewLine.
ReplaceLineEndings(String)	Mengganti semua urutan baris baru dalam string saat ini dengan replacementText.
Split(Char, Int32, StringSplitOptions)	Memisahkan string menjadi jumlah maksimum substring berdasarkan pemisah karakter yang disediakan, secara opsional menghilangkan substring kosong dari hasilnya.
Split(Char, StringSplitOptions)	Memisahkan string menjadi substring berdasarkan karakter pembatas tertentu dan opsi opsional.
Split(Char[], Int32, StringSplitOptions)	Memisahkan string menjadi jumlah maksimum substring berdasarkan karakter pembatas yang ditentukan dan, secara opsional, opsi.
Split(Char[], Int32)	Memisahkan string menjadi jumlah maksimum substring berdasarkan karakter pembatas yang ditentukan.
Split(Char[], StringSplitOptions)	Memisahkan string menjadi substring berdasarkan karakter dan opsi pembatas yang ditentukan.
Split(Char[])	Memisahkan string menjadi substring berdasarkan karakter pembatas yang ditentukan.
Split(ReadOnlySpan<Char>)	Memisahkan string menjadi substring berdasarkan karakter pembatas yang ditentukan.
Split(String, Int32, StringSplitOptions)	Memisahkan string menjadi jumlah maksimum substring berdasarkan string pembatas tertentu dan, secara opsional, opsi.
Split(String, StringSplitOptions)	Memisahkan string menjadi substring yang didasarkan pada pemisah string yang disediakan.
Split(String[], Int32, StringSplitOptions)	Memisahkan string menjadi jumlah maksimum substring berdasarkan string pembatas tertentu dan, secara opsional, opsi.
Split(String[], StringSplitOptions)	Memisahkan string menjadi substring berdasarkan string pembatas tertentu dan, secara opsional, opsi.
StartsWith(Char)	Menentukan apakah instans string ini dimulai dengan karakter yang ditentukan.
StartsWith(String, Boolean, CultureInfo)	Menentukan apakah awal instans string ini cocok dengan string yang ditentukan jika dibandingkan menggunakan budaya yang ditentukan.
StartsWith(String, StringComparison)	Menentukan apakah awal instans string ini cocok dengan string yang ditentukan jika dibandingkan menggunakan opsi perbandingan yang ditentukan.
StartsWith(String)	Menentukan apakah awal instans string ini cocok dengan string yang ditentukan.
Substring(Int32, Int32)	Mengambil substring dari instans ini. Substring dimulai pada posisi karakter tertentu dan memiliki panjang yang ditentukan.
Substring(Int32)	Mengambil substring dari instans ini. Substring dimulai pada posisi karakter yang ditentukan dan berlanjut ke akhir string.
ToCharArray()	Menyalin karakter dalam instans ini ke array karakter Unicode.
ToCharArray(Int32, Int32)	Menyalin karakter dalam substring tertentu dalam instans ini ke array karakter Unicode.
ToLower()	Mengembalikan salinan string ini yang dikonversi menjadi huruf kecil.
ToLower(CultureInfo)	Mengembalikan salinan string ini yang dikonversi menjadi huruf kecil, menggunakan aturan casing dari budaya yang ditentukan.
ToLowerInvariant()	Mengembalikan salinan objek ini String yang dikonversi menjadi huruf kecil menggunakan aturan casing budaya invariant.
ToString()	Mengembalikan instans ini ; Stringtidak ada konversi aktual yang dilakukan.
ToString(IFormatProvider)	Mengembalikan instans ini ; Stringtidak ada konversi aktual yang dilakukan.
ToUpper()	Mengembalikan salinan string ini yang dikonversi menjadi huruf besar.
ToUpper(CultureInfo)	Mengembalikan salinan string ini yang dikonversi ke huruf besar, menggunakan aturan casing dari budaya yang ditentukan.
ToUpperInvariant()	Mengembalikan salinan objek ini String yang dikonversi ke huruf besar menggunakan aturan kapital dari budaya invarian.
Trim()	Menghapus semua karakter spasi putih di depan dan di belakang dari string saat ini.
Trim(Char)	Menghapus semua instans karakter di awal dan akhir dari string saat ini.
Trim(Char[])	Menghapus semua kemunculan awal dan akhir dari sekumpulan karakter yang ditentukan dalam array dari string saat ini.
TrimEnd()	Menghapus semua karakter spasi putih berikutnya dari string saat ini.
TrimEnd(Char)	Menghapus semua kemunculan karakter berikutnya dari string saat ini.
TrimEnd(Char[])	Menghapus semua kemunculan berikutnya dari sekumpulan karakter yang ditentukan dalam array dari string saat ini.
TrimStart()	Menghapus semua karakter spasi putih di depan dari string saat ini.
TrimStart(Char)	Menghapus semua kemunculan awal karakter tertentu dari string saat ini.
TrimStart(Char[])	Menghapus semua kemunculan awal dari sekumpulan karakter yang ditentukan dalam array dari string saat ini.
TryCopyTo(Span<Char>)	Menyalin isi string ini ke dalam rentang tujuan.

Operator

Nama	Deskripsi
Equality(String, String)	Menentukan apakah dua string yang ditentukan memiliki nilai yang sama.
Implicit(String to ReadOnlySpan<Char>)	Menentukan konversi implisit string tertentu ke rentang karakter baca-saja.
Inequality(String, String)	Menentukan apakah dua string yang ditentukan memiliki nilai yang berbeda.

Implementasi Antarmuka Eksplisit

Nama	Deskripsi
IConvertible.ToBoolean(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToDateTime(IFormatProvider).
IConvertible.ToDecimal(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Untuk deskripsi anggota ini, lihat ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Untuk deskripsi anggota ini, lihat ToUInt64(IFormatProvider).
IEnumerable.GetEnumerator()	Mengembalikan enumerator yang melakukan iterasi melalui objek saat ini String .
IEnumerable<Char>.GetEnumerator()	Mengembalikan enumerator yang melakukan iterasi melalui objek saat ini String .
IParsable<String>.Parse(String, IFormatProvider)	Mengurai string menjadi nilai.
IParsable<String>.TryParse(String, IFormatProvider, String)	Mewakili teks sebagai urutan unit kode UTF-16.
ISpanParsable<String>.Parse(ReadOnlySpan<Char>, IFormatProvider)	Mengurai rentang karakter menjadi nilai.
ISpanParsable<String>.TryParse(ReadOnlySpan<Char>, IFormatProvider, String)	Mewakili teks sebagai urutan unit kode UTF-16.

Metode Ekstensi

Nama	Deskripsi
Aggregate<TSource,TAccumulate,TResult>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, Func<TAccumulate,TResult>)	Menerapkan fungsi akumulator secara berurutan. Nilai seed yang ditentukan digunakan sebagai nilai akumulator awal, dan fungsi yang ditentukan digunakan untuk memilih nilai hasil.
Aggregate<TSource,TAccumulate>(IEnumerable<TSource>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>)	Menerapkan fungsi akumulator secara berurutan. Nilai seed yang ditentukan digunakan sebagai nilai akumulator awal.
Aggregate<TSource>(IEnumerable<TSource>, Func<TSource,TSource,TSource>)	Menerapkan fungsi akumulator secara berurutan.
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TKey,TAccumulate>, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)	Menerapkan fungsi akumulator secara berurutan, mengelompokkan hasil menurut kunci.
AggregateBy<TSource,TKey,TAccumulate>(IEnumerable<TSource>, Func<TSource, TKey>, TAccumulate, Func<TAccumulate,TSource,TAccumulate>, IEqualityComparer<TKey>)	Menerapkan fungsi akumulator secara berurutan, mengelompokkan hasil menurut kunci.
All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Menentukan apakah semua elemen urutan memenuhi suatu kondisi.
Ancestors<T>(IEnumerable<T>, XName)	Mengembalikan kumpulan elemen yang difilter yang berisi leluhur setiap simpul dalam kumpulan sumber. Hanya elemen yang memiliki XName yang cocok yang disertakan dalam koleksi.
Ancestors<T>(IEnumerable<T>)	Mengembalikan kumpulan elemen yang berisi leluhur setiap simpul dalam kumpulan sumber.
Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Menentukan apakah ada elemen urutan yang memenuhi kondisi.
Any<TSource>(IEnumerable<TSource>)	Menentukan apakah urutan berisi elemen apa pun.
Append<TSource>(IEnumerable<TSource>, TSource)	Menambahkan nilai ke akhir urutan.
AsEnumerable<TSource>(IEnumerable<TSource>)	Mengembalikan input yang diketik sebagai IEnumerable<T>.
AsMemory(String, Index)	Membuat baru ReadOnlyMemory<Char> di atas sebagian string target yang dimulai pada indeks tertentu.
AsMemory(String, Int32, Int32)	Membuat baru ReadOnlyMemory<Char> di atas sebagian string target yang dimulai pada posisi tertentu dengan panjang.
AsMemory(String, Int32)	Membuat baru ReadOnlyMemory<Char> di atas sebagian string target yang dimulai pada posisi karakter tertentu.
AsMemory(String, Range)	Membuat baru ReadOnlyMemory<Char> di atas rentang string target yang ditentukan.
AsMemory(String)	Membuat baru ReadOnlyMemory<Char> di atas bagian string target.
AsParallel(IEnumerable)	Mengaktifkan paralelisasi kueri.
AsParallel<TSource>(IEnumerable<TSource>)	Mengaktifkan paralelisasi kueri.
AsQueryable(IEnumerable)	Mengonversi IEnumerable menjadi IQueryable.
AsQueryable<TElement>(IEnumerable<TElement>)	Mengonversi IEnumerable<T> generik ke IQueryable<T>generik .
AsSpan(String, Index)	Membuat yang baru ReadOnlySpan<T> di atas sebagian string target dari posisi yang ditentukan ke akhir string.
AsSpan(String, Int32, Int32)	Membuat rentang baca-saja baru di atas sebagian string target dari posisi tertentu untuk jumlah karakter tertentu.
AsSpan(String, Int32)	Membuat rentang baca-saja baru di atas sebagian string target dari posisi yang ditentukan ke akhir string.
AsSpan(String, Range)	Membuat baru ReadOnlySpan<T> melalui sebagian string target menggunakan indeks mulai dan akhir rentang.
AsSpan(String)	Membuat rentang baca-saja baru di atas string.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Menghitung rata-rata urutan nilai Decimal yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Menghitung rata-rata urutan nilai Double yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Menghitung rata-rata urutan nilai Int32 yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Menghitung rata-rata urutan nilai Int64 yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Menghitung rata-rata urutan nilai Decimal nullable yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Menghitung rata-rata urutan nilai Double nullable yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Menghitung rata-rata urutan nilai Int32 nullable yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Menghitung rata-rata urutan nilai Int64 nullable yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Menghitung rata-rata urutan nilai Single nullable yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Menghitung rata-rata urutan nilai Single yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Cast<TResult>(IEnumerable)	Melemparkan elemen IEnumerable ke jenis yang ditentukan.
Chunk<TSource>(IEnumerable<TSource>, Int32)	Membagi elemen urutan menjadi potongan ukuran paling banyak size.
Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Menggabungkan dua urutan.
Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)	Menentukan apakah urutan berisi elemen tertentu dengan menggunakan IEqualityComparer<T>tertentu .
Contains<TSource>(IEnumerable<TSource>, TSource)	Menentukan apakah urutan berisi elemen tertentu dengan menggunakan perbandingan kesetaraan default.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)	Menyalin objek DataRow ke DataTableyang ditentukan , mengingat objek IEnumerable<T> input di mana parameter generik TDataRow.
CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)	Menyalin objek DataRow ke DataTableyang ditentukan , mengingat objek IEnumerable<T> input di mana parameter generik TDataRow.
CopyToDataTable<T>(IEnumerable<T>)	Mengembalikan DataTable yang berisi salinan objek DataRow, mengingat objek IEnumerable<T> input di mana parameter generik TDataRow.
Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Mengembalikan angka yang menunjukkan berapa banyak elemen dalam urutan yang ditentukan memenuhi kondisi.
Count<TSource>(IEnumerable<TSource>)	Mengembalikan jumlah elemen secara berurutan.
CountBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Mengembalikan jumlah elemen dalam urutan sumber yang dikelompokkan menurut kunci.
DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)	Mengembalikan elemen urutan yang ditentukan atau nilai yang ditentukan dalam koleksi singleton jika urutannya kosong.
DefaultIfEmpty<TSource>(IEnumerable<TSource>)	Mengembalikan elemen urutan yang ditentukan atau nilai default parameter jenis dalam koleksi singleton jika urutannya kosong.
DescendantNodes<T>(IEnumerable<T>)	Mengembalikan kumpulan simpul turunan dari setiap dokumen dan elemen dalam kumpulan sumber.
Descendants<T>(IEnumerable<T>, XName)	Mengembalikan kumpulan elemen yang difilter yang berisi elemen turunan dari setiap elemen dan dokumen dalam kumpulan sumber. Hanya elemen yang memiliki XName yang cocok yang disertakan dalam koleksi.
Descendants<T>(IEnumerable<T>)	Mengembalikan kumpulan elemen yang berisi elemen turunan dari setiap elemen dan dokumen dalam kumpulan sumber.
Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Mengembalikan elemen yang berbeda dari urutan dengan menggunakan IEqualityComparer<T> tertentu untuk membandingkan nilai.
Distinct<TSource>(IEnumerable<TSource>)	Mengembalikan elemen yang berbeda dari urutan dengan menggunakan perbandingan kesetaraan default untuk membandingkan nilai.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Mengembalikan elemen yang berbeda dari urutan sesuai dengan fungsi pemilih kunci tertentu dan menggunakan perbandingan yang ditentukan untuk membandingkan kunci.
DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Mengembalikan elemen yang berbeda dari urutan sesuai dengan fungsi pemilih kunci tertentu.
ElementAt<TSource>(IEnumerable<TSource>, Index)	Mengembalikan elemen pada indeks tertentu secara berurutan.
ElementAt<TSource>(IEnumerable<TSource>, Int32)	Mengembalikan elemen pada indeks tertentu secara berurutan.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)	Mengembalikan elemen pada indeks tertentu secara berurutan atau nilai default jika indeks berada di luar rentang.
ElementAtOrDefault<TSource>(IEnumerable<TSource>, Int32)	Mengembalikan elemen pada indeks tertentu secara berurutan atau nilai default jika indeks berada di luar rentang.
Elements<T>(IEnumerable<T>, XName)	Mengembalikan kumpulan elemen turunan yang difilter dari setiap elemen dan dokumen dalam kumpulan sumber. Hanya elemen yang memiliki XName yang cocok yang disertakan dalam koleksi.
Elements<T>(IEnumerable<T>)	Mengembalikan kumpulan elemen turunan dari setiap elemen dan dokumen dalam kumpulan sumber.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Menghasilkan perbedaan yang ditetapkan dari dua urutan dengan menggunakan IEqualityComparer<T> yang ditentukan untuk membandingkan nilai.
Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Menghasilkan perbedaan yang ditetapkan dari dua urutan dengan menggunakan perbandingan kesetaraan default untuk membandingkan nilai.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Menghasilkan perbedaan yang ditetapkan dari dua urutan sesuai dengan fungsi pemilih kunci tertentu.
ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Menghasilkan perbedaan yang ditetapkan dari dua urutan sesuai dengan fungsi pemilih kunci tertentu.
First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Mengembalikan elemen pertama dalam urutan yang memenuhi kondisi tertentu.
First<TSource>(IEnumerable<TSource>)	Mengembalikan elemen pertama dari urutan.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Mengembalikan elemen pertama dari urutan yang memenuhi kondisi, atau nilai default yang ditentukan jika tidak ada elemen tersebut yang ditemukan.
FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Mengembalikan elemen pertama dari urutan yang memenuhi kondisi atau nilai default jika tidak ada elemen tersebut yang ditemukan.
FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)	Mengembalikan elemen pertama dari urutan, atau nilai default yang ditentukan jika urutan tidak berisi elemen.
FirstOrDefault<TSource>(IEnumerable<TSource>)	Mengembalikan elemen pertama dari urutan, atau nilai default jika urutan tidak berisi elemen.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)	Mengelompokkan elemen urutan sesuai dengan fungsi pemilih kunci tertentu dan membuat nilai hasil dari setiap grup dan kuncinya. Nilai kunci dibandingkan dengan menggunakan pembanding tertentu, dan elemen setiap grup diproyeksikan dengan menggunakan fungsi tertentu.
GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)	Mengelompokkan elemen urutan sesuai dengan fungsi pemilih kunci tertentu dan membuat nilai hasil dari setiap grup dan kuncinya. Elemen setiap grup diproyeksikan dengan menggunakan fungsi tertentu.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Mengelompokkan elemen urutan sesuai dengan fungsi pemilih kunci. Kunci dibandingkan dengan menggunakan pembanding dan elemen setiap grup diproyeksikan dengan menggunakan fungsi tertentu.
GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Mengelompokkan elemen urutan sesuai dengan fungsi pemilih kunci tertentu dan memproyeksikan elemen untuk setiap grup dengan menggunakan fungsi tertentu.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)	Mengelompokkan elemen urutan sesuai dengan fungsi pemilih kunci tertentu dan membuat nilai hasil dari setiap grup dan kuncinya. Kunci dibandingkan dengan menggunakan pembanding tertentu.
GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)	Mengelompokkan elemen urutan sesuai dengan fungsi pemilih kunci tertentu dan membuat nilai hasil dari setiap grup dan kuncinya.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Mengelompokkan elemen urutan sesuai dengan fungsi pemilih kunci tertentu dan membandingkan kunci dengan menggunakan perbandingan yang ditentukan.
GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Mengelompokkan elemen urutan sesuai dengan fungsi pemilih kunci tertentu.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)	Menghubungkan elemen dari dua urutan berdasarkan kesetaraan kunci dan mengelompokkan hasilnya. IEqualityComparer<T> tertentu digunakan untuk membandingkan kunci.
GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)	Menghubungkan elemen dari dua urutan berdasarkan kesetaraan kunci dan mengelompokkan hasilnya. Perbandingan kesetaraan default digunakan untuk membandingkan kunci.
Index<TSource>(IEnumerable<TSource>)	Mengembalikan enumerable yang menggabungkan indeks elemen ke dalam tuple.
InDocumentOrder<T>(IEnumerable<T>)	Mengembalikan kumpulan simpul yang berisi semua simpul dalam kumpulan sumber, diurutkan dalam urutan dokumen.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Menghasilkan persimpangan yang ditetapkan dari dua urutan dengan menggunakan IEqualityComparer<T> yang ditentukan untuk membandingkan nilai.
Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Menghasilkan persimpangan yang ditetapkan dari dua urutan dengan menggunakan perbandingan kesetaraan default untuk membandingkan nilai.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Menghasilkan persimpangan yang ditetapkan dari dua urutan sesuai dengan fungsi pemilih kunci tertentu.
IntersectBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)	Menghasilkan persimpangan yang ditetapkan dari dua urutan sesuai dengan fungsi pemilih kunci tertentu.
IsNormalized(String, NormalizationForm)	Menunjukkan apakah string berada dalam formulir normalisasi Unicode tertentu.
IsNormalized(String)	Menunjukkan apakah string yang ditentukan berada dalam formulir normalisasi Unicode C.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Mengkorelasikan elemen dari dua urutan berdasarkan kunci yang cocok. IEqualityComparer<T> tertentu digunakan untuk membandingkan kunci.
Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Mengkorelasikan elemen dari dua urutan berdasarkan kunci yang cocok. Perbandingan kesetaraan default digunakan untuk membandingkan kunci.
Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Mengembalikan elemen terakhir dari urutan yang memenuhi kondisi yang ditentukan.
Last<TSource>(IEnumerable<TSource>)	Mengembalikan elemen terakhir dari urutan.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Mengembalikan elemen terakhir dari urutan yang memenuhi kondisi, atau nilai default yang ditentukan jika tidak ada elemen tersebut yang ditemukan.
LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Mengembalikan elemen terakhir dari urutan yang memenuhi kondisi atau nilai default jika tidak ada elemen tersebut yang ditemukan.
LastOrDefault<TSource>(IEnumerable<TSource>, TSource)	Mengembalikan elemen terakhir dari urutan, atau nilai default yang ditentukan jika urutan tidak berisi elemen.
LastOrDefault<TSource>(IEnumerable<TSource>)	Mengembalikan elemen terakhir dari urutan, atau nilai default jika urutan tidak berisi elemen.
LeftJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Mengkorelasikan elemen dari dua urutan berdasarkan kunci yang cocok. IEqualityComparer<T> tertentu digunakan untuk membandingkan kunci.
LeftJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Mengkorelasikan elemen dari dua urutan berdasarkan kunci yang cocok. Perbandingan kesetaraan default digunakan untuk membandingkan kunci.
LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Mengembalikan Int64 yang mewakili berapa banyak elemen dalam urutan yang memenuhi kondisi.
LongCount<TSource>(IEnumerable<TSource>)	Mengembalikan Int64 yang menunjukkan jumlah total elemen secara berurutan.
Max<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Memanggil fungsi transformasi pada setiap elemen urutan generik dan mengembalikan nilai hasil maksimum.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Decimal maksimum.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Double maksimum.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Int32 maksimum.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Int64 maksimum.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Decimal maksimum yang dapat diubah ke null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Double maksimum yang dapat diubah ke null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Int32 maksimum yang dapat diubah ke null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Int64 maksimum yang dapat diubah ke null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Single maksimum yang dapat diubah ke null.
Max<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Single maksimum.
Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Mengembalikan nilai maksimum dalam urutan generik.
Max<TSource>(IEnumerable<TSource>)	Mengembalikan nilai maksimum dalam urutan generik.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Mengembalikan nilai maksimum dalam urutan generik sesuai dengan fungsi pemilih kunci dan pembanding kunci tertentu.
MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Mengembalikan nilai maksimum dalam urutan generik sesuai dengan fungsi pemilih kunci tertentu.
Min<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Memanggil fungsi transformasi pada setiap elemen urutan generik dan mengembalikan nilai minimum yang dihasilkan.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Decimal minimum.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Double minimum.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Int32 minimum.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Int64 minimum.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Decimal minimum yang dapat diubah ke null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Double minimum yang dapat diubah ke null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Int32 minimum yang dapat diubah ke null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Int64 minimum yang dapat diubah ke null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Single minimum yang dapat diubah ke null.
Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Memanggil fungsi transformasi pada setiap elemen urutan dan mengembalikan nilai Single minimum.
Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Mengembalikan nilai minimum dalam urutan generik.
Min<TSource>(IEnumerable<TSource>)	Mengembalikan nilai minimum dalam urutan generik.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Mengembalikan nilai minimum dalam urutan generik sesuai dengan fungsi pemilih kunci dan pembanding kunci tertentu.
MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Mengembalikan nilai minimum dalam urutan generik sesuai dengan fungsi pemilih kunci tertentu.
Nodes<T>(IEnumerable<T>)	Mengembalikan kumpulan simpul anak dari setiap dokumen dan elemen dalam kumpulan sumber.
Normalize(String, NormalizationForm)	Menormalkan string ke formulir normalisasi Unicode yang ditentukan.
Normalize(String)	Menormalkan string ke formulir normalisasi Unicode C.
OfType<TResult>(IEnumerable)	Memfilter elemen IEnumerable berdasarkan jenis tertentu.
Order<T>(IEnumerable<T>, IComparer<T>)	Mengurutkan elemen urutan dalam urutan naik.
Order<T>(IEnumerable<T>)	Mengurutkan elemen urutan dalam urutan naik.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Mengurutkan elemen urutan dalam urutan naik dengan menggunakan pembanding yang ditentukan.
OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Mengurutkan elemen urutan dalam urutan naik sesuai dengan kunci.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)	Mengurutkan elemen urutan dalam urutan menurun dengan menggunakan pembanding yang ditentukan.
OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Mengurutkan elemen urutan dalam urutan turun sesuai dengan kunci.
OrderDescending<T>(IEnumerable<T>, IComparer<T>)	Mengurutkan elemen urutan dalam urutan turun.
OrderDescending<T>(IEnumerable<T>)	Mengurutkan elemen urutan dalam urutan turun.
Prepend<TSource>(IEnumerable<TSource>, TSource)	Menambahkan nilai ke awal urutan.
Remove<T>(IEnumerable<T>)	Menghapus setiap simpul dalam kumpulan sumber dari simpul induknya.
Reverse<TSource>(IEnumerable<TSource>)	Menginversi urutan elemen secara berurutan.
RightJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)	Mengkorelasikan elemen dari dua urutan berdasarkan kunci yang cocok. IEqualityComparer<T> tertentu digunakan untuk membandingkan kunci.
RightJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)	Mengkorelasikan elemen dari dua urutan berdasarkan kunci yang cocok. Perbandingan kesetaraan default digunakan untuk membandingkan kunci.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,TResult>)	Memproyeksikan setiap elemen urutan ke dalam bentuk baru dengan menggabungkan indeks elemen.
Select<TSource,TResult>(IEnumerable<TSource>, Func<TSource,TResult>)	Memproyeksikan setiap elemen urutan ke dalam bentuk baru.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Memproyeksikan setiap elemen urutan ke IEnumerable<T>, meratakan urutan yang dihasilkan menjadi satu urutan, dan memanggil fungsi pemilih hasil pada setiap elemen di dalamnya.
SelectMany<TSource,TCollection,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TCollection>>, Func<TSource,TCollection,TResult>)	Memproyeksikan setiap elemen urutan ke IEnumerable<T>, meratakan urutan yang dihasilkan menjadi satu urutan, dan memanggil fungsi pemilih hasil pada setiap elemen di dalamnya. Indeks setiap elemen sumber digunakan dalam bentuk proyeksi menengah dari elemen tersebut.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,IEnumerable<TResult>>)	Memproyeksikan setiap elemen urutan ke IEnumerable<T> dan meratakan urutan yang dihasilkan menjadi satu urutan.
SelectMany<TSource,TResult>(IEnumerable<TSource>, Func<TSource,Int32,IEnumerable<TResult>>)	Memproyeksikan setiap elemen urutan ke IEnumerable<T>, dan meratakan urutan yang dihasilkan menjadi satu urutan. Indeks setiap elemen sumber digunakan dalam bentuk elemen yang diproyeksikan.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Menentukan apakah dua urutan sama dengan membandingkan elemennya dengan menggunakan IEqualityComparer<T>tertentu.
SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Menentukan apakah dua urutan sama dengan membandingkan elemen dengan menggunakan perbandingan kesetaraan default untuk jenisnya.
Shuffle<TSource>(IEnumerable<TSource>)	Mengacak urutan elemen urutan.
Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Mengembalikan satu-satunya elemen dari urutan yang memenuhi kondisi tertentu, dan melemparkan pengecualian jika ada lebih dari satu elemen tersebut.
Single<TSource>(IEnumerable<TSource>)	Mengembalikan satu-satunya elemen urutan, dan melemparkan pengecualian jika tidak ada tepat satu elemen dalam urutan.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)	Mengembalikan satu-satunya elemen urutan yang memenuhi kondisi tertentu, atau nilai default yang ditentukan jika tidak ada elemen tersebut; metode ini memberikan pengecualian jika lebih dari satu elemen memenuhi kondisi.
SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Mengembalikan satu-satunya elemen urutan yang memenuhi kondisi tertentu atau nilai default jika tidak ada elemen tersebut; metode ini memberikan pengecualian jika lebih dari satu elemen memenuhi kondisi.
SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)	Mengembalikan satu-satunya elemen urutan, atau nilai default yang ditentukan jika urutannya kosong; metode ini melemparkan pengecualian jika ada lebih dari satu elemen dalam urutan.
SingleOrDefault<TSource>(IEnumerable<TSource>)	Mengembalikan satu-satunya elemen urutan, atau nilai default jika urutannya kosong; metode ini melemparkan pengecualian jika ada lebih dari satu elemen dalam urutan.
Skip<TSource>(IEnumerable<TSource>, Int32)	Melewati jumlah elemen tertentu secara berurutan lalu mengembalikan elemen yang tersisa.
SkipLast<TSource>(IEnumerable<TSource>, Int32)	Mengembalikan koleksi enumerable baru yang berisi elemen dari source dengan elemen terakhir count dari koleksi sumber yang dihilangkan.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Melewati elemen secara berurutan selama kondisi yang ditentukan benar dan kemudian mengembalikan elemen yang tersisa.
SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Melewati elemen secara berurutan selama kondisi yang ditentukan benar dan kemudian mengembalikan elemen yang tersisa. Indeks elemen digunakan dalam logika fungsi predikat.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)	Menghitung jumlah urutan nilai Decimal yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Double>)	Menghitung jumlah urutan nilai Double yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int32>)	Menghitung jumlah urutan nilai Int32 yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Int64>)	Menghitung jumlah urutan nilai Int64 yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)	Menghitung jumlah urutan nilai Decimal nullable yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Double>>)	Menghitung jumlah urutan nilai Double nullable yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)	Menghitung jumlah urutan nilai Int32 nullable yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)	Menghitung jumlah urutan nilai Int64 nullable yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)	Menghitung jumlah urutan nilai Single nullable yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)	Menghitung jumlah urutan nilai Single yang diperoleh dengan memanggil fungsi transformasi pada setiap elemen urutan input.
Take<TSource>(IEnumerable<TSource>, Int32)	Mengembalikan jumlah elemen bersebelahan yang ditentukan dari awal urutan.
Take<TSource>(IEnumerable<TSource>, Range)	Mengembalikan rentang elemen bersebelahan yang ditentukan dari urutan.
TakeLast<TSource>(IEnumerable<TSource>, Int32)	Mengembalikan koleksi baru yang dapat dijumlahkan yang berisi elemen terakhir count dari source.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Mengembalikan elemen dari urutan selama kondisi yang ditentukan adalah true.
TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Mengembalikan elemen dari urutan selama kondisi yang ditentukan adalah true. Indeks elemen digunakan dalam logika fungsi predikat.
ToArray<TSource>(IEnumerable<TSource>)	Membuat array dari IEnumerable<T>.
ToAsyncEnumerable<TSource>(IEnumerable<TSource>)	Mengonversi IEnumerable<T> menjadi IAsyncEnumerable<T>.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Membuat Dictionary<TKey,TValue> dari IEnumerable<T> sesuai dengan fungsi pemilih kunci tertentu, pembanding, dan fungsi pemilih elemen.
ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Membuat Dictionary<TKey,TValue> dari IEnumerable<T> sesuai dengan fungsi pemilih kunci dan pemilih elemen yang ditentukan.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Membuat Dictionary<TKey,TValue> dari IEnumerable<T> sesuai dengan fungsi pemilih kunci dan perbandingan kunci tertentu.
ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Membuat Dictionary<TKey,TValue> dari IEnumerable<T> sesuai dengan fungsi pemilih kunci tertentu.
ToFrozenDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Membuat FrozenDictionary<TKey,TValue> dari IEnumerable<T> sesuai dengan fungsi pemilih kunci dan pemilih elemen yang ditentukan.
ToFrozenDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	FrozenDictionary<TKey,TValue> Membuat dari sesuai dengan fungsi pemilih kunci yang IEnumerable<T> ditentukan.
ToFrozenSet<T>(IEnumerable<T>, IEqualityComparer<T>)	FrozenSet<T> Membuat dengan nilai yang ditentukan.
ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Membuat HashSet<T> dari IEnumerable<T> menggunakan comparer untuk membandingkan kunci.
ToHashSet<TSource>(IEnumerable<TSource>)	Membuat HashSet<T> dari IEnumerable<T>.
ToImmutableArray<TSource>(IEnumerable<TSource>)	Membuat array yang tidak dapat diubah dari koleksi yang ditentukan.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)	Menghitung dan mengubah urutan, dan menghasilkan kamus kontennya yang tidak dapat diubah dengan menggunakan pembanding kunci dan nilai yang ditentukan.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)	Menghitung dan mengubah urutan, dan menghasilkan kamus kontennya yang tidak dapat diubah dengan menggunakan pembanding kunci yang ditentukan.
ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Menghitung dan mengubah urutan, dan menghasilkan kamus kontennya yang tidak dapat diubah.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Membangun kamus yang tidak dapat diubah berdasarkan beberapa transformasi urutan.
ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Membangun kamus yang tidak dapat diubah dari kumpulan elemen yang ada, menerapkan fungsi transformasi ke kunci sumber.
ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)	Menghitung urutan, menghasilkan set hash yang tidak dapat diubah dari kontennya, dan menggunakan perbandingan kesetaraan yang ditentukan untuk jenis yang ditetapkan.
ToImmutableHashSet<TSource>(IEnumerable<TSource>)	Menghitung urutan dan menghasilkan kumpulan hash kontennya yang tidak dapat diubah.
ToImmutableList<TSource>(IEnumerable<TSource>)	Menghitung urutan dan menghasilkan daftar kontennya yang tidak dapat diubah.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)	Menghitung dan mengubah urutan, dan menghasilkan kamus yang diurutkan yang tidak dapat diubah dari kontennya dengan menggunakan pembanding kunci dan nilai yang ditentukan.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)	Menghitung dan mengubah urutan, dan menghasilkan kamus yang diurutkan yang tidak dapat diubah dari kontennya dengan menggunakan pembanding kunci yang ditentukan.
ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)	Menghitung dan mengubah urutan, dan menghasilkan kamus kontennya yang diurutkan tidak dapat diubah.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)	Menghitung urutan, menghasilkan kumpulan kontennya yang diurutkan yang tidak dapat diubah, dan menggunakan pembanding yang ditentukan.
ToImmutableSortedSet<TSource>(IEnumerable<TSource>)	Menghitung urutan dan menghasilkan sekumpulan kontennya yang diurutkan yang tidak dapat diubah.
ToList<TSource>(IEnumerable<TSource>)	Membuat List<T> dari IEnumerable<T>.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)	Membuat Lookup<TKey,TElement> dari IEnumerable<T> sesuai dengan fungsi pemilih kunci tertentu, comparer, dan fungsi pemilih elemen.
ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)	Membuat Lookup<TKey,TElement> dari IEnumerable<T> sesuai dengan fungsi pemilih kunci dan pemilih elemen yang ditentukan.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Membuat Lookup<TKey,TElement> dari IEnumerable<T> sesuai dengan fungsi pemilih kunci dan perbandingan kunci tertentu.
ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)	Membuat Lookup<TKey,TElement> dari IEnumerable<T> sesuai dengan fungsi pemilih kunci tertentu.
TryGetNonEnumeratedCount<TSource>(IEnumerable<TSource>, Int32)	Mencoba menentukan jumlah elemen dalam urutan tanpa memaksa enumerasi.
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)	Menghasilkan penyatuan yang ditetapkan dari dua urutan dengan menggunakan IEqualityComparer<T>tertentu .
Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)	Menghasilkan penyatuan yang ditetapkan dari dua urutan dengan menggunakan perbandingan kesetaraan default.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>, IEqualityComparer<TKey>)	Menghasilkan penyatuan yang ditetapkan dari dua urutan sesuai dengan fungsi pemilih kunci tertentu.
UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)	Menghasilkan penyatuan yang ditetapkan dari dua urutan sesuai dengan fungsi pemilih kunci tertentu.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)	Memfilter urutan nilai berdasarkan predikat.
Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)	Memfilter urutan nilai berdasarkan predikat. Indeks setiap elemen digunakan dalam logika fungsi predikat.
Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)	Menerapkan fungsi tertentu ke elemen yang sesuai dari dua urutan, menghasilkan urutan hasil.
Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)	Menghasilkan urutan tuple dengan elemen dari tiga urutan yang ditentukan.
Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)	Menghasilkan urutan tuple dengan elemen dari dua urutan yang ditentukan.

Keamanan Thread

Jenis ini aman untuk utas.

Lihat juga

• IComparable
• ICloneable
• IConvertible
• IEnumerable
• StringBuilder
• CultureInfo
• Tabel Elemen Kolaksi Unicode Default
• Tipe Pemformatan di .NET
• Praktik Terbaik untuk Menggunakan String di .NET