String Sınıf

Tanım

Metni UTF-16 kod birimi 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 göstermek için kullanılan, sıralı bir karakter koleksiyonudur. Bir String nesne, System.Char bir dizeyi temsil eden nesnelerin sıralı koleksiyonudur; bir nesne, System.Char UTF-16 kod birimine karşılık gelir. Nesnesinin değeri, String sıralı nesne koleksiyonunun içerisidir System.Char ve bu değer sabittir (yani salt okunurdur). Dizelerin imlik durumunu bilme hakkında daha fazla bilgi için bkz. ımdeğiştirici kullanılabilirliği ve StringBuilder sınıfı bölümü. Bellekteki bir nesnenin en büyük boyutu String 2 GB veya yaklaşık 1.000.000.000 karakter olur.

Unicode, UTF-16, kod birimleri, kod noktaları ve ve türleri hakkında daha fazla bilgi Char için Rune bkz. .net 'Te karakter kodlamaya giriş.

Bu bölümdeki konular:

Dize nesnesi örneği oluşturma
Karakter nesneleri ve Unicode karakterler
Dizeler ve Unicode standart
Dizeler ve katıştırılmış null karakterler
Dizeler ve dizinler
Null dizeler ve boş dizeler
İmlebilirlik ve StringBuilder sınıfı
Ordinal ve kültüre duyarlı işlemler
Normalleştirme
Kategoriye göre dize işlemleri

Dize nesnesi örneği oluşturma

StringAşağıdaki yollarla bir nesne örneği oluşturabilirsiniz:

  • Bir değişkene dize sabiti atayarak String . Bu, dize oluşturmak için en yaygın kullanılan yöntemdir. Aşağıdaki örnek, birkaç dize oluşturmak için atama kullanır. C# dilinde, ters eğik çizgi ( \ ) bir kaçış karakteri olduğundan, bir dizedeki sabit ters eğik çizgilerden kaçışlı olması veya dizenin tamamının olması gerektiğini unutmayın @-quoted .

    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
    
    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
    
  • Bir String sınıf oluşturucusunu çağırarak. Aşağıdaki örnek, birkaç sınıf Oluşturucu çağırarak dizeleri örnekleyerek başlatır. Kuruculardan bazılarına karakter dizileri veya imzalı bayt dizileri için parametre olarak işaretçiler ekleneceğini unutmayın. Visual Basic, bu oluşturuculara yapılan çağrıları desteklemez. Oluşturucular hakkında ayrıntılı bilgi için String bkz String . Oluşturucu Özeti.

    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
    
    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
    
  • herhangi bir String örnek ve dize sabit değeri bileşiminden tek bir dize oluşturmak için, dize birleştirme işlecini (+ C# ve & veya + Visual Basic) kullanarak. Aşağıdaki örnek, dize birleştirme işlecinin kullanımını gösterir.

    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.
    
    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 bir dize döndüren bir yöntemi çağırarak. Aşağıdaki örnek, bir alt String dizeyi daha büyük bir dizeden ayıklamak için sınıfının yöntemlerini 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
    
    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 katıştırmak 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.
    
    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ı olarak da bilinen Unicode skaler değeri veya Unicode karakterinin Ordinal (sayısal) değeri tarafından tanımlanır. Her kod noktası UTF-16 kodlaması kullanılarak kodlanır ve Kodlamadaki her öğenin sayısal değeri bir nesne tarafından temsil edilir Char .

Not

Bir örnek, bir String UTF-16 kod birimlerinin sıralı koleksiyonundan oluştuğu için String iyi biçimlendirilmiş bir Unicode dizesi olmayan bir nesne oluşturmak mümkündür. Örneğin, karşılık gelen bir üst yedek olmadan düşük bir yedek içeren bir dize oluşturmak mümkündür. Ad alanındaki nesneleri kodlama ve kod çözme yöntemleri gibi bazı yöntemler, System.Text dizelerin doğru biçimlendirildiğinden emin olmak için denetimler gerçekleştiriyor olsa da, String sınıf üyeleri bir dizenin doğru biçimlendirildiğinden emin olmak için denetim gerçekleştirir.

Tek bir Char nesne genellikle tek bir kod noktasını temsil eder; diğer bir deyişle, 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 fazla Char nesne) gerektirebilir. Unicode standart, birden çok nesneye karşılık gelen iki tür karakteri tanımlar Char : graphemes ve Unicode ek düzlemleri içindeki karakterlere karşılık gelen Unicode ek kod noktaları.

  • Grafem bir temel karakterle ve ardından bir veya daha fazla birleştirme karakteri ile temsil edilir. Örneğin, ä karakteri, Char kod noktası u + 0061 olan ve ardından Char kod noktası u + 0308 olan bir nesne tarafından temsil edilir. Bu karakter Ayrıca, Char U + 00E4 kod noktasına sahip tek bir nesne tarafından tanımlanabilir. Aşağıdaki örnekte gösterildiği gibi, eşitlik için kültüre duyarlı bir karşılaştırma, normal bir sıralı karşılaştırma olmasa da bu iki temsilinin eşit olduğunu gösterir. Ancak, iki dize normalleştirilse, bir sıralı karşılaştırma aynı zamanda eşit olduğunu gösterir. (Dizeleri normalleştirme hakkında daha fazla bilgi için bkz. normalleştirme bölümü.)

    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
    
    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 ek kod noktası (bir vekil çifti), kod noktası yüksek bir Char vekil olan ve ardından Char kod noktası düşük bir vekil olan bir nesne tarafından temsil edilir. Üst yedeklerin kod birimleri U + D800 ile U + DBFF arasındadır. Alt yedeklerin kod birimleri U + DC00 ile U + DFFF arasındadır. Vekil çiftleri 16 Unicode ek düzlemleri içindeki karakterleri temsil etmek için kullanılır. Aşağıdaki örnek, bir yedek karakter oluşturur ve Char.IsSurrogatePair(Char, Char) bir vekil çifti olup olmadığını anlamak için yönteme 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
    
    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 standart

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

Bir dizedeki her bir karakter ilişkili bir Unicode karakter kategorisine sahiptir ve bu, numaralandırmada .NET ile temsil edilir UnicodeCategory . Bir karakter veya bir yedek çiftinin kategorisi, yöntemi çağırarak belirlenebilir CharUnicodeInfo.GetUnicodeCategory .

.NET, farklı platformlarda çalışan bir .NET uygulamasının belirli bir sürümünün aynı karakter kategorisi bilgilerini döndüren kendi karakter tablolarını ve karşılık gelen kategorilerini korumasını sağlar. 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 alınan Unicode Standart sürümleri liste almaktadır.

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

Ayrıca, .NET Unicode standardına göre dize karşılaştırmayı ve sıralamayı destekler. .NET Framework 4 ve önceki sürümler kendi dize verileri tablosunu korur. bu ayrıca, Windows 7 üzerinde çalışan .NET Framework 4,5 ' den başlayarak .NET Framework sürümlerinin de geçerli olduğunu da doğrudur. Windows işletim sisteminin Windows 8 ve sonraki sürümlerinde çalışan .NET Framework 4,5 ' den başlayarak, çalışma zamanı işletim sistemine dize karşılaştırma ve sıralama işlemleri devreder. .net Core ve .net 5 + ' da, dize karşılaştırma ve sıralama bilgileri, Unicode kitaplıkları için uluslararası bileşenler (Windows 10 Mayıs 2019 Güncelleştirmesi ' den önceki Windows sürümler dışında) tarafından sağlanır. Aşağıdaki tabloda, .NET sürümleri ve karakter karşılaştırma ve sıralama temel alınarak Unicode standart sürümleri listelenmiştir.

.NET sürümü Unicode standart sürümü
.NET Framework 1.1 Unicode standardı, sürüm 4.0.0
.NET Framework 2.0 Unicode standardı, 5.0.0 sürümü
.NET Framework 3.5 Unicode standardı, 5.0.0 sürümü
.NET Framework 4 Unicode standardı, 5.0.0 sürümü
.NET Framework 4,5 ve üzeri Windows 7 Unicode standardı, 5.0.0 sürümü
Windows 8 ve üzeri Windows işletim sistemlerinde .NET Framework 4,5 ve üzeri Unicode standardı, sürüm 6.3.0
.NET Core ve .NET 5 + , Temel alınan işletim sistemi tarafından desteklenen Unicode standart sürümüne bağlıdır.

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

