String Sınıf

Tanım

Metni UTF-16 kod birimleri dizisi olarak temsil eder.

public ref class System::String sealed : IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
public ref class System::String sealed : ICloneable, IComparable, IComparable<System::String ^>, IConvertible, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
public ref class System::String sealed : ICloneable, IComparable, IConvertible, System::Collections::IEnumerable
public ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::IEnumerable
public ref class System::String sealed : IComparable, IComparable<System::String ^>, IEquatable<System::String ^>, System::Collections::Generic::IEnumerable<char>
public sealed class String : IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
[System.Serializable]
public sealed class String : ICloneable, IComparable, IConvertible, System.Collections.IEnumerable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public sealed class String : ICloneable, IComparable, IComparable<string>, IConvertible, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.IEnumerable
public sealed class String : IComparable, IComparable<string>, IEquatable<string>, System.Collections.Generic.IEnumerable<char>
type string = class
    interface seq<char>
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
type string = class
    interface seq<char>
    interface IEnumerable
    interface ICloneable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
type string = class
    interface seq<char>
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IConvertible
    interface IEquatable<string>
    interface ICloneable
[<System.Serializable>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IComparable<string>
    interface seq<char>
    interface IEnumerable
    interface IEquatable<string>
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type string = class
    interface IComparable
    interface ICloneable
    interface IConvertible
    interface IEnumerable
    interface IComparable<string>
    interface seq<char>
    interface IEquatable<string>
type string = class
    interface IEnumerable
    interface IComparable
    interface IComparable<string>
    interface IEquatable<string>
type string = class
    interface IComparable
    interface IComparable<string>
    interface IEquatable<string>
    interface seq<char>
    interface IEnumerable
Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
Public NotInheritable Class String
Implements ICloneable, IComparable, IComparable(Of String), IConvertible, IEnumerable(Of Char), IEquatable(Of String)
Public NotInheritable Class String
Implements ICloneable, IComparable, IConvertible, IEnumerable
Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable, IEquatable(Of String)
Public NotInheritable Class String
Implements IComparable, IComparable(Of String), IEnumerable(Of Char), IEquatable(Of String)
Devralma
String
Öznitelikler
Uygulamalar

Açıklamalar

Dize, metni temsil etmek için kullanılan sıralı bir karakter koleksiyonudur. String Nesne, bir dizeyi System.Char temsil eden nesnelerin sıralı koleksiyonudur; System.Char nesne utf-16 kod birimine karşılık gelir. nesnesinin String değeri, sıralı nesne koleksiyonunun System.Char içeriğidir ve bu değer sabittir (yani salt okunurdur). Dizelerin değişmezliği hakkında daha fazla bilgi için Değişmezlik ve StringBuilder sınıfı bölümüne bakın. Bellekteki bir String nesnenin en büyük boyutu 2 GB veya yaklaşık 1 milyar karakterdir.

Unicode, UTF-16, kod birimleri, kod noktaları ve ve CharRune türleri hakkında daha fazla bilgi için bkz. .NET'te karakter kodlamasına giriş.

Bu bölümdeki konular:

String nesnesinin örneğini oluşturma
Karakter nesneleri ve Unicode karakterleri
Dizeler ve Unicode Standardı
Dizeler ve katıştırılmış null karakterleri
Dizeler ve dizinler
Null dizeler ve boş dizeler
Değişmezlik ve StringBuilder sınıfı
Sıra ve kültüre duyarlı işlemlerin karşılaştırılması
Normalleştirme
Kategoriye göre dize işlemleri

String nesnesinin örneğini oluşturma

Bir String nesnenin örneğini aşağıdaki yollarla oluşturabilirsiniz:

  • Bir değişkene String bir dize değişmez değeri atayarak. Bu, dize oluşturmak için en yaygın kullanılan yöntemdir. Aşağıdaki örnek, birkaç dize oluşturmak için atamayı kullanır. C# ve F# dilinde ters eğik çizgi (\) bir kaçış karakteri olduğundan, dizedeki değişmez değer ters eğik çizgilerinin kaçış karakteri olması veya dizenin tamamının @tırnak içine alınması gerektiğini unutmayın.

    using namespace System;
    
    void main()
    {
       String^ string1 = "This is a string created by assignment.";
       Console::WriteLine(string1);
       String^ string2a = "The path is C:\\PublicDocuments\\Report1.doc";
       Console::WriteLine(string2a);
    }
    // The example displays the following output: 
    //       This is a string created by assignment. 
    //       The path is C:\PublicDocuments\Report1.doc
    
    string string1 = "This is a string created by assignment.";
    Console.WriteLine(string1);
    string string2a = "The path is C:\\PublicDocuments\\Report1.doc";
    Console.WriteLine(string2a);
    string string2b = @"The path is C:\PublicDocuments\Report1.doc";
    Console.WriteLine(string2b);
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc
    
    let string1 = "This is a string created by assignment."
    printfn "%s" string1
    let string2a = "The path is C:\\PublicDocuments\\Report1.doc"
    printfn "%s" string2a
    let string2b = @"The path is C:\PublicDocuments\Report1.doc"
    printfn "%s" string2b
    // The example displays the following output:
    //       This is a string created by assignment.
    //       The path is C:\PublicDocuments\Report1.doc
    //       The path is C:\PublicDocuments\Report1.doc
    
    Dim string1 As String = "This is a string created by assignment."
    Console.WriteLine(string1)
    Dim string2 As String = "The path is C:\PublicDocuments\Report1.doc"
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       This is a string created by assignment.
    '       The path is C:\PublicDocuments\Report1.doc
    
  • Sınıf String oluşturucuyu çağırarak. Aşağıdaki örnek, birkaç sınıf oluşturucuyu çağırarak dizelerin örneğini oluşturur. Bazı oluşturucuların karakter dizilerinin işaretçilerini veya parametre olarak imzalı bayt dizilerini içerdiğini unutmayın. Visual Basic bu oluşturuculara yapılan çağrıları desteklemez. Oluşturucular hakkında String ayrıntılı bilgi için oluşturucu özetini String inceleyin.

    using namespace System;
    
    void main()
    {
       wchar_t chars[5] = L"word";
       char bytes[6] = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
       // Create a string from a character array. 
       String^ string1 = gcnew String(chars);
       Console::WriteLine(string1);
    
       // Create a string that consists of a character repeated 20 times. 
       String^ string2 = gcnew String('c', 20);
       Console::WriteLine(string2);
    
       String^ stringFromBytes = nullptr;
       String^ stringFromChars = nullptr;
    
       char * pbytes = &bytes[0];
       // Create a string from a pointer to a signed byte array.
       stringFromBytes = gcnew String(pbytes);
    
       wchar_t* pchars =  &chars[0];
       // Create a string from a pointer to a character array.
       stringFromChars = gcnew String(pchars);
    
       Console::WriteLine(stringFromBytes);
       Console::WriteLine(stringFromChars);
       Console::ReadLine();
    }
    // The example displays the following output: 
    //       word 
    //       cccccccccccccccccccc 
    //       ABCDE 
    //       word
    
    char[] chars = { 'w', 'o', 'r', 'd' };
    sbyte[] bytes = { 0x41, 0x42, 0x43, 0x44, 0x45, 0x00 };
    
    // Create a string from a character array.
    string string1 = new string(chars);
    Console.WriteLine(string1);
    
    // Create a string that consists of a character repeated 20 times.
    string string2 = new string('c', 20);
    Console.WriteLine(string2);
    
    string stringFromBytes = null;
    string stringFromChars = null;
    unsafe
    {
       fixed (sbyte* pbytes = bytes)
       {
          // Create a string from a pointer to a signed byte array.
          stringFromBytes = new string(pbytes);
       }
       fixed (char* pchars = chars)
       {
          // Create a string from a pointer to a character array.
          stringFromChars = new string(pchars);
       }
    }
    Console.WriteLine(stringFromBytes);
    Console.WriteLine(stringFromChars);
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word
    
    let chars = [| 'w'; 'o'; 'r'; 'd' |]
    let bytes = [| 0x41y; 0x42y; 0x43y; 0x44y; 0x45y; 0x00y |]
    
    // Create a string from a character array.
    let string1 = String chars
    printfn "%s" string1
    
    // Create a string that consists of a character repeated 20 times.
    let string2 = String('c', 20)
    printfn "%s" string2
    
    let stringFromBytes =
        // Create a string from a pointer to a signed byte array.
        use pbytes = fixed bytes
        String pbytes
    let stringFromChars = 
        // Create a string from a pointer to a character array.
        use pchars = fixed chars
        String pchars
    
    printfn $"{stringFromBytes}"
    printfn $"{stringFromChars}"
    // The example displays the following output:
    //       word
    //       cccccccccccccccccccc
    //       ABCDE
    //       word
    
    Dim chars() As Char = { "w"c, "o"c, "r"c, "d"c }
    
    ' Create a string from a character array.
    Dim string1 As New String(chars)
    Console.WriteLine(string1)
    
    ' Create a string that consists of a character repeated 20 times.
    Dim string2 As New String("c"c, 20)
    Console.WriteLine(string2)
    ' The example displays the following output:
    '       word
    '       cccccccccccccccccccc
    
  • Dize birleştirme işlecini (C# ve F# dilinde + ve & Visual Basic'te + ) kullanarak, örneklerin ve dize değişmez değerlerinin String herhangi bir bileşiminden tek bir dize oluşturun. Aşağıdaki örnekte dize birleştirme işlecinin kullanımı gösterilmektedir.

    String^ string1 = "Today is " + DateTime::Now.ToString("D") + ".";
    Console::WriteLine(string1);
    
    String^ string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console::WriteLine(string2);
    // The example displays output like the following: 
    //    Today is Tuesday, July 06, 2011. 
    //    This is one sentence. This is a second. This is a third sentence.
    
    string string1 = "Today is " + DateTime.Now.ToString("D") + ".";
    Console.WriteLine(string1);
    
    string string2 = "This is one sentence. " + "This is a second. ";
    string2 += "This is a third sentence.";
    Console.WriteLine(string2);
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    let string1 = "Today is " + DateTime.Now.ToString("D") + "."
    printfn $"{string1}"
    
    let string2 = "This is one sentence. " + "This is a second. "
    let string2 = string2 + "This is a third sentence."
    printfn $"{string2}"
    // The example displays output like the following:
    //    Today is Tuesday, July 06, 2011.
    //    This is one sentence. This is a second. This is a third sentence.
    
    Dim string1 As String = "Today is " + Date.Now.ToString("D") + "."  
    Console.WriteLine(string1)
    Dim string2 As String = "This is one sentence. " + "This is a second. "
    string2 += "This is a third sentence."
    Console.WriteLine(string2)      
    ' The example displays output like the following:
    '    Today is Tuesday, July 06, 2011.
    '    This is one sentence. This is a second. This is a third sentence.
    
  • Bir özelliği alarak veya dize döndüren bir yöntemi çağırarak. Aşağıdaki örnek, daha büyük bir dizeden alt dize ayıklamak için sınıfının yöntemlerini String kullanır.

    String^ sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence->IndexOf(" ") + 1;
    String^ word2 = sentence->Substring(startPosition, 
                                        sentence->IndexOf(" ", startPosition) - startPosition);
    Console::WriteLine("Second word: " + word2);
    
    string sentence = "This sentence has five words.";
    // Extract the second word.
    int startPosition = sentence.IndexOf(" ") + 1;
    string word2 = sentence.Substring(startPosition,
                                      sentence.IndexOf(" ", startPosition) - startPosition);
    Console.WriteLine("Second word: " + word2);
    // The example displays the following output:
    //       Second word: sentence
    
    let sentence = "This sentence has five words."
    // Extract the second word.
    let startPosition = sentence.IndexOf " " + 1
    let word2 = 
        sentence.Substring(startPosition, sentence.IndexOf(" ", startPosition) - startPosition)
    printfn $"Second word: {word2}"
    // The example displays the following output:
    //       Second word: sentence
    
    Dim sentence As String = "This sentence has five words."
    ' Extract the second word.
    Dim startPosition As Integer = sentence.IndexOf(" ") + 1
    Dim word2 As String = sentence.Substring(startPosition, 
                                             sentence.IndexOf(" ", startPosition) - startPosition) 
    Console.WriteLine("Second word: " + word2)
    ' The example displays the following output:
    '       Second word: sentence
    
  • Bir değeri veya nesneyi dize gösterimine dönüştürmek için bir biçimlendirme yöntemi çağırarak. Aşağıdaki örnek, iki nesnenin dize gösterimini bir dizeye eklemek için bileşik biçimlendirme özelliğini kullanır.

    DateTime^ dateAndTime = gcnew DateTime(2011, 7, 6, 7, 32, 0);
    Double temperature = 68.3;
    String^ result = String::Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                   dateAndTime, temperature);
    Console::WriteLine(result);
    // The example displays the following output: 
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.
    
    DateTime dateAndTime = new DateTime(2011, 7, 6, 7, 32, 0);
    double temperature = 68.3;
    string result = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                  dateAndTime, temperature);
    Console.WriteLine(result);
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.
    
    let dateAndTime = DateTime(2011, 7, 6, 7, 32, 0)
    let temperature = 68.3
    String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.", dateAndTime, temperature)
    |> printfn "%s"
    // The example displays the following output:
    //       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.
    
    Dim dateAndTime As DateTime = #07/06/2011 7:32:00AM#
    Dim temperature As Double = 68.3
    Dim result As String = String.Format("At {0:t} on {0:D}, the temperature was {1:F1} degrees Fahrenheit.",
                                         dateAndTime, temperature)
    Console.WriteLine(result)
    ' The example displays the following output:
    '       At 7:32 AM on Wednesday, July 06, 2011, the temperature was 68.3 degrees Fahrenheit.
    

Karakter nesneleri ve Unicode karakterleri

Bir dizedeki her karakter, Unicode kod noktası veya Unicode karakterinin sıralı (sayısal) değeri olarak da adlandırılan Unicode skaler değeriyle tanımlanır. Her kod noktası UTF-16 kodlaması kullanılarak kodlanır ve kodlamanın her öğesinin sayısal değeri bir Char nesneyle temsil edilir.

Not

Bir String örnek UTF-16 kod birimlerinin sıralı koleksiyonundan oluştuğundan, iyi biçimlendirilmiş bir Unicode dizesi olmayan bir String nesne oluşturmak mümkündür. Örneğin, karşılık gelen bir yüksek vekil olmadan düşük vekili olan bir dize oluşturmak mümkündür. Ad alanında nesneleri System.Text kodlama ve kod çözme yöntemleri gibi bazı yöntemler dizelerin iyi biçimlendirilmiş olduğundan emin olmak için denetimler gerçekleştirse de, String sınıf üyeleri bir dizenin iyi biçimlendirildiğinden emin olmaz.

Tek Char bir nesne genellikle tek bir kod noktasını temsil eder; yani sayısal değeri Char kod noktasına eşittir. Örneğin, "a" karakterinin kod noktası U+0061'dir. Ancak, bir kod noktası birden fazla kodlanmış öğe (birden Char fazla nesne) gerektirebilir. Unicode standardı, birden çok Char nesneye karşılık gelen iki tür karakter tanımlar: graphemes ve Unicode tamamlayıcı düzlemlerindeki karakterlere karşılık gelen Unicode ek kod noktaları.

  • Grafeme, bir temel karakterle ve ardından bir veya daha fazla birleştirme karakteriyle gösterilir. Örneğin, ğkarakteri, kod noktası U+0061 olan ve Char ardından kod noktası U+0308 olan bir Char nesne tarafından temsil edilir. Bu karakter, U+00E4 kod noktasına sahip tek Char bir nesne tarafından da tanımlanabilir. Aşağıdaki örnekte gösterildiği gibi, eşitlik için kültüre duyarlı bir karşılaştırma, sıradan bir sıralı karşılaştırma olmasa da bu iki gösterimin eşit olduğunu gösterir. Ancak, iki dize normalleştirilirse, sıralı karşılaştırma da eşit olduklarını gösterir. (Dizeleri normalleştirme hakkında daha fazla bilgi için Normalleştirme bölümüne bakın.)

    using namespace System;
    using namespace System::Globalization;
    using namespace System::IO;
    
    void main()
    {
       StreamWriter^ sw = gcnew StreamWriter(".\\graphemes.txt");
       String^ grapheme = L"a" + L"\u0308";
       sw->WriteLine(grapheme);
    
       String^ singleChar = "\u00e4";
       sw->WriteLine(singleChar);
    
       sw->WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::CurrentCulture));
       sw->WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme, singleChar, 
                                  StringComparison::Ordinal));
       sw->WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                      String::Equals(grapheme->Normalize(), 
                                  singleChar->Normalize(), 
                                  StringComparison::Ordinal));
       sw->Close(); 
    }
    // The example produces the following output: 
    //       ä 
    //       ä 
    //       ä = ä (Culture-sensitive): True 
    //       ä = ä (Ordinal): False 
    //       ä = ä (Normalized Ordinal): True
    
    using System;
    using System.Globalization;
    using System.IO;
    
    public class Example
    {
       public static void Main()
       {
          StreamWriter sw = new StreamWriter(@".\graphemes.txt");
          string grapheme = "\u0061\u0308";
          sw.WriteLine(grapheme);
          
          string singleChar = "\u00e4";
          sw.WriteLine(singleChar);
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture));
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal));
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal));
          sw.Close(); 
       }
    }
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    open System
    open System.IO
    
    do
        use sw = new StreamWriter(@".\graphemes.txt")
        let grapheme = "\u0061\u0308"
        sw.WriteLine grapheme
    
        let singleChar = "\u00e4"
        sw.WriteLine singleChar
    
        sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                    String.Equals(grapheme, singleChar,
                                    StringComparison.CurrentCulture))
        sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar,
                    String.Equals(grapheme, singleChar,
                                    StringComparison.Ordinal))
        sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar,
                    String.Equals(grapheme.Normalize(),
                                    singleChar.Normalize(),
                                    StringComparison.Ordinal))
    // The example produces the following output:
    //       ä
    //       ä
    //       ä = ä (Culture-sensitive): True
    //       ä = ä (Ordinal): False
    //       ä = ä (Normalized Ordinal): True
    
    Imports System.Globalization
    Imports System.IO
    
    Module Example
       Public Sub Main()
          Dim sw As New StreamWriter(".\graphemes.txt")
          Dim grapheme As String = ChrW(&H0061) + ChrW(&h0308)
          sw.WriteLine(grapheme)
          
          Dim singleChar As String = ChrW(&h00e4)
          sw.WriteLine(singleChar)
                
          sw.WriteLine("{0} = {1} (Culture-sensitive): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.CurrentCulture))
          sw.WriteLine("{0} = {1} (Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme, singleChar, 
                                     StringComparison.Ordinal))
          sw.WriteLine("{0} = {1} (Normalized Ordinal): {2}", grapheme, singleChar, 
                       String.Equals(grapheme.Normalize(), 
                                     singleChar.Normalize(), 
                                     StringComparison.Ordinal))
          sw.Close() 
       End Sub
    End Module
    ' The example produces the following output:
    '       ä
    '       ä
    '       ä = ä (Culture-sensitive): True
    '       ä = ä (Ordinal): False
    '       ä = ä (Normalized Ordinal): True
    
  • Unicode tamamlayıcı kod noktası (vekil çift), kod noktası yüksek vekil olan bir Char nesne ve ardından kod noktası düşük vekil olan bir Char nesne tarafından temsil edilir. Yüksek vekillerin kod birimleri U+D800 ile U+DBFF arasında değişir. Düşük vekillerin kod birimleri U+DC00 ile U+DFFF arasında değişir. Vekil çiftler, 16 Unicode tamamlayıcı düzlemdeki karakterleri temsil etmek için kullanılır. Aşağıdaki örnek bir vekil karakter oluşturur ve bunu Char.IsSurrogatePair(Char, Char) bir vekil çift olup olmadığını belirlemek için yöntemine geçirir.

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

