String Sınıf

Tanım

Metni UTF-16 kod birimi dizisi olarak temsil eder.Represents text as a sequence of UTF-16 code units.

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

Açıklamalar

Dize, metni temsil etmek için kullanılan ardışık bir karakter koleksiyonudur.A string is a sequential collection of characters that is used to represent text. String nesnesi, bir dizeyi temsil eden System.Char nesnelerden oluşan sıralı bir koleksiyondur; System.Char nesnesi bir UTF-16 kod birimine karşılık gelir.A String object is a sequential collection of System.Char objects that represent a string; a System.Char object corresponds to a UTF-16 code unit. String nesnesinin değeri, System.Char nesnelerin sıralı koleksiyonunun içerisidir ve bu değer sabittir (yani salt okunurdur).The value of the String object is the content of the sequential collection of System.Char objects, and that value is immutable (that is, it is read-only). Dizelerin imlebilirlik kullanılabilirliği hakkında daha fazla bilgi için bu konunun ilerleyen kısımlarında yer aldığı ımdeğiştirici ve StringBuilder sınıfı bölümüne bakın.For more information about the immutability of strings, see the Immutability and the StringBuilder class section later in this topic. Bellekteki String nesnesinin en büyük boyutu 2 GB veya yaklaşık 1.000.000.000 karakter.The maximum size of a String object in memory is 2GB, or about 1 billion characters.

Bu bölümde:In this section:

Bir dize nesnesi örneği oluşturmaInstantiate a String object
Karakter nesneleri ve Unicode karakterlerChar objects and Unicode characters
Dizeler ve Unicode standartStrings and The Unicode Standard
Dizeler ve katıştırılmış null karakterlerStrings and embedded null characters
Dizeler ve dizinlerStrings and indexes
Null dizeler ve boş dizelerNull strings and empty strings
Imlebilirlik ve StringBuilder sınıfıImmutability and the StringBuilder class
Sıra sayısı ile kültüre duyarlı işlemlerOrdinal vs. culture-sensitive operations
NormalleştirmeNormalization
Kategoriye göre dize işlemleriString operations by category

Dize nesnesi örneği oluşturmaInstantiate a String object