.NET sürümünde bir String nesne, dize uzunluğunun bir parçası olarak saymış gömülü null karakterler içerebilir. Ancak, C ve C++ gibi bazı dillerde, null karakter bir dizenin sonunu belirtir; dizenin bir parçası olarak kabul edilmez ve dize uzunluğunun bir parçası olarak sayılmaz. Bu, c ve C++ programcıları veya C veya C++ dilinde yazılmış olan aşağıdaki yaygın varsayımlar, nesnelere uygulandığında dizelerin geçerli olmadığı anlamına gelir String :

  • strlenOr işlevlerinin döndürdüğü değer wcslen eşit değildir String.Length .

  • Or işlevleri tarafından oluşturulan dize strcpy_s , wcscpy_s yöntemi tarafından oluşturulan dize ile aynı değildir String.Copy .

Nesneleri örnekleyen yerel C ve C++ kodunun String ve String Platform Invoke aracılığıyla nesneleri geçen kodun, gömülü bir boş karakterin dizenin sonunu işaret etmesi gerektiğini varsaymayın.

Bir dizedeki gömülü null karakterler Ayrıca bir dize sıralandığında (veya karşılaştırıldığında) ve bir dize arandığı zaman farklı şekilde değerlendirilir. Sabit kültür kullanılarak karşılaştırmalar da dahil olmak üzere iki dize arasında kültüre duyarlı karşılaştırmalar gerçekleştirirken null karakterler yok sayılır. Bunlar yalnızca sıralı veya büyük/küçük harfe duyarsız sıralı karşılaştırmalar için değerlendirilir. Diğer taraftan,, ve gibi yöntemlerle bir dize aranırken gömülü null karakterler her zaman göz önünde bulundurulmaktadır Contains StartsWith IndexOf .

Dizeler ve dizinler

Dizin, Char içindeki bir nesnenin konumudur (Unicode karakter değil) String . Dizin, dizin konumu sıfır olan dizedeki ilk konumdan başlayan sıfır tabanlı, negatif olmayan bir sayıdır. Ve gibi çeşitli arama yöntemleri, IndexOf LastIndexOf dize örneğindeki bir karakter veya alt dizenin dizinini döndürür.

Chars[]Özelliği, bağımsız Char nesnelere dizedeki dizin konumlarına göre erişmenizi sağlar. Chars[]özelliği varsayılan özellik (Visual Basic) veya dizin oluşturucuda (C# ' de) olduğu için, Char aşağıdaki gibi bir kod kullanarak bir dizedeki ayrı nesnelere erişebilirsiniz. Bu kod, dizenin kaç sözcükten oluşan sözcükleri belirlemekte bir dizedeki 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.
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.

StringSınıfı IEnumerable arabirimini gerçekleştirdiğinden, Char foreach Aşağıdaki örnekte gösterildiği gibi bir yapı kullanarak bir dizedeki nesneler üzerinde de yineleyebilirsiniz.

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.
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, bir Unicode karakteri birden fazla nesne olarak kodlanabileceğinden ardışık Unicode karakterlerine karşılık gelmeyebilir Char . Özellikle, bir dize bir temel karakterle oluşturulmuş metnin, bir veya daha fazla birleştirme karakteri veya vekil çiftleriyle oluşturulan çok karakterli metin birimleri içerebilir. Nesneler yerine Unicode karakterlerle çalışmak için, Char System.Globalization.StringInfo ve TextElementEnumerator sınıflarını veya String.EnumerateRunes yöntemini ve Rune yapısını kullanın. Aşağıdaki örnek, Char Unicode karakterlerle birlikte çalışarak nesneler ve kodla çalışma kodu arasındaki farkı gösterir. Bir tümcenin her bir sözcüğündeki karakter veya metin öğesi sayısını karşılaştırır. Dize, temel bir karakter ve ardından Birleşik karakter içeren iki dizi 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
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, StringInfo.GetTextElementEnumerator TextElementEnumerator bir dizedeki tüm metin öğelerini numaralandırmak için yöntemini ve sınıfını kullanarak metin öğeleriyle birlikte çalışarak. Yöntemini çağırarak her metin öğesinin başlangıç dizinini içeren bir diziyi de alabilirsiniz StringInfo.ParseCombiningCharacters .

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

Null dizeler ve boş dizeler

Tanımlanmış ancak değer atanmamış bir dize null . Bu dizedeki yöntemleri çağırma girişimi bir oluşturur NullReferenceException . Null dize, değeri "" olan bir dize olan boş bir dizeden farklıdır String.Empty . Bazı durumlarda, bir null dize veya boş bir dizeyi bir yöntem çağrısında bağımsız değişken olarak geçirmek özel durum oluşturur. Örneğin, yöntemine bir null dize geçirmek Int32.Parse bir oluşturur ArgumentNullException ve boş bir dizeyi geçirmek bir oluşturur FormatException . Diğer durumlarda, bir yöntem bağımsız değişkeni bir null dize veya boş bir dize olabilir. Örneğin, IFormattable bir sınıf için uygulama sağlıyorsanız, hem null dizeyi hem de boş dizeyi genel ("G") biçim belirticisine eşit olacak şekilde kullanmak istersiniz.

StringSınıfı, bir dizenin boş olup olmadığını test etme olanağı sağlayan aşağıdaki iki kullanışlı yöntemi içerir null :

  • IsNullOrEmpty, bir dizenin ya da eşit olup olmadığını gösterir null String.Empty . Bu yöntem, aşağıdaki gibi kod kullanma gereksinimini ortadan kaldırır:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpacebir dizenin null , eşittir String.Empty veya yalnızca boşluk karakterlerinden oluşan bir dize olup olmadığını gösterir. Bu yöntem, aşağıdaki gibi 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 Is Nothing OrElse str.Equals(String.Empty) OrElse str.Trim().Equals(String.Empty)
    

Aşağıdaki örnek, IsNullOrEmpty yöntemini IFormattable.ToString özel bir sınıfın uygulamasında kullanır Temperature . Yöntemi "G", "C", "F" ve "K" biçim dizelerini destekler. Boş bir biçim dizesi veya değeri yöntemine geçirilen bir biçim dizesi ise null , değeri "G" biçim dizesine 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));
   }                                   
}
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 okunurdur) olarak adlandırılır, çünkü değeri oluşturulduktan sonra değiştirilemez. Nesneyi değiştirmek için görünen Yöntemler String aslında String değişikliği içeren yeni bir nesne döndürür.

Dizeler sabit olduğu için, tek bir dize olarak görünen yinelenen ekleme veya silme işlemleri gerçekleştiren dize düzenleme yordamları, önemli bir performans cezası sağlayabilir. Örneğin, aşağıdaki kod, 0x0001 ile 0x052F aralığında 1000 karakter içeren bir dize oluşturmak için rastgele bir sayı Oluşturucu kullanır. Bu kod, var olan dizeye yeni bir karakter eklemek için dize birleştirme kullanma gibi görünse de str , String her birleştirme işlemi için aslında yeni 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();
   }
}
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

StringBuilder String Bir dizenin değerinde birden çok değişiklik yapan işlemler için sınıfı yerine sınıfını kullanabilirsiniz. Sınıfının örneklerinin aksine String StringBuilder nesneler değişebilir; bir dizeden alt dizeleri birleştirme, ekleme veya silme işlemi yaptığınızda işlemler tek bir dize üzerinde gerçekleştirilir. Bir nesnenin değerini değiştirmeyi bitirdiğinizde StringBuilder , StringBuilder.ToString yöntemini bir dizeye dönüştürmek için çağırabilirsiniz. Aşağıdaki örnek, String bir önceki örnekte kullanılan 1000 rastgele karakteri bir nesne Ile 0x052F aralığında birleştirmek için kullanılır StringBuilder .

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

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

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

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

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

      for (int ctr = 0; ctr <= 1000; ctr++) {
         sb.Append((char)rnd.Next(1, 0x0530));
         if (sb.Length % 60 == 0)
            sb.AppendLine();          
      }                    
      sw.Write(sb.ToString());
      sw.Close();
   }
}
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ı