Dizeler ve Unicode Standardı

Dizedeki karakterler, değerlere karşılık gelen Char UTF-16 kodlanmış kod birimleriyle temsil edilir.

Bir dizedeki her karakter, sabit listesi tarafından .NET'te temsil edilen ilişkili bir Unicode karakter kategorisine UnicodeCategory sahiptir. Bir karakterin veya vekil çiftin kategorisi yöntemi çağrılarak CharUnicodeInfo.GetUnicodeCategory belirlenebilir.

.NET, farklı platformlarda çalışan bir .NET uygulamasının belirli bir sürümünün aynı karakter kategorisi bilgilerini döndürmesini sağlayan kendi karakter tablosunu ve karşılık gelen kategorilerini korur. Tüm .NET sürümlerinde ve tüm işletim sistemi platformlarında karakter kategorisi bilgileri Unicode Karakter Veritabanı tarafından sağlanır.

Aşağıdaki tabloda .NET sürümleri ve karakter kategorilerinin temel aldığı Unicode Standart sürümleri listelenmiştir.

.NET sürümü Unicode Standardı sürümü
.NET Framework 1.1 Unicode Standart, Sürüm 4.0.0
.NET Framework 2.0 Unicode Standart, Sürüm 5.0.0
.NET Framework 3.5 Unicode Standart, Sürüm 5.0.0
.NET Framework 4 Unicode Standart, Sürüm 5.0.0
.NET Framework 4.5 Unicode Standart, Sürüm 6.3.0
.NET Framework 4.5.1 Unicode Standart, Sürüm 6.3.0
.NET Framework 4.5.2 Unicode Standart, Sürüm 6.3.0
.NET Framework 4.6 Unicode Standart, Sürüm 6.3.0
.NET Framework 4.6.1 Unicode Standart, Sürüm 6.3.0
4.6.2 ve sonraki sürümleri .NET Framework Unicode Standart, Sürüm 8.0.0
.NET Core 2.1 Unicode Standart, Sürüm 8.0.0
.NET Core 3.1 Unicode Standart, Sürüm 11.0.0
.NET 5 Unicode Standart, Sürüm 13.0.0

Buna ek olarak. .NET, Unicode standardına göre dize karşılaştırmasını ve sıralamayı destekler. .NET Framework 4 ve önceki sürümler kendi dize verileri tablosunu korur. Bu, Windows 7'de çalışan .NET Framework 4.5'den başlayarak .NET Framework sürümleri için de geçerlidir. Windows işletim sisteminin Windows 8 ve sonraki sürümlerinde çalışan .NET Framework 4.5'den başlayarak, çalışma zamanı dize karşılaştırma ve sıralama işlemlerini işletim sistemine devreder. .NET Core ve .NET 5+ sürümlerinde, dize karşılaştırma ve sıralama bilgileri Unicode kitaplıkları için Uluslararası Bileşenler tarafından sağlanır (Windows 10 Mayıs 2019 Güncelleştirmesi'den önceki Windows sürümleri hariç). Aşağıdaki tabloda karakter karşılaştırma ve sıralamanın temel aldığı .NET sürümleri ve Unicode Standart sürümleri listelenmektedir.

.NET sürümü Unicode Standardı sürümü
.NET Framework 1.1 Unicode Standart, Sürüm 4.0.0
.NET Framework 2.0 Unicode Standart, Sürüm 5.0.0
.NET Framework 3.5 Unicode Standart, Sürüm 5.0.0
.NET Framework 4 Unicode Standart, Sürüm 5.0.0
Windows 7'de .NET Framework 4.5 ve üzeri Unicode Standart, Sürüm 5.0.0
Windows 8 ve üzeri Windows işletim sistemlerinde .NET Framework 4.5 ve üzeri Unicode Standart, Sürüm 6.3.0
.NET Core ve .NET 5+ Temel işletim sistemi tarafından desteklenen Unicode Standard sürümüne bağlıdır.

Dizeler ve katıştırılmış null karakterleri

.NET'te bir String nesne, dize uzunluğunun bir parçası olarak sayılan eklenmiş null karakterler içerebilir. Ancak, C ve C++ gibi bazı dillerde null karakter dizenin sonunu gösterir; dizenin bir parçası olarak kabul edilmez ve dizenin uzunluğunun bir parçası olarak sayılmaz. Bu, C ve C++ programcıları veya C veya C++ ile yazılmış kitaplıkların dizeler hakkında oluşturabileceği yaygın varsayımların nesnelere String uygulandığında geçerli olması gerekmediği anlamına gelir:

  • veya işlevleri tarafından strlen döndürülen değer eşit olmayabilirString.Length.wcslen

  • veya wcscpy_s işlevleri tarafından strcpy_s oluşturulan dize, yöntemi tarafından String.Copy oluşturulan dizeyle aynı olmayabilir.

Nesneleri başlatan String yerel C ve C++ kodunun ve platform aracılığıyla geçirilen nesnelerin çağrıldığından String emin olmanız gerekir. Ekli null karakterin dizenin sonunu işaretlediğini varsaymayın.

Bir dizeye eklenmiş null karakterler, bir dize sıralandığında (veya karşılaştırıldığında) ve bir dize arandığında da farklı kabul edilir. Sabit kültürü kullanan karşılaştırmalar da dahil olmak üzere iki dize arasında kültüre duyarlı karşılaştırmalar yapılırken null karakterler yoksayılır. Bunlar yalnızca sıralı veya büyük/küçük harfe duyarlı olmayan sıralı karşılaştırmalar için kabul edilir. Öte yandan, bir dizede , StartsWithve IndexOfgibi Containsyöntemlerle arama yaparken katıştırılmış null karakterler her zaman dikkate alınır.

Dizeler ve dizinler

Dizin, bir Char nesnenin (Unicode karakteri değil) Stringkonumudur. Dizin, dizedeki ilk konumdan başlayan sıfır tabanlı, olumsuz olmayan bir sayıdır ve dizin konumu sıfırdır. ve LastIndexOfgibi IndexOf bir dizi arama yöntemi, dize örneğinde bir karakterin veya alt dizenin dizinini döndürür.

özelliği, Chars[] dizedeki dizin konumlarına göre tek tek Char nesnelere erişmenizi sağlar. Chars[] Özellik varsayılan özellik (Visual Basic'te) veya dizin oluşturucu (C# ve F# içinde) olduğundan, aşağıdaki gibi bir kod kullanarak bir dizedeki tek tek Char nesnelere erişebilirsiniz. Bu kod, dizenin kaç sözcük içerdiğini belirlemek için bir dizede boşluk veya noktalama karakterleri arar.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

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

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

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

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

String sınıfı arabirimini uyguladığındanIEnumerable, aşağıdaki örnekte gösterildiği gibi bir foreach yapı kullanarak bir dizedeki nesneler arasında Char yineleme de yapabilirsiniz.

using namespace System;

void main()
{
   String^ s1 = "This string consists of a single short sentence.";
   int nWords = 0;

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

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

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

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

Ardışık dizin değerleri ardışık Unicode karakterlerine karşılık gelmeyebilir çünkü Unicode karakteri birden Char fazla nesne olarak kodlanmış olabilir. Özellikle, bir dize, bir temel karakter ve ardından bir veya daha fazla birleştirme karakteri veya vekil çiftler tarafından oluşturulan çok karakterli metin birimleri içerebilir. Nesneler yerine Char Unicode karakterlerle çalışmak için ve TextElementEnumerator sınıflarını System.Globalization.StringInfo veya String.EnumerateRunes yöntemini ve yapısı kullanınRune. Aşağıdaki örnekte, nesnelerle çalışan kod ile Unicode karakterlerle Char çalışan kod arasındaki fark gösterilmektedir. Tümcenin her sözcüğündeki karakter veya metin öğelerinin sayısını karşılaştırır. Dize, bir temel karakterin iki dizisini ve ardından bir birleştirme karakterini içerir.

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

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

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

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

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

   // Display character counts.
   Console::WriteLine("{0,6} {1,20} {2,20}",
                      "Word #", "Char Objects", "Characters"); 
   for (int ctr = 0; ctr < chars->Count; ctr++) 
      Console::WriteLine("{0,6} {1,20} {2,20}",
                         ctr, chars[ctr], elements[ctr]); 
   Console::ReadLine();
}
// The example displays the following output:
//      Word #         Char Objects           Characters
//           0                    2                    2
//           1                    4                    4
//           2                    3                    3
//           3                    4                    4
//           4                    3                    3
//           5                    8                    8
//           6                    8                    7
//           7                    3                    3
//           8                    2                    2
//           9                    8                    8
//          10                    2                    1
//          11                    8                    8
//          12                    3                    3
//          13                    3                    3
//          14                    9                    9
//          15                   15                   15
//          16                    2                    2
//          17                    6                    6
//          18                   12                   12
// First sentence of The Mystery of the Yellow Room, by Leroux.
string opening = "Ce n'est pas sans une certaine émotion que "+
                 "je commence à raconter ici les aventures " +
                 "extraordinaires de Joseph Rouletabille."; 
// Character counters.
int nChars = 0;
// Objects to store word count.
List<int> chars = new List<int>();
List<int> elements = new List<int>();

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

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

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

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

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

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

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

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

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

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

Bu örnek, bir dizedeki StringInfo.GetTextElementEnumerator tüm metin öğelerini listelemek için yöntemini ve TextElementEnumerator sınıfını kullanarak metin öğeleriyle çalışır. Yöntemini çağırarak StringInfo.ParseCombiningCharacters her metin öğesinin başlangıç dizinini içeren bir dizi de alabilirsiniz.

Tek tek Char değerler yerine metin birimleriyle çalışma hakkında daha fazla bilgi için bkz. .NET'te karakter kodlamaya giriş.

Null dizeler ve boş dizeler

Bildirilmiş ancak değer atanmamış bir dize şeklindedir null. Bu dizede yöntemler çağrılmaya çalışılması bir NullReferenceExceptionoluşturur. Null dize, değeri "" veya String.Emptyolan bir dize olan boş dizeden farklıdır. Bazı durumlarda, bir yöntem çağrısında bağımsız değişken olarak null dize veya boş dize geçirmek bir özel durum oluşturur. Örneğin, yöntemine Int32.Parse null dize geçirilmesi bir ArgumentNullExceptionoluşturur ve boş bir dize geçirilmesi bir FormatExceptionoluşturur. Diğer durumlarda, yöntem bağımsız değişkeni null dize veya boş dize olabilir. Örneğin, bir sınıf için bir IFormattable uygulama sağlıyorsanız, hem null dizeyi hem de boş bir dizeyi genel ("G") biçim tanımlayıcısıyla eşitlersiniz.

sınıfı, String bir dizenin null boş veya boş olup olmadığını test etmenizi sağlayan aşağıdaki iki kolaylık yöntemini içerir:

  • IsNullOrEmpty, bir dizenin veya null değerine eşit String.Emptyolup olmadığını gösterir. Bu yöntem, aşağıdaki gibi bir kod kullanma gereksinimini ortadan kaldırır:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    if str = null || str.Equals String.Empty then
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace, bir dizenin , eşittir String.Emptyveya yalnızca boşluk karakterlerinden mi oluştuğunun göstergesidirnull. Bu yöntem, aşağıdaki gibi bir kod kullanma gereksinimini ortadan kaldırır:

    if (str == nullptr || str->Equals(String::Empty) || str->Trim()->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty) || str.Trim().Equals(String.Empty))
    
    if str = null || str.Equals String.Empty || str.Trim().Equals String.Empty then
    
    If str Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

Aşağıdaki örnek, özel Temperature bir sınıfın IFormattable.ToString uygulanmasında yöntemini kullanırIsNullOrEmpty. yöntemi "G", "C", "F" ve "K" biçim dizelerini destekler. Boş bir biçim dizesi veya değeri null yöntemine geçirilen bir biçim dizesiyse, değeri "G" biçim dizesi olarak değiştirilir.

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

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

Değişmezlik ve StringBuilder sınıfı

Bir String nesne sabit (salt okunur) olarak adlandırılır, çünkü değeri oluşturulduktan sonra değiştirilemez. Bir String nesneyi değiştirmek için görünen yöntemler aslında değişikliği içeren yeni String bir nesne döndürür.

Dizeler sabit olduğundan, tek bir dize gibi görünen öğelere yinelenen eklemeler veya silmeler gerçekleştiren dize işleme yordamları önemli bir performans cezasına neden olabilir. Örneğin, aşağıdaki kod, 0x052F için 0x0001 aralığında 1000 karakter içeren bir dize oluşturmak için rastgele bir sayı oluşturucu kullanır. Kod, adlı strmevcut dizeye yeni bir karakter eklemek için dize birleştirmeyi kullanıyor gibi görünse de, aslında her birleştirme işlemi için yeni String bir nesne oluşturur.

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

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

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

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

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

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

do
    let rnd = Random()

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

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

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

Bir dizenin StringBuilder değerinde birden çok değişiklik yapılan işlemler için sınıfı yerine String sınıfını kullanabilirsiniz. Sınıfın String örneklerinden farklı olarak nesneler StringBuilder değiştirilebilir; bir dizeden alt dizeleri birleştirdiğinizde, eklediğinizde veya sildiğinizde, işlemler tek bir dizede gerçekleştirilir. Bir StringBuilder nesnenin değerini değiştirmeyi bitirdiğinizde, nesnesini dizeye dönüştürmek için yöntemini çağırabilirsiniz StringBuilder.ToString . Aşağıdaki örnek, bir nesneyle StringBuilder 0x052F 0x0001 için aralıktaki 1000 rastgele karakteri birleştirmek için önceki örnekte kullanılan öğesinin yerini alırString.

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

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

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

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

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

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

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

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

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

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

Sıra ve kültüre duyarlı işlemlerin karşılaştırılması

Sınıfın String üyeleri bir String nesne üzerinde sıralı veya kültüre duyarlı (dilbilimsel) işlemler gerçekleştirir. Sıralı bir işlem, her Char nesnenin sayısal değeri üzerinde çalışır. Kültüre duyarlı bir işlem nesnenin String değerine göre hareket eder ve kültüre özgü büyük/küçük harfe özgü büyük/küçük harf, sıralama, biçimlendirme ve ayrıştırma kurallarını dikkate alır. Kültüre duyarlı işlemler açıkça bildirilen bir kültür veya örtük geçerli kültür bağlamında yürütülür. İki tür işlem, aynı dize üzerinde gerçekleştirildiğinde çok farklı sonuçlar üretebilir.

.NET ayrıca, bölgeden bağımsız olarak İngilizce dilinin kültür ayarlarını gevşek bir şekilde temel alan sabit kültürü ()CultureInfo.InvariantCulture kullanarak kültüre duyarsız dil dizesi işlemlerini de destekler. Diğer System.Globalization.CultureInfo ayarlardan farklı olarak, sabit kültürün ayarlarının sistemden sisteme ve .NET sürümleri arasında tek bir bilgisayarda tutarlı kalacağı garanti edilir. Sabit kültür, tüm kültürler arasında dize karşılaştırmalarının ve sıralamanın kararlılığını sağlayan bir tür kara kutu olarak görülebilir.