Aşağıdaki yollarla bir String nesnesi örneği oluşturabilirsiniz:You can instantiate a String object in the following ways:

  • Bir String değişkenine bir dize sabiti atayarak.By assigning a string literal to a String variable. Bu, dize oluşturmak için en yaygın kullanılan yöntemdir.This is the most commonly used method for creating a string. Aşağıdaki örnek, birkaç dize oluşturmak için atama kullanır.The following example uses assignment to create several strings. ' De C#, ters eğik çizgi (\) bir kaçış karakteri olduğundan, bir dizedeki sabit ters eğik çizgilerden kaçışlı olması veya tüm dizenin @-quotedolması gerektiğini unutmayın.Note that in C#, because the backslash (\) is an escape character, literal backslashes in a string must be escaped or the entire string must be @-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      
    
  • String sınıf oluşturucusunu çağırarak.By calling a String class constructor. Aşağıdaki örnek, birkaç sınıf Oluşturucu çağırarak dizeleri örnekleyerek başlatır.The following example instantiates strings by calling several class constructors. Kuruculardan bazılarına karakter dizileri veya imzalı bayt dizileri için parametre olarak işaretçiler ekleneceğini unutmayın.Note that some of the constructors include pointers to character arrays or signed byte arrays as parameters. Visual Basic, bu oluşturuculara yapılan çağrıları desteklemez.Visual Basic does not support calls to these constructors. String oluşturucular hakkında ayrıntılı bilgi için bkz. String Oluşturucu Özeti.For detailed information about String constructors, see the String constructor summary.

    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 örnekleri ve dize sabit değeri bileşiminden tek bir dize oluşturmak için, dize birleştirme işlecini (+ ın C# ve & veya + Visual Basic) kullanarak.By using the string concatenation operator (+ in C# and & or + in Visual Basic) to create a single string from any combination of String instances and string literals. Aşağıdaki örnek, dize birleştirme işlecinin kullanımını gösterir.The following example illustrates the use of the string concatenation operator.

    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.By retrieving a property or calling a method that returns a string. Aşağıdaki örnek, bir alt dizeyi daha büyük bir dizeden ayıklamak için String sınıfının yöntemlerini kullanır.The following example uses the methods of the String class to extract a substring from a larger string.

    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.By calling a formatting method to convert a value or object to its string representation. Aşağıdaki örnek, iki nesnenin dize gösterimini bir dizeye katıştırmak için Bileşik biçimlendirme özelliğini kullanır.The following example uses the composite formatting feature to embed the string representation of two objects into a string.

    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 karakterleriChar objects and Unicode characters

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.Each character in a string is defined by a Unicode scalar value, also called a Unicode code point or the ordinal (numeric) value of the Unicode character. Her kod noktası UTF-16 kodlaması kullanılarak kodlanır ve Kodlamadaki her öğenin sayısal değeri bir Char nesnesi tarafından temsil edilir.Each code point is encoded by using UTF-16 encoding, and the numeric value of each element of the encoding is represented by a Char object.

Not

String bir örnek, UTF-16 kod birimlerinin sıralı koleksiyonundan oluştuğu için, iyi biçimlendirilmiş bir Unicode dizesi olmayan bir String nesnesi oluşturmak mümkündür.Note that, because a String instance consists of a sequential collection of UTF-16 code units, it is possible to create a String object that is not a well-formed Unicode string. Örneğin, karşılık gelen bir üst yedek olmadan düşük bir yedek içeren bir dize oluşturmak mümkündür.For example, it is possible to create a string that has a low surrogate without a corresponding high surrogate. System.Text ad alanındaki nesneleri kodlama ve kod çözme yöntemleri gibi bazı yöntemler, dizelerin doğru biçimlendirildiğinden emin olmak için denetim 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.Although some methods, such as the methods of encoding and decoding objects in the System.Text namespace, may performs checks to ensure that strings are well-formed, String class members don't ensure that a string is well-formed.

Tek bir Char nesnesi genellikle tek bir kod noktasını temsil eder; diğer bir deyişle, Char sayısal değeri kod noktasına eşittir.A single Char object usually represents a single code point; that is, the numeric value of the Char equals the code point. Örneğin, "a" karakterinin kod noktası U + 0061 ' dir.For example, the code point for the character "a" is U+0061. Ancak, bir kod noktası birden fazla kodlanmış öğe (birden fazla Char nesnesi) gerektirebilir.However, a code point might require more than one encoded element (more than one Char object). Unicode standart, birden çok Char nesnesine karşılık gelen iki tür karakteri tanımlar: graphemes ve Unicode ek düzlemleri içindeki karakterlere karşılık gelen Unicode ek kod noktaları.The Unicode standard defines two types of characters that correspond to multiple Char objects: graphemes, and Unicode supplementary code points that correspond to characters in the Unicode supplementary planes.

  • Grafem bir temel karakterle ve ardından bir veya daha fazla birleştirme karakteri ile temsil edilir.A grapheme is represented by a base character followed by one or more combining characters. Örneğin, ä karakteri, kod noktası u + 0061 ve ardından kod noktası U + 0308 olan bir Char nesnesi olan Char bir nesne tarafından temsil edilir.For example, the character ä is represented by a Char object whose code point is U+0061 followed by a Char object whose code point is U+0308. Bu karakter Ayrıca, U + 00E4 kod noktasına sahip tek bir Char nesnesi tarafından tanımlanabilir.This character can also be defined by a single Char object that has a code point of U+00E4. 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.As the following example shows, a culture-sensitive comparison for equality indicates that these two representations are equal, although an ordinary ordinal comparison does not. Ancak, iki dize normalleştirilse, bir sıralı karşılaştırma aynı zamanda eşit olduğunu gösterir.However, if the two strings are normalized, an ordinal comparison also indicates that they are equal. (Dizeleri normalleştirme hakkında daha fazla bilgi için bkz. normalleştirme bölümü.)(For more information on normalizing strings, see the Normalization section.)

    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 vekil olan ve ardından kod noktası düşük bir vekil olan bir Char nesnesi olan bir Char nesnesi tarafından temsil edilir.A Unicode supplementary code point (a surrogate pair) is represented by a Char object whose code point is a high surrogate followed by a Char object whose code point is a low surrogate. Üst yedeklerin kod birimleri U + D800 ile U + DBFF arasındadır.The code units of high surrogates range from U+D800 to U+DBFF. Alt yedeklerin kod birimleri U + DC00 ile U + DFFF arasındadır.The code units of low surrogates range from U+DC00 to U+DFFF. Vekil çiftleri 16 Unicode ek düzlemleri içindeki karakterleri temsil etmek için kullanılır.Surrogate pairs are used to represent characters in the 16 Unicode supplementary planes. Aşağıdaki örnek, bir vekil karakter oluşturur ve bir vekil çifti olup olmadığını anlamak için Char.IsSurrogatePair(Char, Char) yöntemine geçirir.The following example creates a surrogate character and passes it to the Char.IsSurrogatePair(Char, Char) method to determine whether it is a surrogate pair.

    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+{0:X2} ", Convert.ToUInt16(surrogate[ctr]));
    
    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 standartStrings and the Unicode Standard

Dizedeki karakterler, Char değerlerine karşılık gelen UTF-16 kodlu kod birimleriyle temsil edilir.Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

Bir dizedeki her bir karakter, UnicodeCategory numaralandırması tarafından .NET olarak temsil edilen ilişkili bir Unicode karakter kategorisine sahiptir.Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. Bir karakter veya yedek çiftinin kategorisi CharUnicodeInfo.GetUnicodeCategory yöntemi çağırarak belirlenebilir.The category of a character or a surrogate pair can be determined by calling the CharUnicodeInfo.GetUnicodeCategory method.

.NET, farklı platformlarda çalışan bir .NET uygulaması belirli bir sürümünü aynı karakter kategori bilgileri döndürür sağlayan kendi tablo karakterleri ve bunların karşılık gelen kategoriler tutar..NET maintains its own table of characters and their corresponding categories, which ensures that a specific version of a .NET implementation running on different platforms returns identical character category information. Linux ve macOS üzerinde .NET Core üzerine karakter kategori bilgileri tarafından sağlanan Unicode için Uluslararası bileşenleri kitaplıkları.On .NET Core running on Linux and macOS, character category information is provided by International Components for Unicode libraries.

Aşağıdaki tabloda, .NET ve Unicode standart, kendi karakter kategorileri temel sürümlerini listeler.The following table lists .NET versions and the versions of the Unicode Standard on which their character categories are based.

.NET sürüm.NET version Unicode standart sürümüVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Unicode standardı, sürüm 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 Unicode standart sürümü 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 Unicode standart sürümü 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Unicode standart sürümü 5.0.0The Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 Unicode standart sürümü 6.3.0The Unicode Standard, Version 6.3.0
.NET framework 4.51.NET Framework 4.51 Unicode standart sürümü 6.3.0The Unicode Standard, Version 6.3.0
.NET framework 4.52.NET Framework 4.52 Unicode standart sürümü 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 Unicode standart sürümü 6.3.0The Unicode Standard, Version 6.3.0
.NET framework 4.61.NET Framework 4.61 Unicode standart sürümü 6.3.0The Unicode Standard, Version 6.3.0
.NET framework 4.6.2 ve sonraki sürümler.NET Framework 4.6.2 and later versions Unicode standart sürümü 8.0.0The Unicode Standard, Version 8.0.0
.NET core (tüm sürümler).NET Core (all versions) Unicode standart sürümü 8.0.0The Unicode Standard, Version 8.0.0

Ayrıca, .NET Unicode standardına göre dize karşılaştırmayı ve sıralamayı destekler.In addition, .NET supports string comparison and sorting based on the Unicode standard. .NET Framework 4.NET Framework 4üzerinden .NET Framework sürümlerinde .NET Framework kendi dize verileri tablosunu tutar.In versions of the .NET Framework through the .NET Framework 4.NET Framework 4, the .NET Framework maintains its own table of string data. Bu Ayrıca, Windows 7 ' de çalışan .NET Framework 4.5.NET Framework 4.5 başlayarak .NET Framework sürümlerinin de geçerli olduğunu da doğrudur.This is also true of versions of the .NET Framework starting with the .NET Framework 4.5.NET Framework 4.5 running on Windows 7. Windows 8 ' de ve Windows işletim sisteminin sonraki sürümlerinde çalışan .NET Framework 4.5.NET Framework 4.5 başlayarak, çalışma zamanı işletim sistemine dize karşılaştırma ve sıralama işlemleri devreder.Starting with the .NET Framework 4.5.NET Framework 4.5 running on Window 8 and later versions of the Windows operating system, the runtime delegates string comparison and sorting operations to the operating system. .NET Core 'da dize karşılaştırma ve sıralama bilgileri, Unicode kitaplıkları Için Uluslararası bileşenler 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.On .NET Core, string comparison and sorting information is provided by International Components for Unicode libraries.The following table lists the versions of .NET and the versions of the Unicode Standard on which character comparison and sorting are based.

.NET sürüm.NET version Unicode standart sürümüVersion of the Unicode Standard
.NET Framework 1.1.NET Framework 1.1 Unicode standardı, sürüm 4.0.0The Unicode Standard, Version 4.0.0
.NET Framework 2.0.NET Framework 2.0 Unicode standardı, 5.0.0 sürümüThe Unicode Standard, Version 5.0.0
.NET Framework 3.5.NET Framework 3.5 Unicode standardı, 5.0.0 sürümüThe Unicode Standard, Version 5.0.0
.NET Framework 4.NET Framework 4 Unicode standardı, 5.0.0 sürümüThe Unicode Standard, Version 5.0.0
Windows 7 ' de .NET Framework 4.5.NET Framework 4.5 ve üzeri.NET Framework 4.5.NET Framework 4.5 and later on Windows 7 Unicode standardı, 5.0.0 sürümüThe Unicode Standard, Version 5.0.0
Windows 8 ve sonraki Windows işletim sistemlerinde .NET Framework 4.5.NET Framework 4.5 ve üzeri.NET Framework 4.5.NET Framework 4.5 and later on Windows 8 and later Windows operating systems Unicode standardı, sürüm 6.3.0The Unicode Standard, Version 6.3.0
.NET core (tüm sürümler).NET Core (all versions) , Temel alınan işletim sistemi tarafından desteklenen Unicode standart sürümüne bağlıdır.Depends on the version of the Unicode Standard supported by the underlying operating system.

Dizeler ve katıştırılmış null karakterleriStrings and embedded null characters

.NET ' te, bir String nesnesi, dizenin uzunluğunun bir parçası olarak saymış gömülü null karakterler içerebilir.In .NET, a String object can include embedded null characters, which count as a part of the string's length. 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.However, in some languages such as C and C++, a null character indicates the end of a string; it is not considered a part of the string and is not counted as part of the string's length. Bu, c ve C++ programcıların ya da c 'de yazılmış olan veya C++ String nesnelere uygulandığında dizelerin geçerli olmadığı durumlarda aşağıdaki yaygın varsayımlar olması anlamına gelir:This means that the following common assumptions that C and C++ programmers or libraries written in C or C++ might make about strings are not necessarily valid when applied to String objects:

  • strlen veya wcslen işlevlerinin döndürdüğü değer String.Lengtheşit değildir.The value returned by the strlen or wcslen functions does not necessarily equal String.Length.

  • strcpy_s veya wcscpy_s işlevleri tarafından oluşturulan dize, String.Copy yöntemi tarafından oluşturulan dizeyle aynı değildir.The string created by the strcpy_s or wcscpy_s functions is not necessarily identical to the string created by the String.Copy method.

String nesneleri örnekleyen yerel C ve C++ kodun ve platform ınvoke aracılığıyla String nesneleri geçirilen kodun, gömülü bir null karakterin dizenin sonunu işaret etmesi gerektiğine dikkat edin.You should ensure that native C and C++ code that instantiates String objects, and code that is passed String objects through platform invoke, don't assume that an embedded null character marks the end of the string.

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.Embedded null characters in a string are also treated differently when a string is sorted (or compared) and when a string is searched. 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.Null characters are ignored when performing culture-sensitive comparisons between two strings, including comparisons using the invariant culture. Bunlar yalnızca sıralı veya büyük/küçük harfe duyarsız sıralı karşılaştırmalar için değerlendirilir.They are considered only for ordinal or case-insensitive ordinal comparisons. Diğer taraftan, Contains, StartsWithve IndexOfgibi yöntemlerle bir dize aranırken gömülü null karakterler her zaman göz önünde bulundurulmaktadır.On the other hand, embedded null characters are always considered when searching a string with methods such as Contains, StartsWith, and IndexOf.

Dizeler ve dizinlerStrings and indexes

Dizin, bir StringChar nesnesinin konumudur (Unicode karakter değil).An index is the position of a Char object (not a Unicode character) in a String. Dizin, dizin konumu sıfır olan dizedeki ilk konumdan başlayan sıfır tabanlı, negatif olmayan bir sayıdır.An index is a zero-based, nonnegative number that starts from the first position in the string, which is index position zero. IndexOf ve LastIndexOfgibi çeşitli arama yöntemleri, dize örneğindeki bir karakter veya alt dizenin dizinini döndürür.A number of search methods, such as IndexOf and LastIndexOf, return the index of a character or substring in the string instance.

Chars[Int32] özelliği, tek tek Char nesnelerine dizedeki dizin konumlarına göre erişmenizi sağlar.The Chars[Int32] property lets you access individual Char objects by their index position in the string. Chars[Int32] özelliği varsayılan Özellik (Visual Basic) veya Dizin Oluşturucu (içinde C#) olduğundan, aşağıdaki gibi bir kod kullanarak bir dizedeki bireysel Char nesnelerine erişebilirsiniz.Because the Chars[Int32] property is the default property (in Visual Basic) or the indexer (in C#), you can access the individual Char objects in a string by using code such as the following. Bu kod, dizenin kaç sözcükten oluşan sözcükleri belirlemekte bir dizedeki boşluk veya noktalama karakterleri arar.This code looks for white space or punctuation characters in a string to determine how many words the string contains.

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.

String sınıfı IEnumerable arabirimini gerçekleştirdiğinden, aşağıdaki örnekte gösterildiği gibi, bir dizedeki Char nesneler üzerinde foreach yapısını kullanarak da yineleyebilirsiniz.Because the String class implements the IEnumerable interface, you can also iterate through the Char objects in a string by using a foreach construct, as the following example shows.

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.

Bir Unicode karakteri birden fazla Char nesnesi olarak kodlanabileceğinden ardışık dizin değerleri ardışık Unicode karakterlerine karşılık gelmeyebilir.Consecutive index values might not correspond to consecutive Unicode characters, because a Unicode character might be encoded as more than one Char object. Ö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.In particular, a string may contain multi-character units of text that are formed by a base character followed by one or more combining characters or by surrogate pairs. Char nesneler yerine Unicode karakterlerle çalışmak için System.Globalization.StringInfo ve TextElementEnumerator sınıflarını kullanın.To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes. Aşağıdaki örnek, Char nesneleriyle ve Unicode karakterlerle birlikte çalışarak kodla birlikte çalışarak kod arasındaki farkı gösterir.The following example illustrates the difference between code that works with Char objects and code that works with Unicode characters. Bir tümcenin her bir sözcüğündeki karakter veya metin öğesi sayısını karşılaştırır.It compares the number of characters or text elements in each word of a sentence. Dize, temel bir karakter ve ardından Birleşik karakter içeren iki dizi içerir.The string includes two sequences of a base character followed by a combining character.

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, bir dizedeki tüm metin öğelerini numaralandırmak için StringInfo.GetTextElementEnumerator yöntemi ve TextElementEnumerator sınıfını kullanarak metin öğeleriyle birlikte çalışarak.This example works with text elements by using the StringInfo.GetTextElementEnumerator method and the TextElementEnumerator class to enumerate all the text elements in a string. Ayrıca, StringInfo.ParseCombiningCharacters yöntemini çağırarak her metin öğesinin başlangıç dizinini içeren bir diziyi de alabilirsiniz.You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

Bireysel Char değerleri yerine metin birimleriyle çalışma hakkında daha fazla bilgi için, StringInfo sınıfına bakın.For more information about working with units of text rather than individual Char values, see the StringInfo class.

Null dizeler ve boş dizelerNull strings and empty strings

Tanımlanan ancak atanmamış bir dize null.A string that has been declared but has not been assigned a value is null. Bu dize üzerinde yöntem çağırma girişimi bir NullReferenceExceptionoluşturur.Attempting to call methods on that string throws a NullReferenceException. Null dize, değeri "" veya String.Emptyolan bir dize olan boş bir dizeden farklıdır.A null string is different from an empty string, which is a string whose value is "" or 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.In some cases, passing either a null string or an empty string as an argument in a method call throws an exception. Örneğin, Int32.Parse metoduna null bir dize geçirmek bir ArgumentNullExceptionoluşturur ve boş bir dizeyi geçirmek bir FormatExceptionoluşturur.For example, passing a null string to the Int32.Parse method throws an ArgumentNullException, and passing an empty string throws a FormatException. Diğer durumlarda, bir yöntem bağımsız değişkeni bir null dize veya boş bir dize olabilir.In other cases, a method argument can be either a null string or an empty string. Örneğin, bir sınıf için IFormattable uygulama sağlıyorsanız, hem null dizeyi hem de boş dizeyi genel ("G") biçim belirticisine eşit olacak şekilde kullanmak istersiniz.For example, if you are providing an IFormattable implementation for a class, you want to equate both a null string and an empty string with the general ("G") format specifier.

String sınıfı, bir dizenin null veya boş olup olmadığını test etmek için aşağıdaki iki kullanışlı yöntemi içerir:The String class includes the following two convenience methods that enable you to test whether a string is null or empty:

  • IsNullOrEmpty, bir dizenin null veya String.Emptyeşit olup olmadığını gösterir.IsNullOrEmpty, which indicates whether a string is either null or is equal to String.Empty. Bu yöntem, aşağıdaki gibi kod kullanma gereksinimini ortadan kaldırır:This method eliminates the need to use code such as the following:

    if (str == nullptr || str->Equals(String::Empty))
    
    if (str == null || str.Equals(String.Empty))
    
    If str Is Nothing OrElse str.Equals(String.Empty) Then
    
  • IsNullOrWhiteSpace, bir dizenin null, eşit String.Emptyveya yalnızca boşluk karakterlerinden oluşan bir değer olup olmadığını gösterir.IsNullOrWhiteSpace, which indicates whether a string is null, equals String.Empty, or consists exclusively of white-space characters. Bu yöntem, aşağıdaki gibi kod kullanma gereksinimini ortadan kaldırır:This method eliminates the need to use code such as the following:

    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, özel bir Temperature sınıfının IFormattable.ToString uygulamasındaki IsNullOrEmpty yöntemini kullanır.The following example uses the IsNullOrEmpty method in the IFormattable.ToString implementation of a custom Temperature class. Yöntemi "G", "C", "F" ve "K" biçim dizelerini destekler.The method supports the "G", "C", "F", and "K" format strings. Boş bir biçim dizesi veya değeri null olan bir biçim dizesi yöntemine geçirilirse, değeri "G" biçim dizesine değiştirilir.If an empty format string or a format string whose value is null is passed to the method, its value is changed to the "G" format string.

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ıImmutability and the StringBuilder class

String nesnesi sabit (salt okunurdur) olarak adlandırılır, çünkü değeri oluşturulduktan sonra değiştirilemez.A String object is called immutable (read-only), because its value cannot be modified after it has been created. String nesneyi değiştirmek için görünen Yöntemler, gerçekten de değişikliği içeren yeni bir String nesnesi döndürüyor.Methods that appear to modify a String object actually return a new String object that contains the modification.

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.Because strings are immutable, string manipulation routines that perform repeated additions or deletions to what appears to be a single string can exact a significant performance penalty. Ö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.For example, the following code uses a random number generator to create a string with 1000 characters in the range 0x0001 to 0x052F. Kod, stradlı mevcut dizeye yeni bir karakter eklemek için dize birleştirme kullanma gibi görünse de, her birleştirme işlemi için yeni bir String nesnesi oluşturur.Although the code appears to use string concatenation to append a new character to the existing string named str, it actually creates a new String object for each concatenation operation.

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 += Convert.ToChar(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

Bir dizenin değerinde birden fazla değişiklik yapan işlemler için String sınıfı yerine StringBuilder sınıfını kullanabilirsiniz.You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. String sınıfının örneklerinin aksine, 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.Unlike instances of the String class, StringBuilder objects are mutable; when you concatenate, append, or delete substrings from a string, the operations are performed on a single string. Bir StringBuilder nesnesinin değerini değiştirmeyi bitirdiğinizde, bir dizeye dönüştürmek için StringBuilder.ToString metodunu çağırabilirsiniz.When you have finished modifying the value of a StringBuilder object, you can call its StringBuilder.ToString method to convert it to a string. Aşağıdaki örnek, önceki örnekte kullanılan String değiştirir ve bu aralıktaki 1000 rastgele karakteri, StringBuilder bir nesne ile 0x052F aralığındadır.The following example replaces the String used in the previous example to concatenate 1000 random characters in the range to 0x0001 to 0x052F with a StringBuilder object.

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(Convert.ToChar(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ıOrdinal vs. culture-sensitive operations

String sınıfının üyeleri, bir String nesnesi üzerinde sıra veya kültüre duyarlı (dil) işlemleri gerçekleştirir.Members of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. Sıralı bir işlem, her bir Char nesnesinin sayısal değeri üzerinde davranır.An ordinal operation acts on the numeric value of each Char object. Kültüre duyarlı bir işlem, String nesnenin değeri üzerinde çalışır ve kültüre özgü büyük/küçük harf, sıralama, biçimlendirme ve ayrıştırma kurallarını hesaba ayırır.A culture-sensitive operation acts on the value of the String object, and takes culture-specific casing, sorting, formatting, and parsing rules into account. 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.Culture-sensitive operations execute in the context of an explicitly declared culture or the implicit current culture. İki tür işlem aynı dize üzerinde gerçekleştirildiğinde çok farklı sonuçlar üretebilir.The two kinds of operations can produce very different results when they are performed on the same string.

.NET ayrıca, alt dilden bağımsız olarak Ingilizce dilinin kültür ayarlarına bağlı olan sabit kültür (CultureInfo.InvariantCulture) kullanılarak kültüre duyarsız dil dizesi işlemlerini destekler..NET also supports culture-insensitive linguistic string operations by using the invariant culture (CultureInfo.InvariantCulture), which is loosely based on the culture settings of the English language independent of region. Diğer System.Globalization.CultureInfo ayarlarından farklı olarak, sabit kültürün ayarlarının tek bir bilgisayarda, sistemden sisteme ve .NET sürümleri arasında tutarlı kalması garanti edilir.Unlike other System.Globalization.CultureInfo settings, the settings of the invariant culture are guaranteed to remain consistent on a single computer, from system to system, and across versions of .NET. 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.The invariant culture can be seen as a kind of black box that ensures stability of string comparisons and ordering across all cultures.

Ö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.If your application makes a security decision about a symbolic identifier such as a file name or named pipe, or about persisted data such as the text-based data in an XML file, the operation should use an ordinal comparison instead of a culture-sensitive comparison. 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.This is because a culture-sensitive comparison can yield different results depending on the culture in effect, whereas an ordinal comparison depends solely on the binary value of the compared characters.

Önemli

Dize işlemleri gerçekleştiren çoğu Yöntem, yöntemin sıralı veya kültüre duyarlı bir işlem gerçekleştirip gerçekleştirmediğini belirtmenize olanak sağlayan StringComparisontüründe bir parametreye sahip bir aşırı yüklemeyi içerir.Most methods that perform string operations include an overload that has a parameter of type StringComparison, which enables you to specify whether the method performs an ordinal or culture-sensitive operation. Genel olarak, yöntem çağrısı amacını açık hale getirmek için bu aşırı yüklemeyi çağırmanız gerekir.In general, you should call this overload to make the intent of your method call clear. 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.For best practices and guidance for using ordinal and culture-sensitive operations on strings, see Best Practices for Using Strings.

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.Operations for casing, parsing and formatting, comparison and sorting, and testing for equality can be either ordinal or culture-sensitive. Aşağıdaki bölümler her bir işlem kategorisini tartışır.The following sections discuss each category of operation.

İpucu

Her zaman yöntem çağrısını açık hale getiren bir yöntem aşırı yüklemesini çağırmanız gerekir.You should always call a method overload that makes the intent of your method call clear. Örneğin, 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 Compare(String, String) yöntemini çağırmak yerine, comparisonType bağımsız değişkeni için bir StringComparison.CurrentCulture değeriyle Compare(String, String, StringComparison) yöntemini çağırmanız gerekir.For example, instead of calling the Compare(String, String) method to perform a culture-sensitive comparison of two strings by using the conventions of the current culture, you should call the Compare(String, String, StringComparison) method with a value of StringComparison.CurrentCulture for the comparisonType argument. Daha fazla bilgi için bkz. dizeleri kullanmak Için En Iyi uygulamalar.For more information, see Best Practices for Using Strings.

Sıralama ağırlığı tablolarını, Windows işletim sistemleri için sıralama ve karşılaştırma işlemlerinde kullanılan karakter ağırlıkları ve varsayılan Unicode harmanlama öğesi tablosu, Linux ve MacOS için sıralama ağırlığı tablosu gibi bilgileri içeren bir metin dosyası kümesi indirebilirsiniz.You can download the Sorting Weight Tables, a set of text files that contain information on the character weights used in sorting and comparison operations for Windows operating systems, and the Default Unicode Collation Element Table, the sort weight table for Linux and macOS.

Büyük/küçük harf kullanımıCasing

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.Casing rules determine how to change the capitalization of a Unicode character; for example, from lowercase to uppercase. Genellikle, bir küçük harf işlemi dize karşılaştırmasından önce gerçekleştirilir.Often, a casing operation is performed before a string comparison. Ö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.For example, a string might be converted to uppercase so that it can be compared with another uppercase string. ToLower veya ToLowerInvariant yöntemini çağırarak bir dizedeki karakterleri küçük harfe dönüştürebilir ve ToUpper ya da ToUpperInvariant yöntemini çağırarak bunları büyük harfe dönüştürebilirsiniz.You can convert the characters in a string to lowercase by calling the ToLower or ToLowerInvariant method, and you can convert them to uppercase by calling the ToUpper or ToUpperInvariant method. Ayrıca, bir dizeyi başlık durumuna dönüştürmek için TextInfo.ToTitleCase yöntemini kullanabilirsiniz.In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

Not

.NET core, yalnızca Linux ve macOS sistemleri üzerinde çalışan: C ve POSIX kültürler için harmanlama davranışı, her zaman bu kültürler beklenen Unicode harmanlama sırası kullanmayın çünkü duyarlıdır..NET Core running on Linux and macOS systems only: The collation behavior for the C and Posix cultures is always case-sensitive because these cultures do not use the expected Unicode collation order. C ya da POSIX dışındaki bir kültür, kültüre duyarlı ve duyarlı sıralama işlemleri gerçekleştirmek için kullanmanızı öneririz.We recommend that you use a culture other than C or Posix for performing culture-sensitive, case-insensitive sorting operations.

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.Casing operations can be based on the rules of the current culture, a specified culture, or the invariant culture. 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.Because case mappings can vary depending on the culture used, the result of casing operations can vary based on culture. Büyük küçük harf bakımından gerçek farklılıklar üç tür:The actual differences in casing are of three kinds:

  • 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)Differences in the case mapping of LATIN CAPITAL LETTER I (U+0049), LATIN SMALL LETTER I (U+0069), LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130), and LATIN SMALL LETTER DOTLESS I (U+0131). Tr-TR (Türkçe) ve az-Latn-AZ (Azerbaycan, Latin) kültürleri ve tr, az ve az-Latn nötr kültürlerde, LATIN büyük harf ı 'nin küçük harfli eşdeğeri LATIN küçük harf NOKTASıZ ı ve LATIN küçük harf ı 'nın büyük harfli eşdeğerini LATIN BÜYÜK HARF ı WITH DOTIn the tr-TR (Turkish (Turkey)) and az-Latn-AZ (Azerbaijan, Latin) cultures, and in the tr, az, and az-Latn neutral cultures, the lowercase equivalent of LATIN CAPITAL LETTER I is LATIN SMALL LETTER DOTLESS I, and the uppercase equivalent of LATIN SMALL LETTER I is LATIN CAPITAL LETTER I WITH DOT ABOVE. 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.In all other cultures, including the invariant culture, LATIN SMALL LETTER I and LATIN CAPITAL LETTER I are lowercase and uppercase equivalents.

    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.The following example demonstrates how a string comparison designed to prevent file system access can fail if it relies on a culture-sensitive casing comparison. (Sabit kültürün büyük/küçük harf kuralları kullanılmış olmalıdır.)(The casing conventions of the invariant culture should have been used.)

    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.Differences in case mappings between the invariant culture and all other cultures. 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.In these cases, using the casing rules of the invariant culture to change a character to uppercase or lowercase returns the same character. Diğer tüm kültürler için farklı bir karakter döndürür.For all other cultures, it returns a different character. Etkilenen karakterlerden bazıları aşağıdaki tabloda listelenmiştir.Some of the affected characters are listed in the following table.

    KarakterCharacter DeğiştirilirseIf changed to DöndürürReturns
    MICRON IŞARETI (U + 00B5)MICRON SIGN (U+00B5) Büyük harfeUppercase YUNANCA BÜYÜK HARF MU (U +-39C)GREEK CAPITAL LETTER MU (U+-39C)
    ÜSTÜNDE NOKTA OLAN LATIN BÜYÜK HARF ı (U + 0130)LATIN CAPITAL LETTER I WITH DOT ABOVE (U+0130) KüçükLowercase LATIN KÜÇÜK HARF ı (U + 0069)LATIN SMALL LETTER I (U+0069)
    LATIN KÜÇÜK HARF NOKTASıZ ı (U + 0131)LATIN SMALL LETTER DOTLESS I (U+0131) Büyük harfeUppercase LATIN BÜYÜK HARF ı (U + 0049)LATIN CAPITAL LETTER I (U+0049)
    LATIN KÜÇÜK HARF UZUN S (U + 017F)LATIN SMALL LETTER LONG S (U+017F) Büyük harfeUppercase LATIN BÜYÜK HARF S (U + 0053)LATIN CAPITAL LETTER S (U+0053)
    LATIN BÜYÜK HARF D WITH KÜÇÜK HARF Z WITH CARON (U + 01C5)LATIN CAPITAL LETTER D WITH SMALL LETTER Z WITH CARON (U+01C5) KüçükLowercase LATIN KÜÇÜK HARF DZ WITH CARON (U + 01C6)LATIN SMALL LETTER DZ WITH CARON (U+01C6)
    BIRLEŞIK YUNANCA YPOGEGRAMMENI (U + 0345)COMBINING GREEK YPOGEGRAMMENI (U+0345) Büyük harfeUppercase YUNANCA BÜYÜK HARF ıOTA (U + 0399)GREEK CAPITAL LETTER IOTA (U+0399)
  • ASCII karakter aralığındaki iki harfli karma servis çiftinin büyük/küçük harf eşleştirmelerinin farklılığı.Differences in case mappings of two-letter mixed-case pairs in the ASCII character range. Ç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.In most cultures, a two-letter mixed-case pair is equal to the equivalent two-letter uppercase or lowercase pair. 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:This is not true for the following two-letter pairs in the following cultures, because in each case they are compared to a digraph:

    • "lJ" ve "nJ" İK-HR (Hırvatça (Hırvatistan)) kültürü."lJ" and "nJ" in the hr-HR (Croatian (Croatia)) culture.

    • CS-CZ (Çekçe (Çek Cumhuriyeti)) ve SK-SK (Slovakça (Slovakya)) kültürleri içinde "cH"."cH" in the cs-CZ (Czech (Czech Republic)) and sk-SK (Slovak (Slovakia)) cultures.

    • "aA" in-DK (Danca (Danimarka)) kültürü."aA" in the da-DK (Danish (Denmark)) culture.

    • "cS", "dZ", "dZS", "nY", "sZ", "tY" ve "zS", HU-HU (Macarca (Macaristan)) kültürü içinde."cS", "dZ", "dZS", "nY", "sZ", "tY", and "zS" in the hu-HU (Hungarian (Hungary)) culture.

    • es-ES_tradnl (Ispanyolca (Ispanya, geleneksel sıralama)) kültüründeki "cH" ve "lL"."cH" and "lL" in the es-ES_tradnl (Spanish (Spain, Traditional Sort)) culture.

    • "cH", "gI", "kH", "nG" "nH", "pH", "qU", "tH" ve "tR" ı-VN (Vietnam dili (Vietnam)) kültürü."cH", "gI", "kH", "nG" "nH", "pH", "qU', "tH", and "tR" in the vi-VN (Vietnamese (Vietnam)) culture.

    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.However, it is unusual to encounter a situation in which a culture-sensitive comparison of these pairs creates problems, because these pairs are uncommon in fixed strings or identifiers.

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.The following example illustrates some of the differences in casing rules between cultures when converting strings to uppercase.

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çimlendirmeParsing and formatting

Biçimlendirme ve ayrıştırma işlemleri ters işlemlerdir.Formatting and parsing are inverse operations. 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.Formatting rules determine how to convert a value, such as a date and time or a number, to its string representation, whereas parsing rules determine how to convert a string representation to a value such as a date and time. Biçimlendirme ve ayrıştırma kurallarının her ikisi de kültürel kurallarına bağımlıdır.Both formatting and parsing rules are dependent on cultural conventions. Aşağıdaki örnek, kültüre özgü bir tarih dizesi yorumlarken ortaya çıkabilecek belirsizlik gösterir.The following example illustrates the ambiguity that can arise when interpreting a culture-specific date string. 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.Without knowing the conventions of the culture that was used to produce a date string, it is not possible to know whether 03/01/2011, 3/1/2011, and 01/03/2011 represent January 3, 2011 or March 1, 2011.

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.Similarly, as the following example shows, a single string can produce different dates depending on the culture whose conventions are used in the parsing operation.

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ıString comparison and sorting

Dizeleri karşılaştırma ve sıralama kuralları, kültürün kültür 'e göre farklılık gösterir.Conventions for comparing and sorting strings vary from culture to culture. Örneğin, sıralama düzeni phonetika veya karakterlerin görsel temsiline dayalı olabilir.For example, the sort order may be based on phonetics or on the visual representation of characters. Doğu Asya dillerinde, karakterler, ideogramların konturuna ve radikal göre sıralanır.In East Asian languages, characters are sorted by the stroke and radical of ideographs. Sıralama Ayrıca, alfabede kullanılan düzen dillerine ve kültürlere bağlıdır.Sorting also depends on the order languages and cultures use for the alphabet. Örneğin, Danimarka dili, alfabede "Z" karakterinden sonra sıralayan bir "Æ" karakteri içeriyor.For example, the Danish language has an "Æ" character that it sorts after "Z" in the alphabet. Ayrıca, karşılaştırmalar büyük/küçük harfe duyarlı veya duyarsız olabilir ve bazı durumlarda büyük/küçük harf kuralları kültür tarafından da farklılık gösterir.In addition, comparisons can be case-sensitive or case-insensitive, and in some cases casing rules also differ by culture. 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.Ordinal comparison, on the other hand, uses the Unicode code points of individual characters in a string when comparing and sorting strings.

Sıralama kuralları, Unicode karakterlerin alfabetik sırasını ve iki dizenin birbirleriyle nasıl karşılaştırılacağını belirleme.Sort rules determine the alphabetic order of Unicode characters and how two strings compare to each other. Örneğin, String.Compare(String, String, StringComparison) yöntemi StringComparison parametresine göre iki dizeyi karşılaştırır.For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. Parametre değeri StringComparison.CurrentCultureise Yöntem, geçerli kültürün kurallarını kullanan bir dil karşılaştırması gerçekleştirir; parametre değeri StringComparison.Ordinal, yöntemi bir sıralı karşılaştırma gerçekleştirir.If the parameter value is StringComparison.CurrentCulture, the method performs a linguistic comparison that uses the conventions of the current culture; if the parameter value is StringComparison.Ordinal, the method performs an ordinal comparison. Sonuç olarak, aşağıdaki örnekte gösterildiği gibi, geçerli kültür ABD Ingilizcesi ise, String.Compare(String, String, StringComparison) metoduna ilk çağrı (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.Consequently, as the following example shows, if the current culture is U.S. English, the first call to the String.Compare(String, String, StringComparison) method (using culture-sensitive comparison) considers "a" less than "A", but the second call to the same method (using ordinal comparison) considers "a" greater than "A".

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:.NET supports word, string, and ordinal sort rules:

  • 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.A word sort performs a culture-sensitive comparison of strings in which certain nonalphanumeric Unicode characters might have special weights assigned to them. Ö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.For example, the hyphen (-) might have a very small weight assigned to it so that "coop" and "co-op" appear next to each other in a sorted list. Sözcük sıralama kurallarını kullanarak iki dizeyi karşılaştıran String yöntemlerinin listesi için bkz. kategoriye göre dize işlemleri bölümü.For a list of the String methods that compare two strings using word sort rules, see the String operations by category section.

  • Dize sıralaması ayrıca kültüre duyarlı bir karşılaştırma gerçekleştirir.A string sort also performs a culture-sensitive comparison. Ö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.It is similar to a word sort, except that there are no special cases, and all nonalphanumeric symbols come before all alphanumeric Unicode characters. İki dize, CompareOptions.StringSortdeğeri sağlanan options parametresine sahip CompareInfo.Compare yöntemi aşırı yüklerini çağırarak dize sıralama kuralları kullanılarak karşılaştırılabilir.Two strings can be compared using string sort rules by calling the CompareInfo.Compare method overloads that have an options parameter that is supplied a value of CompareOptions.StringSort. Bu, dize sıralama kurallarını kullanarak iki dizeyi karşılaştırmak için .NET 'in sağladığı tek yöntemdir.Note that this is the only method that .NET provides to compare two strings using string sort rules.

  • Sıralı sıralama, dizeleri dizedeki her bir Char nesnesinin sayısal değerine göre karşılaştırır.An ordinal sort compares strings based on the numeric value of each Char object in the string. 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.An ordinal comparison is automatically case-sensitive because the lowercase and uppercase versions of a character have different code points. Ancak, durum önemli değilse, büyük/küçük harf durumunu yok sayan bir sıralı karşılaştırma belirtebilirsiniz.However, if case is not important, you can specify an ordinal comparison that ignores case. 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.This is equivalent to converting the string to uppercase by using the invariant culture and then performing an ordinal comparison on the result. Sıralı sıralama kurallarını kullanarak iki dizeyi karşılaştıran String yöntemlerinin listesi için bkz. kategoriye göre dize işlemleri bölümü.For a list of the String methods that compare two strings using ordinal sort rules, see the String operations by category section.

Kültüre duyarlı karşılaştırma, CultureInfo.InvariantCulture özelliği tarafından belirtilen sabit kültür dahil, açıkça veya örtük olarak CultureInfo nesnesini kullanan bir karşılaştırmadır.A culture-sensitive comparison is any comparison that explicitly or implicitly uses a CultureInfo object, including the invariant culture that is specified by the CultureInfo.InvariantCulture property. Örtük kültür, Thread.CurrentCulture ve CultureInfo.CurrentCulture özellikleriyle belirtilen geçerli kültürdür.The implicit culture is the current culture, which is specified by the Thread.CurrentCulture and CultureInfo.CurrentCulture properties. Alfabetik karakterlerin sıralama düzeninde (yani, Char.IsLetter özelliğinin truedöndüren karakterler) kültürler arasında önemli bir çeşitleme vardır.There is considerable variation in the sort order of alphabetic characters (that is, characters for which the Char.IsLetter property returns true) across cultures. Compare(String, String, CultureInfo, CompareOptions)gibi bir dize karşılaştırma yöntemine CultureInfo nesnesi sağlayarak belirli bir kültürün kurallarını kullanan kültüre duyarlı bir karşılaştırma belirtebilirsiniz.You can specify a culture-sensitive comparison that uses the conventions of a specific culture by supplying a CultureInfo object to a string comparison method such as Compare(String, String, CultureInfo, CompareOptions). Geçerli kültürün kurallarını kullanan bir kültüre duyarlı karşılaştırma belirtebilirsiniz StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCaseveya CompareOptions.Ordinal dışında CompareOptions numaralandırmanın herhangi bir üyesini CompareOptions.OrdinalIgnoreCase yönteminin uygun bir aşırı yüküne ekleyebilirsiniz.CompareYou can specify a culture-sensitive comparison that uses the conventions of the current culture by supplying StringComparison.CurrentCulture, StringComparison.CurrentCultureIgnoreCase, or any member of the CompareOptions enumeration other than CompareOptions.Ordinal or CompareOptions.OrdinalIgnoreCase to an appropriate overload of the Compare method. 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.A culture-sensitive comparison is generally appropriate for sorting whereas an ordinal comparison is not. 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.An ordinal comparison is generally appropriate for determining whether two strings are equal (that is, for determining identity) whereas a culture-sensitive comparison is not.

Aşağıdaki örnek, kültüre duyarlı ve sıralı karşılaştırma arasındaki farkı gösterir.The following example illustrates the difference between culture-sensitive and ordinal comparison. Örnek, sıralı karşılaştırma, "Apple", "Æble" ve "AEble" adlı üç dizeyi ve (her biri Compare yöntemi çağrıldığında varsayılan kültür olan) ve en-US kültürlerin kurallarını değerlendirir.The example evaluates three strings, "Apple", "Æble", and "AEble", using ordinal comparison and the conventions of the da-DK and en-US cultures (each of which is the default culture at the time the Compare method is called). Danca dili "Æ" karakterini tek bir harf olarak değerlendirir ve alfabede "Z" karakterinden sonra sıralar. "Æble" dizesi "Apple" değerinden büyük.Because the Danish language treats the character "Æ" as an individual letter and sorts it after "Z" in the alphabet, the string "Æble" is greater than "Apple". Ancak, "Æble", "AEble" olarak kabul edilmez, bu nedenle "Æble" da "AEble" değerinden büyüktür.However, "Æble" is not considered equivalent to "AEble", so "Æble" is also greater than "AEble". 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.The en-US culture doesn't include the letter"Æ" but treats it as equivalent to "AE", which explains why "Æble" is less than "Apple" but equal to "AEble". Sıralı karşılaştırma, diğer yandan "Apple" öğesini "Æble" ve "Æble" yerine "AEble" olarak kabul eder.Ordinal comparison, on the other hand, considers "Apple" to be less than "Æble", and "Æble" to be greater than "AEble".

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

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

  • 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.If you want the strings to be ordered based on the user's culture, you should order them based on the conventions of the current culture. Kullanıcının kültürü değişirse, sıralanmış dizelerin sırası da buna uygun olarak değişir.If the user's culture changes, the order of sorted strings will also change accordingly. Örneğin, bir eşanlamlılar uygulaması her zaman kelimeleri kullanıcının kültürüne göre sıralar.For example, a thesaurus application should always sort words based on the user's culture.

  • Dizelerin belirli bir kültürün kurallarına göre sıralanmasını istiyorsanız, bu kültürü bir karşılaştırma yöntemine göre temsil eden bir CultureInfo nesnesi sağlayarak sipariş etmelisiniz.If you want the strings to be ordered based on the conventions of a specific culture, you should order them by supplying a CultureInfo object that represents that culture to a comparison method. Ö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.For example, in an application designed to teach students a particular language, you want strings to be ordered based on the conventions of one of the cultures that speaks that language.

  • 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.If you want the order of strings to remain unchanged across cultures, you should order them based on the conventions of the invariant culture or use an ordinal comparison. Ö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.For example, you would use an ordinal sort to organize the names of files, processes, mutexes, or named pipes.

  • 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, Equals yönteminin aşırı yüklemesini çağırarak her zaman eşitlik için sıralı bir test gerçekleştirmeniz gerekir.For a comparison that involves a security decision (such as whether a username is valid), you should always perform an ordinal test for equality by calling an overload of the Equals method.

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.The culture-sensitive sorting and casing rules used in string comparison depend on the version of the .NET. .NET Framework 4,5 ve sonraki sürümlerinde Windows 8Windows 8 işletim sisteminde çalışan, sıralama, büyük/küçük harf, normalleştirme ve Unicode karakter bilgileri Unicode 6,0 standardına uygundur.In the .NET Framework 4.5 and later versions running on the Windows 8Windows 8 operating system, sorting, casing, normalization, and Unicode character information conforms to the Unicode 6.0 standard. Diğer Windows işletim sistemlerinde, Unicode 5,0 standardına uygundur.On other Windows operating systems, it conforms to the Unicode 5.0 standard. .NET Core 'da, temel işletim sistemi tarafından desteklenen Unicode standardının sürümüne bağlıdır.On .NET Core, it depends on the version of the Unicode Standard supported by the underlying operating system.

Sözcük, dize ve sıra sıralama kuralları hakkında daha fazla bilgi için System.Globalization.CompareOptions konusuna bakın.For more information about word, string, and ordinal sort rules, see the System.Globalization.CompareOptions topic. Her kuralın ne zaman kullanılacağı konusunda ek öneriler için bkz. dizeleri kullanmak Için En Iyi uygulamalar.For additional recommendations on when to use each rule, see Best Practices for Using Strings.

Normalde, dizelerin sıralama düzenini belirlemede doğrudan Compare gibi dize karşılaştırma yöntemlerini çağırmazsınız.Ordinarily, you don't call string comparison methods such as Compare directly to determine the sort order of strings. Bunun yerine, karşılaştırma yöntemleri Array.Sort veya List<T>.Sortgibi sıralama yöntemleri tarafından çağırılır.Instead, comparison methods are called by sorting methods such as Array.Sort or 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, sözcük sabit kültür, sıralı sıralama ve sabit kültür kullanarak dize sıralaması kullanarak sıralama), bir dize karşılaştırma yöntemi açıkça çağrılmadan, Ayrıca, kullanılacak karşılaştırma türünü belirtseler de.The following example performs four different sorting operations (word sort using the current culture, word sort using the invariant culture, ordinal sort, and string sort using the invariant culture) without explicitly calling a string comparison method, although they do specify the type of comparison to use. Her sıralama türünün dizisinde dizelerin benzersiz bir sıralamasını ürettiğini unutmayın.Note that each type of sort produces a unique ordering of strings in its array.

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.Internally, .NET uses sort keys to support culturally sensitive string comparison. Dizedeki her karaktere alfabetik, büyük/küçük harf ve aksan de dahil olmak üzere birkaç sıralama ağırlıkları kategorisi verilir.Each character in a string is given several categories of sort weights, including alphabetic, case, and diacritic. SortKey sınıfıyla temsil edilen bir sıralama anahtarı, belirli bir dize için bu ağırlıkların bir deposunu sağlar.A sort key, represented by the SortKey class, provides a repository of these weights for a particular string. 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.If your app performs a large number of searching or sorting operations on the same set of strings, you can improve its performance by generating and storing sort keys for all the strings that it uses. Sıralama veya karşılaştırma işlemi gerektiğinde, dizeler yerine Sıralama tuşlarını kullanırsınız.When a sort or comparison operation is required, you use the sort keys instead of the strings. Daha fazla bilgi için SortKey sınıfına bakın.For more information, see the SortKey class.

Bir dize karşılaştırma kuralı belirtmezseniz, Array.Sort(Array) gibi sıralama yöntemleri, dizelerde kültüre duyarlı, büyük/küçük harfe duyarlı bir sıralama gerçekleştirir.If you don't specify a string comparison convention, sorting methods such as Array.Sort(Array) perform a culture-sensitive, case-sensitive sort on strings. Aşağıdaki örnek, geçerli kültürün bir dizideki sıralanmış dizelerin sırasını nasıl etkilediğini gösterir.The following example illustrates how changing the current culture affects the order of sorted strings in an array. Üç dizeden oluşan bir dizi oluşturur.It creates an array of three strings. İlk olarak, System.Threading.Thread.CurrentThread.CurrentCulture özelliğini en-US olarak ayarlar ve Array.Sort(Array) yöntemini çağırır.First, it sets the System.Threading.Thread.CurrentThread.CurrentCulture property to en-US and calls the Array.Sort(Array) method. Elde edilen sıralama düzeni, Ingilizce (Birleşik Devletler) kültürün sıralama kurallarına dayanır.The resulting sort order is based on sorting conventions for the English (United States) culture. Ardından örnek, System.Threading.Thread.CurrentThread.CurrentCulture özelliğini de-DK olarak ayarlar ve Array.Sort yöntemini yeniden çağırır.Next, the example sets the System.Threading.Thread.CurrentThread.CurrentCulture property to da-DK and calls the Array.Sort method again. 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.Notice how the resulting sort order differs from the en-US results because it uses the sorting conventions for Danish (Denmark).

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

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

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

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

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

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

      // Display the values of the array.
      Console.WriteLine("After sorting for the culture \"da-DK\":");
      PrintIndexAndValues(stringArray); 
   }
   public static void PrintIndexAndValues(string[] myArray)  
   {
      for (int i = myArray.GetLowerBound(0); i <= 
            myArray.GetUpperBound(0); i++ )
         Console.WriteLine("[{0}]: {1}", i, myArray[i]);
      Console.WriteLine();      
   }
}
// The example displays the following output:
//       The original string array:
//       [0]: Apple
//       [1]: Æble
//       [2]: Zebra
//       
//       After sorting for the "en-US" culture:
//       [0]: Æble
//       [1]: Apple
//       [2]: Zebra
//       
//       After sorting for the culture "da-DK":
//       [0]: Apple
//       [1]: Zebra
//       [2]: Æble
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 amaçlarınız eşitse, String.Equals yöntemini çağırmanız gerekir.If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. Genellikle, bir sıralı karşılaştırma gerçekleştirmek için Equals kullanmanız gerekir.Typically, you should use Equals to perform an ordinal comparison. String.Compare yöntemi öncelikli olarak dizeleri sıralayacak şekilde hazırlanmıştır.The String.Compare method is intended primarily to sort strings.

String.StartsWith ve String.IndexOfgibi dize arama yöntemleri de kültüre duyarlı veya sıralı dize karşılaştırmaları gerçekleştirebilir.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. Aşağıdaki örnek, IndexOf yöntemi kullanılarak Ordinal ve kültüre duyarlı karşılaştırmalar arasındaki farkları göstermektedir.The following example illustrates the differences between ordinal and culture-sensitive comparisons using the IndexOf method. 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.A culture-sensitive search in which the current culture is English (United States) considers the substring "oe" to match the ligature "œ". Yumuşak tire (U + 00AD) sıfır genişlikli bir karakter olduğundan arama, yumuşak kısa çizgiyi Empty eşdeğer olarak değerlendirir ve dizenin başlangıcında bir eşleşme bulur.Because a soft hyphen (U+00AD) is a zero-width character, the search treats the soft hyphen as equivalent to Empty and finds a match at the beginning of the string. Diğer yandan bir sıra araması, her iki durumda da eşleşme bulamaz.An ordinal search, on the other hand, does not find a match in either case.

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

Dizeleri aramaSearching Strings

String.StartsWith ve String.IndexOfgibi dize arama yöntemleri, belirli bir dizede bir karakter veya alt dizenin bulunup bulunmadığını belirlemede kültüre duyarlı veya sıralı dize karşılaştırmaları gerçekleştirebilir.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons to determine whether a character or substring is found in a specified string.

IndexOf yöntemi gibi tek bir karakteri veya IndexOfAny yöntemi gibi bir karakter kümesinden birini aramak için String sınıfındaki arama yöntemleri, hepsi bir sıralı arama gerçekleştirir.The search methods in the String class that search for an individual character, such as the IndexOf method, or one of a set of characters, such as the IndexOfAny method, all perform an ordinal search. Bir karakter için kültüre duyarlı bir arama gerçekleştirmek için CompareInfo.IndexOf(String, Char) veya CompareInfo.LastIndexOf(String, Char)gibi bir CompareInfo yöntemi çağırmanız gerekir.To perform a culture-sensitive search for a character, you must call a CompareInfo method such as CompareInfo.IndexOf(String, Char) or 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.Note that the results of searching for a character using ordinal and culture-sensitive comparison can be very different. Ö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.For example, a search for a precomposed Unicode character such as the ligature "Æ" (U+00C6) might match any occurrence of its components in the correct sequence, such as "AE" (U+041U+0045), depending on the culture. Aşağıdaki örnek, tek bir karakter ararken String.IndexOf(Char) ve CompareInfo.IndexOf(String, Char) yöntemleri arasındaki farkı gösterir.The following example illustrates the difference between the String.IndexOf(Char) and CompareInfo.IndexOf(String, Char) methods when searching for an individual character. "Æ" (U + 00E6) ligatürü, en-US kültürünün kuralları kullanılırken "havadan" dizesinde bulunur, ancak da-DK kültürünün veya bir sıralı karşılaştırma gerçekleştirilirken değil.The ligature "æ" (U+00E6) is found in the string "aerial" when using the conventions of the en-US culture, but not when using the conventions of the da-DK culture or when performing an ordinal comparison.

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

Diğer taraftan, bir karakter yerine bir dize aramak için, arama seçenekleri StringComparisontüründe bir parametre tarafından açıkça belirtilmemişse, kültüre duyarlı arama yapmak için bir karakter yerine bir dizeyi arayarak String sınıf yöntemleri.On the other hand, String class methods that search for a string rather than a character perform a culture-sensitive search if search options are not explicitly specified by a parameter of type StringComparison. Tek istisna, sıralı arama gerçekleştiren Contains.The sole exception is Contains, which performs an ordinal search.

Eşitlik sınamasıTesting for equality

Sıralama düzeninde iki dizenin ilişkisini öğrenmek için String.Compare yöntemini kullanın.Use the String.Compare method to determine the relationship of two strings in the sort order. Genellikle bu, kültüre duyarlı bir işlemdir.Typically, this is a culture-sensitive operation. Buna karşılık, eşitlik için test etmek üzere String.Equals yöntemini çağırın.In contrast, call the String.Equals method to test for equality. Eşitlik testi genellikle kullanıcı girişini geçerli bir Kullanıcı adı, parola veya dosya sistemi yolu gibi bilinen bir dizeyle karşılaştırdığından, genellikle sıralı bir işlemdir.Because the test for equality usually compares user input with some known string, such as a valid user name, a password, or a file system path, it is typically an ordinal operation.

Uyarı

String.Compare yöntemini çağırarak ve dönüş değerinin sıfır olup olmadığını belirleyerek eşitlik için test etmek mümkündür.It is possible to test for equality by calling the String.Compare method and determining whether the return value is zero. Ancak, bu uygulama önerilmez.However, this practice is not recommended. İki dizenin eşit olup olmadığını anlamak için String.Equals yönteminin aşırı yüklerinden birini çağırmanız gerekir.To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. Her iki yöntem de karşılaştırma türünü açıkça belirten bir System.StringComparison parametresi içerdiğinden çağırmak için tercih edilen aşırı yükleme, örnek Equals(String, StringComparison) yöntemi ya da statik Equals(String, String, StringComparison) yöntemidir.The preferred overload to call is either the instance Equals(String, StringComparison) method or the static Equals(String, String, StringComparison) method, because both methods include a System.StringComparison parameter that explicitly specifies the type of comparison.

Aşağıdaki örnek, bunun yerine bir sıra olarak kullanılması gereken eşitlik için kültüre duyarlı bir karşılaştırma gerçekleştirmede tehlike gösterir.The following example illustrates the danger of performing a culture-sensitive comparison for equality when an ordinal one should be used instead. Bu durumda, kodun amacı "FILE://" veya "file://" ile başlayan URL 'lerden, "FILE://" dizesiyle bir URL 'nin başlangıcını büyük küçük harfe duyarsız bir karşılaştırma gerçekleştirerek dosya sistemi erişimini yasaklamaktır.In this case, the intent of the code is to prohibit file system access from URLs that begin with "FILE://" or "file://" by performing a case-insensitive comparison of the beginning of a URL with the string "FILE://". Bununla birlikte, "file://" ile başlayan bir URL 'de Türkçe (Türkiye) kültürü kullanılarak kültüre duyarlı bir karşılaştırma gerçekleştirilirse, eşitlik için karşılaştırma başarısız olur, çünkü "i" küçük harfli Türkçe büyük harfli eşdeğeri "i" yerine "i" olur.However, if a culture-sensitive comparison is performed using the Turkish (Turkey) culture on a URL that begins with "file://", the comparison for equality fails, because the Turkish uppercase equivalent of the lowercase "i" is "İ" instead of "I". Sonuç olarak, dosya sistemi erişimine yanlışlıkla izin verilir.As a result, file system access is inadvertently permitted. Öte yandan, bir sıralı karşılaştırma gerçekleştirilirse, eşitlik için karşılaştırma başarılı olur ve dosya sistemi erişimi reddedilir.On the other hand, if an ordinal comparison is performed, the comparison for equality succeeds, and file system access is denied.

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ştirmeNormalization

Bazı Unicode karakterlerinin birden çok temsili vardır.Some Unicode characters have multiple representations. Örneğin, aşağıdaki kod noktalarından herhangi biri "ắ" harfini temsil edebilir:For example, any of the following code points can represent the letter "ắ":

  • U + 1EAFU+1EAF

  • U + 0103 U + 0301U+0103 U+0301

  • U + 0061 U + 0306 U + 0301U+0061 U+0306 U+0301

Tek bir karakter için birden çok temsili arama, sıralama, eşleştirme ve diğer dize işlemlerini karmaşıklaştırır.Multiple representations for a single character complicate searching, sorting, matching, and other string operations.

Unicode standardı, eşdeğer ikili gösterimlerden herhangi biri için bir Unicode karakterinin ikili gösterimini döndüren normalleştirme adlı bir işlemi tanımlar.The Unicode standard defines a process called normalization that returns one binary representation of a Unicode character for any of its equivalent binary representations. Normalleştirme, farklı kuralları izleyen normalleştirme formları olarak adlandırılan birkaç algoritma kullanabilir.Normalization can use several algorithms, called normalization forms, that follow different rules. .NET, C, D, KC ve KD Unicode normalleştirme biçimlerini destekler..NET supports Unicode normalization forms C, D, KC, and KD. Dizeler aynı normalleştirme formuna normalleştirildiklerinde, sıralı karşılaştırma kullanılarak karşılaştırılabilir.When strings have been normalized to the same normalization form, they can be compared by using ordinal comparison.

Sıralı karşılaştırma, her dizedeki karşılık gelen Char nesnelerinin Unicode skaler değeri olan ikili bir karşılaştırmayla yapılır.An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. String sınıfı, aşağıdakiler dahil olmak üzere bir sıralı karşılaştırma gerçekleştirebilen çeşitli yöntemler içerir:The String class includes a number of methods that can perform an ordinal comparison, including the following:

String.IsNormalized() yöntemini çağırarak bir dizenin normalleştirme biçimi C 'ye normalleştirip normalleştirilmediğini belirleyebilir veya bir dizenin belirtilen bir normalleştirme formuna normalleştirilmesi gerekip gerekmediğini anlamak için String.IsNormalized(NormalizationForm) metodunu çağırabilirsiniz.You can determine whether a string is normalized to normalization form C by calling the String.IsNormalized() method, or you can call the String.IsNormalized(NormalizationForm) method to determine whether a string is normalized to a specified normalization form. Ayrıca, bir dizeyi, normalleştirme biçimi C 'ye dönüştürmek için String.Normalize() yöntemini çağırabilirsiniz veya bir dizeyi belirtilen normalleştirme biçimine dönüştürmek için String.Normalize(NormalizationForm) metodunu çağırabilirsiniz.You can also call the String.Normalize() method to convert a string to normalization form C, or you can call the String.Normalize(NormalizationForm) method to convert a string to a specified normalization form. Dizelerin normalleştirilmesi ve karşılaştırılması hakkında adım adım bilgiler için Normalize() ve Normalize(NormalizationForm) yöntemlerine bakın.For step-by-step information about normalizing and comparing strings, see the Normalize() and Normalize(NormalizationForm) methods.

Aşağıdaki basit örnekte dize normalleştirmesi gösterilmektedir.The following simple example illustrates string normalization. "Ố" harfini üç farklı dizedeki üç farklı şekilde tanımlar ve her bir dizenin diğer iki dizeden farklı olduğunu anlamak için eşitlik için sıralı bir karşılaştırma kullanır.It defines the letter "ố" in three different ways in three different strings, and uses an ordinal comparison for equality to determine that each string differs from the other two strings. Ardından, her bir dizeyi desteklenen normalleştirme formlarına dönüştürür ve belirtilen normalleştirme formundaki her bir dizenin sıralı karşılaştırmasını gerçekleştirir.It then converts each string to the supported normalization forms, and again performs an ordinal comparison of each string in a specified normalization form. Her durumda, eşitlik için ikinci test dizelerin eşit olduğunu gösterir.In each case, the second test for equality shows that the strings are equal.

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 += String.Format("{0} ", Convert.ToUInt16(ch).ToString("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, bkz. System.Text.NormalizationFormve Unicode standart ek #15: Unicode normalleştirme formları ve Unicode.org web sitesinde normalleştirme hakkında SSS .For more information about normalization and normalization forms, see System.Text.NormalizationForm, as well as Unicode Standard Annex #15: Unicode Normalization Forms and the Normalization FAQ on the unicode.org website.

Kategoriye göre dize işlemleriString operations by category

String sınıfı, dizeleri karşılaştırmak, eşitlik için dizeleri test etmek, bir dizedeki karakter veya alt dizeleri bulmak, bir dizeyi değiştirmek, bir dizeden alt dizeleri ayıklamak, dizeleri birleştirmek ve bir dizeyi normalleştiriyor için Üyeler sağlar.The String class provides members for comparing strings, testing strings for equality, finding characters or substrings in a string, modifying a string, extracting substrings from a string, combining strings, formatting values, copying a string, and normalizing a string.

Dizeleri karşılaştırmaComparing strings

Aşağıdaki String yöntemlerini kullanarak sıralama düzeninde göreli konumlarını belirleyecek dizeleri karşılaştırabilirsiniz:You can compare strings to determine their relative position in the sort order by using the following String methods:

  • Compare, bir dizenin sıralama düzeninde ikinci bir dizeye ilişkisini gösteren bir tamsayı döndürür.Compare returns an integer that indicates the relationship of one string to a second string in the sort order.

  • CompareOrdinal, kod noktalarının karşılaştırmasını temel alarak bir dizenin ikinci bir dizeye ilişkisini gösteren bir tamsayı döndürür.CompareOrdinal returns an integer that indicates the relationship of one string to a second string based on a comparison of their code points.

  • CompareTo, geçerli dize örneğinin sıralama düzeninde ikinci bir dizeye ilişkisini gösteren bir tamsayı döndürür.CompareTo returns an integer that indicates the relationship of the current string instance to a second string in the sort order. CompareTo(String) yöntemi String sınıfı için IComparable ve IComparable<T> uygulamalarını sağlar.The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

Dizeleri eşitlik için sınamaTesting strings for equality

İki dizenin eşit olup olmadığını anlamak için Equals yöntemini çağırın.You call the Equals method to determine whether two strings are equal. Örnek Equals(String, String, StringComparison) ve statik Equals(String, StringComparison) aşırı yüklemeleri, karşılaştırmanın kültüre duyarlı veya sıralı olup olmadığını ve büyük/küçük harfe katılıp alınmadığını belirtmenize olanak tanır.The instance Equals(String, String, StringComparison) and the static Equals(String, StringComparison) overloads let you specify whether the comparison is culture-sensitive or ordinal, and whether case is considered or ignored. Eşitlik için çoğu test sıralı olur ve bir sistem kaynağına erişimi (örneğin bir dosya sistemi nesnesi) tanımlayan eşitlik karşılaştırmaları her zaman sıralı olmalıdır.Most tests for equality are ordinal, and comparisons for equality that determine access to a system resource (such as a file system object) should always be ordinal.

Bir dizede karakter bulmaFinding characters in a string

String sınıfı iki tür arama yöntemi içerir:The String class includes two kinds of search methods:

Uyarı

Belirli bir alt dize yerine belirli bir model için bir dizeyi aramak isterseniz, normal ifadeleri kullanmanız gerekir.If you want to search a string for a particular pattern rather than a specific substring, you should use regular expressions. Daha fazla bilgi için bkz. .net normal ifadeler.For more information, see .NET Regular Expressions.

Bir dizeyi değiştirmeModifying a string

String sınıfı, bir dizenin değerini değiştirmek için görüntülenen aşağıdaki yöntemleri içerir:The String class includes the following methods that appear to modify the value of a string:

  • Insert geçerli String örneğine bir dize ekler.Insert inserts a string into the current String instance.

  • PadLeft bir dizenin başlangıcında belirtilen karakterin bir veya daha fazla örneğini ekler.PadLeft inserts one or more occurrences of a specified character at the beginning of a string.

  • PadRight bir dizenin sonunda belirtilen karakterin bir veya daha fazla örneğini ekler.PadRight inserts one or more occurrences of a specified character at the end of a string.

  • Remove geçerli String örneğinden bir alt dizeyi siler.Remove deletes a substring from the current String instance.

  • Replace, bir alt dizeyi geçerli String örneğindeki başka bir alt dizeyle değiştirir.Replace replaces a substring with another substring in the current String instance.

  • ToLower ve ToLowerInvariant bir dizedeki tüm karakterleri küçük harfe dönüştürür.ToLower and ToLowerInvariant convert all the characters in a string to lowercase.

  • ToUpper ve ToUpperInvariant bir dizedeki tüm karakterleri büyük harfe dönüştürür.ToUpper and ToUpperInvariant convert all the characters in a string to uppercase.

  • Trim bir dizenin başındaki ve sonundaki bir karakterin tüm oluşumlarını kaldırır.Trim removes all occurrences of a character from the beginning and end of a string.

  • TrimEnd bir dizenin sonundaki bir karakterin tüm oluşumlarını kaldırır.TrimEnd removes all occurrences of a character from the end of a string.

  • TrimStart bir dizenin başından bir karakterin tüm oluşumlarını kaldırır.TrimStart removes all occurrences of a character from the beginning of a string.

Önemli

Tüm dize değiştirme yöntemleri yeni bir String nesnesi döndürür.All string modification methods return a new String object. Geçerli örneğin değerini değiştirmez.They don't modify the value of the current instance.

Bir dizedeki alt dizeleri ayıklamaExtracting substrings from a string

String.Split yöntemi, tek bir dizeyi birden çok dizeye ayırır.The String.Split method separates a single string into multiple strings. Yöntemin aşırı yüklemeleri, yöntemin devraldığı en fazla alt dize sayısını belirlemek ve döndürülen dizeler arasında boş dizeler (sınırlayıcılar bitişik olduğunda meydana gelir) belirlemek için birden çok sınırlayıcı belirtmenize olanak tanır.Overloads of the method allow you to specify multiple delimiters, to determine the maximum number of substrings that the method extracts, and to determine whether empty strings (which occur when delimiters are adjacent) are included among the returned strings.

Dizeleri birleştirmeCombining strings

Aşağıdaki String yöntemleri dize birleştirme için kullanılabilir:The following String methods can be used for string concatenation:

  • Concat bir veya daha fazla alt dizeyi tek bir dizeye birleştirir.Concat combines one or more substrings into a single string.

  • Join bir veya daha fazla alt dizeyi tek bir öğe içine birleştirir ve her alt dize arasına bir ayırıcı ekler.Join concatenates one or more substrings into a single element and adds a separator between each substring.

Değerleri biçimlendirmeFormatting values

String.Format yöntemi, bir dizedeki bir veya daha fazla yer tutucuyu, bazı nesne veya değer dize temsili ile değiştirmek için bileşik biçimlendirme özelliğini kullanır.The String.Format method uses the composite formatting feature to replace one or more placeholders in a string with the string representation of some object or value. Format yöntemi genellikle aşağıdakileri yapmak için kullanılır:The Format method is often used to do the following:

  • Bir dizedeki sayısal değerin dize gösterimini eklemek için.To embed the string representation of a numeric value in a string.

  • Bir dizedeki tarih ve saat değerinin dize gösterimini eklemek için.To embed the string representation of a date and time value in a string.

  • Bir sabit listesi değerinin dize gösterimini bir dizeye eklemek için.To embed the string representation of an enumeration value in a string.

  • Bir dizedeki IFormattable arabirimini destekleyen bazı nesnenin dize temsilini eklemek için.To embed the string representation of some object that supports the IFormattable interface in a string.

  • Daha büyük bir dizedeki bir alanda bir alt dizeyi sağ veya sol Alta Yasla.To right-justify or left-justify a substring in a field within a larger string.

Biçimlendirme işlemleri ve örnekleri hakkında ayrıntılı bilgi için bkz. Format aşırı yükleme özeti.For detailed information about formatting operations and examples, see the Format overload summary.

Bir dizeyi kopyalamaCopying a string

Bir dizenin kopyasını oluşturmak için aşağıdaki String yöntemlerini çağırabilirsiniz:You can call the following String methods to make a copy of a string:

  • Clone, var olan bir String nesnesine bir başvuru döndürür.Clone returns a reference to an existing String object.

  • Copy var olan bir dizenin bir kopyasını oluşturur.Copy creates a copy of an existing string.

  • CopyTo bir dizenin bir bölümünü bir karakter dizisine kopyalar.CopyTo copies a portion of a string to a character array.

Bir dizeyi normalleştirmeNormalizing a string

Unicode 'da, tek bir karakter birden çok kod noktasına sahip olabilir.In Unicode, a single character can have multiple code points. Normalleştirme, bu denk karakterleri aynı ikili gösterimine dönüştürür.Normalization converts these equivalent characters into the same binary representation. String.Normalize yöntemi normalleştirme gerçekleştirir ve String.IsNormalized yöntemi bir dizenin normalleştirilip normalleştirilmediğini belirler.The String.Normalize method performs the normalization, and the String.IsNormalized method determines whether a string is normalized.

Daha fazla bilgi ve bir örnek için, bu konunun önceki bölümlerinde bulunan normalleştirme bölümüne bakın.For more information and an example, see the Normalization section earlier in this topic.

Oluşturucular

String(Char*)

String sınıfının yeni bir örneğini, belirli bir işaretçi tarafından gösterilen değere bir Unicode karakter dizisine başlatır.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters.

String(Char*, Int32, Int32)

String sınıfının yeni bir örneğini, bir Unicode karakter dizisine, bu dizideki bir başlangıç karakter konumuna ve bir uzunluğa göre belirtilen bir işaretçi tarafından belirtilen değere başlatır.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of Unicode characters, a starting character position within that array, and a length.

String(Char, Int32)

String sınıfının yeni bir örneğini, belirtilen bir Unicode karakteriyle belirtilen sayıda tekrarlayarak belirtilen değere başlatır.Initializes a new instance of the String class to the value indicated by a specified Unicode character repeated a specified number of times.

String(Char[])

String sınıfının yeni bir örneğini belirtilen karakter dizisinde belirtilen Unicode karakterlerine başlatır.Initializes a new instance of the String class to the Unicode characters indicated in the specified character array.

String(Char[], Int32, Int32)

String sınıfının yeni bir örneğini bir Unicode karakterleri dizisi, bu dizideki bir başlangıç karakter konumu ve uzunluğu ile belirtilen değere başlatır.Initializes a new instance of the String class to the value indicated by an array of Unicode characters, a starting character position within that array, and a length.

String(ReadOnlySpan<Char>)

String sınıfının yeni bir örneğini, belirtilen salt okunurdur.Initializes a new instance of the String class to the Unicode characters indicated in the specified read-only span.

String(SByte*)

String sınıfının yeni bir örneğini, 8 bit işaretli tamsayılar dizisinin bir işaretçisi tarafından belirtilen değere başlatır.Initializes a new instance of the String class to the value indicated by a pointer to an array of 8-bit signed integers.

String(SByte*, Int32, Int32)

String sınıfının yeni bir örneğini, bir 8 bit işaretli tamsayılar dizisine, bu dizideki başlangıç konumuna ve bir uzunluğa göre belirtilen bir işaretçi tarafından belirtilen değere başlatır.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, and a length.

String(SByte*, Int32, Int32, Encoding)

String sınıfının yeni bir örneğini, bir 8 bit işaretli tamsayılar dizisine, bu dizideki bir başlangıç konumuna, uzunluğa ve bir Encoding nesnesine başlatır.Initializes a new instance of the String class to the value indicated by a specified pointer to an array of 8-bit signed integers, a starting position within that array, a length, and an Encoding object.

Alanlar

Empty

Boş dizeyi temsil eder.Represents the empty string. Bu alan salt okunur durumdadır.This field is read-only.

Özellikler

Chars[Int32]

Geçerli String nesnesinde belirtilen konumdaki Char nesnesini alır.Gets the Char object at a specified position in the current String object.

Length

Geçerli String nesnesindeki karakter sayısını alır.Gets the number of characters in the current String object.

Yöntemler

Clone()

Bu Stringörneğine bir başvuru döndürür.Returns a reference to this instance of String.

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

Belirtilen iki String nesnenin alt dizelerini karşılaştırır ve sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.Compares substrings of two specified String objects and returns an integer that indicates their relative position in the sort order.

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

Belirtilen iki String nesnenin alt dizelerini karşılaştırır, durumlarını yoksayar veya dikkate alır ve sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.Compares substrings of two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

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

Belirtilen iki String nesnenin alt dizelerini karşılaştırır, 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 konumlarını gösteren bir tamsayı döndürür.Compares substrings of two specified String objects, ignoring or honoring their case and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

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

Karşılaştırmayı etkilemek için belirtilen karşılaştırma seçeneklerini ve kültüre özgü bilgileri kullanarak belirtilen iki String nesnesinin 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.Compares substrings of two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two substrings to each other in the sort order.

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

Belirtilen kuralları kullanarak belirtilen iki String nesnenin alt dizelerini karşılaştırır ve sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.Compares substrings of two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

Compare(String, String)

Belirtilen iki String nesnesini karşılaştırır ve sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.Compares two specified String objects and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean)

Belirtilen iki String nesnesini karşılaştırır, durumlarını yoksayarak veya dikkate alarak sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.Compares two specified String objects, ignoring or honoring their case, and returns an integer that indicates their relative position in the sort order.

Compare(String, String, Boolean, CultureInfo)

Belirtilen iki String nesnesini karşılaştırır, durumlarını yoksayar veya dikkate alarak, 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.Compares two specified String objects, ignoring or honoring their case, and using culture-specific information to influence the comparison, and returns an integer that indicates their relative position in the sort order.

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 String nesnesini karşılaştırır ve sıralama düzeninde iki dizenin birbirleriyle ilişkisini gösteren bir tamsayı döndürür.Compares two specified String objects using the specified comparison options and culture-specific information to influence the comparison, and returns an integer that indicates the relationship of the two strings to each other in the sort order.

Compare(String, String, StringComparison)

Belirtilen kuralları kullanarak belirtilen iki String nesnesini karşılaştırır ve sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.Compares two specified String objects using the specified rules, and returns an integer that indicates their relative position in the sort order.

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

Her alt dizeden karşılık gelen Char nesnelerinin sayısal değerlerini değerlendirerek belirtilen iki String nesnenin alt dizelerini karşılaştırır.Compares substrings of two specified String objects by evaluating the numeric values of the corresponding Char objects in each substring.

CompareOrdinal(String, String)

Her dizedeki karşılık gelen Char nesnelerinin sayısal değerlerini değerlendirerek belirtilen iki String nesnesini karşılaştırır.Compares two specified String objects by evaluating the numeric values of the corresponding Char objects in each string.

CompareTo(Object)

Bu örneği belirtilen bir Object karşılaştırır ve bu örneğin belirtilen Objectgöre sıralama düzeninde aynı konumda olup olmadığını gösterir.Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object.

CompareTo(String)

Bu örneği belirtilen bir String nesnesiyle karşılaştırır ve belirtilen dize ile sıralama düzeninde aynı konumda yer alır ve bu örneğin ne kadar önce kullanılacağını gösterir.Compares this instance with a specified String object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified string.

Concat(IEnumerable<String>)

Stringtüründeki oluşturulan IEnumerable<T> koleksiyonun üyelerini birleştirir.Concatenates the members of a constructed IEnumerable<T> collection of type String.

Concat(Object)

Belirtilen nesnenin dize temsilini oluşturur.Creates the string representation of a specified object.

Concat(Object, Object)

Belirtilen iki nesnenin dize gösterimlerini birleştirir.Concatenates the string representations of two specified objects.

Concat(Object, Object, Object)

Belirtilen üç nesnenin dize gösterimlerini birleştirir.Concatenates the string representations of three specified objects.

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.Concatenates the string representations of four specified objects and any objects specified in an optional variable length parameter list.

Concat(Object[])

Belirtilen bir Object dizisindeki öğelerin dize gösterimlerini birleştirir.Concatenates the string representations of the elements in a specified Object array.

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

Belirtilen iki salt okunurdur karakter yayılmalarını dize temsillerini birleştirir.Concatenates the string representations of two specified read-only character spans.

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

Belirtilen üç salt okunurdur karakter yayılımünün dize gösterimlerini birleştirir.Concatenates the string representations of three specified read-only character spans.

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

Belirtilen dört salt okunurdur karakter yayılımünü dize temsillerini birleştirir.Concatenates the string representations of four specified read-only character spans.

Concat(String, String)

Stringbelirtilen iki örneğini birleştirir.Concatenates two specified instances of String.

Concat(String, String, String)

Stringbelirtilen üç örneğini birleştirir.Concatenates three specified instances of String.

Concat(String, String, String, String)

Belirtilen dört Stringörneğini art arda ekler.Concatenates four specified instances of String.

Concat(String[])

Belirtilen String dizisinin öğelerini birleştirir.Concatenates the elements of a specified String array.

Concat<T>(IEnumerable<T>)

IEnumerable<T> uygulamasının üyelerini art arda ekler.Concatenates the members of an IEnumerable<T> implementation.

Contains(Char)

Bu dize içinde belirtilen bir karakterin oluşup oluşmadığını gösteren bir değer döndürür.Returns a value indicating whether a specified character occurs within this string.

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.Returns a value indicating whether a specified character occurs within this string, using the specified comparison rules.

Contains(String)

Belirtilen bir alt dizenin bu dize içinde olup olmadığını gösteren bir değer döndürür.Returns a value indicating whether a specified substring occurs within this string.

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.Returns a value indicating whether a specified string occurs within this string, using the specified comparison rules.

Copy(String)

Belirtilen Stringaynı değere sahip String yeni bir örneğini oluşturur.Creates a new instance of String with the same value as a specified String.

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

Bu örnekteki belirli bir konumdan belirtilen sayıda karakteri bir Unicode karakter dizisinde belirtilen konuma kopyalar.Copies a specified number of characters from a specified position in this instance to a specified position in an array of Unicode characters.

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

Belirli bir uzunluğa sahip yeni bir dize oluşturur ve belirtilen geri çağırma kullanılarak oluşturulduktan sonra başlatır.Creates a new string with a specific length and initializes it after creation by using the specified callback.

EndsWith(Char)

Bu dize örneğinin sonunun belirtilen karakterle eşleşip eşleşmediğini belirler.Determines whether the end of this string instance matches the specified character.

EndsWith(String)

Bu dize örneğinin sonunun belirtilen dizeyle eşleşip eşleşmediğini belirler.Determines whether the end of this string instance matches the specified string.

EndsWith(String, Boolean, CultureInfo)

Belirtilen kültür kullanılarak karşılaştırıldığında, bu dize örneğinin sonunun belirtilen dizeyle eşleşip eşleşmediğini belirler.Determines whether the end of this string instance matches the specified string when compared using the specified culture.

EndsWith(String, StringComparison)

Belirtilen karşılaştırma seçeneği kullanılarak karşılaştırılan bu dize örneğinin sonunun belirtilen dizeyle eşleşip eşleşmediğini belirler.Determines whether the end of this string instance matches the specified string when compared using the specified comparison option.

EnumerateRunes()

Bu dizeden Rune bir sabit listesi döndürür.Returns an enumeration of Rune from this string.

Equals(Object)

Bu örneğin ve aynı zamanda bir String nesnesi olması gereken belirtilen nesnenin aynı değere sahip olup olmadığını belirler.Determines whether this instance and a specified object, which must also be a String object, have the same value.

Equals(String)

Bu örneğin ve belirtilen başka bir String nesnesinin aynı değere sahip olup olmadığını belirler.Determines whether this instance and another specified String object have the same value.

Equals(String, String)

Belirtilen iki String nesnesinin aynı değere sahip olup olmadığını belirler.Determines whether two specified String objects have the same value.

Equals(String, String, StringComparison)

Belirtilen iki String nesnesinin aynı değere sahip olup olmadığını belirler.Determines whether two specified String objects have the same value. Bir parametre, Karşılaştırmada kullanılan kültür, durum ve sıralama kurallarını belirtir.A parameter specifies the culture, case, and sort rules used in the comparison.

Equals(String, StringComparison)

Bu dizenin ve belirtilen String nesnesinin aynı değere sahip olup olmadığını belirler.Determines whether this string and a specified String object have the same value. Bir parametre, Karşılaştırmada kullanılan kültür, durum ve sıralama kurallarını belirtir.A parameter specifies the culture, case, and sort rules used in the comparison.

Format(IFormatProvider, String, Object)

Belirtilen dizedeki biçim öğesini veya öğeleri karşılık gelen nesnenin dize gösterimiyle değiştirir.Replaces the format item or items in a specified string with the string representation of the corresponding object. Parametresi kültüre özgü biçimlendirme bilgilerini sağlar.A parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object, Object)

Bir dizedeki biçim öğelerini, belirtilen iki nesnenin dize gösterimiyle değiştirir.Replaces the format items in a string with the string representation of two specified objects. Parametresi kültüre özgü biçimlendirme bilgilerini sağlar.A parameter supplies culture-specific formatting information.

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

Bir dizedeki biçim öğelerini, belirtilen üç nesnenin dize gösterimiyle değiştirir.Replaces the format items in a string with the string representation of three specified objects. Parametresi kültüre özgü biçimlendirme bilgilerini sağlar.An parameter supplies culture-specific formatting information.

Format(IFormatProvider, String, Object[])

Bir dizedeki biçim öğelerini, belirtilen dizide karşılık gelen nesnelerin dize gösterimlerine göre değiştirir.Replaces the format items in a string with the string representations of corresponding objects in a specified array. Parametresi kültüre özgü biçimlendirme bilgilerini sağlar.A parameter supplies culture-specific formatting information.

Format(String, Object)

Bir dizedeki bir veya daha fazla biçim öğesini, belirtilen nesnenin dize gösterimiyle değiştirir.Replaces one or more format items in a string with the string representation of a specified object.

Format(String, Object, Object)

Bir dizedeki biçim öğelerini, belirtilen iki nesnenin dize gösterimiyle değiştirir.Replaces the format items in a string with the string representation of two specified objects.

Format(String, Object, Object, Object)

Bir dizedeki biçim öğelerini, belirtilen üç nesnenin dize gösterimiyle değiştirir.Replaces the format items in a string with the string representation of three specified objects.

Format(String, Object[])

Belirtilen dizedeki biçim öğesini, belirtilen dizide karşılık gelen nesnenin dize gösterimiyle değiştirir.Replaces the format item in a specified string with the string representation of a corresponding object in a specified array.

GetEnumerator()

Bu dizedeki ayrı karakterler arasında yineleyebilir bir nesne alır.Retrieves an object that can iterate through the individual characters in this string.

GetHashCode()

Bu dize için karma kodu döndürür.Returns the hash code for this string.

GetHashCode(ReadOnlySpan<Char>)

Belirtilen salt okunurdur karakter aralığı için karma kodu döndürür.Returns the hash code for the provided read-only character span.

GetHashCode(ReadOnlySpan<Char>, StringComparison)

Belirtilen kuralları kullanarak, sunulan salt okunurdur karakter aralığı için karma kodu döndürür.Returns the hash code for the provided read-only character span using the specified rules.

GetHashCode(StringComparison)

Belirtilen kuralları kullanarak bu dize için karma kodu döndürür.Returns the hash code for this string using the specified rules.

GetPinnableReference()

Sıfır dizinindeki dizenin öğesine bir başvuru döndürür.Returns a reference to the element of the string at index zero.

GetType()

Geçerli örneğin Type alır.Gets the Type of the current instance.

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

String sınıfının TypeCode döndürür.Returns the TypeCode for the String class.

IndexOf(Char)

Bu dizedeki belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini bildirir.Reports the zero-based index of the first occurrence of the specified Unicode character in this string.

IndexOf(Char, Int32)

Bu dizedeki belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini bildirir.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. Arama belirtilen bir karakter konumunda başlar.The search starts at a specified character position.

IndexOf(Char, Int32, Int32)

Bu örnekte belirtilen karakterin ilk oluşumunun sıfır tabanlı dizinini bildirir.Reports the zero-based index of the first occurrence of the specified character in this instance. Arama belirtilen bir karakter konumunda başlar ve belirtilen sayıda karakter konumunu inceler.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(Char, StringComparison)

Bu dizedeki belirtilen Unicode karakterinin ilk oluşumunun sıfır tabanlı dizinini bildirir.Reports the zero-based index of the first occurrence of the specified Unicode character in this string. Bir parametre belirtilen karakter için kullanılacak arama türünü belirtir.A parameter specifies the type of search to use for the specified character.

IndexOf(String)

Bu örnekteki belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini bildirir.Reports the zero-based index of the first occurrence of the specified string in this instance.

IndexOf(String, Int32)

Bu örnekteki belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini bildirir.Reports the zero-based index of the first occurrence of the specified string in this instance. Arama belirtilen bir karakter konumunda başlar.The search starts at a specified character position.

IndexOf(String, Int32, Int32)

Bu örnekteki belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini bildirir.Reports the zero-based index of the first occurrence of the specified string in this instance. Arama belirtilen bir karakter konumunda başlar ve belirtilen sayıda karakter konumunu inceler.The search starts at a specified character position and examines a specified number of character positions.

IndexOf(String, Int32, Int32, StringComparison)

Geçerli String nesnesinde belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar.Reports the zero-based index of the first occurrence of the specified string in the current String object. 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.Parameters specify the starting search position in the current string, the number of characters in the current string to search, and the type of search to use for the specified string.

IndexOf(String, Int32, StringComparison)

Geçerli String nesnesinde belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar.Reports the zero-based index of the first occurrence of the specified string in the current String object. Parametreler geçerli dizedeki başlangıç arama konumunu ve belirtilen dize için kullanılacak arama türünü belirtir.Parameters specify the starting search position in the current string and the type of search to use for the specified string.

IndexOf(String, StringComparison)

Geçerli String nesnesinde belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini raporlar.Reports the zero-based index of the first occurrence of the specified string in the current String object. Bir parametre, belirtilen dize için kullanılacak arama türünü belirtir.A parameter specifies the type of search to use for the specified string.

IndexOfAny(Char[])

Belirli bir Unicode karakter dizisindeki herhangi bir karakterin bu örneğindeki ilk oluşumun sıfır tabanlı dizinini raporlar.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters.

IndexOfAny(Char[], Int32)

Belirli bir Unicode karakter dizisindeki herhangi bir karakterin bu örneğindeki ilk oluşumun sıfır tabanlı dizinini raporlar.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. Arama belirtilen bir karakter konumunda başlar.The search starts at a specified character position.

IndexOfAny(Char[], Int32, Int32)

Belirli bir Unicode karakter dizisindeki herhangi bir karakterin bu örneğindeki ilk oluşumun sıfır tabanlı dizinini raporlar.Reports the zero-based index of the first occurrence in this instance of any character in a specified array of Unicode characters. Arama belirtilen bir karakter konumunda başlar ve belirtilen sayıda karakter konumunu inceler.The search starts at a specified character position and examines a specified number of character positions.

Insert(Int32, String)

Bu örnekteki belirtilen dizin konumunda belirtilen bir dizenin eklendiği yeni bir dize döndürür.Returns a new string in which a specified string is inserted at a specified index position in this instance.

Intern(String)

Belirtilen Stringsistemin başvurusunu alır.Retrieves the system's reference to the specified String.

IsInterned(String)

Belirtilen bir Stringbaşvurusunu alır.Retrieves a reference to a specified String.

IsNormalized()

Bu dizenin Unicode normalleştirme biçimi C biçiminde olup olmadığını gösterir.Indicates whether this string is in Unicode normalization form C.

IsNormalized(NormalizationForm)

Bu dizenin belirtilen Unicode normalleştirme biçiminde olup olmadığını gösterir.Indicates whether this string is in the specified Unicode normalization form.

IsNullOrEmpty(String)

Belirtilen dizenin null mi yoksa boş bir dize mi ("") olduğunu gösterir.Indicates whether the specified string is null or an empty string ("").

IsNullOrWhiteSpace(String)

Belirtilen bir dizenin null, boş veya yalnızca boşluk karakterlerinden oluşan bir değer olup olmadığını gösterir.Indicates whether a specified string is null, empty, or consists only of white-space characters.

Join(Char, Object[])

Her üye arasında belirtilen ayırıcıyı kullanarak bir nesne dizisinin dize gösterimlerini birleştirir.Concatenates the string representations of an array of objects, using the specified separator between each member.

Join(Char, String[])

Her üye arasında belirtilen ayırıcıyı kullanarak bir dize dizisini birleştirir.Concatenates an array of strings, using the specified separator between each member.

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

Her üye arasında belirtilen ayırıcıyı kullanarak, startIndex konumunda bulunan value ' deki öğeden başlayarak ve count öğelerin sonuna kadar olan bir dizi dizeyi birleştirir.Concatenates an array of strings, using the specified separator between each member, starting with the element in value located at the startIndex position, and concatenating up to count elements.

Join(String, IEnumerable<String>)

Her üye arasında belirtilen ayırıcıyı kullanarak Stringtüründeki oluşturulan IEnumerable<T> koleksiyonun üyelerini birleştirir.Concatenates the members of a constructed IEnumerable<T> collection of type String, using the specified separator between each member.

Join(String, Object[])

Her öğe arasında belirtilen ayırıcıyı kullanarak bir nesne dizisinin öğelerini birleştirir.Concatenates the elements of an object array, using the specified separator between each element.

Join(String, String[])

Her öğe arasında belirtilen ayırıcıyı kullanarak bir dize dizisinin tüm öğelerini birleştirir.Concatenates all the elements of a string array, using the specified separator between each element.

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

Her öğe arasında belirtilen ayırıcıyı kullanarak bir dize dizisinin belirtilen öğelerini birleştirir.Concatenates the specified elements of a string array, using the specified separator between each element.

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

Her üye arasındaki belirtilen ayırıcıyı kullanarak bir koleksiyonun üyelerini art arda ekler.Concatenates the members of a collection, using the specified separator between each member.

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

Her üye arasındaki belirtilen ayırıcıyı kullanarak bir koleksiyonun üyelerini art arda ekler.Concatenates the members of a collection, using the specified separator between each member.

LastIndexOf(Char)

Bu örnek içinde belirtilen bir Unicode karakterinin son oluşumunun sıfır tabanlı dizin konumunu bildirir.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance.

LastIndexOf(Char, Int32)

Bu örnek içinde belirtilen bir Unicode karakterinin son oluşumunun sıfır tabanlı dizin konumunu bildirir.Reports the zero-based index position of the last occurrence of a specified Unicode character within this instance. Arama, belirtilen karakter konumunda başlar ve dizenin başına doğru geriye gider.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(Char, Int32, Int32)

Bu örnek içindeki bir alt dizede belirtilen Unicode karakterinin son oluşumunun sıfır tabanlı dizin konumunu bildirir.Reports the zero-based index position of the last occurrence of the specified Unicode character in a substring within this instance. Arama belirtilen bir karakter konumunda başlar ve belirtilen sayıda karakter konumu için dizenin başlangıcına doğru ilerler.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

LastIndexOf(String)

Bu örnekte belirtilen bir dizenin son ortaya çıkışına ilişkin sıfır tabanlı bir dizin konumunu rapor eder.Reports the zero-based index position of the last occurrence of a specified string within this instance.

LastIndexOf(String, Int32)

Bu örnekte belirtilen bir dizenin son ortaya çıkışına ilişkin sıfır tabanlı bir dizin konumunu rapor eder.Reports the zero-based index position of the last occurrence of a specified string within this instance. Arama, belirtilen karakter konumunda başlar ve dizenin başına doğru geriye gider.The search starts at a specified character position and proceeds backward toward the beginning of the string.

LastIndexOf(String, Int32, Int32)

Bu örnekte belirtilen bir dizenin son ortaya çıkışına ilişkin sıfır tabanlı bir dizin konumunu rapor eder.Reports the zero-based index position of the last occurrence of a specified string within this instance. Arama belirtilen bir karakter konumunda başlar ve belirtilen sayıda karakter konumu için dizenin başlangıcına doğru ilerler.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

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.Reports the zero-based index position of the last occurrence of a specified string within this instance. Arama belirtilen bir karakter konumunda başlar ve belirtilen karakter konumları sayısı için dizenin başına doğru ilerler.The search starts at a specified character position and proceeds backward toward the beginning of the string for the specified number of character positions. Bir parametre, belirtilen dize aranırken gerçekleştirilecek karşılaştırma türünü belirtir.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, Int32, StringComparison)

Geçerli String nesnesi içinde belirtilen bir dizenin son oluşumunun sıfır tabanlı dizinini raporlar.Reports the zero-based index of the last occurrence of a specified string within the current String object. Arama, belirtilen karakter konumunda başlar ve dizenin başına doğru geriye gider.The search starts at a specified character position and proceeds backward toward the beginning of the string. Bir parametre, belirtilen dize aranırken gerçekleştirilecek karşılaştırma türünü belirtir.A parameter specifies the type of comparison to perform when searching for the specified string.

LastIndexOf(String, StringComparison)

Geçerli String nesnesi içinde belirtilen bir dizenin son oluşumunun sıfır tabanlı dizinini raporlar.Reports the zero-based index of the last occurrence of a specified string within the current String object. Bir parametre, belirtilen dize için kullanılacak arama türünü belirtir.A parameter specifies the type of search to use for the specified string.

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.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array.

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.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. Arama, belirtilen karakter konumunda başlar ve dizenin başına doğru geriye gider.The search starts at a specified character position and proceeds backward toward the beginning of the string.

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.Reports the zero-based index position of the last occurrence in this instance of one or more characters specified in a Unicode array. Arama belirtilen bir karakter konumunda başlar ve belirtilen sayıda karakter konumu için dizenin başlangıcına doğru ilerler.The search starts at a specified character position and proceeds backward toward the beginning of the string for a specified number of character positions.

MemberwiseClone()

Geçerli Objectbasit bir kopyasını oluşturur.Creates a shallow copy of the current Object.

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

Metinsel değeri bu dize ile aynı olan, ancak ikili temsili Unicode normalleştirme biçimi C içinde olan yeni bir dize döndürür.Returns a new string whose textual value is the same as this string, but whose binary representation is in Unicode normalization form C.

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.Returns a new string whose textual value is the same as this string, but whose binary representation is in the specified Unicode normalization form.

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.Returns a new string that right-aligns the characters in this instance by padding them with spaces on the left, for a specified total length.

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.Returns a new string that right-aligns the characters in this instance by padding them on the left with a specified Unicode character, for a specified total length.

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.Returns a new string that left-aligns the characters in this string by padding them with spaces on the right, for a specified total length.

PadRight(Int32, Char)

Belirtilen toplam uzunluk için, belirtilen bir Unicode karakteriyle sağa doğru doldurma yoluyla bu dizedeki karakterleri sola hizalayan yeni bir dize döndürür.Returns a new string that left-aligns the characters in this string by padding them on the right with a specified Unicode character, for a specified total length.

Remove(Int32)

Geçerli örnekteki tüm karakterlerin, belirtilen bir konumdan başlayarak ve son konumdan devam eden silindiği yeni bir dize döndürür.Returns a new string in which all the characters in the current instance, beginning at a specified position and continuing through the last position, have been deleted.

Remove(Int32, Int32)

Geçerli örnekte belirtilen bir konumdan başlayarak belirtilen sayıda karakter silindiği yeni bir dize döndürür.Returns a new string in which a specified number of characters in the current instance beginning at a specified position have been deleted.

Replace(Char, Char)

Bu örnekteki belirtilen Unicode karakterinin tüm oluşumlarının, belirtilen başka bir Unicode karakterle değiştirildiği yeni bir dize döndürür.Returns a new string in which all occurrences of a specified Unicode character in this instance are replaced with another specified Unicode character.

Replace(String, String)

Geçerli örnekteki belirtilen bir dizenin tüm oluşumlarının, belirtilen başka bir dizeyle değiştirildiği yeni bir dize döndürür.Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string.

Replace(String, String, Boolean, CultureInfo)

Geçerli örnekteki belirtilen dizenin tüm oluşumlarının, belirtilen kültür ve büyük/küçük harf duyarlılığı kullanılarak başka bir belirtilen dizeyle değiştirildiği yeni bir dize döndürür.Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string, using the provided culture and case sensitivity.

Replace(String, String, StringComparison)

Geçerli örnekteki belirtilen bir dizenin tüm örneklerinin, belirtilen karşılaştırma türü kullanılarak, belirtilen başka bir dizeyle değiştirildiği yeni bir dize döndürür.Returns a new string in which all occurrences of a specified string in the current instance are replaced with another specified string, using the provided comparison type.

Split(Char, Int32, StringSplitOptions)

Bir dizeyi, belirtilen karakter ayırıcısına göre en fazla sayı alt dizelere böler.Splits a string into a maximum number substrings based on the provided character separator.

Split(Char, StringSplitOptions)

Belirtilen karakter ayırıcısına göre bir dizeyi alt dizelere böler.Splits a string into substrings based on the provided character separator.

Split(Char[])

Bir dizeyi, ayırıcı dizideki karakterleri temel alan alt dizelere böler.Splits a string into substrings that are based on the characters in the separator array.

Split(Char[], Int32)

Bir dizeyi dizideki karakterlere göre en fazla sayıda alt dize olarak böler.Splits a string into a maximum number of substrings based on the characters in an array. Döndürülecek en fazla alt dize sayısını da belirtirsiniz.You also specify the maximum number of substrings to return.

Split(Char[], Int32, StringSplitOptions)

Bir dizeyi dizideki karakterlere göre en fazla sayıda alt dize olarak böler.Splits a string into a maximum number of substrings based on the characters in an array.

Split(Char[], StringSplitOptions)

Bir dizeyi dizideki karakterlere göre alt dizelere böler.Splits a string into substrings based on the characters in an array. Alt dizelerin boş dizi öğeleri içerip içermediğini belirtebilirsiniz.You can specify whether the substrings include empty array elements.

Split(String, Int32, StringSplitOptions)

Bir dizeyi, belirtilen dize ayırıcısına göre en fazla alt dize sayısına böler.Splits a string into a maximum number of substrings based on the provided string separator.

Split(String, StringSplitOptions)

Bir dizeyi, belirtilen dize ayırıcısını temel alan alt dizelere böler.Splits a string into substrings that are based on the provided string separator.

Split(String[], Int32, StringSplitOptions)

Bir dizeyi bir dizideki dizeleri temel alarak en fazla alt dize sayısına böler.Splits a string into a maximum number of substrings based on the strings in an array. Alt dizelerin boş dizi öğeleri içerip içermediğini belirtebilirsiniz.You can specify whether the substrings include empty array elements.

Split(String[], StringSplitOptions)

Bir dizeyi dizideki dizelere göre alt dizelere böler.Splits a string into substrings based on the strings in an array. Alt dizelerin boş dizi öğeleri içerip içermediğini belirtebilirsiniz.You can specify whether the substrings include empty array elements.

StartsWith(Char)

Bu dize örneğinin belirtilen karakterle başlatılıp başlatılmayacağını belirler.Determines whether this string instance starts with the specified character.

StartsWith(String)

Bu dize örneğinin başlangıcının belirtilen dizeyle eşleşip eşleşmediğini belirler.Determines whether the beginning of this string instance matches the specified string.

StartsWith(String, Boolean, CultureInfo)

Belirtilen kültür kullanılarak karşılaştırıldığında, bu dize örneğinin başlangıcının belirtilen dizeyle eşleşip eşleşmediğini belirler.Determines whether the beginning of this string instance matches the specified string when compared using the specified culture.

StartsWith(String, StringComparison)

Belirtilen karşılaştırma seçeneği kullanılarak karşılaştırıldığında, bu dize örneğinin başlangıcının belirtilen dizeyle eşleşip eşleşmediğini belirler.Determines whether the beginning of this string instance matches the specified string when compared using the specified comparison option.

Substring(Int32)

Bu örnekten bir alt dize alır.Retrieves a substring from this instance. Alt dize belirtilen bir karakter konumunda başlar ve dizenin sonuna kadar devam eder.The substring starts at a specified character position and continues to the end of the string.

Substring(Int32, Int32)

Bu örnekten bir alt dize alır.Retrieves a substring from this instance. Alt dize belirtilen bir karakter konumunda başlar ve belirtilen uzunluğa sahiptir.The substring starts at a specified character position and has a specified length.

ToCharArray()

Bu örnekteki karakterleri Unicode karakter dizisine kopyalar.Copies the characters in this instance to a Unicode character array.

ToCharArray(Int32, Int32)

Bu örnekteki belirtilen bir alt dizenin karakterlerini bir Unicode karakter dizisine kopyalar.Copies the characters in a specified substring in this instance to a Unicode character array.

ToLower()

Bu dizenin küçük harfe dönüştürülmüş bir kopyasını döndürür.Returns a copy of this string converted to lowercase.

ToLower(CultureInfo)

Belirtilen kültürün büyük/küçük harf kuralları kullanılarak bu dizenin küçük harfe dönüştürülmüş bir kopyasını döndürür.Returns a copy of this string converted to lowercase, using the casing rules of the specified culture.

ToLowerInvariant()

Sabit kültürün büyük/küçük harf kuralları kullanılarak bu String nesnesinin küçük harfe dönüştürülmüş bir kopyasını döndürür.Returns a copy of this String object converted to lowercase using the casing rules of the invariant culture.

ToString()

Bu Stringörneğini döndürür; hiçbir gerçek dönüştürme gerçekleştirilmez.Returns this instance of String; no actual conversion is performed.

ToString(IFormatProvider)

Bu Stringörneğini döndürür; hiçbir gerçek dönüştürme gerçekleştirilmez.Returns this instance of String; no actual conversion is performed.

ToUpper()

Bu dizenin büyük harfe dönüştürülmüş bir kopyasını döndürür.Returns a copy of this string converted to uppercase.

ToUpper(CultureInfo)

Belirtilen kültürün büyük/küçük harf kuralları kullanılarak bu dizenin büyük harfe dönüştürülmüş bir kopyasını döndürür.Returns a copy of this string converted to uppercase, using the casing rules of the specified culture.

ToUpperInvariant()

Bu String nesnesinin, sabit kültürün büyük/küçük harf kuralları kullanılarak büyük harfe dönüştürülmüş bir kopyasını döndürür.Returns a copy of this String object converted to uppercase using the casing rules of the invariant culture.

Trim()

Geçerli dizeden tüm baştaki ve sondaki boşluk karakterlerini kaldırır.Removes all leading and trailing white-space characters from the current string.

Trim(Char)

Geçerli dizeden bir karakterin tüm öndeki ve sondaki örneklerini kaldırır.Removes all leading and trailing instances of a character from the current string.

Trim(Char[])

Geçerli dizeden bir dizide belirtilen bir karakter kümesinin tüm öndeki ve sondaki oluşumlarını kaldırır.Removes all leading and trailing occurrences of a set of characters specified in an array from the current string.

TrimEnd()

Geçerli dizeden tüm sondaki boşluk karakterlerini kaldırır.Removes all the trailing white-space characters from the current string.

TrimEnd(Char)

Geçerli dizeden bir karakterin tüm sonundaki oluşumlarını kaldırır.Removes all the trailing occurrences of a character from the current string.

TrimEnd(Char[])

Geçerli dizeden bir dizide belirtilen bir karakter kümesinin tüm sondaki oluşumlarını kaldırır.Removes all the trailing occurrences of a set of characters specified in an array from the current string.

TrimStart()

Geçerli dizeden tüm baştaki boşluk karakterlerini kaldırır.Removes all the leading white-space characters from the current string.

TrimStart(Char)

Geçerli dizeden belirtilen bir karakterin tüm önde gelen oluşumlarını kaldırır.Removes all the leading occurrences of a specified character from the current string.

TrimStart(Char[])

Geçerli dizeden bir dizide belirtilen bir karakter kümesinin tüm önde gelen oluşumlarını kaldırır.Removes all the leading occurrences of a set of characters specified in an array from the current string.

İşleçler

Equality(String, String)

Belirtilen iki dizenin aynı değere sahip olup olmadığını belirler.Determines whether two specified strings have the same value.

Implicit(String to ReadOnlySpan<Char>)

Belirli bir dizenin salt okunurdur bir karakter aralığına örtük olarak dönüştürülmesini tanımlar.Defines an implicit conversion of a given string to a read-only span of characters.

Inequality(String, String)

Belirtilen iki dizenin farklı değerlere sahip olup olmadığını belirler.Determines whether two specified strings have different values.

Belirtik Arabirim Kullanımları

IComparable.CompareTo(Object)

Bu örneği belirtilen bir Object karşılaştırır ve bu örneğin belirtilen Objectgöre sıralama düzeninde aynı konumda olup olmadığını gösterir.Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object.

IConvertible.GetTypeCode()

String sınıfının TypeCode döndürür.Returns the TypeCode for the String class.

IConvertible.ToBoolean(IFormatProvider)

Bu üyenin açıklaması için bkz. ToBoolean(IFormatProvider).For a description of this member, see ToBoolean(IFormatProvider).

IConvertible.ToByte(IFormatProvider)

Bu üyenin açıklaması için bkz. ToByte(IFormatProvider).For a description of this member, see ToByte(IFormatProvider).

IConvertible.ToChar(IFormatProvider)

Bu üyenin açıklaması için bkz. ToChar(IFormatProvider).For a description of this member, see ToChar(IFormatProvider).

IConvertible.ToDateTime(IFormatProvider)

Bu üyenin açıklaması için bkz. ToDateTime(IFormatProvider).For a description of this member, see ToDateTime(IFormatProvider).

IConvertible.ToDecimal(IFormatProvider)

Bu üyenin açıklaması için bkz. ToDecimal(IFormatProvider).For a description of this member, see ToDecimal(IFormatProvider).

IConvertible.ToDouble(IFormatProvider)

Bu üyenin açıklaması için bkz. ToDouble(IFormatProvider).For a description of this member, see ToDouble(IFormatProvider).

IConvertible.ToInt16(IFormatProvider)

Bu üyenin açıklaması için bkz. ToInt16(IFormatProvider).For a description of this member, see ToInt16(IFormatProvider).

IConvertible.ToInt32(IFormatProvider)

Bu üyenin açıklaması için bkz. ToInt32(IFormatProvider).For a description of this member, see ToInt32(IFormatProvider).

IConvertible.ToInt64(IFormatProvider)

Bu üyenin açıklaması için bkz. ToInt64(IFormatProvider).For a description of this member, see ToInt64(IFormatProvider).

IConvertible.ToSByte(IFormatProvider)

Bu üyenin açıklaması için bkz. ToSByte(IFormatProvider).For a description of this member, see ToSByte(IFormatProvider).

IConvertible.ToSingle(IFormatProvider)

Bu üyenin açıklaması için bkz. ToSingle(IFormatProvider).For a description of this member, see ToSingle(IFormatProvider).

IConvertible.ToString(IFormatProvider)

Bu üyenin açıklaması için bkz. ToString(IFormatProvider).For a description of this member, see ToString(IFormatProvider).

IConvertible.ToType(Type, IFormatProvider)

Bu üyenin açıklaması için bkz. ToType(Type, IFormatProvider).For a description of this member, see ToType(Type, IFormatProvider).

IConvertible.ToUInt16(IFormatProvider)

Bu üyenin açıklaması için bkz. ToUInt16(IFormatProvider).For a description of this member, see ToUInt16(IFormatProvider).

IConvertible.ToUInt32(IFormatProvider)

Bu üyenin açıklaması için bkz. ToUInt32(IFormatProvider).For a description of this member, see ToUInt32(IFormatProvider).

IConvertible.ToUInt64(IFormatProvider)

Bu üyenin açıklaması için bkz. ToUInt64(IFormatProvider).For a description of this member, see ToUInt64(IFormatProvider).

IEnumerable.GetEnumerator()

Geçerli String nesnesi boyunca yinelenen bir Numaralandırıcı döndürür.Returns an enumerator that iterates through the current String object.

IEnumerable<Char>.GetEnumerator()

Geçerli String nesnesi boyunca yinelenen bir Numaralandırıcı döndürür.Returns an enumerator that iterates through the current String object.

Uzantı Metotları

ToImmutableArray<TSource>(IEnumerable<TSource>)

Belirtilen koleksiyondan sabit bir dizi oluşturur.Creates an immutable array from the specified collection.

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

Kaynak anahtarlarına bir dönüştürme işlevi uygulayarak, varolan bir öğe koleksiyonundan sabit bir sözlük oluşturur.Constructs an immutable dictionary from an existing collection of elements, applying a transformation function to the source keys.

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

Bir dizinin bazı dönüştürmesinden temel olarak sabit bir sözlük oluşturur.Constructs an immutable dictionary based on some transformation of a sequence.

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

Bir sırayı numaralandırır ve dönüştürür ve içeriklerinin sabit bir sözlüğünü üretir.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents.

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

Bir sırayı numaralandırır ve dönüştürür ve belirtilen anahtar karşılaştırıcıyı kullanarak içeriklerinin sabit bir sözlüğünü oluşturur.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key comparer.

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

Bir sırayı numaralandırır ve dönüştürür ve belirtilen anahtar ve değer Karşılaştırıcılar kullanılarak içeriklerinin sabit bir sözlüğünü üretir.Enumerates and transforms a sequence, and produces an immutable dictionary of its contents by using the specified key and value comparers.

ToImmutableHashSet<TSource>(IEnumerable<TSource>)

Bir diziyi numaralandırır ve içeriklerinin sabit bir karma kümesini oluşturur.Enumerates a sequence and produces an immutable hash set of its contents.

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

Bir diziyi numaralandırır, içeriklerinin sabit bir karma kümesini üretir ve küme türü için belirtilen eşitlik karşılaştırıcıyı kullanır.Enumerates a sequence, produces an immutable hash set of its contents, and uses the specified equality comparer for the set type.

ToImmutableList<TSource>(IEnumerable<TSource>)

Bir diziyi numaralandırır ve içeriklerinin sabit bir listesini oluşturur.Enumerates a sequence and produces an immutable list of its contents.

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

Bir sırayı numaralandırır ve dönüştürür ve içeriklerinin sabit sıralanmış bir sözlüğünü üretir.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents.

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

Bir sırayı numaralandırır ve dönüştürür ve belirtilen anahtar karşılaştırıcıyı kullanarak içeriklerinin sabit sıralanmış bir sözlüğünü üretir.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key comparer.

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

Bir sırayı numaralandırır ve dönüştürür ve belirtilen anahtar ve değer Karşılaştırıcılar kullanılarak içeriklerinin sabit sıralanmış bir sözlüğünü üretir.Enumerates and transforms a sequence, and produces an immutable sorted dictionary of its contents by using the specified key and value comparers.

ToImmutableSortedSet<TSource>(IEnumerable<TSource>)

Bir diziyi numaralandırır ve içeriklerinin sabit sıralanmış bir kümesini oluşturur.Enumerates a sequence and produces an immutable sorted set of its contents.

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

Bir diziyi numaralandırır, içeriklerinin sabit sıralanmış bir kümesini üretir ve belirtilen karşılaştırıcıyı kullanır.Enumerates a sequence, produces an immutable sorted set of its contents, and uses the specified comparer.

CopyToDataTable<T>(IEnumerable<T>)

Genel parametre T DataRowbir giriş IEnumerable<T> nesnesi verildiğinde, DataRow nesnelerinin kopyalarını içeren DataTable döndürür.Returns a DataTable that contains copies of the DataRow objects, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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

DataRow nesneleri, genel parametre T DataRowbir giriş IEnumerable<T> nesnesi verildiğinde, belirtilen DataTablekopyalar.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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

DataRow nesneleri, genel parametre T DataRowbir giriş IEnumerable<T> nesnesi verildiğinde, belirtilen DataTablekopyalar.Copies DataRow objects to the specified DataTable, given an input IEnumerable<T> object where the generic parameter T is DataRow.

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

Bir sıra üzerinde bir biriktiricidir işlevi uygular.Applies an accumulator function over a sequence.

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

Bir sıra üzerinde bir biriktiricidir işlevi uygular.Applies an accumulator function over a sequence. Belirtilen çekirdek değeri, ilk biriktiricidir değeri olarak kullanılır.The specified seed value is used as the initial accumulator value.

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

Bir sıra üzerinde bir biriktiricidir işlevi uygular.Applies an accumulator function over a sequence. Belirtilen çekirdek değeri, ilk biriktiricidir değeri olarak kullanılır ve sonuç değerini seçmek için belirtilen işlev kullanılır.The specified seed value is used as the initial accumulator value, and the specified function is used to select the result value.

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

Bir dizinin tüm öğelerinin bir koşulu karşılayıp karşılamadığını belirler.Determines whether all elements of a sequence satisfy a condition.

Any<TSource>(IEnumerable<TSource>)

Bir sıranın herhangi bir öğe içerip içermediğini belirler.Determines whether a sequence contains any elements.

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

Bir dizinin herhangi bir öğesinin bir koşulu karşılayıp karşılamadığını belirler.Determines whether any element of a sequence satisfies a condition.

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

Dizinin sonuna bir değer ekler.Appends a value to the end of the sequence.

AsEnumerable<TSource>(IEnumerable<TSource>)

IEnumerable<T>olarak yazılan girişi döndürür.Returns the input typed as IEnumerable<T>.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen Decimal değerleri dizisinin ortalamasını hesaplar.Computes the average of a sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen Double değerleri dizisinin ortalamasını hesaplar.Computes the average of a sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen Int32 değerleri dizisinin ortalamasını hesaplar.Computes the average of a sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen Int64 değerleri dizisinin ortalamasını hesaplar.Computes the average of a sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir Decimal değerleri dizisinin ortalamasını hesaplar.Computes the average of a sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir Double değerleri dizisinin ortalamasını hesaplar.Computes the average of a sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir Int32 değerleri dizisinin ortalamasını hesaplar.Computes the average of a sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir Int64 değerleri dizisinin ortalamasını hesaplar.Computes the average of a sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir Single değerleri dizisinin ortalamasını hesaplar.Computes the average of a sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen Single değerleri dizisinin ortalamasını hesaplar.Computes the average of a sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

Cast<TResult>(IEnumerable)

IEnumerable öğelerini belirtilen türe yayınlar.Casts the elements of an IEnumerable to the specified type.

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

İki diziyi art arda ekler.Concatenates two sequences.

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

Varsayılan eşitlik karşılaştırıcısını kullanarak bir sıranın belirtilen öğeyi içerip içermediğini belirler.Determines whether a sequence contains a specified element by using the default equality comparer.

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

Belirtilen bir IEqualityComparer<T>kullanarak bir sıranın belirtilen öğeyi içerip içermediğini belirler.Determines whether a sequence contains a specified element by using a specified IEqualityComparer<T>.

Count<TSource>(IEnumerable<TSource>)

Dizideki öğe sayısını döndürür.Returns the number of elements in a sequence.

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

Belirtilen dizideki kaç öğenin bir koşulu karşılayıp karşılamadığını temsil eden bir sayı döndürür.Returns a number that represents how many elements in the specified sequence satisfy a condition.

DefaultIfEmpty<TSource>(IEnumerable<TSource>)

Dizi boşsa, tek bir koleksiyonda belirtilen sıranın veya tür parametresinin varsayılan değerinin varsayılan değerini döndürür.Returns the elements of the specified sequence or the type parameter's default value in a singleton collection if the sequence is empty.

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

Dizi boşsa, tek bir koleksiyonda belirtilen sıranın veya belirtilen değerin öğelerini döndürür.Returns the elements of the specified sequence or the specified value in a singleton collection if the sequence is empty.

Distinct<TSource>(IEnumerable<TSource>)

Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcıyı kullanarak bir dizideki ayrı öğeleri döndürür.Returns distinct elements from a sequence by using the default equality comparer to compare values.

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

Değerleri karşılaştırmak için belirtilen IEqualityComparer<T> kullanarak bir dizideki farklı öğeleri döndürür.Returns distinct elements from a sequence by using a specified IEqualityComparer<T> to compare values.

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

Bir dizideki belirtilen dizindeki öğeyi döndürür.Returns the element at a specified index in a sequence.

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

Dizin aralık dışında bir dizide belirtilen dizindeki öğeyi veya varsayılan değeri döndürür.Returns the element at a specified index in a sequence or a default value if the index is out of range.

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

Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcıyı kullanarak iki sıranın ayarlama farkını üretir.Produces the set difference of two sequences by using the default equality comparer to compare values.

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

Değerleri karşılaştırmak için belirtilen IEqualityComparer<T> kullanarak iki sıranın ayarlama farkını üretir.Produces the set difference of two sequences by using the specified IEqualityComparer<T> to compare values.

First<TSource>(IEnumerable<TSource>)

Sıradaki ilk öğeyi döndürür.Returns the first element of a sequence.

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

Belirli bir koşulu karşılayan bir dizideki ilk öğeyi döndürür.Returns the first element in a sequence that satisfies a specified condition.

FirstOrDefault<TSource>(IEnumerable<TSource>)

Bir dizinin ilk öğesini veya dizi hiçbir öğe içermiyorsa varsayılan değeri döndürür.Returns the first element of a sequence, or a default value if the sequence contains no elements.

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

Bu tür bir öğe bulunamazsa, bir koşulu karşılayan dizinin ilk öğesini veya varsayılan değeri döndürür.Returns the first element of the sequence that satisfies a condition or a default value if no such element is found.

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

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır.Groups the elements of a sequence according to a specified key selector function.

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

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır ve belirtilen karşılaştırıcıyı kullanarak anahtarları karşılaştırır.Groups the elements of a sequence according to a specified key selector function and compares the keys by using a specified comparer.

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ır ve belirtilen bir işlevi kullanarak her grup için öğeleri projeler halinde gruplandırır.Groups the elements of a sequence according to a specified key selector function and projects the elements for each group by using a specified function.

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

Bir sıranın öğelerini bir anahtar Seçici işlevine göre gruplandırır.Groups the elements of a sequence according to a key selector function. 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ılmakta.The keys are compared by using a comparer and each group's elements are projected by using a specified function.

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

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır ve her bir gruptan ve onun anahtarından bir sonuç değeri oluşturur.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key.

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

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır ve her bir gruptan ve onun anahtarından bir sonuç değeri oluşturur.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Anahtarlar, belirtilen karşılaştırıcı kullanılarak karşılaştırılır.The keys are compared by using a specified comparer.

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

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır ve her bir gruptan ve onun anahtarından bir sonuç değeri oluşturur.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Her grubun öğeleri belirtilen bir işlev kullanılarak yansıtıllardır.The elements of each group are projected by using a specified function.

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

Bir dizinin öğelerini belirtilen bir anahtar Seçicisi işlevine göre gruplandırır ve her bir gruptan ve onun anahtarından bir sonuç değeri oluşturur.Groups the elements of a sequence according to a specified key selector function and creates a result value from each group and its key. Anahtar değerleri belirtilen 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ılmakta.Key values are compared by using a specified comparer, and the elements of each group are projected by using a specified function.

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 sıranın öğelerini karşılıklı olarak ilişkilendirir ve sonuçları gruplandırır.Correlates the elements of two sequences based on equality of keys and groups the results. Anahtarları karşılaştırmak için varsayılan eşitlik karşılaştırıcısı kullanılır.The default equality comparer is used to compare keys.

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

İki sıranın öğelerini anahtar eşitliğine göre ilişkilendirir ve sonuçları gruplandırır.Correlates the elements of two sequences based on key equality and groups the results. Anahtarları karşılaştırmak için belirtilen IEqualityComparer<T> kullanılır.A specified IEqualityComparer<T> is used to compare keys.

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

Değerleri karşılaştırmak için varsayılan eşitlik karşılaştırıcıyı kullanarak iki sıranın küme kesişimini üretir.Produces the set intersection of two sequences by using the default equality comparer to compare values.

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

Değerleri karşılaştırmak için belirtilen IEqualityComparer<T> kullanarak iki sıranın küme kesişimini üretir.Produces the set intersection of two sequences by using the specified IEqualityComparer<T> to compare values.

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

İki sıranın öğelerini eşleşen anahtarlara göre karşılıklı olarak ilişkilendirir.Correlates the elements of two sequences based on matching keys. Anahtarları karşılaştırmak için varsayılan eşitlik karşılaştırıcısı kullanılır.The default equality comparer is used to compare keys.

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

İki sıranın öğelerini eşleşen anahtarlara göre karşılıklı olarak ilişkilendirir.Correlates the elements of two sequences based on matching keys. Anahtarları karşılaştırmak için belirtilen IEqualityComparer<T> kullanılır.A specified IEqualityComparer<T> is used to compare keys.

Last<TSource>(IEnumerable<TSource>)

Sıradaki son öğeyi döndürür.Returns the last element of a sequence.

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

Belirtilen bir koşulu karşılayan bir dizinin son öğesini döndürür.Returns the last element of a sequence that satisfies a specified condition.

LastOrDefault<TSource>(IEnumerable<TSource>)

Bir sıranın son öğesini veya dizi hiçbir öğe içermiyorsa varsayılan değeri döndürür.Returns the last element of a sequence, or a default value if the sequence contains no elements.

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

Böyle bir öğe bulunmazsa bir koşulu karşılayan bir sıranın son öğesini veya varsayılan değeri döndürür.Returns the last element of a sequence that satisfies a condition or a default value if no such element is found.

LongCount<TSource>(IEnumerable<TSource>)

Bir dizideki toplam öğe sayısını temsil eden bir Int64 döndürür.Returns an Int64 that represents the total number of elements in a sequence.

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

Bir dizideki kaç öğenin bir koşulu karşılayıp karşılamadığını temsil eden bir Int64 döndürür.Returns an Int64 that represents how many elements in a sequence satisfy a condition.

Max<TSource>(IEnumerable<TSource>)

Genel dizideki en büyük değeri döndürür.Returns the maximum value in a generic sequence.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en büyük Decimal değerini döndürür.Invokes a transform function on each element of a sequence and returns the maximum Decimal value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en büyük Double değerini döndürür.Invokes a transform function on each element of a sequence and returns the maximum Double value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en büyük Int32 değerini döndürür.Invokes a transform function on each element of a sequence and returns the maximum Int32 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en büyük Int64 değerini döndürür.Invokes a transform function on each element of a sequence and returns the maximum Int64 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en fazla null atanabilir Decimal değeri döndürür.Invokes a transform function on each element of a sequence and returns the maximum nullable Decimal value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en fazla null atanabilir Double değeri döndürür.Invokes a transform function on each element of a sequence and returns the maximum nullable Double value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en fazla null atanabilir Int32 değeri döndürür.Invokes a transform function on each element of a sequence and returns the maximum nullable Int32 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en fazla null atanabilir Int64 değeri döndürür.Invokes a transform function on each element of a sequence and returns the maximum nullable Int64 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en fazla null atanabilir Single değeri döndürür.Invokes a transform function on each element of a sequence and returns the maximum nullable Single value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en büyük Single değerini döndürür.Invokes a transform function on each element of a sequence and returns the maximum Single value.

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

Genel bir dizinin her öğesinde bir Transform işlevini çağırır ve elde edilen en büyük değeri döndürür.Invokes a transform function on each element of a generic sequence and returns the maximum resulting value.

Min<TSource>(IEnumerable<TSource>)

Genel bir dizideki en küçük değeri döndürür.Returns the minimum value in a generic sequence.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en düşük Decimal değerini döndürür.Invokes a transform function on each element of a sequence and returns the minimum Decimal value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en düşük Double değerini döndürür.Invokes a transform function on each element of a sequence and returns the minimum Double value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en düşük Int32 değerini döndürür.Invokes a transform function on each element of a sequence and returns the minimum Int32 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en düşük Int64 değerini döndürür.Invokes a transform function on each element of a sequence and returns the minimum Int64 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en az null atanabilir Decimal değeri döndürür.Invokes a transform function on each element of a sequence and returns the minimum nullable Decimal value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en az null atanabilir Double değeri döndürür.Invokes a transform function on each element of a sequence and returns the minimum nullable Double value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en az null atanabilir Int32 değeri döndürür.Invokes a transform function on each element of a sequence and returns the minimum nullable Int32 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en az null atanabilir Int64 değeri döndürür.Invokes a transform function on each element of a sequence and returns the minimum nullable Int64 value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en az null atanabilir Single değeri döndürür.Invokes a transform function on each element of a sequence and returns the minimum nullable Single value.

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

Bir dizideki her öğe için bir Transform işlevini çağırır ve en düşük Single değerini döndürür.Invokes a transform function on each element of a sequence and returns the minimum Single value.

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

Genel bir dizinin her öğesinde bir Transform işlevini çağırır ve elde edilen en küçük değeri döndürür.Invokes a transform function on each element of a generic sequence and returns the minimum resulting value.

OfType<TResult>(IEnumerable)

IEnumerable öğelerini belirtilen bir türe göre filtreler.Filters the elements of an IEnumerable based on a specified type.

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

Bir dizinin öğelerini bir anahtara göre artan düzende sıralar.Sorts the elements of a sequence in ascending order according to a key.

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

Belirtilen karşılaştırıcıyı kullanarak bir sıranın öğelerini artan düzende sıralar.Sorts the elements of a sequence in ascending order by using a specified comparer.

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

Bir dizinin öğelerini bir anahtara göre azalan düzende sıralar.Sorts the elements of a sequence in descending order according to a key.

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

Belirtilen karşılaştırıcıyı kullanarak bir dizinin öğelerini azalan sırada sıralar.Sorts the elements of a sequence in descending order by using a specified comparer.

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

Dizinin başlangıcına bir değer ekler.Adds a value to the beginning of the sequence.

Reverse<TSource>(IEnumerable<TSource>)

Bir dizideki öğelerin sırasını tersine çevirir.Inverts the order of the elements in a sequence.

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

Bir dizinin her öğesini yeni bir biçimde projeler.Projects each element of a sequence into a new form.

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

Öğenin dizinini ekleyerek bir sıranın her öğesini yeni bir biçimde projeler.Projects each element of a sequence into a new form by incorporating the element's index.

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

Bir sıranın her öğesini bir IEnumerable<T> için projeler ve ortaya çıkan dizileri tek bir sırayla düzleştirir.Projects each element of a sequence to an IEnumerable<T> and flattens the resulting sequences into one sequence.

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

Bir sıranın her öğesini bir IEnumerable<T>için projeler ve ortaya çıkan dizileri tek bir sırayla düzleştirir.Projects each element of a sequence to an IEnumerable<T>, and flattens the resulting sequences into one sequence. Her kaynak öğenin dizini, bu öğenin öngörülen formunda kullanılır.The index of each source element is used in the projected form of that element.

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

Bir sıranın her öğesini bir IEnumerable<T>için projeler, ortaya çıkan dizileri tek bir sırayla düzleştirir ve içindeki her öğe için bir sonuç Seçicisi işlevini çağırır.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein.

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

Bir sıranın her öğesini bir IEnumerable<T>için projeler, ortaya çıkan dizileri tek bir sırayla düzleştirir ve içindeki her öğe için bir sonuç Seçicisi işlevini çağırır.Projects each element of a sequence to an IEnumerable<T>, flattens the resulting sequences into one sequence, and invokes a result selector function on each element therein. Her kaynak öğenin dizini, bu öğenin ara tasarlanan formunda kullanılır.The index of each source element is used in the intermediate projected form of that element.

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

İki sıranın, türleri için varsayılan eşitlik karşılaştırıcıyı kullanarak öğeleri karşılaştırarak eşit olup olmadığını belirler.Determines whether two sequences are equal by comparing the elements by using the default equality comparer for their type.

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

Belirtilen bir IEqualityComparer<T>kullanarak öğelerini karşılaştırarak iki sıranın eşit olup olmadığını belirler.Determines whether two sequences are equal by comparing their elements by using a specified IEqualityComparer<T>.

Single<TSource>(IEnumerable<TSource>)

Sıranın tek bir öğesini döndürür ve dizide tam olarak bir öğe yoksa bir özel durum oluşturur.Returns the only element of a sequence, and throws an exception if there is not exactly one element in the sequence.

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

Belirtilen koşulu karşılayan bir dizinin tek öğesini döndürür ve birden fazla öğe varsa bir özel durum oluşturur.Returns the only element of a sequence that satisfies a specified condition, and throws an exception if more than one such element exists.

SingleOrDefault<TSource>(IEnumerable<TSource>)

Bir dizinin tek bir öğesini veya dizi boşsa varsayılan değeri döndürür; dizide birden fazla öğe varsa, bu yöntem bir özel durum oluşturur.Returns the only element of a sequence, or a default value if the sequence is empty; this method throws an exception if there is more than one element in the sequence.

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

Belirtilen bir koşulu veya böyle bir öğe yoksa varsayılan değeri karşılayan bir dizinin tek öğesini döndürür; Bu yöntem, koşulu karşılıyorsa, birden fazla öğe bir özel durum oluşturur.Returns the only element of a sequence that satisfies a specified condition or a default value if no such element exists; this method throws an exception if more than one element satisfies the condition.

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

Bir dizide belirtilen sayıda öğeyi atlar ve ardından kalan öğeleri döndürür.Bypasses a specified number of elements in a sequence and then returns the remaining elements.

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

Kaynak koleksiyonun son count öğeleri hariç source öğeleri içeren yeni bir sıralanabilir koleksiyon döndürür.Returns a new enumerable collection that contains the elements from source with the last count elements of the source collection omitted.

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

Belirtilen koşul doğru olduğu sürece dizideki öğeleri atlar ve kalan öğeleri döndürür.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements.

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

Belirtilen koşul doğru olduğu sürece dizideki öğeleri atlar ve kalan öğeleri döndürür.Bypasses elements in a sequence as long as a specified condition is true and then returns the remaining elements. Öğenin dizini koşul işlevinin mantığında kullanılır.The element's index is used in the logic of the predicate function.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen Decimal değerleri dizisinin toplamını hesaplar.Computes the sum of the sequence of Decimal values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen Double değerleri dizisinin toplamını hesaplar.Computes the sum of the sequence of Double values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen Int32 değerleri dizisinin toplamını hesaplar.Computes the sum of the sequence of Int32 values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen Int64 değerleri dizisinin toplamını hesaplar.Computes the sum of the sequence of Int64 values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir Decimal değerleri dizisinin toplamını hesaplar.Computes the sum of the sequence of nullable Decimal values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir Double değerleri dizisinin toplamını hesaplar.Computes the sum of the sequence of nullable Double values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir Int32 değerleri dizisinin toplamını hesaplar.Computes the sum of the sequence of nullable Int32 values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir Int64 değerleri dizisinin toplamını hesaplar.Computes the sum of the sequence of nullable Int64 values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir Single değerleri dizisinin toplamını hesaplar.Computes the sum of the sequence of nullable Single values that are obtained by invoking a transform function on each element of the input sequence.

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

Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen Single değerleri dizisinin toplamını hesaplar.Computes the sum of the sequence of Single values that are obtained by invoking a transform function on each element of the input sequence.

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

Bir sıranın başından itibaren belirtilen sayıda bitişik öğeyi döndürür.Returns a specified number of contiguous elements from the start of a sequence.

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

sourceson count öğelerini içeren yeni bir sıralanabilir koleksiyon döndürür.Returns a new enumerable collection that contains the last count elements from source.

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

Belirtilen koşul doğru olduğu sürece bir dizideki öğeleri döndürür.Returns elements from a sequence as long as a specified condition is true.

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

Belirtilen koşul doğru olduğu sürece bir dizideki öğeleri döndürür.Returns elements from a sequence as long as a specified condition is true. Öğenin dizini koşul işlevinin mantığında kullanılır.The element's index is used in the logic of the predicate function.

ToArray<TSource>(IEnumerable<TSource>)

IEnumerable<T>bir dizi oluşturur.Creates an array from a IEnumerable<T>.

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

Belirtilen anahtar Seçicisi işlevine göre IEnumerable<T> bir Dictionary<TKey,TValue> oluşturur.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function.

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

Belirtilen anahtar Seçici işlevine ve anahtar karşılaştırıcısı 'na göre IEnumerable<T> bir Dictionary<TKey,TValue> oluşturur.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function and key comparer.

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

Belirtilen anahtar seçicisine ve öğe Seçici işlevlerine göre IEnumerable<T> bir Dictionary<TKey,TValue> oluşturur.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to specified key selector and element selector functions.

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

Belirtilen anahtar Seçici işlevine, karşılaştırıcının ve öğe Seçici işlevine göre IEnumerable<T> bir Dictionary<TKey,TValue> oluşturur.Creates a Dictionary<TKey,TValue> from an IEnumerable<T> according to a specified key selector function, a comparer, and an element selector function.

ToHashSet<TSource>(IEnumerable<TSource>)

Bir HashSet<T> öğesinden IEnumerable<T> oluşturur.Creates a HashSet<T> from an IEnumerable<T>.

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

Anahtarları karşılaştırmak için comparer kullanarak IEnumerable<T> bir HashSet<T> oluşturur.Creates a HashSet<T> from an IEnumerable<T> using the comparer to compare keys.

ToList<TSource>(IEnumerable<TSource>)

Bir List<T> öğesinden IEnumerable<T> oluşturur.Creates a List<T> from an IEnumerable<T>.

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

Belirtilen anahtar Seçicisi işlevine göre IEnumerable<T> bir Lookup<TKey,TElement> oluşturur.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function.

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

Belirtilen anahtar Seçici işlevine ve anahtar karşılaştırıcısı 'na göre IEnumerable<T> bir Lookup<TKey,TElement> oluşturur.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function and key comparer.

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

Belirtilen anahtar seçicisine ve öğe Seçici işlevlerine göre IEnumerable<T> bir Lookup<TKey,TElement> oluşturur.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to specified key selector and element selector functions.

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

Bir IEnumerable<T>, belirtilen anahtar Seçici işlevine, karşılaştırıcının ve öğe Seçici işlevine göre bir Lookup<TKey,TElement> oluşturur.Creates a Lookup<TKey,TElement> from an IEnumerable<T> according to a specified key selector function, a comparer and an element selector function.

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

Varsayılan eşitlik karşılaştırıcıyı kullanarak iki sıranın set birleşimini üretir.Produces the set union of two sequences by using the default equality comparer.

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

Belirtilen bir IEqualityComparer<T>kullanarak iki sıranın ayarlanan birleşimini üretir.Produces the set union of two sequences by using a specified IEqualityComparer<T>.

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

Bir koşula göre bir değer dizisini filtreler.Filters a sequence of values based on a predicate.

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

Bir koşula göre bir değer dizisini filtreler.Filters a sequence of values based on a predicate. Her öğenin dizini koşul işlevinin mantığındaki kullanılır.Each element's index is used in the logic of the predicate function.

Zip<TFirst,TSecond>(IEnumerable<TFirst>, IEnumerable<TSecond>)

Belirtilen iki dizideki öğeleri içeren bir tanımlama grubu sırası üretir.Produces a sequence of tuples with elements from the two specified sequences.

Zip<TFirst,TSecond,TResult>(IEnumerable<TFirst>, IEnumerable<TSecond>, Func<TFirst,TSecond,TResult>)

Belirtilen bir işlevi, iki sıranın karşılık gelen öğelerine uygular ve sonuçların bir dizisini üretir.Applies a specified function to the corresponding elements of two sequences, producing a sequence of the results.

AsParallel(IEnumerable)

Bir sorgunun paralelleştirilmesini mümkün hale getirme.Enables parallelization of a query.

AsParallel<TSource>(IEnumerable<TSource>)

Bir sorgunun paralelleştirilmesini mümkün hale getirme.Enables parallelization of a query.

AsQueryable(IEnumerable)

Bir IEnumerable IQueryabledönüştürür.Converts an IEnumerable to an IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

Genel bir IEnumerable<T> genel IQueryable<T>dönüştürür.Converts a generic IEnumerable<T> to a generic IQueryable<T>.

AsMemory(String)

Hedef dizenin bölümü üzerinde yeni bir ReadOnlyMemory<Char> oluşturur.Creates a new ReadOnlyMemory<Char> over the portion of the target string.

AsMemory(String, Index)

Belirtilen dizinden başlayarak hedef dizenin bir bölümü üzerinde yeni bir ReadOnlyMemory<Char> oluşturur.Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified index.

AsMemory(String, Int32)

Belirtilen karakter konumundan başlayarak hedef dizenin bir bölümü üzerinde yeni bir ReadOnlyMemory<Char> oluşturur.Creates a new ReadOnlyMemory<Char> over a portion of the target string starting at a specified character position.

AsMemory(String, Int32, Int32)

Hedef dizenin bir bölümü üzerinde, belirtilen bir konumdan başlayarak yeni bir ReadOnlyMemory<Char> oluşturur.Creates a new ReadOnlyMemory<Char> over a portion of the target string beginning at a specified position with a length.

AsMemory(String, Range)

Hedef dizenin belirtilen aralığında yeni bir ReadOnlyMemory<Char> oluşturur.Creates a new ReadOnlyMemory<Char> over a specified range of the target string.

AsSpan(String)

Belirtilen sayıda karakter için, belirtilen konumdan hedef dizenin bir bölümü üzerinde yeni bir salt okunurdur.Creates a new read-only span over a portion of the target string from a specified position for a specified number of characters.

AsSpan(String, Int32)

Belirtilen konumdan dizenin sonuna kadar hedef dizenin bir bölümü üzerinde yeni bir salt okunurdur.Creates a new read-only span over a portion of the target string from a specified position to the end of the string.

AsSpan(String, Int32, Int32)

Bir dize üzerinde yeni bir salt okunurdur.Creates a new read-only span over a string.

IsNormalized(String)

Belirtilen dizenin Unicode normalleştirme biçimi C biçiminde olup olmadığını gösterir.Indicates whether the specified string is in Unicode normalization form C.

IsNormalized(String, NormalizationForm)

Bir dizenin belirtilen Unicode normalleştirme biçiminde olup olmadığını gösterir.Indicates whether a string is in a specified Unicode normalization form.

Normalize(String)

Bir dizeyi bir Unicode normalleştirme biçimi C olarak normalleştirir.Normalizes a string to a Unicode normalization form C.

Normalize(String, NormalizationForm)

Bir dizeyi belirtilen Unicode normalleştirme formuna normalleştirir.Normalizes a string to the specified Unicode normalization form.

Ancestors<T>(IEnumerable<T>)

Kaynak koleksiyondaki her düğümün üst öğelerini içeren öğelerin koleksiyonunu döndürür.Returns a collection of elements that contains the ancestors of every node in the source collection.

Ancestors<T>(IEnumerable<T>, XName)

Kaynak koleksiyondaki her düğümün üst öğelerini içeren bir öğe filtrelenmiş koleksiyonunu döndürür.Returns a filtered collection of elements that contains the ancestors of every node in the source collection. Yalnızca eşleşen XName olan öğeler koleksiyona dahil edilir.Only elements that have a matching XName are included in the collection.

DescendantNodes<T>(IEnumerable<T>)

Kaynak koleksiyondaki her belge ve öğenin alt düğümlerinin bir koleksiyonunu döndürür.Returns a collection of the descendant nodes of every document and element in the source collection.

Descendants<T>(IEnumerable<T>)

Kaynak koleksiyondaki her öğe ve belge için alt öğeleri içeren öğelerin koleksiyonunu döndürür.Returns a collection of elements that contains the descendant elements of every element and document in the source collection.

Descendants<T>(IEnumerable<T>, XName)

Kaynak koleksiyondaki her öğe ve belge için alt öğeleri içeren öğelerin filtrelenmiş bir koleksiyonunu döndürür.Returns a filtered collection of elements that contains the descendant elements of every element and document in the source collection. Yalnızca eşleşen XName olan öğeler koleksiyona dahil edilir.Only elements that have a matching XName are included in the collection.

Elements<T>(IEnumerable<T>)

Kaynak koleksiyondaki her öğe ve belgenin alt öğelerinin bir koleksiyonunu döndürür.Returns a collection of the child elements of every element and document in the source collection.

Elements<T>(IEnumerable<T>, XName)

Kaynak koleksiyondaki her öğe ve belge için alt öğelerin filtrelenmiş bir koleksiyonunu döndürür.Returns a filtered collection of the child elements of every element and document in the source collection. Yalnızca eşleşen XName olan öğeler koleksiyona dahil edilir.Only elements that have a matching XName are included in the collection.

InDocumentOrder<T>(IEnumerable<T>)

Belge düzeninde sıralanan, kaynak koleksiyondaki tüm düğümleri içeren düğümlerin bir koleksiyonunu döndürür.Returns a collection of nodes that contains all nodes in the source collection, sorted in document order.

Nodes<T>(IEnumerable<T>)

Kaynak koleksiyondaki her belge ve öğenin alt düğümlerinin bir koleksiyonunu döndürür.Returns a collection of the child nodes of every document and element in the source collection.

Remove<T>(IEnumerable<T>)

Kaynak koleksiyondaki her düğümü üst düğümünden kaldırır.Removes every node in the source collection from its parent node.

Şunlara uygulanır

İş Parçacığı Güvenliği

Bu güvenli iş parçacığı türüdür.This type is thread safe.

Ayrıca bkz.