StringSınıfının üyeleri bir nesne üzerinde sıra veya kültüre duyarlı (dil) işlemleri gerçekleştirir String . Sıralı bir işlem, her nesnenin sayısal değeri üzerinde davranır Char . Kültüre duyarlı bir işlem, nesnenin değeri üzerinde davranır String ve kültüre özel büyük/küçük harf, sıralama, biçimlendirme ve ayrıştırma kurallarını hesaba götürür. Kültüre duyarlı işlemler açıkça tanımlanmış 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, dilden CultureInfo.InvariantCulture bağımsız olarak İngilizce dilinin kültür ayarlarına bağlı olarak, sabit kültür () kullanarak kültüre duyarsız dil dizesi işlemlerini destekler. Diğer ayarlardan farklı olarak System.Globalization.CultureInfo , sabit kültürün ayarlarının tek bir bilgisayarda, sistemden sisteme ve .NET sürümleri arasında tutarlı kalması garanti edilir. Sabit kültür, tüm kültürler genelinde dize karşılaştırmalarının ve sıralığının kararlılığını sağlayan bir tür siyah kutu olarak görülebilir.

Önemli

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

Önemli

Dize işlemleri gerçekleştiren çoğu Yöntem StringComparison , yöntemin sıralı veya kültüre duyarlı bir işlem gerçekleştirip gerçekleştirmediğini belirtmenize olanak sağlayan, türünde bir parametreye sahip bir aşırı yüklemeyi içerir. Genel olarak, yöntem çağrısı amacını açık hale getirmek için bu aşırı yüklemeyi çağırmanız gerekir. Dizeler üzerinde sıra ve kültüre duyarlı işlemleri kullanmaya yönelik en iyi uygulamalar ve yönergeler için bkz. dizeleri kullanmak Için En Iyi uygulamalar.

Büyük/ küçük harf, ayrıştırma ve biçimlendirme, karşılaştırma ve sıralamaişlemleri ve eşitlik için testler , sıralı ya da kültüre duyarlı olabilir. Aşağıdaki bölümler her bir işlem kategorisini tartışır.

İpucu

Her zaman yöntem çağrısını açık hale getiren bir yöntem aşırı yüklemesini çağırmanız gerekir. Örneğin, Compare(String, String) geçerli kültürün kurallarını kullanarak iki dizenin kültüre duyarlı bir şekilde karşılaştırmasını gerçekleştirmek için yöntemini çağırmak yerine, Compare(String, String, StringComparison) StringComparison.CurrentCulture bağımsız değişken için bir değeriyle yöntemini çağırmanız gerekir comparisonType . Daha fazla bilgi için bkz. dizeleri kullanmak Için En Iyi uygulamalar.

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

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