Önemli

Uygulamanız dosya adı veya adlandırılmış kanal gibi sembolik tanımlayıcılar veya XML dosyasındaki metin tabanlı veriler gibi kalıcı veriler hakkında güvenlik kararı verirse, işlem kültüre duyarlı karşılaştırma yerine sıralı karşılaştırma kullanmalıdır. Bunun nedeni kültüre duyarlı karşılaştırmanın, geçerli kültüre bağlı olarak farklı sonuçlar verebiliyor olması, sıralı karşılaştırmanın ise yalnızca karşılaştırılan karakterlerin ikili değerine bağlı olmasıdır.

Önemli

Dize işlemlerini gerçekleştiren yöntemlerin çoğu, yönteminin sıralı veya kültüre duyarlı bir işlem gerçekleştirip gerçekleştirmediğini belirtmenize olanak tanıyan türünde StringComparisonbir parametresi olan bir aşırı yükleme içerir. Genel olarak, yöntem çağrınızın amacını net hale getirmek için bu aşırı yüklemeyi çağırmanız gerekir. Dizelerde sıralı ve kültüre duyarlı işlemleri kullanmaya yönelik en iyi yöntemler ve yönergeler için bkz. Dizeleri Kullanmak için En İyi Yöntemler.

Büyük /küçük harfe ayırma, ayrıştırma ve biçimlendirme, karşılaştırma ve sıralama ve eşitlik testi işlemleri sıralı veya kültüre duyarlı olabilir. Aşağıdaki bölümlerde her işlem kategorisi ele alınıyor.

İpucu

Her zaman yöntem çağrınızın amacını net hale getiren bir yöntem aşırı yüklemesi çağırmanız gerekir. Örneğin, geçerli kültürün Compare(String, String) kurallarını kullanarak iki dizenin kültüre duyarlı karşılaştırmasını gerçekleştirmek için yöntemini çağırmak yerine, bağımsız değişken için comparisonType değeriyle StringComparison.CurrentCulture yöntemini çağırmanız Compare(String, String, StringComparison) gerekir. Daha fazla bilgi için bkz. Dizeleri Kullanmak için En İyi Yöntemler.

Sıralama ve karşılaştırma işlemlerinde kullanılan karakter ağırlıkları hakkında bilgi içeren bir dizi metin dosyası olan sıralama ağırlık tablolarını aşağıdaki bağlantılardan indirebilirsiniz:

Büyük/Küçük Harf Kullanımı

Büyük/küçük harf kuralları, Unicode karakterinin büyük harfe çevirmesinin nasıl değiştirileceğini belirler; örneğin, küçük harften büyük harfe. Genellikle, bir büyük/küçük harfe dönüştürme işlemi bir dize karşılaştırması öncesinde gerçekleştirilir. Örneğin, bir dize başka bir büyük harf dizeyle karşılaştırılabilmesi için büyük harfe dönüştürülebilir. veya yöntemini çağırarak ToLower bir dizedeki karakterleri küçük harfe dönüştürebilir ve veya ToLowerInvariantToUpperInvariant yöntemini çağırarak ToUpper bunları büyük harfe dönüştürebilirsiniz. Ayrıca, bir dizeyi TextInfo.ToTitleCase büyük/küçük harfe dönüştürmek için yöntemini kullanabilirsiniz.

Not

Yalnızca Linux ve macOS sistemlerinde çalışan .NET Core: C ve Posix kültürleri için harmanlama davranışı her zaman büyük/küçük harfe duyarlıdır çünkü bu kültürler beklenen Unicode harmanlama sırasını kullanmaz. Kültüre duyarlı, büyük/küçük harfe duyarlı olmayan sıralama işlemleri gerçekleştirmek için C veya Posix dışında bir kültür kullanmanızı öneririz.

Büyük/küçük harf işlemleri geçerli kültürün, belirtilen kültürün veya sabit kültürün kurallarını temel alabilir. Büyük/küçük harf eşlemeleri kullanılan kültüre bağlı olarak farklılık gösterebileceğinden, büyük/küçük harf işlemlerinin sonucu kültüre göre değişebilir. Büyük/küçük harf arasındaki gerçek farklar üç türdedir:

  • LATIN BÜYÜK HARF I (U+0049), LATIN KÜÇÜK HARF I (U+0069), ÜSTÜNDE NOKTA OLAN LATIN BÜYÜK HARF I (U+0130) ve LATIN KÜÇÜK NOKTASIZ I (U+0131) harf eşlemesindeki farklar. tr-TR (Türkçe (Türkiye)) ve az-Latn-AZ (Azerbaycan, Latin) kültürlerinde ve tr, az ve az-Latn nötr kültürlerinde LATIN BÜYÜK HARF I'nin küçük harfle eşdeğeri LATIN KÜÇÜK HARF NOKTASIZ I, LATIN KÜÇÜK HARF I'nin büyük/küçük eşdeğeri ISE ÜSTÜNDE NOKTA OLAN LATIN BÜYÜK HARF I'dir. Sabit kültür de dahil olmak üzere diğer tüm kültürlerde, LATIN KÜÇÜK HARF I ve LATIN BÜYÜK HARF I küçük ve büyük harf eşdeğerleridir.

    Aşağıdaki örnekte, kültüre duyarlı bir büyük/küçük harf karşılaştırması kullanıyorsa dosya sistemi erişimini önlemek için tasarlanmış bir dize karşılaştırmasının nasıl başarısız olabileceği gösterilmektedir. (Sabit kültürün büyük/küçük harf kuralları kullanılmış olmalıdır.)

    using System;
    using System.Globalization;
    using System.Threading;
    
    public class Example
    {
       const string disallowed = "file";
       
       public static void Main()
       {
          IsAccessAllowed(@"FILE:\\\c:\users\user001\documents\FinancialInfo.txt");
       }
    
       private static void IsAccessAllowed(String resource)
       {
          CultureInfo[] cultures = { CultureInfo.CreateSpecificCulture("en-US"),
                                     CultureInfo.CreateSpecificCulture("tr-TR") };
          String scheme = null;
          int index = resource.IndexOfAny( new Char[] { '\\', '/' } );
          if (index > 0) 
             scheme = resource.Substring(0, index - 1);
    
          // Change the current culture and perform the comparison.
          foreach (var culture in cultures) {
             Thread.CurrentThread.CurrentCulture = culture;
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName);
             Console.WriteLine(resource);
             Console.WriteLine("Access allowed: {0}", 
                               ! String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase));      
             Console.WriteLine();
          }   
       }
    }
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //       
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    open System
    open System.Globalization
    open System.Threading
    
    let disallowed = "file"
    
    let isAccessAllowed (resource: string) =
        let cultures = 
            [| CultureInfo.CreateSpecificCulture "en-US"
               CultureInfo.CreateSpecificCulture "tr-TR" |]
        let index = resource.IndexOfAny [| '\\'; '/' |]
        let scheme =
            if index > 0 then
                resource.Substring(0, index - 1)
            else 
                null
    
        // Change the current culture and perform the comparison.
        for culture in cultures do
            Thread.CurrentThread.CurrentCulture <- culture
            printfn $"Culture: {CultureInfo.CurrentCulture.DisplayName}"
            printfn $"{resource}"
            printfn $"Access allowed: {String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase) |> not}"
            printfn ""
            
    isAccessAllowed @"FILE:\\\c:\users\user001\documents\FinancialInfo.txt"
    // The example displays the following output:
    //       Culture: English (United States)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: False
    //
    //       Culture: Turkish (Turkey)
    //       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    //       Access allowed: True
    
    Imports System.Globalization
    Imports System.Threading
    
    Module Example
       Const disallowed = "file"
       
       Public Sub Main()
          IsAccessAllowed("FILE:\\\c:\users\user001\documents\FinancialInfo.txt")
       End Sub
    
       Private Sub IsAccessAllowed(resource As String)
          Dim cultures() As CultureInfo = { CultureInfo.CreateSpecificCulture("en-US"),
                                            CultureInfo.CreateSpecificCulture("tr-TR") }
          Dim scheme As String = Nothing
          Dim index As Integer = resource.IndexOfAny( {"\"c, "/"c })
          If index > 0 Then scheme = resource.Substring(0, index - 1)
    
          ' Change the current culture and perform the comparison.
          For Each culture In cultures
             Thread.CurrentThread.CurrentCulture = culture
             Console.WriteLine("Culture: {0}", CultureInfo.CurrentCulture.DisplayName)
             Console.WriteLine(resource)
             Console.WriteLine("Access allowed: {0}", 
                               Not String.Equals(disallowed, scheme, StringComparison.CurrentCultureIgnoreCase))      
             Console.WriteLine()
          Next   
       End Sub      
    End Module
    ' The example displays the following output:
    '       Culture: English (United States)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: False
    '       
    '       Culture: Turkish (Turkey)
    '       FILE:\\\c:\users\user001\documents\FinancialInfo.txt
    '       Access allowed: True
    
  • Sabit kültür ve diğer tüm kültürler arasındaki büyük/küçük harf eşlemelerindeki farklılıklar. Böyle durumlarda, bir karakteri büyük veya küçük harfle değiştirmek için sabit kültürün büyük/küçük harf kurallarının kullanılması aynı karakteri döndürür. Diğer tüm kültürler için farklı bir karakter döndürür. Etkilenen karakterlerden bazıları aşağıdaki tabloda listelenmiştir.

    Karakter olarak değiştirilirse Döndürülenler
    MIKRON İŞARETI (U+00B5) Büyük harfe YUNANCA BÜYÜK HARF MU (U+-39C)
    ÜSTÜNDE NOKTA BULUNAN LATIN BÜYÜK I HARFI (U+0130) Küçük harf LATIN KÜÇÜK HARF I (U+0069)
    LATIN KÜÇÜK NOKTASıZ I HARFI (U+0131) Büyük harfe LATIN BÜYÜK HARF I (U+0049)
    LATIN KÜÇÜK UZUN S HARFI (U+017F) Büyük harfe LATIN BÜYÜK S HARFI (U+0053)
    KÜÇÜK Z HARFI VE CARON IÇEREN LATIN BÜYÜK D HARFI (U+01C5) Küçük harf LATIN KÜÇÜK HARF DZ WITH CARON (U+01C6)
    YUNANCA YPOGEGRAMMENI'YI BIRLEŞTIRME (U+0345) Büyük harfe YUNANCA BÜYÜK HARF IOTA (U+0399)
  • ASCII karakter aralığındaki iki harfli karma büyük/küçük harf çiftlerinin büyük/küçük harf eşlemelerindeki farklar. Çoğu kültürde, iki harfli bir karma çift, eşdeğer iki harfli büyük veya küçük harf çiftine eşittir. Bu, aşağıdaki kültürlerdeki aşağıdaki iki harfli çiftler için geçerli değildir, çünkü her durumda bunlar bir digrafla karşılaştırılır:

    • hr-HR (Hırvatistan)) kültüründe "lJ" ve "nJ".

    • cs-CZ (Çek Cumhuriyeti) ve sk-SK (Slovakya)) kültürlerinde "cH".

    • da-DK (Danca (Danimarka)) kültüründe "aA".

    • hu-HU (Macaristan)) kültüründe "cS", "dZ", "dZS", "nY", "sZ", "tY" ve "zS".

    • es-ES_tradnl (İspanyolca (İspanya, Geleneksel Sıralama)) kültüründe "cH" ve "lL".

    • vi-VN (Vietnamca (Vietnam)) kültüründe "cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH" ve "tR".

    Ancak, bu çiftlerin kültüre duyarlı bir karşılaştırmasının sorun oluşturduğu bir durumla karşılaşmak olağan dışıdır çünkü bu çiftler sabit dizelerde veya tanımlayıcılarda nadirdir.

Aşağıdaki örnekte, dizeleri büyük harfe dönüştürürken kültürler arasındaki büyük/küçük harf kurallarındaki farklardan bazıları gösterilmektedir.

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

String^ ShowHexValue(String^ s);

void main()
{
   StreamWriter^ sw = gcnew StreamWriter(".\\case.txt");   
   array<String^>^ words = gcnew array<String^> { L"file", L"sıfır", L"Dženana" };
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"),  
                                                               gcnew CultureInfo("tr-TR") };

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

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

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

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

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

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

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

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

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

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

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

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

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

Ayrıştırma ve biçimlendirme

Biçimlendirme ve ayrıştırma ters işlemlerdir. Biçimlendirme kuralları, tarih ve saat veya sayı gibi bir değerin dize gösterimine nasıl dönüştürüleceğini belirlerken, ayrıştırma kuralları bir dize gösteriminin tarih ve saat gibi bir değere nasıl dönüştürüleceğini belirler. Hem biçimlendirme hem de ayrıştırma kuralları kültürel kurallara bağlıdır. Aşağıdaki örnekte kültüre özgü bir tarih dizesi yorumlandığında ortaya çıkabilecek belirsizlik gösterilmektedir. Tarih dizesi oluşturmak için kullanılan kültürün kurallarını bilmeden, 01.03.2011, 1.3.2011 ve 03.01.2011'in 3 Ocak 2011'i mi yoksa 1 Mart 2011'i mi temsil ettiğini bilmek mümkün değildir.

using namespace System;
using namespace System::Globalization;