Büyük/küçük harf kuralları bir Unicode karakteri için büyük/küçük harf kullanımının nasıl değiştirileceğini belirleme Örneğin, küçük harften büyük harfe kadar. Genellikle, bir küçük harf işlemi dize karşılaştırmasından önce gerçekleştirilir. Örneğin, bir dize büyük harfe dönüştürülebilir ve bu sayede başka bir büyük dizeyle karşılaştırılabilir. Or metodunu çağırarak bir dizedeki karakterleri küçük harfe dönüştürebilir ToLower ToLowerInvariant ve ya da metodunu çağırarak bunları büyük harfe dönüştürebilirsiniz ToUpper ToUpperInvariant . Ayrıca, TextInfo.ToTitleCase bir dizeyi başlık durumuna 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 duyarsız 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ına göre yapılabilir. Büyük/küçük harf eşlemeleri kullanılan kültüre bağlı olarak değişebildiğinden, büyük/küçük harf işlemlerinin sonucu Kültür temelinde farklılık gösterebilir. Büyük küçük harf bakımından gerçek farklılıklar üç tür:

  • LATIN büyük harf ı (U + 0049), LATIN küçük harf ı (U + 0069), Latin büyük harf ı (u + 0130) ve LATIN küçük harf NOKTASıZ ı (U + 0131) Tr-TR (Türkçe (Türkiye)) ve az-Latn-AZ (Azerbaycan, Latin) kültürleri ve tr, az ve az-Latn nötr kültürleri içinde LATIN büyük harf ı 'nin küçük harfli eşdeğeri LATIN küçük harfle NOKTASıZ ı ve Latin küçük harf ı 'nın büyük harfle eşittir. Diğer tüm kültürlerde, sabit kültür dahil, LATIN küçük harf ı ve LATIN büyük harf ı, küçük harf ve büyük harf eşdeğerleri.

    Aşağıdaki örnek, bir kültüre duyarlı büyük küçük harfe kıyasla dosya sistemi erişimini engellemek için tasarlanan bir dize karşılaştırmasının nasıl başarısız olduğunu gösterir. (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
    
    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şlemelerinde farklılıklar. Bu durumlarda, bir karakteri büyük veya küçük harf olarak değiştirmek için sabit kültürün büyük/küçük harf kuralları 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 Değiştirilirse Döndürülenler
    MICRON IŞARETI (U + 00B5) Büyük harfe YUNANCA BÜYÜK HARF MU (U +-39C)
    ÜSTÜNDE NOKTA OLAN LATIN BÜYÜK HARF ı (U + 0130) Küçük harf LATIN KÜÇÜK HARF ı (U + 0069)
    LATIN KÜÇÜK HARF NOKTASıZ ı (U + 0131) Büyük harfe LATIN BÜYÜK HARF ı (U + 0049)
    LATIN KÜÇÜK HARF UZUN S (U + 017F) Büyük harfe LATIN BÜYÜK HARF S (U + 0053)
    LATIN BÜYÜK HARF D WITH KÜÇÜK HARF Z WITH CARON (U + 01C5) Küçük harf LATIN KÜÇÜK HARF DZ WITH CARON (U + 01C6)
    BIRLEŞIK YUNANCA YPOGEGRAMMENI (U + 0345) Büyük harfe YUNANCA BÜYÜK HARF ıOTA (U + 0399)
  • ASCII karakter aralığındaki iki harfli karma servis çiftinin büyük/küçük harf eşleştirmelerinin farklılığı. Çoğu kültürde, iki harfli bir karışık büyük harf çifti, eşdeğer iki harfli büyük veya küçük harfli çift harfe eşittir. Bu, aşağıdaki kültürler için aşağıdaki iki harfli çiftler için doğru değildir, çünkü her durumda bir dile karşılaştırılır:

    • "lJ" ve "nJ" İK-HR (Hırvatça (Hırvatistan)) kültürü.

    • CS-CZ (Çekçe (Çek Cumhuriyeti)) ve SK-SK (Slovakça (Slovakya)) kültürleri içinde "cH".

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

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" ve "zS", HU-HU (Macarca (Macaristan)) kültürü içinde.

    • es-ES_tradnl (Ispanyolca (Ispanya, geleneksel sıralama)) kültüründeki "cH" ve "lL".

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU", "tH" ve "tR" ı-VN (Vietnam dili (Vietnam)) kültürü.

    Ancak, bu çiftler, sabit dizeler veya tanımlayıcılardaki yaygın olmayan bir durumdur çünkü bu çiftler için kültüre duyarlı bir karşılaştırmanın sorun oluşturduğunu bir durumla karşılaşmanız mümkündür.

Aşağıdaki örnek, dizeleri büyük harfe dönüştürürken kültürler arasındaki küçük harfli kuralların bazı farklarını gösterir.

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
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 işlemleri ters işlemlerdir. Biçimlendirme kuralları bir tarih ve saat veya sayı gibi bir değerin dize gösterimine nasıl dönüştürüleceğini, ancak ayrıştırma kuralları bir dize gösteriminin tarih ve saat gibi bir değere nasıl dönüştürüleceğini belirlemektir. Biçimlendirme ve ayrıştırma kurallarının her ikisi de kültürel kurallarına bağımlıdır. Aşağıdaki örnek, kültüre özgü bir tarih dizesi yorumlarken ortaya çıkabilecek belirsizlik gösterir. Bir tarih dizesi üretmek için kullanılan kültürün kurallarını bilmeden, 03/01/2011, 3/1/2011 ve 01/03/2011 3 Ocak 2011 mi yoksa 1 Mart 2011 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
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, kuralları ayrıştırma işleminde kullanılan kültüre bağlı olarak farklı tarihler oluşturabilir.

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
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ürün kültür 'e göre farklılık gösterir. Örneğin, sıralama düzeni phonetika veya karakterlerin görsel temsiline dayalı olabilir. Doğu Asya dillerinde, karakterler, ideogramların konturuna ve radikal göre sıralanır. Sıralama Ayrıca, alfabede kullanılan düzen dillerine ve kültürlere bağlıdır. Örneğin, Danimarka dili, alfabede "Z" karakterinden sonra sıralayan bir "Æ" karakteri içeriyor. Ayrıca, karşılaştırmalar büyük/küçük harfe duyarlı veya büyük/küçük harfe duyarsız olabilir ve büyük/küçük harf kuralları kültüre göre farklılık gösterebilir. Sıralı karşılaştırma, diğer yandan 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 birbirleriyle nasıl karşılaştırılacağını belirleme. Örneğin, String.Compare(String, String, StringComparison) yöntemi parametresi temelinde iki dizeyi karşılaştırır StringComparison . Parametre değeri ise Yöntem, StringComparison.CurrentCulture geçerli kültürün kurallarını kullanan bir dil karşılaştırması gerçekleştirir; parametre değeri ise StringComparison.Ordinal , yöntem bir sıralı karşılaştırma gerçekleştirir. Sonuç olarak, aşağıdaki örnekte gösterildiği gibi, geçerli kültür ABD Ingilizcesi ise, yönteme yapılan ilk çağrı String.Compare(String, String, StringComparison) (kültüre duyarlı karşılaştırma kullanılarak) "a" değerini "a" olarak kabul eder, ancak aynı yönteme yapılan ikinci çağrı (sıra karşılaştırması kullanılarak) "a" ' dan büyük "bir" değerini alır.

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
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ıra sıralama kurallarını destekler:

  • Sözcük sıralaması, belirli alfasayısal olmayan Unicode karakterlerine atanmış özel ağırlıklardaki dizelerin kültüre duyarlı bir şekilde karşılaştırmasını gerçekleştirir. Örneğin, kısa çizgi (-), "Coop" ve "Co-op" bir sıralanmış listede birbirini izleyen bir şekilde atanmış çok küçük bir ağırlığa sahip olabilir. StringSözcük sıralama kurallarını kullanarak iki dizeyi karşılaştıran yöntemlerin listesi için bkz. kategoriye göre dize işlemleri bölümü.

  • Dize sıralaması ayrıca kültüre duyarlı bir karşılaştırma gerçekleştirir. Özel durum olmaması dışında, tüm alfasayısal olmayan semboller tüm alfasayısal Unicode karakterlerinden önce geldiğinden, sözcük sıralamasına benzer. CompareInfo.CompareBir değeri sağlanan bir parametreye sahip olan yöntem aşırı yüklerini çağırarak, dize sıralama kuralları kullanılarak iki dize karşılaştırılabilir options CompareOptions.StringSort . Bu, dize sıralama kurallarını kullanarak iki dizeyi karşılaştırmak için .NET 'in sağladığı tek yöntemdir.

  • Sıralı sıralama, dizeleri dizedeki her nesnenin sayısal değerine göre karşılaştırır Char . 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, durum önemli değilse, büyük/küçük harf durumunu yok sayan bir sıralı karşılaştırma belirtebilirsiniz. Bu, sabit kültür kullanılarak dizenin büyük harfe dönüştürülmesiyle eşdeğerdir ve sonuç üzerinde bir sıralı karşılaştırma gerçekleştirerek. StringSıralı sıralama kurallarını kullanarak iki dizeyi karşılaştıran yöntemlerin listesi için bkz. kategoriye göre dize işlemleri bölümü.

Kültüre duyarlı karşılaştırma, CultureInfo özelliği tarafından belirtilen sabit kültür dahil, açıkça veya dolaylı bir şekilde nesne kullanan herhangi bir karşılaştırmadır CultureInfo.InvariantCulture . Örtük kültür, ve özellikleri tarafından belirtilen geçerli kültürdür Thread.CurrentCulture CultureInfo.CurrentCulture . Alfabetik karakterlerin sıralama düzeninde (yani, Char.IsLetter özelliğin döndürdüğü karakterler true ) kültürler arasında önemli bir çeşitleme vardır. Gibi bir dize karşılaştırma yöntemine bir nesne sağlayarak belirli bir kültürün kurallarını kullanan kültüre duyarlı bir karşılaştırma belirtebilirsiniz CultureInfo Compare(String, String, CultureInfo, CompareOptions) . Geçerli kültürün kurallarını kullanan StringComparison.CurrentCulture , veya StringComparison.CurrentCultureIgnoreCase CompareOptions CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase öğesinin uygun bir aşırı yüklemesine veya dışında bir numaralandırma üyesi Compare sağlayarak, kültüre duyarlı bir karşılaştırma belirtebilirsiniz. Kültüre duyarlı bir karşılaştırma genellikle sıralama için uygundur, ancak sıralı bir karşılaştırma değildir. Sıralı karşılaştırma genellikle iki dizenin eşit olup olmadığını belirlemek için (yani, kimlik belirlemek için), kültüre duyarlı bir karşılaştırma değildir.

Aşağıdaki örnek, kültüre duyarlı ve sıralı karşılaştırma arasındaki farkı gösterir. Örnek, sıralı karşılaştırma, "Apple", "Æble" ve "AEble" gibi üç dizeyi (her biri, yöntemin çağrıldığı sırada varsayılan kültür olan) kullanarak değerlendirir Compare . Danca dili "Æ" karakterini tek bir harf olarak değerlendirir ve alfabede "Z" karakterinden sonra sıralar. "Æble" dizesi "Apple" değerinden büyük. Ancak, "Æble", "AEble" olarak kabul edilmez, bu nedenle "Æble" da "AEble" değerinden büyüktür. En-US kültürü "Æ" harfini içermez ancak "Æble" değerinin "Apple" değerinden küçük olduğunu ancak "AEble" değerine eşit olduğunu anlatan "AE" ile eşdeğer olarak davranır. Sıralı karşılaştırma, diğer yandan "Apple" öğesini "Æble" ve "Æble" yerine "AEble" olarak kabul eder.

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
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, geçerli kültürün kurallarına göre sıralama yapmanız gerekir. Kullanıcının kültürü değişirse, sıralanmış dizelerin sırası da buna uygun olarak değişir. Örneğin, bir eşanlamlılar uygulaması her zaman kelimeleri kullanıcının kültürüne göre sıralar.

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

  • Dizelerin, kültürler arasında değişmeden kalmasını istiyorsanız, sabit kültürün kurallarına göre sıralama yapmanız veya bir sıra karşılaştırması kullanmanız gerekir. Örneğin, dosya, işlem, birbirini kapsamayan veya adlandırılmış kanalların adlarını düzenlemek için sıralı sıralama kullanırsınız.

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

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ının sürümüne bağlıdır. .NET Framework 4,5 ve sonraki sürümlerinde Windows 8 veya üzeri sürümlerde çalışan 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ıra sıralama kuralları hakkında daha fazla bilgi için konusuna bakın System.Globalization.CompareOptions . Her kuralın ne zaman kullanılacağı konusunda ek öneriler için bkz. dizeleri kullanmak Için En Iyi uygulamalar.

Normalde, Compare dizelerin sıralama düzenini belirlemede doğrudan gibi dize karşılaştırma yöntemlerini çağırmazsınız. Bunun yerine, karşılaştırma yöntemleri veya gibi sıralama yöntemleri tarafından çağırılır Array.Sort List<T>.Sort . Aşağıdaki örnek dört farklı sıralama işlemi gerçekleştirir (geçerli kültürü kullanarak Word sıralaması yapın, bir dize karşılaştırma yöntemi açıkça çağrılmadan sabit kültür, sıralı sıralama ve dize sıralaması kullanarak sıralama), ancak kullanılacak karşılaştırma türünü belirtmeleri gerekir. 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
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

Dahili olarak, .NET, önemli dize karşılaştırmayı desteklemek için sıralama anahtarları kullanır. Dizedeki her karaktere alfabetik, büyük/küçük harf ve aksan de dahil olmak üzere birkaç sıralama ağırlıkları kategorisi verilir. Sınıfı tarafından temsil edilen bir sıralama anahtarı SortKey , belirli bir dize için bu ağırlıkların bir deposunu sağlar. Uygulamanız aynı dizeler kümesi üzerinde çok sayıda arama veya sıralama işlemi gerçekleştiriyorsa, kullandığı tüm dizeler için sıralama anahtarları oluşturarak ve depolayarak performansını artırabilirsiniz. Sıralama veya karşılaştırma işlemi gerektiğinde, dizeler yerine Sıralama tuşlarını kullanırsınız. Daha fazla bilgi için, SortKey sınıfına bakın.

Dize karşılaştırma kuralı belirtmezseniz, Array.Sort(Array) dizelerde kültüre duyarlı, büyük/küçük harfe duyarlı sıralama yapma gibi yöntemleri sıralama. Aşağıdaki örnek, geçerli kültürün bir dizideki sıralanmış dizelerin sırasını nasıl etkilediğini gösterir. Üç dizeden oluşan bir dizi oluşturur. İlk olarak, System.Threading.Thread.CurrentThread.CurrentCulture özelliğini en-US olarak ayarlar ve Array.Sort(Array) yöntemini çağırır. Elde edilen sıralama düzeni, Ingilizce (Birleşik Devletler) kültürün sıralama kurallarına dayanır. Ardından örnek, System.Threading.Thread.CurrentThread.CurrentCulture özelliğini de-dk olarak ayarlar ve Array.Sort yöntemi yeniden çağırır. Danca (Danimarka) için sıralama kurallarını kullandığından, sonuçta elde edilen sıralama sırasının en-US sonuçlarından nasıl farklı olduğuna dikkat edin.

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
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ıran birincil amacı, eşit olup olmadıklarını tespit etmek ise, yöntemini çağırmanız gerekir String.Equals . Genellikle, Equals bir sıralı karşılaştırma gerçekleştirmek için kullanmanız gerekir. String.CompareYöntemi öncelikli olarak dizeleri sıralamak içindir.

Ve gibi dize arama yöntemleri String.StartsWith String.IndexOf de kültüre duyarlı veya sıralı dize karşılaştırmaları gerçekleştirebilir. Aşağıdaki örnek, yöntemi kullanılarak Ordinal ve kültüre duyarlı karşılaştırmalar arasındaki farkları göstermektedir IndexOf . Geçerli kültürün Ingilizce olduğu kültüre duyarlı arama (Birleşik Devletler) "OE" alt dizesini "œ" ligatürü ile eşleşecek şekilde değerlendirir. Yumuşak tire (U + 00AD) sıfır genişlikli bir karakter olduğundan arama, yumuşak kısa çizgiyi öğesine eşdeğer olarak değerlendirir Empty ve dizenin başlangıcında bir eşleşme bulur. Diğer yandan bir sıra araması, 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
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 ara

Ve gibi dize arama yöntemleri, String.StartsWith String.IndexOf belirli bir dizede bir karakter veya alt dizenin bulunup bulunmadığını tespit etmek için kültüre duyarlı veya sıralı dize karşılaştırmaları gerçekleştirebilir.

StringSınıfında, yöntemi gibi tek bir karakteri IndexOf veya bir karakter kümesinden birini (örneğin, bir IndexOfAny sıra araması yapar) arama yöntemleri. Bir karakter için kültüre duyarlı bir arama gerçekleştirmek için, CompareInfo veya gibi bir yöntemi çağırmanız gerekir CompareInfo.IndexOf(String, Char) CompareInfo.LastIndexOf(String, Char) . Sıra ve kültüre duyarlı karşılaştırma kullanarak bir karakter arama sonuçlarının çok farklı olabileceğini unutmayın. Örneğin, "Æ" (U + 00C6) gibi önceden oluşturulmuş bir Unicode karakter araması, kültüre bağlı olarak, "AE" (U + 041U + 0045) gibi doğru sırada kendi bileşenlerinin herhangi bir tekrarı ile eşleşmeyebilir. Aşağıdaki örnek, String.IndexOf(Char) CompareInfo.IndexOf(String, Char) tek bir karakter ararken ve yöntemleri arasındaki farkı gösterir. En-US kültürünün kuralları kullanılarak "havadan" dizesinde "ä" (U+00E6) adlandırması bulunur, ancak da-DK kültürünün kuralları kullanırken veya sırasal karşılaştırma yaparken değil.

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
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 dizeyi aratan sınıf yöntemleri, arama seçenekleri türünde bir parametre tarafından açıkça belirtilmezse kültüre duyarlı String bir arama StringComparison gerçekleştirin. Tek özel Contains durum, bir ordinal arama gerçekleştiren 'tir.

Eşitlik sınaması

sıralama String.Compare düzeninde iki dizenin ilişkisini belirlemek için yöntemini kullanın. Bu genellikle kültüre duyarlı bir işlemdir. Buna karşılık, String.Equals eşitliği test etmek için yöntemini çağırma. 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ırıldığından, bu genellikle bir sıra işlemidir.

Uyarı

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

Aşağıdaki örnek, bunun yerine bir ordinal kullanılmalıdırken eşitlik için kültüre duyarlı karşılaştırma gerçekleştirmenin tehlikelerini göstermektedir. Bu durumda, kodun amacı , "FILE://" veya "file://" ile başlayan URL'lerden dosya sistemi erişimini bir URL'nin başında "FILE://" dizesiyle büyük/küçük harfe duyarlı olmayan bir karşılaştırma yaparak yasaklamaktır. Ancak, "file://" ile başlayan bir URL'de Türkçe (Türkçe) kültürü kullanılarak kültüre duyarlı bir karşılaştırma yapılırsa, "i" küçük harfli Türkçe büyük harf eşdeğeri "I" yerine "I" olduğundan eşitlik karşılaştırması başarısız olur. Sonuç olarak, dosya sistemi erişimine yanlışlıkla izin verilir. Öte yandan, bir ordinal karşılaştırması 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.
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 noktalardan herhangi biri "ắ" harfini temsil ediyor olabilir:

  • 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şık hale döndürür.

Unicode standardı, eşdeğer ikili gösterimlerinden herhangi biri için bir Unicode karakterinin ikili gösterimini döndüren normalleştirme adlı bir işlem tanımlar. Normalleştirme, normalleştirme formları olarak adlandırılan ve farklı kurallara uygun çeşitli algoritmalar kullanabilir. .NET; C, D, KC ve KD Unicode normalleştirme formlarını destekler. Dizeler aynı normalleştirme formuna normalleştirilmiş olduğunda, bunlar normal karşılaştırma kullanılarak karşılaştırabilirsiniz.

Bir dizi karşılaştırma, her dizedeki karşılık gelen nesnelerin Unicode skaler değerinin ikili Char karşılaştırmasıdır. Stringsınıfı, aşağıdakiler de dahil olmak üzere bir dizi yordam karşılaştırması gerçekleştirebilirsiniz:

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

Aşağıdaki basit örnek, dize normalleştirmeyi göstermektedir. Üç farklı dizede "ố" harfini tanımlar ve her dizenin diğer iki dizeden farklı olduğunu belirlemek için eşitlik için bir dizi 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 bir dizi karşılaştırması 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
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, web sitesinin Unicode Standart Ek System.Text.NormalizationForm #15: Unicode Normalleştirme Formları ve Normalleştirme Hakkında SSS bölümüne unicode.org bakın.

Kategoriye göre dize işlemleri

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

Dizeleri karşılaştırma

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

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

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

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

Dizeleri eşitlik için test etmek

İki dizenin Equals eşit olup olmadığını belirlemek için yöntemini çağırarak. Örnek ve statik aşırı yüklemeler, karşılaştırmanın kültüre duyarlı mı yoksa özel durumlu mu olduğunu ve büyük/büyük harf olarak kabul edilir veya Equals(String, String, StringComparison) Equals(String, StringComparison) yoksayılır mı olduğunu belirtmenize izin verir. Eşitlik testlerinin çoğu sırasaldır ve bir sistem kaynağına (dosya sistemi nesnesi gibi) erişimi belirleyen eşitlik karşılaştırmaları her zaman sırasaldır.

Dizedeki karakterleri bulma

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

Uyarı

Bir dizeyi belirli bir alt dize yerine belirli bir desen için aramak için normal ifadeler kullansanız iyi olur. Daha fazla bilgi için bkz. .NET Normal İfadeleri.

Dizeyi değiştirme

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

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

  • PadLeft bir dizenin başına belirtilen karakterin bir veya daha fazla oluşumunu ekler.

  • PadRight bir dizenin sonuna belirtilen karakterin bir veya daha fazla oluşumunu ekler.

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

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

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

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

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

  • TrimEnd bir karakterin tüm oluşumlarını dizenin sonundan 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 bir nesne String döndürür. Geçerli örneğin değerini değiştirmezler.

Dizeden alt dizeleri ayıklama

yöntemi String.Split tek bir dizeyi birden çok dizeye ayırıyor. Yöntemin aşırı yüklemeleri birden çok sınırlayıcı belirtmenize, yöntemin ayıkladığı alt dize sayısını sınırlamaya, alt dizelerden boşluk kırpmaya ve boş dizelerin (sınırlayıcılar bitişik olduğunda gerçekleşir) döndürülen dizelere dahil olup olmadığını belirtmenize olanak sağlar.

Dizeleri birleştirme

Dizeleri String biriktirma için aşağıdaki 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 bir ekler ve her alt dizeye bir ayırıcı ekler.

Değerleri biçimlendirme

yöntemi, bileşik biçimlendirme özelliğini kullanarak bir dizedeki bir veya daha fazla yer tutucuyu bir nesnenin veya String.Format değerin dize gösterimiyle değiştirir. Formatyöntemi genellikle şunları yapmak için kullanılır:

  • Bir 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 numaralama değerinin dize gösterimini bir dizeye eklemek için.

  • Arabirimi destekleyen bir nesnenin dize gösterimini bir IFormattable dizeye 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 örnekleri hakkında ayrıntılı bilgi için aşırı yükleme Format özetine bakın.

Dize kopyalama

Bir dizenin kopyasını String yapmak için aşağıdaki yöntemleri çağırebilirsiniz:

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

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

  • CopyTo bir dizenin bir kısmını bir karakter dizisine kopyalar.

Dizeyi normalleştirme

Unicode 'da, tek bir karakter birden çok kod noktasına sahip olabilir. Normalleştirme, bu denk karakterleri aynı ikili gösterimine dönüştürür. String.NormalizeYöntemi, String.IsNormalized normalleştirmeyi gerçekleştirir ve yöntemi bir dizenin normalleştirilmiş olup olmadığını belirler.

Daha fazla bilgi ve bir örnek için, bu konunun önceki bölümlerinde bulunan normalleştirme bölümüne bakın.

Oluşturucular

String(Char*)

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

String(Char*, Int32, Int32)

Sınıfın yeni bir örneğini, bir String Unicode karakter dizisi, bu dizideki bir başlangıç karakter konumu ve uzunluğu için belirtilen bir işaretçi tarafından belirtilen değere başlatır.

String(Char, Int32)

Belirtilen String sayıda yinelenen belirtilen Unicode karakteri tarafından belirtilen değere sınıfının yeni bir örneğini başlatır.

String(Char[])

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

String(Char[], Int32, Int32)

Bir String Unicode karakter dizisi, bu dizideki başlangıç karakter konumu ve uzunluğu ile belirtilen değere sınıfının yeni bir örneğini başlatır.

String(ReadOnlySpan<Char>)

StringBelirtilen salt-tanımlı yayılma alanında belirtilen Unicode karakterlerine sınıfının yeni bir örneğini başlatır.

String(SByte*)

Sınıfının yeni bir örneğini String , 8 bit işaretli tamsayılar dizisinin bir işaretçisi tarafından belirtilen değere başlatır.

String(SByte*, Int32, Int32)

Sınıfın yeni bir örneğini, bir String 8 bit işaretli tamsayılar dizisine, bu dizideki bir başlangıç konumuna ve bir uzunluğa göre belirtilen bir işaretçi tarafından belirtilen değere başlatır.

String(SByte*, Int32, Int32, Encoding)

Sınıfın yeni bir örneğini String , belirli bir işaretçi tarafından belirtilen bir dizi 8 bit işaretli tamsayılar, bu dizideki bir başlangıç konumu, uzunluk ve bir nesne olarak başlatır Encoding .

Alanlar

Empty

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

Özellikler

Chars[Int32]

CharGeçerli nesnede belirtilen konumdaki nesneyi alır String .

Length

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

Yöntemler

Clone()

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

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

Belirtilen iki nesnelerin alt dizelerini String karşılar ve sıralama düzeninde göreli konumlarını belirten bir tamsayı döndürür.

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

Belirtilen iki nesnenin alt dizelerini karşılaştırır String , durumlarını yoksayar veya dikkate alı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, CultureInfo)

Belirtilen iki nesnenin alt dizelerini karşılaştırır String , durumlarını yoksayar veya dikkate alır ve karşılaştırmayı etkilemek için kültüre özgü bilgileri kullanarak karşılaştırma ve sıralama düzeninde göreli konumunu gösteren bir tamsayı döndürür.

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

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

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

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

Compare(String, String)

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

Compare(String, String, Boolean)

Belirtilen iki String nesneyi karşılaştırır, durumlarını yoksayar veya dikkate alarak sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.

Compare(String, String, Boolean, CultureInfo)

Belirtilen iki nesneleri karşılar, durumlarını yoksayarak veya kabul ederek ve karşılaştırmayı etkilemek için kültüre özgü bilgileri kullanır ve sıralama düzeninde göreli konumlarını belirten bir String 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 iki nesneyle karşılaştırılması ve sıralama düzeninde iki dizenin birbirine ilişkisini gösteren bir String tamsayı döndürür.

Compare(String, String, StringComparison)

StringBelirtilen kuralları kullanarak belirtilen 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)

StringHer alt dizeden karşılık gelen nesnelerin sayısal değerlerini değerlendirerek belirtilen iki nesnenin alt dizelerini karşılaştırır Char .

CompareOrdinal(String, String)

StringHer dizedeki karşılık gelen nesnelerin sayısal değerlerini değerlendirerek belirtilen iki nesneyi karşılaştırır Char .