void main()
{
   DateTime^ date = gcnew DateTime(2011, 3, 1);
   array<CultureInfo^>^ cultures = gcnew array<CultureInfo^> { CultureInfo::InvariantCulture, 
                                                               gcnew CultureInfo("en-US"), 
                                                               gcnew CultureInfo("fr-FR") };

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

public class Example
{
   public static void Main()
   {
      DateTime date = new DateTime(2011, 3, 1);
      CultureInfo[] cultures = { CultureInfo.InvariantCulture, 
                                 new CultureInfo("en-US"), 
                                 new CultureInfo("fr-FR") };

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

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

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

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

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

Benzer şekilde, aşağıdaki örnekte gösterildiği gibi, tek bir dize ayrıştırma işleminde kuralları kullanılan kültüre bağlı olarak farklı tarihler üretebilir.

using namespace System;
using namespace System::Globalization;

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

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

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

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

Dize karşılaştırması ve sıralaması

Dizeleri karşılaştırma ve sıralama kuralları kültürden kültüre farklılık gösterir. Örneğin, sıralama düzeni fonetiği veya karakterlerin görsel gösterimini temel alabilir. Doğu Asya dillerinde karakterler, ideografların vuruş ve radikallerine göre sıralanır. Sıralama, alfabe için kullanılan dillere ve kültürlere de bağlıdır. Örneğin, Danca dilinde alfabede "Z" işaretinden sonra sıralayan bir "Æ" karakteri vardır. Buna ek olarak, karşılaştırmalar büyük/küçük harfe duyarlı veya büyük/küçük harfe duyarlı olmayabilir ve büyük/küçük harf kuralları kültüre göre farklılık gösterebilir. Sıralı karşılaştırma ise dizeleri karşılaştırırken ve sıralarken dizedeki tek tek karakterlerin Unicode kod noktalarını kullanır.

Sıralama kuralları, Unicode karakterlerin alfabetik sırasını ve iki dizenin birbiriyle karşılaştırmasını belirler. Örneğin, String.Compare(String, String, StringComparison) yöntemi parametresine göre iki dizeyi StringComparison karşılaştırır. Parametre değeri ise StringComparison.CurrentCulture, yöntem geçerli kültürün kurallarını kullanan bir dilsel karşılaştırma gerçekleştirir; parametre değeri ise StringComparison.Ordinal, yöntem sıralı bir karşılaştırma gerçekleştirir. Sonuç olarak, aşağıdaki örnekte gösterildiği gibi, geçerli kültür ABD İngilizcesi ise, yönteme String.Compare(String, String, StringComparison) yapılan ilk çağrı (kültüre duyarlı karşılaştırma kullanılarak), "a" değerini "A" değerinden küçük olarak kabul eder, ancak aynı yönteme yapılan ikinci çağrı (sıralı karşılaştırma kullanılarak) "a" değerini "A" değerinden büyük olarak kabul eder.

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("en-US");
   Console::WriteLine(String::Compare("A", "a", StringComparison::CurrentCulture));
   Console::WriteLine(String::Compare("A", "a", StringComparison::Ordinal));
}
// The example displays the following output: 
//       1 
//       -32
using System;
using System.Globalization;
using System.Threading;

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

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

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

.NET sözcük, dize ve sıralı sıralama kurallarını destekler:

  • Sözcük sıralama, belirli sayısal olmayan Unicode karakterlerin kendilerine atanmış özel ağırlıklara sahip olabileceği dizelerin kültüre duyarlı bir karşılaştırmasını gerçekleştirir. Örneğin, kısa çizginin (-) üzerine çok küçük bir ağırlık atanmış olabilir, böylece "coop" ve "co-op" yan yana sıralanmış bir listede görünür. Sözcük sıralama kurallarını kullanarak iki dizeyi karşılaştıran yöntemlerin listesi String için Kategoriye göre dize işlemleri bölümüne bakın.

  • Dize sıralama, kültüre duyarlı bir karşılaştırma da gerçekleştirir. Özel durumlar olmaması ve tüm alfasayısal Unicode karakterlerinden önce gelen tüm alfasayısal olmayan simgelerin olması dışında, sözcük sıralamaya benzer. dize sıralama kuralları kullanılarak, değeri CompareOptions.StringSortsağlanan bir options parametreye CompareInfo.Compare sahip yöntem aşırı yüklemeleri çağrılarak iki dize karşılaştırılabilir. .NET'in dize sıralama kurallarını kullanarak iki dizeyi karşılaştırmak için sağladığı tek yöntemin bu olduğunu unutmayın.

  • Sıralı sıralama, dizedeki her Char nesnenin sayısal değerine göre dizeleri karşılaştırır. Bir karakterin küçük ve büyük harfli sürümleri farklı kod noktalarına sahip olduğundan sıralı karşılaştırma otomatik olarak büyük/küçük harfe duyarlıdır. Ancak, büyük/küçük harf önemli değilse, büyük/küçük harfleri yoksayan sıralı bir karşılaştırma belirtebilirsiniz. Bu, sabit kültürü kullanarak dizeyi büyük harfe dönüştürmeye ve ardından sonuç üzerinde sıralı bir karşılaştırma yapmaya eşdeğerdir. Sıralı sıralama kurallarını kullanarak iki dizeyi karşılaştıran yöntemlerin listesi String için Kategoriye göre dize işlemleri bölümüne bakın.

Kültüre duyarlı karşılaştırma, özelliği tarafından CultureInfo.InvariantCulture belirtilen sabit kültür de dahil olmak üzere bir nesneyi açıkça veya örtük olarak kullanan herhangi bir CultureInfo karşılaştırmadır. Örtük kültür, ve CultureInfo.CurrentCulture özellikleri tarafından Thread.CurrentCulture belirtilen geçerli kültürdür. Kültürler arasında alfabetik karakterlerin (yani özelliğin döndürdüğü truekarakterlerin) sıralama düzeninde Char.IsLetter önemli farklılıklar vardır. gibi Compare(String, String, CultureInfo, CompareOptions)bir dize karşılaştırma yöntemine nesne sağlayarak CultureInfo belirli bir kültürün kurallarını kullanan kültüre duyarlı bir karşılaştırma belirtebilirsiniz. geçerli kültürün kurallarını kullanan kültüre duyarlı bir karşılaştırma belirtmek için , StringComparison.CurrentCultureIgnoreCaseveya dışında bir sabit listesi CompareOptions.Ordinal üyesini CompareOptions veya CompareOptions.OrdinalIgnoreCase yönteminin uygun bir aşırı yüklemesini Compare sağlayabilirsinizStringComparison.CurrentCulture. Kültüre duyarlı karşılaştırma genellikle sıralama için uygundur ancak sıralı karşılaştırma uygun değildir. Sıralı karşılaştırma genellikle iki dizenin eşit olup olmadığını belirlemek için uygundur (diğer bir ifadeyle kimliği belirlemek için), kültüre duyarlı karşılaştırma ise değildir.

Aşağıdaki örnekte kültüre duyarlı ve sıralı karşılaştırma arasındaki fark gösterilmektedir. Örnek, sıralı karşılaştırmayı ve da-DK ve en-US kültürlerinin kurallarını (yöntemin çağrıldığı sırada Compare varsayılan kültür olan her biri) kullanarak "Apple", "Æble" ve "AEble" olmak üzere üç dizeyi değerlendirir. Danca dili "Æ" karakterini tek bir harf olarak ele alıp alfabedeki "Z" harfinden sonra sıraladığı için , "Æble" dizesi "Apple" değerinden büyüktür. Bununla birlikte, "Æble" "AEble" ile eşdeğer olarak kabul edilmez, bu nedenle "Æble" da "AEble" değerinden büyüktür. EN-US kültürü "Æ" harfini içermez, ancak "AE" ile eşdeğer olarak ele alır ve bu da "Æble"ın neden "Apple"dan küçük ama "AEble" ile eşit olduğunu açıklar. Sıralı karşılaştırma ise "Apple"ın "Æble" değerinden küçük, "Æble" değerinin ise "AEble" değerinden büyük olduğunu düşünmektedir.

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

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

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

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

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

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

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

Uygun bir sıralama veya dize karşılaştırma yöntemi seçmek için aşağıdaki genel yönergeleri kullanın:

  • Dizelerin kullanıcının kültürüne göre sıralanmasını istiyorsanız, bunları geçerli kültürün kurallarına göre sıralamanız gerekir. Kullanıcının kültürü değişirse, sıralanmış dizelerin sırası da buna göre değişir. Örneğin, eş anlamlılar sözlüğü uygulaması sözcükleri her zaman kullanıcının kültürüne göre sıralamalıdır.

  • Dizelerin belirli bir kültürün kurallarına göre sıralanmasını istiyorsanız, karşılaştırma yöntemine bu kültürü temsil eden bir CultureInfo nesne sağlayarak bunları sıralamanız gerekir. Örneğin, öğrencilere belirli bir dili öğretmek için tasarlanmış bir uygulamada, dizelerin bu dili konuşan kültürlerden birinin kurallarına göre sıralanmasını istersiniz.

  • Dizelerin sırasının kültürler arasında değişmeden kalmasını istiyorsanız, bunları sabit kültürün kurallarına göre sıralamanız veya sıralı bir karşılaştırma kullanmanız gerekir. Örneğin, dosyaların, işlemlerin, mutex'lerin veya adlandırılmış kanalların adlarını düzenlemek için sıralı bir sıralama kullanırsınız.

  • Bir güvenlik kararı (örneğin kullanıcı adının geçerli olup olmadığı) içeren bir karşılaştırma için, yöntemin aşırı yüklemesini Equals çağırarak her zaman eşitlik için sıralı bir test gerçekleştirmeniz gerekir.

Not

Dize karşılaştırmasında kullanılan kültüre duyarlı sıralama ve büyük/küçük harf kuralları .NET sürümüne bağlıdır. .NET Core'da dize karşılaştırması, temel alınan işletim sistemi tarafından desteklenen Unicode Standardı sürümüne bağlıdır. Windows 8 veya sonraki sürümlerde çalıştırılan .NET Framework 4.5 ve üzeri sürümlerde sıralama, büyük/küçük harf, normalleştirme ve Unicode karakter bilgileri Unicode 6.0 standardına uygundur. Diğer Windows işletim sistemlerinde Unicode 5.0 standardına uygundur.

Sözcük, dize ve sıralı sıralama kuralları hakkında daha fazla bilgi için konuya bakın System.Globalization.CompareOptions . Her kuralın ne zaman kullanılacağına ilişkin ek öneriler için bkz. Dizeleri Kullanmak için En İyi Yöntemler.

Normalde, dizelerin sıralama düzenini belirlemek için doğrudan gibi Compare dize karşılaştırma yöntemlerini çağırmazsınız. Bunun yerine, karşılaştırma yöntemleri veya List<T>.Sortgibi Array.Sort sıralama yöntemleriyle çağrılır. Aşağıdaki örnek, kullanılacak karşılaştırma türünü belirtmelerine rağmen, dize karşılaştırma yöntemini açıkça çağırmadan dört farklı sıralama işlemi (geçerli kültür kullanılarak sözcük sıralama, sabit kültür kullanılarak sözcük sıralama, sıralı sıralama ve sabit kültürü kullanarak dize sıralama) gerçekleştirir. Her sıralama türünün dizisinde dizelerin benzersiz bir sıralamasını ürettiğini unutmayın.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

İpucu

.NET, kültürel açıdan hassas dize karşılaştırmasını desteklemek için dahili olarak sıralama anahtarlarını kullanır. Bir dizedeki her karaktere alfabetik, büyük/küçük harf ve aksan gibi çeşitli sıralama ağırlıkları kategorisi verilir. sınıfı tarafından SortKey temsil edilen sıralama anahtarı, belirli bir dize için bu ağırlıkların deposunu sağlar. Uygulamanız aynı dize kümesinde çok sayıda arama veya sıralama işlemi gerçekleştiriyorsa, kullandığı tüm dizeler için sıralama anahtarları oluşturup depolayarak performansını geliştirebilirsiniz. Sıralama veya karşılaştırma işlemi gerektiğinde, dizeler yerine sıralama anahtarlarını kullanırsınız. Daha fazla bilgi için sınıfına SortKey bakın.

Dize karşılaştırma kuralı belirtmezseniz, dizelerde kültüre duyarlı, büyük/küçük harfe duyarlı sıralama gerçekleştirme gibi Array.Sort(Array) sıralama yöntemleri. Aşağıdaki örnekte, geçerli kültürü değiştirmenin dizideki sıralanmış dizelerin sırasını nasıl etkilediği gösterilmektedir. Üç dizeden oluşan bir dizi oluşturur. İlk olarak, özelliğini en-US olarak ayarlar System.Threading.Thread.CurrentThread.CurrentCulture ve yöntemini çağırır Array.Sort(Array) . Sonuçta elde edilen sıralama düzeni, İngilizce (Birleşik Devletler) kültürü için sıralama kurallarını temel alır. Ardından, örnek özelliğini da-DK olarak ayarlar System.Threading.Thread.CurrentThread.CurrentCulture ve yöntemini yeniden çağırır Array.Sort . Danca (Danimarka) için sıralama kurallarını kullandığından elde edilen sıralama düzeninin en-US sonuçlarından nasıl farklı olduğunu görebilirsiniz.

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

Uyarı

Dizeleri karşılaştırmadaki birincil amacınız eşit olup olmadıklarını belirlemekse yöntemini çağırmanız String.Equals gerekir. Genellikle, sıralı bir karşılaştırma yapmak için kullanmanız Equals gerekir. String.Compare yöntemi öncelikle dizeleri sıralamak için tasarlanmıştır.

ve String.IndexOfgibi String.StartsWith dize arama yöntemleri kültüre duyarlı veya sıralı dize karşılaştırmaları da gerçekleştirebilir. Aşağıdaki örnekte, yöntemini kullanarak IndexOf sıra ve kültüre duyarlı karşılaştırmalar arasındaki farklar gösterilmektedir. Geçerli kültürün İngilizce (Birleşik Devletler) olduğu kültüre duyarlı bir arama, "œ" ligatürüyle eşleşecek şekilde "oe" alt dizesini dikkate alır. Yumuşak kısa çizgi (U+00AD) sıfır genişlikli bir karakter olduğundan, arama yumuşak kısa çizgiye Empty eşdeğer olarak davranır ve dizenin başında bir eşleşme bulur. Öte yandan sıralı arama her iki durumda da eşleşme bulamaz.

using namespace System;

void FindInString(String^ s, String^ substring, StringComparison options);

void main()
{
   // Search for "oe" and "�u" in "�ufs" and "oeufs".
   String^ s1 = L"�ufs";
   String^ s2 = L"oeufs";
   FindInString(s1, "oe", StringComparison::CurrentCulture);
   FindInString(s1, "oe", StringComparison::Ordinal);
   FindInString(s2, "�u", StringComparison::CurrentCulture);
   FindInString(s2, "�u", StringComparison::Ordinal);
   Console::WriteLine();

   String^ s3 = L"co\x00ADoperative";
   FindInString(s3, L"\x00AD", StringComparison::CurrentCulture);
   FindInString(s3, L"\x00AD", StringComparison::Ordinal);
}

void FindInString(String^ s, String^ substring, StringComparison options)
{
   int result = s->IndexOf(substring, options);
   if (result != -1)
      Console::WriteLine("'{0}' found in {1} at position {2}", 
                        substring, s, result);
   else
      Console::WriteLine("'{0}' not found in {1}", 
                        substring, s);                                                  
}
// The example displays the following output:
//      'oe' found in oufs at position 0
//      'oe' not found in oufs
//      'ou' found in oeufs at position 0
//      'ou' not found in oeufs
//
//      '-' found in co-operative at position 0
//      '-' found in co-operative at position 2
using System;

public class Example
{
   public static void Main()
   {
      // Search for "oe" and "œu" in "œufs" and "oeufs".
      string s1 = "œufs";
      string s2 = "oeufs";
      FindInString(s1, "oe", StringComparison.CurrentCulture);
      FindInString(s1, "oe", StringComparison.Ordinal);
      FindInString(s2, "œu", StringComparison.CurrentCulture);
      FindInString(s2, "œu", StringComparison.Ordinal);
      Console.WriteLine();
      
      string s3 = "co\u00ADoperative";
      FindInString(s3, "\u00AD", StringComparison.CurrentCulture);
      FindInString(s3, "\u00AD", StringComparison.Ordinal);
   }

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

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

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

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

// The example displays the following output:
//       'oe' found in œufs at position 0
//       'oe' not found in œufs
//       'œu' found in oeufs at position 0
//       'œu' not found in oeufs
//
//       '­' found in co­operative at position 0
//       '­' found in co­operative at position 2
Module Example
   Public Sub Main()
      ' Search for "oe" and "œu" in "œufs" and "oeufs".
      Dim s1 As String = "œufs"
      Dim s2 As String = "oeufs"
      FindInString(s1, "oe", StringComparison.CurrentCulture)
      FindInString(s1, "oe", StringComparison.Ordinal)
      FindInString(s2, "œu", StringComparison.CurrentCulture)
      FindInString(s2, "œu", StringComparison.Ordinal)
      Console.WriteLine()
      
      Dim softHyphen As String = ChrW(&h00AD)
      Dim s3 As String = "co" + softHyphen + "operative"
      FindInString(s3, softHyphen, StringComparison.CurrentCulture)
      FindInString(s3, softHyphen, StringComparison.Ordinal)
   End Sub

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

Dizelerde arama

ve String.IndexOfgibi String.StartsWith dize arama yöntemleri, bir karakterin veya alt dizenin belirtilen dizede bulunup bulunmadığını belirlemek için kültüre duyarlı veya sıralı dize karşılaştırmaları da gerçekleştirebilir.

sınıfındaki String yöntem gibi tek bir karakteri veya yöntem gibi IndexOf bir dizi karakterden IndexOfAny birini arayan arama yöntemleri sıralı bir arama gerçekleştirir. Bir karakter için kültüre duyarlı bir arama gerçekleştirmek için veya CompareInfo.LastIndexOf(String, Char)gibi CompareInfo.IndexOf(String, Char) bir CompareInfo yöntemi çağırmanız gerekir. Sıralı ve kültüre duyarlı karşılaştırma kullanarak bir karakter aramanın sonuçlarının çok farklı olabileceğini unutmayın. Örneğin, "Æ" (U+00C6) ligatürü gibi önceden derlenmiş bir Unicode karakteri için yapılan bir arama, bileşenlerinin kültüre bağlı olarak "AE" (U+041U+0045) gibi doğru dizideki herhangi bir oluşumuyla eşleşebilir. Aşağıdaki örnekte, tek bir karakter aranırken ve CompareInfo.IndexOf(String, Char) yöntemleri arasındaki String.IndexOf(Char) fark gösterilmektedir. "æ" (U+00E6) ligatürü, en-US kültürünün kurallarını kullanırken "havadan" dizesinde bulunur, ancak da-DK kültürünün kurallarını kullanırken veya sıralı karşılaştırma yaparken bulunmaz.

using System;
using System.Globalization;

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

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

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

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

Öte yandan, bir karakter yerine bir dizeyi arayan sınıf yöntemleri, String arama seçenekleri türündeki StringComparisonbir parametre tarafından açıkça belirtilmezse kültüre duyarlı bir arama gerçekleştirir. Tek istisna, sıralı bir arama gerçekleştiren 'dir Contains.

Eşitlik sınaması

Sıralama düzenindeki String.Compare iki dizenin ilişkisini belirlemek için yöntemini kullanın. Bu genellikle kültüre duyarlı bir işlemdir. Buna karşılık, eşitliği test etmek için yöntemini çağırın String.Equals . Eşitlik testi genellikle kullanıcı girişini geçerli bir kullanıcı adı, parola veya dosya sistemi yolu gibi bilinen bir dizeyle karşılaştırdığından, bu genellikle sıralı bir işlemdir.

Uyarı

yöntemini çağırarak ve dönüş değerinin String.Compare sıfır olup olmadığını belirleyerek eşitliği test etmek mümkündür. Ancak, bu uygulama önerilmez. İki dizenin eşit olup olmadığını belirlemek için yönteminin aşırı yüklemelerinden String.Equals birini çağırmanız gerekir. Çağrılmak için tercih edilen aşırı yükleme, örnek Equals(String, StringComparison) yöntemi veya statik Equals(String, String, StringComparison) yöntemdir, çünkü her iki yöntem de karşılaştırma türünü açıkça belirten bir System.StringComparison parametre içerir.

Aşağıdaki örnekte, bunun yerine sıralı bir karşılaştırma kullanılması gerektiğinde eşitlik için kültüre duyarlı bir karşılaştırma yapma tehlikesi gösterilmektedir. Bu durumda kodun amacı, "FILE://" veya "file://" ile başlayan URL'lerden dosya sistemi erişimini yasaklayarak url'nin başlangıcını "FILE://" dizesiyle büyük/küçük harfe duyarsız bir şekilde karşılaştırmaktır. Ancak " file://" ile başlayan bir URL üzerinde Türkçe (Türkiye) kültürü kullanılarak kültüre duyarlı bir karşılaştırma yapılırsa, eşitlik karşılaştırması başarısız olur, çünkü küçük harf "i" nin Türkçe büyük harfi "I" yerine "İ" olur. Sonuç olarak, dosya sistemi erişimine yanlışlıkla izin verilir. Öte yandan, sıralı bir karşılaştırma yapılırsa, eşitlik karşılaştırması başarılı olur ve dosya sistemi erişimi reddedilir.

using namespace System;
using namespace System::Globalization;
using namespace System::Threading;

bool TestForEquality(String^ str, StringComparison cmp);

void main()
{
   Thread::CurrentThread->CurrentCulture = CultureInfo::CreateSpecificCulture("tr-TR");      

   String^ filePath = "file://c:/notes.txt";

   Console::WriteLine("Culture-sensitive test for equality:");
   if (! TestForEquality(filePath, StringComparison::CurrentCultureIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);

   Console::WriteLine("\nOrdinal test for equality:");
   if (! TestForEquality(filePath, StringComparison::OrdinalIgnoreCase))
      Console::WriteLine("Access to {0} is allowed.", filePath);
   else
      Console::WriteLine("Access to {0} is not allowed.", filePath);
}

bool TestForEquality(String^ str, StringComparison cmp)
{
      int position = str->IndexOf("://");
      if (position < 0) return false;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Normalleştirme

Bazı Unicode karakterlerinin birden çok gösterimi vardır. Örneğin, aşağıdaki kod noktalarından herhangi biri "ắ" harfini temsil edebilir:

  • U+1EAF

  • U+0103 U+0301

  • U+0061 U+0306 U+0301

Tek bir karakter için birden çok gösterim arama, sıralama, eşleştirme ve diğer dize işlemlerini karmaşıklaştırır.

Unicode standardı, eşdeğer ikili gösterimlerinden herhangi biri için bir Unicode karakterinin bir ikili gösterimini döndüren normalleştirme adlı bir işlemi tanımlar. Normalleştirme, farklı kurallara uyan ve normalleştirme formları olarak adlandırılan çeşitli algoritmalar kullanabilir. .NET, C, D, KC ve KD Unicode normalleştirme formlarını destekler. Dizeler aynı normalleştirme formuna normalleştirildiğinde sıralı karşılaştırma kullanılarak karşılaştırılabilir.

Sıralı karşılaştırma, her dizedeki karşılık gelen Char nesnelerin Unicode skaler değerinin ikili karşılaştırmasıdır. sınıfı, String aşağıdakiler de dahil olmak üzere sıralı karşılaştırma gerçekleştirebilen bir dizi yöntem içerir:

Yöntemini çağırarak String.IsNormalized() bir dizenin C normalleştirme formuna normalleştirilip normalleştirilmediğini belirleyebilir veya bir dizenin String.IsNormalized(NormalizationForm) belirtilen normalleştirme formuna normalleştirilip normalleştirilmediğini belirlemek için yöntemini çağırabilirsiniz. Ayrıca bir dizeyi String.Normalize() C normalleştirme formuna dönüştürmek için yöntemini çağırabilir veya bir dizeyi String.Normalize(NormalizationForm) belirtilen normalleştirme formuna dönüştürmek için yöntemini çağırabilirsiniz. Dizeleri normalleştirme ve karşılaştırma hakkında adım adım bilgi için ve Normalize(NormalizationForm) yöntemlerine Normalize() bakın.

Aşağıdaki basit örnekte dize normalleştirmesi gösterilmektedir. Üç farklı dizede üç farklı şekilde "ố" harfini tanımlar ve her dizenin diğer iki dizeden farklı olduğunu belirlemek için eşitlik için sıralı bir karşılaştırma kullanır. Ardından her dizeyi desteklenen normalleştirme formlarına dönüştürür ve yine belirtilen normalleştirme formundaki her dizenin sıralı karşılaştırmasını gerçekleştirir. Her durumda, ikinci eşitlik testi dizelerin eşit olduğunu gösterir.

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

public ref class Example
{
private:
   StreamWriter^ sw;

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

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

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

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

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

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

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

      sw->Close(); 
   }
};

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Normalleştirme ve normalleştirme formları hakkında daha fazla bilgi için unicode.org web sitesindeki Unicode Standart Ek #15: Unicode Normalleştirme Formları ve Normalleştirme SSS bölümüne bakınSystem.Text.NormalizationForm.

Kategoriye göre dize işlemleri

String sınıfı dizeleri karşılaştırmak, dizeleri eşitlik için test etme, dizedeki karakterleri veya alt dizeleri bulma, dizeyi değiştirme, dizeden alt dize ayıklama, dizeleri birleştirme, değerleri biçimlendirme, dizeyi kopyalama ve bir dizeyi normalleştirme için üyeler sağlar.

Dizeleri karşılaştırma

Aşağıdaki String yöntemleri kullanarak sıralama düzenindeki göreli konumlarını belirlemek için dizeleri karşılaştırabilirsiniz:

  • Compare , bir dizenin sıralama düzenindeki ikinci bir dizeyle ilişkisini gösteren bir tamsayı döndürür.

  • CompareOrdinal , kod noktalarının karşılaştırmasına göre bir dizenin ikinci bir dizeyle ilişkisini gösteren bir tamsayı döndürür.

  • CompareTo geçerli dize örneğinin sıralama düzenindeki ikinci bir dizeyle ilişkisini gösteren bir tamsayı döndürür. yöntemi, CompareTo(String) sınıfı için String ve IComparable<T> uygulamalarını sağlarIComparable.

Eşitlik için dizeleri test etme

İki dizenin Equals eşit olup olmadığını belirlemek için yöntemini çağırırsınız. Örnek Equals(String, String, StringComparison) ve statik Equals(String, StringComparison) aşırı yüklemeler, karşılaştırmanın kültüre duyarlı mı yoksa sıralı mı olduğunu ve büyük/küçük harf dikkate alınıp alınmayacağını belirtmenize olanak tanır. Eşitlik testlerinin çoğu sıralıdır ve bir sistem kaynağına (dosya sistemi nesnesi gibi) erişimi belirleyen eşitlik karşılaştırmaları her zaman sıralı olmalıdır.

Dizedeki karakterleri bulma

String sınıfı iki tür arama yöntemi içerir:

Uyarı

Bir dizede belirli bir alt dize yerine belirli bir deseni aramak istiyorsanız, normal ifadeler kullanmanız gerekir. Daha fazla bilgi için bkz . .NET Normal İfadeleri.

Dizeyi değiştirme

sınıfı, String bir dizenin değerini değiştirmek için görünen aşağıdaki yöntemleri içerir:

  • Insert geçerli String örneğe bir dize ekler.

  • PadLeft bir dizenin başına belirtilen bir karakterin bir veya daha fazla örneğini ekler.

  • PadRight bir dizenin sonuna belirtilen karakterin bir veya daha fazla örneğini ekler.

  • Remove geçerli String örnekten bir alt dize siler.

  • Replace geçerli örnekteki bir alt dizeyi String başka bir alt dizeyle değiştirir.

  • ToLower ve ToLowerInvariant bir dizedeki tüm karakterleri küçük harfe dönüştürün.

  • ToUpper ve ToUpperInvariant bir dizedeki tüm karakterleri büyük harfe dönüştürün.

  • Trim bir dizenin başından ve sonundan karakterin tüm oluşumlarını kaldırır.

  • TrimEnd bir karakterin dizenin sonundan tüm oluşumlarını kaldırır.

  • TrimStart bir karakterin tüm oluşumlarını dizenin başından kaldırır.

Önemli

Tüm dize değiştirme yöntemleri yeni String bir nesne döndürür. Geçerli örneğin değerini değiştirmezler.

Dizeden alt dize ayıklama

yöntemi tek String.Split bir dizeyi birden çok dizeye ayırır. yönteminin aşırı yüklemeleri, yöntemin ayıkladığı alt dize sayısını sınırlamak, alt dizelerden boşluk kırpmak ve boş dizelerin (sınırlayıcılar bitişik olduğunda gerçekleşir) döndürülen dizeler arasına eklenip eklenmeyeceğini belirtmenize olanak sağlar.

Dizeleri birleştirme

Dize birleştirme için aşağıdaki String yöntemler kullanılabilir:

  • Concat bir veya daha fazla alt dizeyi tek bir dizede birleştirir.

  • Join bir veya daha fazla alt dizeyi tek bir öğede birleştirir ve her alt dize arasına bir ayırıcı ekler.

Değerleri biçimlendirme

yöntemi, String.Format bir dizedeki bir veya daha fazla yer tutucuyu bazı nesne veya değerin dize gösterimiyle değiştirmek için bileşik biçimlendirme özelliğini kullanır. Format yöntemi genellikle aşağıdakileri yapmak için kullanılır:

  • Sayısal değerin dize gösterimini bir dizeye eklemek için.

  • Bir tarih ve saat değerinin dize gösterimini bir dizeye eklemek için.

  • Bir sabit listesi değerinin dize gösterimini bir dizeye eklemek için.

  • Arabirimi destekleyen bir nesnenin dize gösterimini bir dizeye IFormattable eklemek için.

  • Daha büyük bir dize içindeki bir alanda alt dizeyi sağa yaslama veya sola yaslama.

Biçimlendirme işlemleri ve örnekler hakkında ayrıntılı bilgi için bkz Format . aşırı yükleme özeti.

Dize kopyalama

Bir dizenin kopyasını oluşturmak için aşağıdaki String yöntemleri çağırabilirsiniz:

  • Clone var olan String bir nesneye başvuru döndürür.

  • Copy var olan bir dizenin kopyasını oluşturur.

  • CopyTo dizenin bir bölümünü bir karakter dizisine kopyalar.

Dizeyi normalleştirme

Unicode'da tek bir karakter birden çok kod noktasına sahip olabilir. Normalleştirme, bu eşdeğer karakterleri aynı ikili gösterime dönüştürür. String.Normalize yöntemi normalleştirmeyi gerçekleştirir ve yöntemi bir dizenin String.IsNormalized normalleştirilip normalleştirilmediğini belirler.

Daha fazla bilgi ve örnek için bu konunun önceki bölümlerinde yer alan Normalleştirme bölümüne bakın.

Oluşturucular

String(Char*)

Sınıfın String yeni bir örneğini, belirtilen bir Unicode karakter dizisi işaretçisi tarafından belirtilen değere başlatır.

String(Char*, Int32, Int32)

Sınıfın String yeni bir örneğini, belirtilen bir Unicode karakter dizisi işaretçisi tarafından belirtilen değere, bu dizi içinde bir başlangıç karakteri konumuna ve bir uzunluğa başlatır.

String(Char, Int32)

Sınıfın String yeni bir örneğini belirtilen sayıda yinelenen belirtilen Unicode karakteriyle belirtilen değere başlatır.

String(Char[])

Belirtilen karakter dizisinde belirtilen Unicode karakterlerine sınıfın yeni bir örneğini String başlatır.

String(Char[], Int32, Int32)

Sınıfın String yeni bir örneğini unicode karakter dizisi, bu dizi içinde bir başlangıç karakteri konumu ve bir uzunluk ile belirtilen değere başlatır.

String(ReadOnlySpan<Char>)

Sınıfın String yeni bir örneğini, belirtilen salt okunur yayılma alanında belirtilen Unicode karakterlerine başlatır.

String(SByte*)

Sınıfın String yeni bir örneğini, 8 bit imzalı tamsayılar dizisinin işaretçisi ile gösterilen değere başlatır.

String(SByte*, Int32, Int32)

Sınıfın String yeni bir örneğini, 8 bit imzalı tamsayılardan oluşan bir diziye, bu dizi içinde bir başlangıç konumuna ve bir uzunluğa işaret eden belirtilen işaretçiyle belirtilen değere başlatır.

String(SByte*, Int32, Int32, Encoding)

Sınıfın String yeni bir örneğini 8 bit imzalı tamsayılar dizisi, bu dizi içinde başlangıç konumu, uzunluk ve Encoding nesnenin belirtilen işaretçisi tarafından belirtilen değere başlatır.

Alanlar

Empty

Boş dizeyi temsil eder. Bu alan salt okunur durumdadır.

Özellikler

Chars[Int32]

Char Nesneyi geçerli String nesnede belirtilen konumda alır.

Length

Geçerli String nesnedeki karakter sayısını alır.

Yöntemler

Clone()

Bu örneğine Stringbir başvuru döndürür.

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

Belirtilen String iki nesnenin alt dizelerini karşılaştırır ve sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.

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

Belirtilen String iki nesnenin alt dizelerini karşılaştırır, büyük/küçük harflerini yoksayır veya dikkate alır ve sıralama düzenindeki göreli konumlarını belirten bir tamsayı döndürür.

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

Belirtilen String iki nesnenin alt dizelerini karşılaştırır, büyük/küçük harflerini yok sayar veya dikkate alır ve karşılaştırmayı etkilemek için kültüre özgü bilgileri kullanarak sıralama düzenindeki göreli konumlarını gösteren bir tamsayı döndürür.

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

Karşılaştırmayı etkilemek için belirtilen karşılaştırma seçeneklerini ve kültüre özgü bilgileri kullanarak belirtilen String iki nesnenin alt dizelerini karşılaştırır ve iki alt dizenin sıralama düzeninde birbiriyle ilişkisini gösteren bir tamsayı döndürür.

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

Belirtilen kuralları kullanarak belirtilen String iki nesnenin alt dizelerini karşılaştırır ve sıralama düzenindeki göreli konumlarını gösteren bir tamsayı döndürür.

Compare(String, String)

Belirtilen String iki nesneyi karşılaştırır ve sıralama düzenindeki göreli konumlarını gösteren bir tamsayı döndürür.

Compare(String, String, Boolean)

Belirtilen String iki nesneyi karşılaştırır, büyük/küçük harflerini yoksayır veya dikkate alır ve sıralama düzenindeki göreli konumlarını belirten bir tamsayı döndürür.

Compare(String, String, Boolean, CultureInfo)

Belirtilen String iki nesneyi karşılaştırır, büyük/küçük harflerini yoksayarak veya dikkate alır ve karşılaştırmayı etkilemek için kültüre özgü bilgileri kullanarak sıralama düzenindeki göreli konumlarını gösteren bir tamsayı döndürür.

Compare(String, String, CultureInfo, CompareOptions)

Karşılaştırmayı etkilemek için belirtilen karşılaştırma seçeneklerini ve kültüre özgü bilgileri kullanarak belirtilen String iki nesneyi karşılaştırır ve iki dizenin sıralama düzeninde birbiriyle ilişkisini gösteren bir tamsayı döndürür.

Compare(String, String, StringComparison)

Belirtilen kuralları kullanarak belirtilen String iki nesneyi karşılaştırır ve sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.

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

Her alt dizedeki ilgili Char nesnelerin sayısal değerlerini değerlendirerek belirtilen String iki nesnenin alt dizelerini karşılaştırır.

CompareOrdinal(String, String)

Her dizedeki ilgili Char nesnelerin sayısal değerlerini değerlendirerek belirtilen String iki nesneyi karşılaştırır.

CompareTo(Object)

Bu örneği belirtilen Object bir ile karşılaştırır ve bu örneğin belirtilen ile aynı sıralama düzeninde Objectönce mi, takip mi yoksa aynı konumda mı göründüğünü gösterir.

CompareTo(String)

Bu örneği belirtilen String bir nesneyle karşılaştırır ve bu örneğin belirtilen dizeyle aynı sıralama düzeninde önce mi, takip mi yoksa aynı konumda mı göründüğünü gösterir.

Concat(IEnumerable<String>)

türündeki Stringbir derlenen IEnumerable<T> koleksiyonun üyelerini birleştirir.

Concat(Object)

Belirtilen nesnenin dize gösterimini oluşturur.

Concat(Object, Object)

Belirtilen iki nesnenin dize gösterimlerini birleştirir.

Concat(Object, Object, Object)

Belirtilen üç nesnenin dize gösterimlerini birleştirir.

Concat(Object, Object, Object, Object)

Belirtilen dört nesnenin dize gösterimlerini ve isteğe bağlı değişken uzunluğu parametre listesinde belirtilen nesneleri birleştirir.

Concat(Object[])

Belirtilen Object dizideki öğelerin dize gösterimlerini birleştirir.

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

Belirtilen iki salt okunur karakter aralığının dize gösterimlerini birleştirir.

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

Belirtilen üç salt okunur karakter aralığının dize gösterimlerini birleştirir.

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

Belirtilen dört salt okunur karakter aralığının dize gösterimlerini birleştirir.

Concat(String, String)

belirtilen iki örneğini Stringbirleştirir.

Concat(String, String, String)

Belirtilen üç örneğini Stringbirleştirir.

Concat(String, String, String, String)

Belirtilen dört örneğini Stringbirleştirir.

Concat(String[])

Belirtilen String dizinin öğelerini birleştirir.

Concat<T>(IEnumerable<T>)

Bir uygulamanın üyelerini birleştirir IEnumerable<T> .

Contains(Char)

Belirtilen karakterin bu dize içinde olup olmadığını belirten bir değer döndürür.

Contains(Char, StringComparison)

Belirtilen karşılaştırma kurallarını kullanarak belirtilen karakterin bu dizede olup olmadığını belirten bir değer döndürür.

Contains(String)

Belirtilen bir alt dizenin bu dize içinde olup olmadığını belirten bir değer döndürür.

Contains(String, StringComparison)

Belirtilen karşılaştırma kurallarını kullanarak belirtilen dizenin bu dize içinde olup olmadığını belirten bir değer döndürür.

Copy(String)
Kullanımdan kalktı.

Belirtilen Stringile aynı değere sahip yeni bir örneği String oluşturur.

CopyTo(Int32, Char[], Int32, Int32)

Belirtilen sayıda karakteri bu örnekte belirtilen konumdan Unicode karakter dizisindeki belirtilen konuma kopyalar.

CopyTo(Span<Char>)

Bu dizenin içeriğini hedef yayılma alanına kopyalar.

Create(IFormatProvider, DefaultInterpolatedStringHandler)

Belirtilen ilişkilendirilmiş dizenin biçimlendirmesini denetlemek için belirtilen sağlayıcıyı kullanarak yeni bir dize oluşturur.

Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)

Belirtilen ilişkilendirilmiş dizenin biçimlendirmesini denetlemek için belirtilen sağlayıcıyı kullanarak yeni bir dize oluşturur.

Create<TState>(Int32, TState, SpanAction<Char,TState>)

Belirli bir uzunluğa sahip yeni bir dize oluşturur ve belirtilen geri çağırmayı kullanarak oluşturulduktan sonra bu dizeyi başlatır.

EndsWith(Char)

Bu dize örneğinin sonunun belirtilen karakterle eşleşip eşleşmediğini belirler.

EndsWith(String)

Bu dize örneğinin sonunun belirtilen dizeyle eşleşip eşleşmediğini belirler.

EndsWith(String, Boolean, CultureInfo)

Belirtilen kültür kullanıldığında bu dize örneğinin sonunun belirtilen dizeyle eşleşip eşleşmediğini belirler.

EndsWith(String, StringComparison)

Belirtilen karşılaştırma seçeneği kullanıldığında bu dize örneğinin sonunun belirtilen dizeyle eşleşip eşleşmediğini belirler.

EnumerateRunes()

Bu dizeden bir numaralandırma Rune döndürür.

Equals(Object)

Bu örneğin ve aynı zamanda nesne olması gereken belirtilen bir String nesnenin aynı değere sahip olup olmadığını belirler.

Equals(String)

Bu örneğin ve belirtilen String başka bir nesnenin aynı değere sahip olup olmadığını belirler.

Equals(String, String)

Belirtilen String iki nesnenin aynı değere sahip olup olmadığını belirler.

Equals(String, String, StringComparison)

Belirtilen String iki nesnenin aynı değere sahip olup olmadığını belirler. Parametre, karşılaştırmada kullanılan kültür, durum ve sıralama kurallarını belirtir.

Equals(String, StringComparison)

Bu dizenin ve belirtilen String bir nesnenin aynı değere sahip olup olmadığını belirler. Parametre, karşılaştırmada kullanılan kültür, durum ve sıralama kurallarını belirtir.

Format(IFormatProvider, String, Object)

Belirtilen dizedeki biçim öğesini veya öğelerini ilgili nesnenin dize gösterimiyle değiştirir. Parametresi kültüre özgü biçimlendirme bilgileri sağlar.

Format(IFormatProvider, String, Object, Object)

Bir dizedeki biçim öğelerini belirtilen iki nesnenin dize gösterimiyle değiştirir. Parametresi kültüre özgü biçimlendirme bilgileri sağlar.

Format(IFormatProvider, String, Object, Object, Object)

Bir dizedeki biçim öğelerini belirtilen üç nesnenin dize gösterimiyle değiştirir. Bir parametre kültüre özgü biçimlendirme bilgileri sağlar.

Format(IFormatProvider, String, Object[])

Bir dizedeki biçim öğelerini, belirtilen dizideki karşılık gelen nesnelerin dize gösterimleriyle değiştirir. Parametresi kültüre özgü biçimlendirme bilgileri sağlar.

Format(String, Object)

Bir dizedeki bir veya daha fazla biçim öğesini belirtilen nesnenin dize gösterimiyle değiştirir.

Format(String, Object, Object)

Bir dizedeki biçim öğelerini belirtilen iki nesnenin dize gösterimiyle değiştirir.

Format(String, Object, Object, Object)

Bir dizedeki biçim öğelerini belirtilen üç nesnenin dize gösterimiyle değiştirir.

Format(String, Object[])

Belirtilen dizedeki biçim öğesini, belirtilen dizideki karşılık gelen bir nesnenin dize gösterimiyle değiştirir.

GetEnumerator()

Bu dizedeki tek tek karakterler arasında yineleme yapabilecek bir nesne alır.

GetHashCode()

Bu dizenin karma kodunu döndürür.

GetHashCode(ReadOnlySpan<Char>)

Sağlanan salt okunur karakter aralığı için karma kodu döndürür.

GetHashCode(ReadOnlySpan<Char>, StringComparison)

Belirtilen kuralları kullanarak sağlanan salt okunur karakter aralığı için karma kodu döndürür.

GetHashCode(StringComparison)

Belirtilen kuralları kullanarak bu dizenin karma kodunu döndürür.

GetPinnableReference()

Sıfır dizinindeki dizenin öğesine bir başvuru döndürür.

Bu yöntem .NET derleyicilerini desteklemeye yöneliktir ve kullanıcı kodu tarafından çağrılmak üzere tasarlanmamıştır.

GetType()

Type Geçerli örneğini alır.

(Devralındığı yer: Object)
GetTypeCode()

sınıfı için değerini TypeCodeString döndürür.

IndexOf(Char)

Bu dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini bildirir.

IndexOf(Char, Int32)

Bu dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini bildirir. Arama belirtilen karakter konumunda başlar.

IndexOf(Char, Int32, Int32)

Bu örnekte belirtilen karakterin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumunu inceler.

IndexOf(Char, StringComparison)

Bu dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini bildirir. Parametre, belirtilen karakter için kullanılacak arama türünü belirtir.

IndexOf(String)

Bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar.

IndexOf(String, Int32)

Bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar.

IndexOf(String, Int32, Int32)

Bu örnekte belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumunu inceler.

IndexOf(String, Int32, Int32, StringComparison)

Geçerli String nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametreler geçerli dizedeki başlangıç arama konumunu, aranacak geçerli dizedeki karakter sayısını ve belirtilen dize için kullanılacak arama türünü belirtir.

IndexOf(String, Int32, StringComparison)

Geçerli String nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametreler geçerli dizedeki başlangıç arama konumunu ve belirtilen dize için kullanılacak arama türünü belirtir.

IndexOf(String, StringComparison)

Geçerli String nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar. Parametresi, belirtilen dize için kullanılacak arama türünü belirtir.

IndexOfAny(Char[])

Belirtilen Unicode karakter dizisindeki herhangi bir karakterin bu örneğindeki ilk oluşumun sıfır tabanlı dizinini raporlar.

IndexOfAny(Char[], Int32)

Belirtilen Unicode karakter dizisindeki herhangi bir karakterin bu örneğindeki ilk oluşumun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar.

IndexOfAny(Char[], Int32, Int32)

Belirtilen Unicode karakter dizisindeki herhangi bir karakterin bu örneğindeki ilk oluşumun sıfır tabanlı dizinini raporlar. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumunu inceler.

Insert(Int32, String)

Bu örnekte belirtilen bir dizin konumunda belirtilen dizenin eklendiği yeni bir dize döndürür.

Intern(String)

Sistemin belirtilen Stringöğesine başvuruyu alır.

IsInterned(String)

Belirtilen Stringöğesine başvuru alır.

IsNormalized()

Bu dizenin C Unicode normalleştirme formunda olup olmadığını gösterir.

IsNormalized(NormalizationForm)

Bu dizenin belirtilen Unicode normalleştirme formunda olup olmadığını gösterir.

IsNullOrEmpty(String)

Belirtilen dizenin boş bir dize mi ("") olduğunu null gösterir.

IsNullOrWhiteSpace(String)

Belirtilen dizenin null, boş veya yalnızca boşluk karakterlerinden mi oluştuğuna işaret eder.

Join(Char, Object[])

Her üye arasında belirtilen ayırıcıyı kullanarak bir nesne dizisinin dize gösterimlerini birleştirir.

Join(Char, String[])

Her üye arasında belirtilen ayırıcıyı kullanarak bir dize dizisini birleştirir.

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

Her üye arasında belirtilen ayırıcıyı kullanarak, konumunda bulunan startIndex öğesinden value başlayarak ve öğelere kadar birleştirerek bir dize dizisini count birleştirir.

Join(String, IEnumerable<String>)

Her üye arasında belirtilen ayırıcıyı kullanarak türündeki Stringbir yapılı IEnumerable<T> koleksiyonun üyelerini birleştirir.

Join(String, Object[])

Her öğe arasında belirtilen ayırıcıyı kullanarak bir nesne dizisinin öğelerini birleştirir.

Join(String, String[])

Her öğe arasında belirtilen ayırıcıyı kullanarak bir dize dizisinin tüm öğelerini birleştirir.

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

Her öğe arasında belirtilen ayırıcıyı kullanarak bir dize dizisinin belirtilen öğelerini birleştirir.

Join<T>(Char, IEnumerable<T>)

Her üye arasında belirtilen ayırıcıyı kullanarak bir koleksiyonun üyelerini birleştirir.

Join<T>(String, IEnumerable<T>)

Her üye arasında belirtilen ayırıcıyı kullanarak bir koleksiyonun üyelerini birleştirir.

LastIndexOf(Char)

Bu örnekte belirtilen Unicode karakterinin son oluşumunun sıfır tabanlı dizin konumunu bildirir.

LastIndexOf(Char, Int32)

Bu örnekte belirtilen Unicode karakterinin son oluşumunun sıfır tabanlı dizin konumunu bildirir. Arama, belirtilen karakter konumunda başlar ve dizenin başına doğru geriye gider.

LastIndexOf(Char, Int32, Int32)

Bu örnekteki bir alt dizede belirtilen Unicode karakterinin son oluşumunun sıfır tabanlı dizin konumunu bildirir. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumu için dizenin başına doğru geriye doğru ilerler.

LastIndexOf(String)

Bu örnekte belirtilen bir dizenin son ortaya çıkışına ilişkin sıfır tabanlı bir dizin konumunu rapor eder.

LastIndexOf(String, Int32)

Bu örnekte belirtilen bir dizenin son ortaya çıkışına ilişkin sıfır tabanlı bir dizin konumunu rapor eder. Arama, belirtilen karakter konumunda başlar ve dizenin başına doğru geriye gider.

LastIndexOf(String, Int32, Int32)

Bu örnekte belirtilen bir dizenin son ortaya çıkışına ilişkin sıfır tabanlı bir dizin konumunu rapor eder. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumu için dizenin başına doğru geriye doğru ilerler.

LastIndexOf(String, Int32, Int32, StringComparison)

Bu örnekte belirtilen bir dizenin son ortaya çıkışına ilişkin sıfır tabanlı bir dizin konumunu rapor eder. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumu için dizenin başına doğru geriye doğru ilerler. Parametre, belirtilen dizeyi ararken gerçekleştirilecek karşılaştırma türünü belirtir.

LastIndexOf(String, Int32, StringComparison)

Belirtilen dizenin geçerli String nesne içinde son oluşumunun sıfır tabanlı dizinini raporlar. Arama, belirtilen karakter konumunda başlar ve dizenin başına doğru geriye gider. Parametre, belirtilen dizeyi ararken gerçekleştirilecek karşılaştırma türünü belirtir.

LastIndexOf(String, StringComparison)

Belirtilen dizenin geçerli String nesne içinde son oluşumunun sıfır tabanlı dizinini raporlar. Parametresi, belirtilen dize için kullanılacak arama türünü belirtir.

LastIndexOfAny(Char[])

Bir Unicode dizisinde belirtilen bir veya daha fazla karakterin bu örneğinde son olarak ortaya çıkışına ilişkin sıfır tabanlı konum dizinini rapor eder.

LastIndexOfAny(Char[], Int32)

Bir Unicode dizisinde belirtilen bir veya daha fazla karakterin bu örneğinde son olarak ortaya çıkışına ilişkin sıfır tabanlı konum dizinini rapor eder. Arama, belirtilen karakter konumunda başlar ve dizenin başına doğru geriye gider.

LastIndexOfAny(Char[], Int32, Int32)

Bir Unicode dizisinde belirtilen bir veya daha fazla karakterin bu örneğinde son olarak ortaya çıkışına ilişkin sıfır tabanlı konum dizinini rapor eder. Arama belirtilen karakter konumunda başlar ve belirtilen sayıda karakter konumu için dizenin başına doğru geriye doğru ilerler.

MemberwiseClone()

Geçerli Objectöğesinin sığ bir kopyasını oluşturur.

(Devralındığı yer: Object)
Normalize()

Metin değeri bu dizeyle aynı olan ancak ikili gösterimi C Unicode normalleştirme formunda olan yeni bir dize döndürür.

Normalize(NormalizationForm)

Metin değeri bu dizeyle aynı olan ancak ikili gösterimi belirtilen Unicode normalleştirme formunda olan yeni bir dize döndürür.

PadLeft(Int32)

Bu örnekteki karakterleri, belirtilen toplam uzunluk için solda boşluklarla doldurarak sağa hizalayan yeni bir dize döndürür.

PadLeft(Int32, Char)

Bu örnekteki karakterleri, belirtilen toplam uzunluğu için solda belirtilen unicode karakterle doldurarak sağa hizalayan yeni bir dize döndürür.

PadRight(Int32)

Belirtilen toplam uzunluk için, bu dizedeki karakterleri sağdaki boşluklarla doldurarak sola hizalayan yeni bir dize döndürür.

PadRight(Int32, Char)

Bu dizedeki karakterleri belirtilen toplam uzunluk için belirtilen Unicode karakteriyle sağda doldurarak sola hizalayan yeni bir dize döndürür.

Remove(Int32)

Belirtilen konumdan başlayıp son konumdan devam ederek geçerli örnekteki tüm karakterlerin silindiği yeni bir dize döndürür.

Remove(Int32, Int32)

Geçerli örnekte belirtilen konumdan başlayarak belirtilen sayıda karakterin silindiği yeni bir dize döndürür.

Replace(Char, Char)

Bu örnekte belirtilen Unicode karakterinin tüm oluşumlarının başka bir belirtilen Unicode karakteriyle değiştirildiği yeni bir dize döndürür.

Replace(String, String)

Geçerli örnekte belirtilen dizenin tüm oluşumlarının başka bir belirtilen dizeyle değiştirildiği yeni bir dize döndürür.

Replace(String, String, Boolean, CultureInfo)

Belirtilen dizenin geçerli örnekteki tüm oluşumlarının, sağlanan kültür ve büyük/küçük harf duyarlılığı kullanılarak başka bir belirtilen dizeyle değiştirildiği yeni bir dize döndürür.

Replace(String, String, StringComparison)

Belirtilen dizenin geçerli örnekteki tüm oluşumlarının, sağlanan karşılaştırma türü kullanılarak başka bir belirtilen dizeyle değiştirildiği yeni bir dize döndürür.

ReplaceLineEndings()

Geçerli dizedeki tüm yeni satır dizilerini ile NewLinedeğiştirir.

ReplaceLineEndings(String)

Geçerli dizedeki tüm yeni satır dizilerini ile replacementTextdeğiştirir.

Split(Char, Int32, StringSplitOptions)

Bir dizeyi belirtilen sınırlayıcı karaktere ve isteğe bağlı olarak seçeneklere göre en fazla sayıda alt dizeye böler. Sağlanan karakter ayırıcısına göre dizeyi en fazla alt dize sayısına böler ve isteğe bağlı olarak sonuçtan boş alt dizeleri atlar.

Split(Char, StringSplitOptions)

Bir dizeyi belirtilen sınırlayıcı karaktere ve isteğe bağlı olarak seçeneklere göre alt dizelere böler.

Split(Char[])

Belirtilen sınırlandırma karakterlerine göre bir dizeyi alt dizelere böler.

Split(Char[], Int32)

Belirtilen sınırlayıcı karakterlere göre bir dizeyi en fazla alt dize sayısına böler.

Split(Char[], Int32, StringSplitOptions)

Belirtilen sınırlandırma karakterlerine ve isteğe bağlı olarak seçeneklere göre bir dizeyi en fazla sayıda alt dizeye böler.

Split(Char[], StringSplitOptions)

Belirtilen sınırlandırma karakterlerine ve seçeneklerine göre bir dizeyi alt dizelere böler.

Split(String, Int32, StringSplitOptions)

Belirtilen sınırlayıcı dizeye ve isteğe bağlı olarak seçeneklere göre bir dizeyi en fazla sayıda alt dizeye böler.

Split(String, StringSplitOptions)

Bir dizeyi, sağlanan dize ayırıcısını temel alan alt dizelere böler.

Split(String[], Int32, StringSplitOptions)

Belirtilen sınırlayıcı dizelere ve isteğe bağlı olarak seçeneklere göre bir dizeyi en fazla sayıda alt dizeye böler.

Split(String[], StringSplitOptions)

Belirtilen sınırlayıcı dizeye ve isteğe bağlı olarak seçeneklere göre bir dizeyi alt dizelere böler.

StartsWith(Char)

Bu dize örneğinin belirtilen karakterle başlayıp başlamadığını belirler.

StartsWith(String)

Bu dize örneğinin başlangıcının belirtilen dizeyle eşleşip eşleşmediğini belirler.

StartsWith(String, Boolean, CultureInfo)

Belirtilen kültür kullanıldığında bu dize örneğinin başlangıcının belirtilen dizeyle eşleşip eşleşmediğini belirler.

StartsWith(String, StringComparison)

Belirtilen karşılaştırma seçeneği kullanıldığında bu dize örneğinin başlangıcının belirtilen dizeyle eşleşip eşleşmediğini belirler.

Substring(Int32)

Bu örnekten bir alt dize alır. Alt dize belirtilen karakter konumunda başlar ve dizenin sonuna kadar devam eder.

Substring(Int32, Int32)

Bu örnekten bir alt dize alır. Alt dize belirtilen karakter konumunda başlar ve belirtilen uzunluğa sahiptir.

ToCharArray()

Bu örnekteki karakterleri bir Unicode karakter dizisine kopyalar.

ToCharArray(Int32, Int32)

Bu örnekte belirtilen bir alt dizedeki karakterleri bir Unicode karakter dizisine kopyalar.

ToLower()

Bu dizenin küçük harfe dönüştürülmüş bir kopyasını döndürür.

ToLower(CultureInfo)

Belirtilen kültürün büyük/küçük harf kurallarını kullanarak bu dizenin küçük harfe dönüştürülmüş bir kopyasını döndürür.

ToLowerInvariant()

Sabit kültürün büyük/küçük harf kurallarını kullanarak bu String nesnenin küçük harfe dönüştürülmüş bir kopyasını döndürür.

ToString()

Öğesinin bu örneğini Stringdöndürür; gerçek dönüştürme işlemi yapılmaz.

ToString(IFormatProvider)

Öğesinin bu örneğini Stringdöndürür; gerçek dönüştürme işlemi yapılmaz.

ToUpper()

Bu dizenin büyük harfe dönüştürülmüş bir kopyasını döndürür.

ToUpper(CultureInfo)

Belirtilen kültürün büyük/küçük harf kurallarını kullanarak bu dizenin büyük harfe dönüştürülmüş bir kopyasını döndürür.

ToUpperInvariant()

Sabit kültürün büyük/küçük harf kurallarını kullanarak bu String nesnenin büyük harfe dönüştürülmüş bir kopyasını döndürür.

Trim()

Geçerli dizeden baştaki ve sondaki tüm boşluk karakterlerini kaldırır.

Trim(Char)

Geçerli dizeden bir karakterin tüm baştaki ve sondaki örneklerini kaldırır.

Trim(Char[])

Bir dizide belirtilen bir karakter kümesinin tüm baştaki ve sondaki oluşumlarını geçerli dizeden kaldırır.

TrimEnd()

Geçerli dizeden sondaki tüm boşluk karakterlerini kaldırır.

TrimEnd(Char)

Geçerli dizeden bir karakterin sondaki tüm oluşumlarını kaldırır.

TrimEnd(Char[])

Bir dizide belirtilen karakter kümesinin sondaki tüm oluşumlarını geçerli dizeden kaldırır.

TrimStart()

Geçerli dizeden baştaki tüm boşluk karakterlerini kaldırır.

TrimStart(Char)

Belirtilen karakterin geçerli dizeden baştaki tüm oluşumlarını kaldırır.

TrimStart(Char[])

Bir dizide belirtilen bir karakter kümesinin tüm baştaki oluşumlarını geçerli dizeden kaldırır.

TryCopyTo(Span<Char>)

Bu dizenin içeriğini hedef yayılma alanına kopyalar.

İşleçler

Equality(String, String)

Belirtilen iki dizenin aynı değere sahip olup olmadığını belirler.

Implicit(String to ReadOnlySpan<Char>)

Belirli bir dizenin, karakterlerin salt okunur bir aralığına örtük bir dönüştürmesini tanımlar.

Inequality(String, String)

Belirtilen iki dizenin farklı değerlere sahip olup olmadığını belirler.

Belirtik Arabirim Kullanımları

IComparable.CompareTo(Object)

Bu örneği belirtilen Object bir ile karşılaştırır ve bu örneğin belirtilen ile aynı sıralama düzeninde Objectönce gelip gelmeyeceğini, takip edip etmediğini veya aynı konumda görüntülenip görüntülenmediğini gösterir.

IConvertible.GetTypeCode()

sınıfı için değerini TypeCodeString döndürür.

IConvertible.ToBoolean(IFormatProvider)

Bu üyenin açıklaması için bkz ToBoolean(IFormatProvider). .

IConvertible.ToByte(IFormatProvider)

Bu üyenin açıklaması için bkz ToByte(IFormatProvider). .

IConvertible.ToChar(IFormatProvider)

Bu üyenin açıklaması için bkz ToChar(IFormatProvider). .

IConvertible.ToDateTime(IFormatProvider)

Bu üyenin açıklaması için bkz ToDateTime(IFormatProvider). .

IConvertible.ToDecimal(IFormatProvider)

Bu üyenin açıklaması için bkz ToDecimal(IFormatProvider). .

IConvertible.ToDouble(IFormatProvider)

Bu üyenin açıklaması için bkz ToDouble(IFormatProvider). .

IConvertible.ToInt16(IFormatProvider)

Bu üyenin açıklaması için bkz ToInt16(IFormatProvider). .

IConvertible.ToInt32(IFormatProvider)

Bu üyenin açıklaması için bkz ToInt32(IFormatProvider). .

IConvertible.ToInt64(IFormatProvider)

Bu üyenin açıklaması için bkz ToInt64(IFormatProvider). .

IConvertible.ToSByte(IFormatProvider)

Bu üyenin açıklaması için bkz ToSByte(IFormatProvider). .

IConvertible.ToSingle(IFormatProvider)

Bu üyenin açıklaması için bkz ToSingle(IFormatProvider). .

IConvertible.ToString(IFormatProvider)

Bu üyenin açıklaması için bkz ToString(IFormatProvider). .

IConvertible.ToType(Type, IFormatProvider)

Bu üyenin açıklaması için bkz ToType(Type, IFormatProvider). .

IConvertible.ToUInt16(IFormatProvider)

Bu üyenin açıklaması için bkz ToUInt16(IFormatProvider). .

IConvertible.ToUInt32(IFormatProvider)

Bu üyenin açıklaması için bkz ToUInt32(IFormatProvider). .

IConvertible.ToUInt64(IFormatProvider)

Bu üyenin açıklaması için bkz ToUInt64(IFormatProvider). .

IEnumerable.GetEnumerator()

Geçerli String nesnede yineleyen bir numaralandırıcı döndürür.

IEnumerable<Char>.GetEnumerator()

Geçerli String nesnede yineleyen bir numaralandırıcı döndürür.

Uzantı Metotları

ToImmutableArray<TSource>(IEnumerable<TSource>)

Belirtilen koleksiyondan sabit bir dizi oluşturur.

ToImmutableDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Var olan bir öğe koleksiyonundan sabit bir sözlük oluşturur ve kaynak anahtarlara bir dönüştürme işlevi uygular.

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

Bir dizinin bazı dönüşümlerini temel alan sabit bir sözlük oluşturur.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Bir diziyi numaralandırır ve dönüştürür ve içeriğinin sabit bir sözlüğünü üretir.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>)

Bir diziyi numaralandırır ve dönüştürür ve belirtilen anahtar karşılaştırıcısını kullanarak içeriğinin sabit bir sözlüğünü üretir.

ToImmutableDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IEqualityComparer<TKey>, IEqualityComparer<TValue>)

Bir diziyi numaralandırır ve dönüştürür ve belirtilen anahtar ve değer karşılaştırıcılarını kullanarak içeriğinin sabit bir sözlüğünü üretir.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Bir diziyi numaralandırır ve içeriğinin sabit karma kümesini oluşturur.

ToImmutableHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Bir diziyi numaralandırır, içeriğinin sabit bir karma kümesini oluşturur ve küme türü için belirtilen eşitlik karşılaştırıcısını kullanır.

ToImmutableList<TSource>(IEnumerable<TSource>)

Bir diziyi numaralandırır ve içeriğinin sabit bir listesini oluşturur.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>)