CompareTo(Object)

Bu örneği belirtilen bir ile karşılaştırır Object ve belirtilen şekilde sıralama düzeninde aynı konumda olup olmadığını, bu örneği takip edip etmeyeceğini veya göründüğünü gösterir Object .

CompareTo(String)

Bu örneği belirtilen bir nesne ile karşılaştırır String ve belirtilen dize olarak sıralama düzeninde aynı konumda, bu örneğin ne kadar önce kullanılacağını, aşağıda veya göründüğünü gösterir.

Concat(IEnumerable<String>)

Oluşturulmuş bir koleksiyon türündeki üyeleri birleştirir IEnumerable<T> String .

Concat(Object)

Belirtilen nesnenin dize temsilini 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 tüm nesneleri birleştirir.

Concat(Object[])

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

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

Belirtilen iki salt okunurdur karakter yayılmalarını dize temsillerini birleştirir.

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

Belirtilen üç salt okunurdur karakter yayılımünün dize gösterimlerini birleştirir.

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

Belirtilen dört salt okunurdur karakter yayılımünü dize temsillerini birleştirir.

Concat(String, String)

Belirtilen iki örneğini birleştirir String .

Concat(String, String, String)

Belirtilen üç örneğini birleştirir String .

Concat(String, String, String, String)

Belirtilen dört örneği birleştirir String .

Concat(String[])

Belirtilen dizinin öğelerini birleştirir String .

Concat<T>(IEnumerable<T>)

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

Contains(Char)

Bu dize içinde belirtilen bir karakterin oluşup oluşmadığını gösteren bir değer döndürür.

Contains(Char, StringComparison)

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

Contains(String)

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

Contains(String, StringComparison)

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

Copy(String)
Kullanımdan kalktı.

StringBelirtilen değerle aynı değere sahip yeni bir örneğini oluşturur String .

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

Bu örnekteki belirli bir konumdan belirtilen sayıda karakteri bir Unicode karakter dizisinde belirtilen konuma kopyalar.

CopyTo(Span<Char>)

Bu dizenin içeriğini hedef aralığına kopyalar.

Create(IFormatProvider, DefaultInterpolatedStringHandler)

Belirtilen irdelenmiş dizenin biçimlendirmesini kontrol etmek için belirtilen sağlayıcıyı kullanarak yeni bir dize oluşturur.

Create(IFormatProvider, Span<Char>, DefaultInterpolatedStringHandler)

Belirtilen irdelenmiş dizenin biçimlendirmesini kontrol etmek için belirtilen sağlayıcıyı kullanarak yeni bir dize oluşturur.

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

Belirli bir uzunluktan yeni bir dize oluşturur ve belirtilen geri çağırmayı kullanarak oluşturmadan sonra dizeyi başlatıyor.

EndsWith(Char)

Bu dize örneğinin sonunun belirtilen karakterle eş olup olmadığını belirler.

EndsWith(String)

Bu dize örneğinin sonunun belirtilen dizeyle eş olup olmadığını belirler.

EndsWith(String, Boolean, CultureInfo)

Belirtilen kültür kullanılarak karşılaştırıldıklarında bu dize örneğinin sonunun belirtilen dizeyle eş olup olmadığını belirler.

EndsWith(String, StringComparison)

Belirtilen karşılaştırma seçeneği kullanılarak karşılaştırıldıklarında bu dize örneğinin sonunun belirtilen dizeyle eş olup olmadığını belirler.

EnumerateRunes()

Bu dizeden bir Rune numaralama döndürür.

Equals(Object)

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

Equals(String)

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

Equals(String, String)

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

Equals(String, String, StringComparison)

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

Equals(String, StringComparison)

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

Format(IFormatProvider, String, Object)

Belirtilen dizedeki biçim öğesini veya öğeleri karşılık gelen nesnenin dize gösterimiyle değiştirir. Parametresi kültüre özgü biçimlendirme bilgilerini sağlar.

Format(IFormatProvider, String, Object, Object)

Bir dizedeki biçim öğelerini belirtilen iki nesnelerin 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 üç nesnelerin dize gösterimiyle değiştirir. Parametresi 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 nesnelerin dize gösterimiyle değiştirir.

Format(String, Object, Object, Object)

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

Format(String, Object[])

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

GetEnumerator()

Bu dizedeki tek tek karakterler arasında geçerek geçe 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()

Dizenin sıfır dizinindeki öğesine başvuru döndürür.

Bu yöntem .NET derleyicilerini desteklemeye yöneliktir ve kullanıcı kodu tarafından çağrılma amacına yönelik değildir.

GetType()

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

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

sınıfı TypeCode için String döndürür.

IndexOf(Char)

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

IndexOf(Char, Int32)

Bu dizede belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini raporlar. 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 raporlar. Parametresi, belirtilen karakter için kullanmak üzere 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 nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini bildirir String . 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 nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini String raporlar. Parametreler geçerli dizede başlangıç arama konumunu ve belirtilen dize için kullanmak üzere arama türünü belirtir.

IndexOf(String, StringComparison)

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

IndexOfAny(Char[])

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

IndexOfAny(Char[], Int32)

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

IndexOfAny(Char[], Int32, Int32)

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

Insert(Int32, String)

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

Intern(String)

Sistemin belirtilen başvurusunu alır String .

IsInterned(String)

Belirtilen bir başvuruyu alır String .

IsNormalized()

Bu dizenin Unicode normalleştirme biçimi C biçiminde olup olmadığını gösterir.

IsNormalized(NormalizationForm)

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

IsNullOrEmpty(String)

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

IsNullOrWhiteSpace(String)

Belirtilen bir dizenin null boş, boş veya yalnızca boşluk karakterlerinden oluşan bir dize olup olmadığını gösterir.

Join(Char, Object[])

Her üye arasındaki belirtilen ayırıcıyı kullanarak bir nesne dizisinin dize gösterimlerini birler.

Join(Char, String[])

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

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

konumunda bulunan öğesiyle başlayarak ve öğelerine kadar bire birerek, her üye arasında belirtilen ayırıcıyı kullanarak bir dize value startIndex dizisini count birletir.

Join(String, IEnumerable<String>)

türüne sahip oluşturulmuş bir koleksiyonun IEnumerable<T> üyelerini, her String üye arasındaki belirtilen ayırıcıyı kullanarak bir ayırır.

Join(String, Object[])

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

Join(String, String[])

Her öğe arasındaki belirtilen ayırıcıyı kullanarak bir dize dizisinin tüm öğelerini birler.

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

Her öğe arasındaki belirtilen ayırıcıyı kullanarak bir dize dizisinin belirtilen öğelerini bir alır.

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

Her üye arasındaki belirtilen ayırıcıyı kullanarak bir koleksiyonun üyelerini art arda ekler.

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

Her üye arasındaki belirtilen ayırıcıyı kullanarak bir koleksiyonun üyelerini art arda ekler.

LastIndexOf(Char)

Bu örnek içinde belirtilen bir Unicode karakterinin son oluşumunun sıfır tabanlı dizin konumunu bildirir.

LastIndexOf(Char, Int32)

Bu örnek içinde belirtilen bir 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 örnek içindeki bir alt dizede belirtilen Unicode karakterinin son oluşumunun sıfır tabanlı dizin konumunu bildirir. Arama belirtilen bir karakter konumunda başlar ve belirtilen sayıda karakter konumu için dizenin başlangıcına 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 bir karakter konumunda başlar ve belirtilen sayıda karakter konumu için dizenin başlangıcına 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 karakter konumu sayısı için dizenin başına doğru geriye doğru ilerler. Parametresi, belirtilen dizeyi ararken gerçekleştirecek karşılaştırma türünü belirtir.

LastIndexOf(String, Int32, StringComparison)

Geçerli nesne içindeki belirli bir dizenin son oluşumunun sıfır tabanlı dizinini raporlar String . Arama, belirtilen karakter konumunda başlar ve dizenin başına doğru geriye gider. Bir parametre, belirtilen dize aranırken gerçekleştirilecek karşılaştırma türünü belirtir.

LastIndexOf(String, StringComparison)

Geçerli nesne içindeki belirli bir dizenin son oluşumunun sıfır tabanlı dizinini raporlar String . Bir parametre, 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()

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

Normalize(NormalizationForm)

Metinsel değeri bu dize ile aynı olan, ancak ikili temsili belirtilen Unicode normalleştirme biçiminde olan yeni bir dize döndürür.

PadLeft(Int32)

Bu örnekteki karakterlerin, belirtilen toplam uzunluk için sol taraftaki boşluklar ile doldurmasını sağlayan yeni bir dize döndürür.

PadLeft(Int32, Char)

Belirtilen toplam uzunluk için, belirtilen bir Unicode karakteriyle sola doldurarak bu örnekteki karakterlerin sağına doğru şekilde hizalandığını belirten yeni bir dize döndürür.

PadRight(Int32)

Bu dizedeki karakterleri, belirtilen toplam uzunluk için sağdaki boşluklar ile 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ğ tarafta doldurmayla sola hizalanmış yeni bir dize döndürür.

Remove(Int32)

Belirtilen konumdan başerek ve son konumdan devam eden geçerli örnekteki tüm karakterlerin silinmiş olduğu yeni bir dize döndürür.

Remove(Int32, Int32)