Bir diziyi numaralandırır ve dönüştürür ve içeriğinin sabit sıralanmış bir sözlüğünü üretir.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>)

Bir diziyi numaralandırır ve dönüştürür ve belirtilen anahtar karşılaştırıcıyı kullanarak içeriğinin sabit sıralı bir sözlüğünü üretir.

ToImmutableSortedDictionary<TSource,TKey,TValue>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TValue>, IComparer<TKey>, IEqualityComparer<TValue>)

Bir diziyi numaralandırır ve dönüştürür ve belirtilen anahtar ve değer karşılaştırıcılarını kullanarak içeriğinin sabit sıralı bir sözlüğünü üretir.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Bir diziyi numaralandırır ve içeriğinin sabit sıralı bir kümesini oluşturur.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Bir diziyi numaralandırır, içeriğinin sabit sıralı bir kümesini oluşturur ve belirtilen karşılaştırıcıyı kullanır.

CopyToDataTable<T>(IEnumerable<T>)

DataTable Genel parametrenin TDataRowolduğu bir giriş IEnumerable<T> nesnesi verildiğinde nesnelerin kopyalarını DataRow içeren bir döndürür.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption)

DataRow Genel parametrenin TDataRowolduğu bir giriş IEnumerable<T> nesnesi verildiğinde nesneleri belirtilen DataTableöğesine kopyalar.