Geçerli örnekte belirtilen konumdan itibaren belirtilen sayıda karakterin silinmiş olduğu 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ştiriliyor olduğu yeni bir dize döndürür.

Replace(String, String)

Geçerli örnekte belirtilen bir dizenin tüm oluşumlarının başka bir belirtilen dizeyle değiştiriliyor olduğu 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ştiriliyor olduğu 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ştiriliyor olduğu yeni bir dize döndürür.

ReplaceLineEndings()

Geçerli dizede yer alan tüm yeni satır dizilerini ile NewLine değiştirir.

ReplaceLineEndings(String)

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

Split(Char, Int32, StringSplitOptions)

Bir dizeyi, belirtilen sınırlandırma karakteri ve isteğe bağlı olarak seçenekler temelinde en fazla sayıda alt dize olarak böler. Bir dizeyi, belirtilen karakter ayırıcısına göre, isteğe bağlı olarak sonuçtan boş alt dizeleri atlayarak en fazla sayıda alt dize olarak böler.

Split(Char, StringSplitOptions)

Belirtilen sınırlandırma karakteri ve isteğe bağlı olarak seçenekleri temel alarak bir dizeyi alt dizelere böler.

Split(Char[])

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

Split(Char[], Int32)

Bir dizeyi, belirtilen sınırlandırma karakterlere göre en fazla sayıda alt dize olarak böler.

Split(Char[], Int32, StringSplitOptions)

Bir dizeyi, belirtilen sınırlandırma karakterlerine ve isteğe bağlı olarak seçeneklere göre en fazla alt dize sayısına böler.

Split(Char[], StringSplitOptions)

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

Split(String, Int32, StringSplitOptions)

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

Split(String, StringSplitOptions)

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

Split(String[], Int32, StringSplitOptions)

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

Split(String[], StringSplitOptions)

Belirtilen sınırlandırma dizesine 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şlatıp başlamay olmadığını belirler.

StartsWith(String)

Bu dize örneğinin başlangıcının belirtilen dizeyle eş olup olmadığını belirler.

StartsWith(String, Boolean, CultureInfo)

Belirtilen kültür kullanılarak karşılaştırıldıklarında bu dize örneğinin başlangıcının belirtilen dizeyle eş olup olmadığını belirler.

StartsWith(String, StringComparison)

Belirtilen karşılaştırma seçeneği kullanılarak karşılaştırıldıklarında bu dize örneğinin başlangıcının belirtilen dizeyle eş olup olmadığını 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 uzunluktadır.

ToCharArray()

Bu örnekteki karakterleri bir Unicode karakter dizisine kopyalar.

ToCharArray(Int32, Int32)

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

ToLower()

Bu dizenin küçük harfe dönüştürülen 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ülen bir kopyasını döndürür.

ToLowerInvariant()

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

ToString()

bu örneğini String döndürür; gerçek dönüştürme gerçekleştirilecek değil.

ToString(IFormatProvider)

bu örneğini String döndürür; gerçek dönüştürme gerçekleştirilecek değil.

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ülen bir kopyasını döndürür.

ToUpperInvariant()

Sabit kültürün String büyük/küçük harf kuralları kullanılarak büyük harfe dönüştürülen bu nesnenin 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 öndeki ve sondaki tüm örneklerini kaldırır.

Trim(Char[])

Geçerli dizeden bir dizide belirtilen karakter kümesinde baştaki ve sondaki tüm oluşumları 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ümesinde sondaki tüm oluşumları geçerli dizeden kaldırır.

TrimStart()

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

TrimStart(Char)

Belirtilen bir karakterin önde gelen tüm oluşumlarını geçerli dizeden kaldırır.

TrimStart(Char[])

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

TryCopyTo(Span<Char>)

Bu dizenin içeriğini hedef yayılmaya 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 salt okunurdur bir karakter aralığına örtük olarak dönüştürülmesini 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 bir ile karşılar ve bu örneğin belirtilen sıralama düzeninde önce mi, sonra mı yoksa aynı konumda Object mı olduğunu Object gösterir.

IConvertible.GetTypeCode()

TypeCodeSınıfı için döndürür String .

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 nesnede tekrar eden bir numaralayıcı String döndürür.

IEnumerable<Char>.GetEnumerator()

Geçerli nesnede tekrar eden bir numaralayıcı String 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 bir karma kümesini oluşturur.

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

Bir diziyi numaralandırır, içeriğini sabit bir karma kümesi 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 DataRowDataRow T olduğu bir giriş IEnumerable<T> nesnesi verildiğinde nesnelerin kopyalarını içeren bir döndürür.

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

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

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

DataRow Genel parametresinin T DataRowolduğ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 dizi öğesinin bir koşulu karşılayıp karşılamayacağı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, belirtilen dizinin öğelerini veya bir singleton koleksiyonundaki belirtilen değeri 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 farklı öğeler döndürür.

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

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

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

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

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

Belirli bir 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 farklı öğ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)

Dizin aralık dışındaysa, belirtilen dizindeki bir dizideki veya varsayılan değerdeki öğesini döndürür.

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

Dizin aralık dışındaysa, belirtilen dizindeki bir dizideki veya varsayılan değerdeki öğesini 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 sıranın 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 göre 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ırın. Belirtilen IEqualityComparer<T> anahtarlar karşılaştırmak için 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 dizi öğe içermiyorsa varsayılan değeri döndürür.

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

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

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

Böyle bir öğe bulunamazsa, bir koşulu veya varsayılan değeri karşılayan bir dizinin son öğesini 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>)

Int64 Bir 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 bir 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 en düşük null atanabilir Int32 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 en düşük null atanabilir Int64 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 en düşük null atanabilir Single 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 küçü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)

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

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 tuşa göre azalan düzende sıralar.

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

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

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

Dizinin başına bir değer ekler.

Reverse<TSource>(IEnumerable<TSource>)

Bir dizideki öğelerin sırasını tersine ç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 dizideki her öğeyi yeni bir forma projeler.

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

Bir dizinin her öğesini bir IEnumerable<T> öğesine 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 bir IEnumerable<T>öğesine 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 biçiminde 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>)

Bir dizide belirtilen koşulu karşılayan tek öğeyi 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 bir 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)

Bir dizide belirtilen koşulu karşılayan tek öğeyi 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ış olan öğ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. öğesinin 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ğrılarak 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ğrılarak 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ğrılarak 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ğrılarak 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 atanabilir Decimal değerler 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 atanabilir Double değerler 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 atanabilir Int32 değerler 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 atanabilir Int64 değerler 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 atanabilir Single değerler dizisinin toplamını hesaplar.

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

Giriş dizisinin her öğesinde bir dönüştürme işlevi çağrılarak 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 öğeleri döndürür.

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

Belirtilen koşul true olduğu sürece bir diziden öğeleri döndürür. öğesinin 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>)

Belirtilen anahtar seçici işlevine göre bir'den IEnumerable<T> bir Dictionary<TKey,TValue> oluşturur.

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

Belirtilen bir anahtar seçici işlevine ve anahtar karşılaştırıcısına göre'den IEnumerable<T> bir Dictionary<TKey,TValue> 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 içinden bir HashSet<T> IEnumerable<T>oluşturur.

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

anahtarları karşılaştırmak comparer için kullanarak içinden bir HashSet<T> IEnumerable<T> oluşturur.

ToList<TSource>(IEnumerable<TSource>)

bir içinden bir List<T> IEnumerable<T>oluşturur.

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

Belirtilen anahtar seçici işlevine göre bir'den IEnumerable<T> bir Lookup<TKey,TElement> oluşturur.

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

Belirtilen bir anahtar seçici işlevine ve anahtar karşılaştırıcısına göre'den IEnumerable<T> bir Lookup<TKey,TElement> 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 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.

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

Bir sabit listesi 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 sıranın küme birleşimini üretir.

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

Belirtilen IEqualityComparer<T>bir kullanarak iki sıranın küme birleşimini üretir.

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

Belirtilen anahtar seçici işlevine göre iki sıranın 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 sıranın 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 sağlar.

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 bir bölümü üzerinde uzunluğu olan 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üne 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üne 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.