CopyToDataTable<T>(IEnumerable<T>, DataTable, LoadOption, FillErrorEventHandler)

DataRow Genel parametrenin TDataRowolduğu bir giriş IEnumerable<T> nesnesi verildiğinde nesneleri belirtilen DataTableöğesine kopyalar.

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

Bir dizi üzerinde bir biriktirici işlevi uygular.

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

Bir dizi üzerinde bir biriktirici işlevi uygular. Belirtilen çekirdek değeri ilk biriktirici değeri olarak kullanılır.

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

Bir dizi üzerinde bir biriktirici işlevi uygular. Belirtilen çekirdek değeri ilk biriktirici değeri olarak kullanılır ve belirtilen işlev sonuç değerini seçmek için kullanılır.

All<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Bir dizinin tüm öğelerinin bir koşulu karşılayıp karşılamadığını belirler.

Any<TSource>(IEnumerable<TSource>)

Bir dizinin herhangi bir öğe içerip içermediğini belirler.

Any<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Bir dizinin herhangi bir öğesinin bir koşulu karşılayıp sağlamadığını belirler.

Append<TSource>(IEnumerable<TSource>, TSource)

Sıranın sonuna bir değer ekler.

AsEnumerable<TSource>(IEnumerable<TSource>)

olarak IEnumerable<T>yazılan girişi döndürür.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Giriş dizisinin Decimal her öğesinde bir dönüştürme işlevi çağırarak elde edilen bir değer dizisinin ortalamasını hesaplar.

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

Giriş dizisinin Double her öğesinde bir dönüştürme işlevi çağırarak elde edilen bir değer dizisinin ortalamasını hesaplar.

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

Giriş dizisinin Int32 her öğesinde bir dönüştürme işlevi çağırarak elde edilen bir değer dizisinin ortalamasını hesaplar.

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

Giriş dizisinin Int64 her öğesinde bir dönüştürme işlevi çağırarak elde edilen bir değer dizisinin ortalamasını hesaplar.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null atanabilir Decimal değerler dizisinin ortalamasını hesaplar.

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

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null atanabilir Double değerler dizisinin ortalamasını hesaplar.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null atanabilir Int32 değerler dizisinin ortalamasını hesaplar.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null atanabilir Int64 değerler dizisinin ortalamasını hesaplar.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null atanabilir Single değerler dizisinin ortalamasını hesaplar.

Average<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Giriş dizisinin Single her öğesinde bir dönüştürme işlevi çağırarak elde edilen bir değer dizisinin ortalamasını hesaplar.

Cast<TResult>(IEnumerable)

öğesinin IEnumerable öğelerini belirtilen türe atar.

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

Bir dizinin öğelerini en sizefazla boyut öbeklerine böler.

Concat<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

İki diziyi birleştirir.

Contains<TSource>(IEnumerable<TSource>, TSource)

Varsayılan eşitlik karşılaştırıcısını kullanarak bir dizinin belirtilen öğeyi içerip içermediğini belirler.

Contains<TSource>(IEnumerable<TSource>, TSource, IEqualityComparer<TSource>)

Belirtilen öğesini kullanarak IEqualityComparer<T>bir dizinin belirtilen öğeyi içerip içermediğini belirler.

Count<TSource>(IEnumerable<TSource>)

Bir dizideki öğelerin sayısını döndürür.

Count<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Belirtilen dizideki bir koşulu karşılayan öğe sayısını temsil eden bir sayı döndürür.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Belirtilen dizinin öğelerini veya dizi boşsa bir singleton koleksiyonunda tür parametresinin varsayılan değerini döndürür.

DefaultIfEmpty<TSource>(IEnumerable<TSource>, TSource)

Dizi boşsa, bir tek koleksiyonda belirtilen dizinin veya belirtilen değerin öğelerini döndürür.

Distinct<TSource>(IEnumerable<TSource>)

Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcısını kullanarak bir diziden ayrı öğeler döndürür.

Distinct<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

Değerleri karşılaştırmak için belirtilen IEqualityComparer<T> öğesini kullanarak bir diziden ayrı öğeler döndürür.

DistinctBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Belirtilen anahtar seçici işlevine göre bir diziden ayrı öğeler döndürür.

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

Belirtilen anahtar seçici işlevine göre ve anahtarları karşılaştırmak için belirtilen karşılaştırıcıyı kullanarak bir diziden ayrı öğeler döndürür.

ElementAt<TSource>(IEnumerable<TSource>, Index)

Bir dizideki belirtilen dizindeki öğesini döndürür.

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

Bir dizideki belirtilen dizindeki öğesini döndürür.

ElementAtOrDefault<TSource>(IEnumerable<TSource>, Index)

Belirtilen dizindeki öğeyi bir dizide veya dizin aralık dışındaysa varsayılan bir değerle döndürür.

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

Belirtilen dizindeki öğeyi bir dizide veya dizin aralık dışındaysa varsayılan bir değerle döndürür.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcısını kullanarak iki dizinin küme farkını üretir.

Except<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Değerleri karşılaştırmak için belirtilen IEqualityComparer<T> öğesini kullanarak iki dizinin küme farkını üretir.

ExceptBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TKey>, Func<TSource,TKey>)

Belirtilen anahtar seçici işlevine göre iki sıranın küme farkını üretir.

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

Belirtilen anahtar seçici işlevine göre iki sıranın küme farkını üretir.

First<TSource>(IEnumerable<TSource>)

Bir dizinin ilk öğesini döndürür.

First<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Belirtilen koşulu karşılayan bir dizideki ilk öğeyi döndürür.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Bir dizinin ilk öğesini veya dizide öğe yoksa varsayılan değeri döndürür.

FirstOrDefault<TSource>(IEnumerable<TSource>, TSource)

Bir dizinin ilk öğesini veya dizi öğe içermiyorsa belirtilen varsayılan değeri döndürür.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Böyle bir öğe bulunamazsa, bir koşulu veya varsayılan değeri karşılayan dizinin ilk öğesini döndürür.

FirstOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Bir koşulu karşılayan dizinin ilk öğesini veya böyle bir öğe bulunamazsa belirtilen varsayılan değeri döndürür.

GroupBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Bir dizinin öğelerini belirtilen anahtar seçici işlevine göre gruplandırın.

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

Bir dizinin öğelerini belirtilen bir anahtar seçici işlevine göre gruplandırır ve belirtilen bir karşılaştırıcıyı kullanarak anahtarları karşılaştırır.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Bir dizinin öğelerini belirtilen bir anahtar seçici işlevine göre gruplandırın ve belirtilen bir işlevi kullanarak her grubun öğelerini projeler.

GroupBy<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Bir dizinin öğelerini bir anahtar seçici işlevine göre gruplandırın. Anahtarlar bir karşılaştırıcı kullanılarak karşılaştırılır ve her grubun öğeleri belirtilen bir işlev kullanılarak yansıtılır.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>)

Bir dizinin öğelerini belirtilen anahtar seçici işlevine göre gruplandırın ve her gruptan ve anahtarından bir sonuç değeri oluşturur.

GroupBy<TSource,TKey,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TKey,IEnumerable<TSource>,TResult>, IEqualityComparer<TKey>)

Bir dizinin öğelerini belirtilen anahtar seçici işlevine göre gruplandırın ve her gruptan ve anahtarından bir sonuç değeri oluşturur. Anahtarlar, belirtilen bir karşılaştırıcı kullanılarak karşılaştırılır.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>,TResult>)

Bir dizinin öğelerini belirtilen anahtar seçici işlevine göre gruplandırın ve her gruptan ve anahtarından bir sonuç değeri oluşturur. Her grubun öğeleri, belirtilen bir işlev kullanılarak yansıtılır.

GroupBy<TSource,TKey,TElement,TResult>(IEnumerable<TSource>, Func<TSource, TKey>, Func<TSource,TElement>, Func<TKey,IEnumerable<TElement>, TResult>, IEqualityComparer<TKey>)

Bir dizinin öğelerini belirtilen anahtar seçici işlevine göre gruplandırın ve her gruptan ve anahtarından bir sonuç değeri oluşturur. Anahtar değerleri belirtilen bir karşılaştırıcı kullanılarak karşılaştırılır ve her grubun öğeleri belirtilen bir işlev kullanılarak yansıtılır.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>)

Anahtarların eşitliğine bağlı olarak iki dizinin öğelerini ilişkilendirir ve sonuçları gruplar. Varsayılan eşitlik karşılaştırıcısı anahtarları karşılaştırmak için kullanılır.

GroupJoin<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,IEnumerable<TInner>, TResult>, IEqualityComparer<TKey>)

Anahtar eşitliğine göre iki dizinin öğelerini ilişkilendirir ve sonuçları gruplandırir. Anahtarları karşılaştırmak için belirtilen IEqualityComparer<T> bir kullanılır.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcısını kullanarak iki dizinin küme kesişimini üretir.

Intersect<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Değerleri karşılaştırmak için belirtilen IEqualityComparer<T> öğesini kullanarak iki dizinin küme kesişimini üretir.

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

Belirtilen anahtar seçici işlevine göre iki dizinin küme kesişimini üretir.

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

Belirtilen anahtar seçici işlevine göre iki dizinin küme kesişimini üretir.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>)

eşleşen anahtarlara göre iki dizinin öğelerini ilişkilendirir. Varsayılan eşitlik karşılaştırıcısı anahtarları karşılaştırmak için kullanılır.

Join<TOuter,TInner,TKey,TResult>(IEnumerable<TOuter>, IEnumerable<TInner>, Func<TOuter,TKey>, Func<TInner,TKey>, Func<TOuter,TInner,TResult>, IEqualityComparer<TKey>)

eşleşen anahtarlara göre iki dizinin öğelerini ilişkilendirir. Anahtarları karşılaştırmak için belirtilen IEqualityComparer<T> bir kullanılır.

Last<TSource>(IEnumerable<TSource>)

Bir dizinin son öğesini döndürür.

Last<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Belirtilen koşulu karşılayan bir dizinin son öğesini döndürür.

LastOrDefault<TSource>(IEnumerable<TSource>)

Bir dizinin son öğesini veya dizide öğe yoksa varsayılan değeri döndürür.

LastOrDefault<TSource>(IEnumerable<TSource>, TSource)

Bir dizinin son öğesini veya dizide öğe yoksa belirtilen varsayılan değeri döndürür.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Bir koşulu karşılayan bir dizinin son öğesini veya böyle bir öğe bulunamazsa varsayılan değeri döndürür.

LastOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Bir koşulu karşılayan bir dizinin son öğesini veya böyle bir öğe bulunamazsa belirtilen varsayılan değeri döndürür.

LongCount<TSource>(IEnumerable<TSource>)

Bir Int64 dizideki öğelerin toplam sayısını temsil eden bir döndürür.

LongCount<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Bir Int64 dizideki kaç öğenin koşulu karşıladığını temsil eden bir döndürür.

Max<TSource>(IEnumerable<TSource>)

Genel bir dizideki en büyük değeri döndürür.

Max<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Genel bir dizideki en büyük değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en büyük Decimal değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en büyük Double değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en büyük Int32 değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en büyük Int64 değeri döndürür.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Decimal en yüksek değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Double en yüksek değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Int32 en yüksek değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Int64 en yüksek değeri döndürür.

Max<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Single en yüksek değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en büyük Single değeri döndürür.

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

Genel bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve sonuçta elde edilen en yüksek değeri döndürür.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Belirtilen anahtar seçici işlevine göre genel bir dizideki en büyük değeri döndürür.

MaxBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Belirtilen anahtar seçici işlevine ve anahtar karşılaştırıcısına göre genel bir dizideki en büyük değeri döndürür.

Min<TSource>(IEnumerable<TSource>)

Genel bir dizideki en küçük değeri döndürür.

Min<TSource>(IEnumerable<TSource>, IComparer<TSource>)

Genel bir dizideki en küçük değeri döndürür.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en düşük Decimal değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en düşük Double değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en düşük Int32 değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en düşük Int64 değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Decimal en düşük değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Double en düşük değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Int32 en düşük değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Int64 en düşük değeri döndürür.

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

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve null atanabilir Single en düşük değeri döndürür.

Min<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve en düşük Single değeri döndürür.

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

Genel bir dizinin her öğesinde bir dönüştürme işlevi çağırır ve sonuçta elde edilen en düşük değeri döndürür.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Belirtilen anahtar seçici işlevine göre genel bir dizideki en düşük değeri döndürür.

MinBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Belirtilen anahtar seçici işlevine ve anahtar karşılaştırıcısına göre genel bir dizideki en düşük değeri döndürür.

OfType<TResult>(IEnumerable)

Öğesinin IEnumerable öğelerini belirtilen türe göre filtreler.

Order<T>(IEnumerable<T>)

Bir dizinin öğelerini artan düzende sıralar.

Order<T>(IEnumerable<T>, IComparer<T>)

Bir dizinin öğelerini artan düzende sıralar.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Bir dizinin öğelerini bir anahtara göre artan düzende sıralar.

OrderBy<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Belirtilen karşılaştırıcıyı kullanarak bir dizinin öğelerini artan düzende sıralar.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Bir dizinin öğelerini bir anahtara göre azalan düzende sıralar.

OrderByDescending<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>, IComparer<TKey>)

Belirtilen bir karşılaştırıcıyı kullanarak bir dizinin öğelerini azalan düzende sıralar.

OrderDescending<T>(IEnumerable<T>)

Bir dizinin öğelerini azalan düzende sıralar.

OrderDescending<T>(IEnumerable<T>, IComparer<T>)

Bir dizinin öğelerini azalan düzende sıralar.

Prepend<TSource>(IEnumerable<TSource>, TSource)

Sıranın başına bir değer ekler.

Reverse<TSource>(IEnumerable<TSource>)

Bir dizideki öğelerin sırasını ters çevirir.

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

Bir dizinin her öğesini yeni bir forma projeler.

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

Öğenin dizinini birleştirerek bir dizinin her öğesini yeni bir forma projeler.

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

Bir dizinin her öğesini öğesine IEnumerable<T> projeler ve sonuçta elde edilen dizileri tek bir sırayla düzleştirir.

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

Bir dizinin her öğesini öğesine IEnumerable<T>projeler ve sonuçta elde edilen dizileri tek bir sırayla düzleştirir. Her kaynak öğenin dizini, bu öğenin öngörülen biçiminde kullanılır.

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

Bir dizinin her öğesini bir IEnumerable<T>öğesine projeler, sonuçta elde edilen dizileri tek bir sırayla düzleştirir ve buradaki her öğede bir sonuç seçici işlevi çağırır.

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

Bir dizinin her öğesini bir IEnumerable<T>öğesine projeler, sonuçta elde edilen dizileri tek bir sırayla düzleştirir ve buradaki her öğede bir sonuç seçici işlevi çağırır. Her kaynak öğenin dizini, bu öğenin ara öngörülen formunda kullanılır.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Türleri için varsayılan eşitlik karşılaştırıcısını kullanarak öğeleri karşılaştırarak iki dizinin eşit olup olmadığını belirler.

SequenceEqual<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Belirtilen IEqualityComparer<T>bir kullanarak öğelerini karşılaştırarak iki dizinin eşit olup olmadığını belirler.

Single<TSource>(IEnumerable<TSource>)

Bir dizinin tek öğesini döndürür ve dizide tam olarak bir öğe yoksa bir özel durum oluşturur.

Single<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Belirtilen koşulu karşılayan bir dizinin tek öğesini döndürür ve birden fazla öğe varsa bir özel durum oluşturur.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Bir dizinin tek öğesini veya dizi boşsa varsayılan değeri döndürür; bu yöntem, dizide birden fazla öğe varsa bir özel durum oluşturur.

SingleOrDefault<TSource>(IEnumerable<TSource>, TSource)

Bir dizinin tek öğesini veya dizi boşsa belirtilen varsayılan değeri döndürür; bu yöntem, dizide birden fazla öğe varsa bir özel durum oluşturur.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Belirtilen koşulu karşılayan bir dizinin tek öğesini veya böyle bir öğe yoksa varsayılan değeri döndürür; Bu yöntem, koşulu birden fazla öğe karşılarsa bir özel durum oluşturur.

SingleOrDefault<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>, TSource)

Belirtilen koşulu karşılayan bir dizinin tek öğesini veya böyle bir öğe yoksa belirtilen varsayılan değeri döndürür; Bu yöntem, koşulu birden fazla öğe karşılarsa bir özel durum oluşturur.

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

Bir dizideki belirtilen sayıda öğeyi atlar ve sonra kalan öğeleri döndürür.

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

Kaynak koleksiyonun son count öğeleri atlanmış olarak öğelerini source içeren yeni bir numaralandırılabilir koleksiyon döndürür.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Belirtilen koşul true olduğu sürece bir dizideki öğeleri atlar ve sonra kalan öğeleri döndürür.

SkipWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Belirtilen koşul true olduğu sürece bir dizideki öğeleri atlar ve sonra kalan öğeleri döndürür. Öğenin dizini koşul işlevinin mantığında kullanılır.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Decimal>)

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağırarak elde edilen değer dizisinin Decimal toplamını hesaplar.

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

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağırarak elde edilen değer dizisinin Double toplamını hesaplar.

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

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağırarak elde edilen değer dizisinin Int32 toplamını hesaplar.

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

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağırarak elde edilen değer dizisinin Int64 toplamını hesaplar.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Decimal>>)

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null değer Decimal dizisinin toplamını hesaplar.

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

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null değer Double dizisinin toplamını hesaplar.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int32>>)

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null değer Int32 dizisinin toplamını hesaplar.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Int64>>)

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null değer Int64 dizisinin toplamını hesaplar.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Nullable<Single>>)

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak elde edilen null değer Single dizisinin toplamını hesaplar.

Sum<TSource>(IEnumerable<TSource>, Func<TSource,Single>)

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağırarak elde edilen değer dizisinin Single toplamını hesaplar.

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

Bir sıranın başlangıcından belirtilen sayıda bitişik öğe döndürür.

Take<TSource>(IEnumerable<TSource>, Range)

Bir diziden belirli bir bitişik öğe aralığını döndürür.

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

öğesinden sourceson count öğeleri içeren yeni bir numaralandırılabilir koleksiyon döndürür.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Belirtilen koşul true olduğu sürece bir diziden öğe döndürür.

TakeWhile<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Belirtilen koşul true olduğu sürece bir diziden öğe döndürür. Öğenin dizini koşul işlevinin mantığında kullanılır.

ToArray<TSource>(IEnumerable<TSource>)

bir dizininden bir IEnumerable<T>dizi oluşturur.

ToDictionary<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Dictionary<TKey,TValue> Belirtilen anahtar seçici işlevine göre bir'den IEnumerable<T> bir oluşturur.

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

Dictionary<TKey,TValue> Belirtilen bir anahtar seçici işlevine ve anahtar karşılaştırıcısına göre'den IEnumerable<T> bir oluşturur.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Belirtilen anahtar seçici ve öğe seçici işlevlerine göre öğesinden bir Dictionary<TKey,TValue>IEnumerable<T> oluşturur.

ToDictionary<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Dictionary<TKey,TValue> Belirtilen anahtar seçici işlevine, karşılaştırıcıya ve öğe seçici işlevine göre öğesinden IEnumerable<T> bir oluşturur.

ToHashSet<TSource>(IEnumerable<TSource>)

bir 'den bir HashSet<T>IEnumerable<T>oluşturur.

ToHashSet<TSource>(IEnumerable<TSource>, IEqualityComparer<TSource>)

anahtarları karşılaştırmak için kullanarak comparer içinden bir HashSet<T>IEnumerable<T> oluşturur.

ToList<TSource>(IEnumerable<TSource>)

bir 'den bir List<T>IEnumerable<T>oluşturur.

ToLookup<TSource,TKey>(IEnumerable<TSource>, Func<TSource,TKey>)

Lookup<TKey,TElement> Belirtilen anahtar seçici işlevine göre bir'den IEnumerable<T> bir oluşturur.

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

Lookup<TKey,TElement> Belirtilen bir anahtar seçici işlevine ve anahtar karşılaştırıcısına göre'den IEnumerable<T> bir oluşturur.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>)

Belirtilen anahtar seçici ve öğe seçici işlevlerine göre öğesinden bir Lookup<TKey,TElement>IEnumerable<T> oluşturur.

ToLookup<TSource,TKey,TElement>(IEnumerable<TSource>, Func<TSource,TKey>, Func<TSource,TElement>, IEqualityComparer<TKey>)

Lookup<TKey,TElement> Belirtilen bir anahtar seçici işlevine, bir karşılaştırıcıya ve öğe seçici işlevine göre öğesinden IEnumerable<T> bir oluşturur.

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

Bir numaralandırmayı zorlamadan bir dizideki öğelerin sayısını belirlemeye çalışır.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>)

Varsayılan eşitlik karşılaştırıcısını kullanarak iki dizinin küme birleşimini üretir.

Union<TSource>(IEnumerable<TSource>, IEnumerable<TSource>, IEqualityComparer<TSource>)

Belirtilen IEqualityComparer<T>bir kullanarak iki dizinin küme birleşimini üretir.

UnionBy<TSource,TKey>(IEnumerable<TSource>, IEnumerable<TSource>, Func<TSource,TKey>)

Belirtilen anahtar seçici işlevine göre iki dizinin küme birleşimini üretir.

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

Belirtilen anahtar seçici işlevine göre iki dizinin küme birleşimini üretir.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Boolean>)

Bir koşula göre bir değer dizisini filtreler.

Where<TSource>(IEnumerable<TSource>, Func<TSource,Int32,Boolean>)

Bir koşula göre bir değer dizisini filtreler. Her öğenin dizini koşul işlevinin mantığında kullanılır.

Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

Belirtilen iki dizideki öğelerle bir tanımlama grubu dizisi oluşturur.

Zip<TFirst,TSecond,TThird>(IEnumerable<TFirst>, IEnumerable<TSecond>, IEnumerable<TThird>)

Belirtilen üç dizideki öğelerle bir tanımlama grubu dizisi oluşturur.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Belirtilen bir işlevi, sonuçların bir dizisini oluşturan iki dizinin karşılık gelen öğelerine uygular.

AsParallel(IEnumerable)

Sorgunun paralelleştirilmesini etkinleştirir.

AsParallel<TSource>(IEnumerable<TSource>)

Sorgunun paralelleştirilmesini sağlar.

AsQueryable(IEnumerable)

bir IEnumerable öğesini öğesine IQueryabledönüştürür.

AsQueryable<TElement>(IEnumerable<TElement>)

Genel bir öğesini genel IEnumerable<T> bir IQueryable<T>öğesine dönüştürür.

AsMemory(String)

Hedef dizenin bölümü üzerinde yeni ReadOnlyMemory<Char> bir oluşturur.

AsMemory(String, Index)

Belirtilen dizinden başlayarak hedef dizenin bir bölümü üzerinde yeni ReadOnlyMemory<Char> bir oluşturur.

AsMemory(String, Int32)

Belirtilen karakter konumundan başlayarak hedef dizenin bir bölümü üzerinde yeni ReadOnlyMemory<Char> bir oluşturur.

AsMemory(String, Int32, Int32)

Hedef dizenin belirli bir konumdan başlayan ve uzunluğu olan bir bölümü üzerinde yeni ReadOnlyMemory<Char> bir oluşturur.

AsMemory(String, Range)

Hedef dizenin belirtilen aralığı üzerinde yeni ReadOnlyMemory<Char> bir oluşturur.

AsSpan(String)

Bir dize üzerinde yeni bir salt okunur yayılma oluşturur.

AsSpan(String, Int32)

Belirtilen konumdan dizenin sonuna kadar hedef dizenin bir bölümü üzerinde yeni bir salt okunur yayılma oluşturur.

AsSpan(String, Int32, Int32)

Belirtilen sayıda karakter için belirtilen konumdan hedef dizenin bir bölümü üzerinde yeni bir salt okunur yayılma oluşturur.

IsNormalized(String)

Belirtilen dizenin C Unicode normalleştirme formunda olup olmadığını gösterir.

IsNormalized(String, NormalizationForm)

Bir dizenin belirtilen Unicode normalleştirme formunda olup olmadığını gösterir.

Normalize(String)

Bir dizeyi C Unicode normalleştirme formuna normalleştirir.

Normalize(String, NormalizationForm)

Bir dizeyi belirtilen Unicode normalleştirme formuna normalleştirir.

Ancestors<T>(IEnumerable<T>)

Kaynak koleksiyondaki her düğümün üst öğelerini içeren bir öğe koleksiyonu döndürür.

Ancestors<T>(IEnumerable<T>, XName)

Kaynak koleksiyondaki her düğümün üst öğelerini içeren filtrelenmiş bir öğe koleksiyonu döndürür. Yalnızca eşleştirmesi XName olan öğeler koleksiyona dahil edilir.

DescendantNodes<T>(IEnumerable<T>)

Kaynak koleksiyondaki her belge ve öğenin alt düğümlerinden oluşan bir koleksiyon döndürür.

Descendants<T>(IEnumerable<T>)

Kaynak koleksiyondaki her öğenin ve belgenin alt öğelerini içeren bir öğe koleksiyonu döndürür.

Descendants<T>(IEnumerable<T>, XName)

Kaynak koleksiyondaki her öğenin ve belgenin alt öğelerini içeren filtrelenmiş bir öğe koleksiyonu döndürür. Yalnızca eşleştirmesi XName olan öğeler koleksiyona dahil edilir.

Elements<T>(IEnumerable<T>)

Kaynak koleksiyondaki her öğenin ve belgenin alt öğelerinin bir koleksiyonunu döndürür.

Elements<T>(IEnumerable<T>, XName)

Kaynak koleksiyondaki her öğenin ve belgenin alt öğelerinin filtrelenmiş bir koleksiyonunu döndürür. Yalnızca eşleştirmesi XName olan öğeler koleksiyona dahil edilir.

InDocumentOrder<T>(IEnumerable<T>)

Kaynak koleksiyondaki tüm düğümleri içeren ve belge düzenine göre sıralanmış bir düğüm koleksiyonu döndürür.

Nodes<T>(IEnumerable<T>)

Kaynak koleksiyondaki her belge ve öğenin alt düğümlerinden oluşan bir koleksiyon döndürür.

Remove<T>(IEnumerable<T>)

Kaynak koleksiyondaki her düğümü üst düğümünden kaldırır.

Şunlara uygulanır

İş Parçacığı Güvenliği

Bu güvenli iş parçacığı türüdür.

Ayrıca bkz.