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

Açıklamalar

Dize, metni göstermek için kullanılan, sıralı bir karakter koleksiyonudur.A string is a sequential collection of characters that's used to represent text. Bir String nesne, System.Char bir dizeyi temsil eden nesnelerin sıralı koleksiyonudur; bir nesne, System.Char UTF-16 kod birimine karşılık gelir.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. Nesnesinin değeri, String sıralı nesne koleksiyonunun içerisidir System.Char 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 imlik durumunu bilme hakkında daha fazla bilgi için bkz. ımdeğiştirici kullanılabilirliği ve StringBuilder sınıfı bölümü.For more information about the immutability of strings, see the Immutability and the StringBuilder class section. Bellekteki bir nesnenin en büyük boyutu String 2 GB veya yaklaşık 1.000.000.000 karakter olur.The maximum size of a String object in memory is 2-GB, or about 1 billion characters.

Unicode, UTF-16, kod birimleri, kod noktaları ve ve türleri hakkında daha fazla bilgi Char için Rune bkz. .net 'Te karakter kodlamaya giriş.For more information about Unicode, UTF-16, code units, code points, and the Char and Rune types, see Introduction to character encoding in .NET.

Bu bölümdeki konular:In this section:

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
İmlebilirlik ve StringBuilder sınıfıImmutability and the StringBuilder class
Ordinal ve 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

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

  • Bir değişkene dize sabiti atayarak String .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. C# dilinde, ters eğik çizgi ( \ ) bir kaçış karakteri olduğundan, bir dizedeki sabit ters eğik çizgilerden kaçışlı olması veya dizenin tamamının olması gerektiğini unutmayın @-quoted .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      
    
  • Bir 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. Oluşturucular hakkında ayrıntılı bilgi için String 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 örnek ve dize sabit değeri bileşiminden tek bir dize oluşturmak için, dize birleştirme işlecini (+ C# ve & veya + Visual Basic) kullanarak.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 String dizeyi daha büyük bir dizeden ayıklamak için 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 nesne tarafından temsil edilir Char .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

Bir örnek, bir String UTF-16 kod birimlerinin sıralı koleksiyonundan oluştuğu için String iyi biçimlendirilmiş bir Unicode dizesi olmayan bir nesne oluşturmak mümkündür.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. Ad alanındaki nesneleri kodlama ve kod çözme yöntemleri gibi bazı yöntemler, System.Text dizelerin doğru biçimlendirildiğinden emin olmak için denetimler gerçekleştiriyor olsa da, String sınıf üyeleri bir dizenin doğru biçimlendirildiğinden emin olmak için denetim gerçekleştirir.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 nesne genellikle tek bir kod noktasını temsil eder; diğer bir deyişle, sayısal değeri Char 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 nesne) gerektirebilir.However, a code point might require more than one encoded element (more than one Char object). Unicode standart, birden çok nesneye karşılık gelen iki tür karakteri tanımlar Char : graphemes ve Unicode ek düzlemleri içindeki karakterlere karşılık gelen Unicode ek kod noktaları.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, Char kod noktası u + 0061 olan ve ardından Char kod noktası u + 0308 olan 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, Char U + 00E4 kod noktasına sahip tek bir nesne 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 Char vekil olan ve ardından Char kod noktası düşük bir vekil olan bir nesne 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 yedek karakter oluşturur ve Char.IsSurrogatePair(Char, Char) bir vekil çifti olup olmadığını anlamak için yönteme 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, değerlere karşılık gelen UTF-16 kodlu kod birimleriyle temsil edilir Char .Characters in a string are represented by UTF-16 encoded code units, which correspond to Char values.

Bir dizedeki her bir karakter ilişkili bir Unicode karakter kategorisine sahiptir ve bu, numaralandırmada .NET ile temsil edilir UnicodeCategory .Each character in a string has an associated Unicode character category, which is represented in .NET by the UnicodeCategory enumeration. Bir karakter veya bir yedek çiftinin kategorisi, yöntemi çağırarak belirlenebilir CharUnicodeInfo.GetUnicodeCategory .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ının belirli bir sürümünün aynı karakter kategori bilgilerini döndürdüğünden emin olmak için kendi karakter ve bunlara karşılık gelen kategorilerini saklar..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. Tüm .NET sürümlerinde ve tüm işletim sistemi platformlarında, karakter kategorisi bilgileri Unicode karakter veritabanıtarafından sağlanır.On all .NET versions and across all OS platforms, character category information is provided by the Unicode Character Database.

Aşağıdaki tabloda, .NET sürümleri ve üzerinde karakter kategorilerinin temel aldığı Unicode standart sürümleri listelenmiştir.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 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
.NET Framework 4.5.NET Framework 4.5 Unicode standardı, sürüm 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.5.1.NET Framework 4.5.1 Unicode standardı, sürüm 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.5.2.NET Framework 4.5.2 Unicode standardı, sürüm 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.NET Framework 4.6 Unicode standardı, sürüm 6.3.0The Unicode Standard, Version 6.3.0
.NET Framework 4.6.1.NET Framework 4.6.1 Unicode standardı, 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 standardı, sürüm 8.0.0The Unicode Standard, Version 8.0.0
.NET Core 2.1.NET Core 2.1 Unicode standardı, sürüm 8.0.0The Unicode Standard, Version 8.0.0
.NET Core 3,1.NET Core 3.1 Unicode standardı, sürüm 11.0.0The Unicode Standard, Version 11.0.0
.NET 5.NET 5 Unicode standardı, sürüm 13.0.0The Unicode Standard, Version 13.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 ve önceki sürümler kendi dize verileri tablosunu korur..NET Framework 4 and previous versions maintain their own table of string data. Bu Ayrıca, Windows 7 ' de çalışan .NET Framework 4,5 ' den başlayarak .NET Framework sürümlerinden de de geçerlidir.This is also true of versions of .NET Framework starting with .NET Framework 4.5 running on Windows 7. Windows 8 ve Windows işletim sisteminin sonraki sürümlerinde çalışan .NET Framework 4,5 ' den itibaren, çalışma zamanı işletim sistemine dize karşılaştırma ve sıralama işlemleri devreder.Starting with .NET Framework 4.5 running on Windows 8 and later versions of the Windows operating system, the runtime delegates string comparison and sorting operations to the operating system. .NET Core ve .NET 5 + ' da, dize karşılaştırma ve sıralama bilgileri, Unicode kitaplıkları Için Uluslararası bileşenler (Windows 10 Mayıs 2019 ' den önceki Windows sürümleri hariç) tarafından sağlanır.On .NET Core and .NET 5+, string comparison and sorting information is provided by International Components for Unicode libraries (except on Windows versions prior to Windows 10 May 2019 Update). 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.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
.NET Framework 4.5.NET Framework 4.5 Windows 7 ' de ve üzeriand later on Windows 7 Unicode standardı, 5.0.0 sürümüThe Unicode Standard, Version 5.0.0
.NET Framework 4.5.NET Framework 4.5 ve üzeri Windows 8 ve sonraki Windows işletim sistemlerindeand 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 ve .NET 5 +.NET Core and .NET 5+ , 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 sürümünde bir String nesne, dize 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ı veya C veya C++ dilinde yazılmış olan aşağıdaki yaygın varsayımlar, nesnelere uygulandığında dizelerin geçerli olmadığı anlamına gelir String :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:

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

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

Nesneleri örnekleyen yerel C ve C++ kodunun String ve String Platform Invoke aracılığıyla nesneleri geçen kodun, gömülü bir boş karakterin dizenin sonunu işaret etmesi gerektiğini varsaymayın.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,, ve gibi yöntemlerle bir dize aranırken gömülü null karakterler her zaman göz önünde bulundurulmaktadır Contains StartsWith IndexOf .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, Char içindeki bir nesnenin konumudur (Unicode karakter değil) String .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. Ve gibi çeşitli arama yöntemleri, IndexOf LastIndexOf 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[]Özelliği, bağımsız Char nesnelere dizedeki dizin konumlarına göre erişmenizi sağlar.The Chars[] property lets you access individual Char objects by their index position in the string. Chars[]Özelliği varsayılan Özellik (Visual Basic) veya dizin oluşturucuda (C# ' de) olduğu için, Char aşağıdaki gibi bir kod kullanarak bir dizedeki ayrı nesnelere erişebilirsiniz.Because the Chars[] 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.

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

Ardışık dizin değerleri, bir Unicode karakteri birden fazla nesne olarak kodlanabileceğinden ardışık Unicode karakterlerine karşılık gelmeyebilir Char .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. Nesneler yerine Unicode karakterlerle çalışmak için, Char System.Globalization.StringInfo ve TextElementEnumerator sınıflarını veya String.EnumerateRunes yöntemini ve Rune yapısını kullanın.To work with Unicode characters instead of Char objects, use the System.Globalization.StringInfo and TextElementEnumerator classes, or the String.EnumerateRunes method and the Rune struct. Aşağıdaki örnek, Char Unicode karakterlerle birlikte çalışarak nesneler ve kodla çalışma kodu 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, StringInfo.GetTextElementEnumerator TextElementEnumerator bir dizedeki tüm metin öğelerini numaralandırmak için yöntemini ve sınıfını kullanarak metin öğeleriyle birlikte çalışarak.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. Yöntemini çağırarak her metin öğesinin başlangıç dizinini içeren bir diziyi de alabilirsiniz StringInfo.ParseCombiningCharacters .You can also retrieve an array that contains the starting index of each text element by calling the StringInfo.ParseCombiningCharacters method.

Tek tek değerler yerine metin birimleriyle çalışma hakkında daha fazla bilgi için Char bkz. .net 'te karakter kodlamaya giriş.For more information about working with units of text rather than individual Char values, see Introduction to character encoding in .NET.

Null dizeler ve boş dizelerNull strings and empty strings

Tanımlanmış ancak değer atanmamış bir dize null .A string that has been declared but has not been assigned a value is null. Bu dizedeki yöntemleri çağırma girişimi bir oluşturur NullReferenceException .Attempting to call methods on that string throws a NullReferenceException. Null dize, değeri "" olan bir dize olan boş bir dizeden farklıdır String.Empty .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, yöntemine bir null dize geçirmek Int32.Parse bir oluşturur ArgumentNullException ve boş bir dizeyi geçirmek bir oluşturur FormatException .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, IFormattable bir sınıf için uygulama sağlıyorsanız, hem null dizeyi hem de boş dizeyi genel ("G") biçim belirticisine eşit olacak şekilde kullanmak istersiniz.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.

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

  • IsNullOrEmpty, bir dizenin ya da eşit olup olmadığını gösterir null String.Empty .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
    
  • IsNullOrWhiteSpacebir dizenin null , eşittir String.Empty veya yalnızca boşluk karakterlerinden oluşan bir dize 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, IsNullOrEmpty yöntemini IFormattable.ToString özel bir sınıfın uygulamasında kullanır Temperature .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 yöntemine geçirilen bir biçim dizesi ise null , 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

Bir String nesne 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. Nesneyi değiştirmek için görünen Yöntemler String aslında String değişikliği içeren yeni bir nesne döndürür.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. Bu kod, var olan dizeye yeni bir karakter eklemek için dize birleştirme kullanma gibi görünse de str , String her birleştirme işlemi için aslında yeni bir nesne oluşturur.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

StringBuilder String Bir dizenin değerinde birden çok değişiklik yapan işlemler için sınıfı yerine sınıfını kullanabilirsiniz.You can use the StringBuilder class instead of the String class for operations that make multiple changes to the value of a string. Sınıfının örneklerinin aksine String StringBuilder nesneler değişebilir; bir dizeden alt dizeleri birleştirme, ekleme veya silme işlemi yaptığınızda işlemler tek bir dize üzerinde gerçekleştirilir.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 nesnenin değerini değiştirmeyi bitirdiğinizde StringBuilder , StringBuilder.ToString yöntemini bir dizeye dönüştürmek için ç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, String bir önceki örnekte kullanılan 1000 rastgele karakteri bir nesne Ile 0x052F aralığında birleştirmek için kullanılır StringBuilder .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

StringSınıfının üyeleri bir nesne üzerinde sıra veya kültüre duyarlı (dil) işlemleri gerçekleştirir String .Members of the String class perform either ordinal or culture-sensitive (linguistic) operations on a String object. Sıralı bir işlem, her nesnenin sayısal değeri üzerinde davranır Char .An ordinal operation acts on the numeric value of each Char object. Kültüre duyarlı bir işlem, nesnenin değeri üzerinde davranır String ve kültüre özel büyük/küçük harf, sıralama, biçimlendirme ve ayrıştırma kurallarını hesaba götürür.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, dilden CultureInfo.InvariantCulture bağımsız olarak İngilizce dilinin kültür ayarlarına bağlı olarak, sabit kültür () kullanarak kültüre duyarsız dil dizesi işlemlerini destekler..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 ayarlardan farklı olarak System.Globalization.CultureInfo , sabit kültürün ayarlarının tek bir bilgisayarda, sistemden sisteme ve .NET sürümleri arasında tutarlı kalması garanti edilir.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 StringComparison , yöntemin sıralı veya kültüre duyarlı bir işlem gerçekleştirip gerçekleştirmediğini belirtmenize olanak sağlayan, türünde bir parametreye sahip bir aşırı yüklemeyi içerir.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, Compare(String, String) geçerli kültürün kurallarını kullanarak iki dizenin kültüre duyarlı bir şekilde karşılaştırmasını gerçekleştirmek için yöntemini çağırmak yerine, Compare(String, String, StringComparison) StringComparison.CurrentCulture bağımsız değişken için bir değeriyle yöntemini çağırmanız gerekir comparisonType .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 ve karşılaştırma işlemlerinde kullanılan karakter ağırlıkları hakkında bilgi içeren bir metin dosyaları kümesi olan sıralama ağırlığı tablolarını aşağıdaki bağlantılardan indirebilirsiniz: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, from the following links:

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. Or metodunu çağırarak bir dizedeki karakterleri küçük harfe dönüştürebilir ToLower ToLowerInvariant ve ya da metodunu çağırarak bunları büyük harfe dönüştürebilirsiniz ToUpper ToUpperInvariant .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, TextInfo.ToTitleCase bir dizeyi başlık durumuna dönüştürmek için yöntemini kullanabilirsiniz.In addition, you can use the TextInfo.ToTitleCase method to convert a string to title case.

Not

Yalnızca Linux ve macOS sistemlerinde çalışan .NET Core: C ve POSIX kültürleri için harmanlama davranışı her zaman büyük/küçük harfe duyarlıdır çünkü bu kültürler beklenen Unicode harmanlama sırasını kullanmaz..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. Kültüre duyarlı, büyük/küçük harfe duyarsız sıralama işlemleri gerçekleştirmek için C veya POSIX dışında bir kültür kullanmanızı öneririz.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 (Türkiye)) ve az-Latn-AZ (Azerbaycan, Latin) kültürleri ve tr, az ve az-Latn nötr kültürleri içinde LATIN büyük harf ı 'nin küçük harfli eşdeğeri LATIN küçük harfle NOKTASıZ ı ve Latin küçük harf ı 'nın büyük harfle eşittir.In 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ülenlerReturns
    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üçük harfLowercase 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üçük harfLowercase 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 büyük/küçük harfe duyarsız olabilir ve büyük/küçük harf kuralları kültüre göre farklılık gösterebilir.In addition, comparisons can be case-sensitive or case-insensitive, and casing rules might 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 parametresi temelinde iki dizeyi karşılaştırır StringComparison .For example, the String.Compare(String, String, StringComparison) method compares two strings based on the StringComparison parameter. Parametre değeri ise Yöntem, StringComparison.CurrentCulture geçerli kültürün kurallarını kullanan bir dil karşılaştırması gerçekleştirir; parametre değeri ise StringComparison.Ordinal , yöntem bir sıralı karşılaştırma gerçekleştirir.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, yönteme yapılan ilk çağrı String.Compare(String, String, StringComparison) (kültüre duyarlı karşılaştırma kullanılarak) "a" değerini "a" olarak kabul eder, ancak aynı yönteme yapılan ikinci çağrı (sıra karşılaştırması kullanılarak) "a" ' dan büyük "bir" değerini alır.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. StringSözcük sıralama kurallarını kullanarak iki dizeyi karşılaştıran yöntemlerin listesi için bkz. kategoriye göre dize işlemleri bölümü.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. CompareInfo.CompareBir değeri sağlanan bir parametreye sahip olan yöntem aşırı yüklerini çağırarak, dize sıralama kuralları kullanılarak iki dize karşılaştırılabilir options CompareOptions.StringSort .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 nesnenin sayısal değerine göre karşılaştırır Char .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. StringSıralı sıralama kurallarını kullanarak iki dizeyi karşılaştıran yöntemlerin listesi için bkz. kategoriye göre dize işlemleri bölümü.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 özelliği tarafından belirtilen sabit kültür dahil, açıkça veya dolaylı bir şekilde nesne kullanan herhangi bir karşılaştırmadır CultureInfo.InvariantCulture .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, ve özellikleri tarafından belirtilen geçerli kültürdür Thread.CurrentCulture CultureInfo.CurrentCulture .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ğin döndürdüğü karakterler true ) 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. Gibi bir dize karşılaştırma yöntemine bir nesne sağlayarak belirli bir kültürün kurallarını kullanan kültüre duyarlı bir karşılaştırma belirtebilirsiniz CultureInfo Compare(String, String, CultureInfo, CompareOptions) .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 StringComparison.CurrentCulture , veya StringComparison.CurrentCultureIgnoreCase CompareOptions CompareOptions.Ordinal CompareOptions.OrdinalIgnoreCase öğesinin uygun bir aşırı yüklemesine veya dışında bir numaralandırma üyesi Compare sağlayarak, kültüre duyarlı bir karşılaştırma belirtebilirsiniz.You 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" gibi üç dizeyi (her biri, yöntemin çağrıldığı sırada varsayılan kültür olan) kullanarak değerlendirir Compare .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, bir CultureInfo karşılaştırma yöntemine bu kültürü temsil eden bir nesne sağlayarak bunları sıralayın.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, metodun aşırı yüklemesini çağırarak her zaman eşitlik için sıralı bir test gerçekleştirmeniz gerekir Equals .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 Core 'da dize karşılaştırması, temel alınan işletim sistemi tarafından desteklenen Unicode standardının sürümüne bağlıdır.On .NET Core, string comparison depends on the version of the Unicode Standard supported by the underlying operating system. .NET Framework 4,5 ' de ve Windows 8 veya üzeri sürümlerde çalışan sürümler, sıralama, büyük/küçük harf, normalleştirme ve Unicode karakter bilgileri Unicode 6,0 standardına uygundur.In .NET Framework 4.5 and later versions running on Windows 8 or later, sorting, casing, normalization, and Unicode character information conform to the Unicode 6.0 standard. Diğer Windows işletim sistemlerinde, Unicode 5,0 standardına uygundur.On other Windows operating systems, they conform to the Unicode 5.0 standard.

Sözcük, dize ve sıra sıralama kuralları hakkında daha fazla bilgi için konusuna bakın System.Globalization.CompareOptions .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, Compare dizelerin sıralama düzenini belirlemede doğrudan 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 veya gibi sıralama yöntemleri tarafından çağırılır Array.Sort List<T>.Sort .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, bir dize karşılaştırma yöntemi açıkça çağrılmadan sabit kültür, sıralı sıralama ve dize sıralaması kullanarak sıralama), ancak kullanılacak karşılaştırma türünü belirtmeleri gerekir.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. Sınıfı tarafından temsil edilen bir sıralama anahtarı SortKey , belirli bir dize için bu ağırlıkların bir deposunu sağlar.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.

Dize karşılaştırma kuralı belirtmezseniz, Array.Sort(Array) dizelerde kültüre duyarlı, büyük/küçük harfe duyarlı sıralama yapma gibi yöntemleri sıralama.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öntemi 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 amacı, eşit olup olmadıklarını tespit etmek ise, yöntemini çağırmanız gerekir String.Equals .If your primary purpose in comparing strings is to determine whether they are equal, you should call the String.Equals method. Genellikle, Equals bir sıralı karşılaştırma gerçekleştirmek için kullanmanız gerekir.Typically, you should use Equals to perform an ordinal comparison. String.CompareYöntemi öncelikli olarak dizeleri sıralamak içindir.The String.Compare method is intended primarily to sort strings.

Ve gibi dize arama yöntemleri String.StartsWith String.IndexOf de kültüre duyarlı veya sıralı dize karşılaştırmaları gerçekleştirebilir.String search methods, such as String.StartsWith and String.IndexOf, also can perform culture-sensitive or ordinal string comparisons. Aşağıdaki örnek, yöntemi kullanılarak Ordinal ve kültüre duyarlı karşılaştırmalar arasındaki farkları göstermektedir IndexOf .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 öğesine eşdeğer olarak değerlendirir Empty 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

Dizelerde araSearch in strings

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

StringSınıfında, yöntemi gibi tek bir karakteri IndexOf veya bir karakter kümesinden birini (örneğin, bir IndexOfAny sıra araması yapar) arama yöntemleri.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 veya gibi bir yöntemi çağırmanız gerekir CompareInfo.IndexOf(String, Char) CompareInfo.LastIndexOf(String, Char) .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, String.IndexOf(Char) CompareInfo.IndexOf(String, Char) tek bir karakter ararken ve 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, String bir karakter yerine bir dize için arama yapan sınıf yöntemleri, arama seçenekleri açıkça türü bir parametreyle belirtilmemişse kültüre duyarlı bir arama gerçekleştirir StringComparison .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 özel durum Contains , sıralı arama gerçekleştiren bir durumdur.The sole exception is Contains, which performs an ordinal search.

Eşitlik sınamasıTesting for equality

String.CompareSıralama düzeninde iki dizenin ilişkisini öğrenmek için 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, String.Equals eşitlik için test etmek üzere 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.CompareYö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, yönteminin aşırı yüklerinden birini çağırmanız gerekir String.Equals .To determine whether two strings are equal, you should call one of the overloads of the String.Equals method. Çağırmak için tercih edilen aşırı yükleme, Equals(String, StringComparison) Equals(String, String, StringComparison) her iki yöntem de System.StringComparison karşılaştırma türünü açıkça belirten bir parametre içerdiğinden, örnek yöntemi ya da static 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 nesnelerin Unicode skaler değeri olan ikili bir karşılaştırmayla yapılır Char .An ordinal comparison is a binary comparison of the Unicode scalar value of corresponding Char objects in each string. StringSınıfı, aşağıdakiler de 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:

Yöntemini çağırarak bir dizenin normalleştirme biçimi C ' ye normalleştirilip normalleştirilmediğini belirleyebilir String.IsNormalized() veya String.IsNormalized(NormalizationForm) bir dizenin belirtilen normalleştirme formuna normalleştirilmesi gerekip gerekmediğini anlamak için yöntemini ç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, String.Normalize() bir dizeyi, normalleştirme biçimi C 'ye dönüştürmek için yöntemini çağırabilir veya String.Normalize(NormalizationForm) bir dizeyi belirtilen normalleştirme biçimine dönüştürmek için yöntemini ç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, bkz Normalize() Normalize(NormalizationForm) . ve yöntemleri.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.NormalizationForm ., 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

StringSı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ırmaCompare strings

Aşağıdaki yöntemleri kullanarak sıralama düzeninde göreli konumlarını belirleyecek dizeleri karşılaştırabilirsiniz String :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 bir dizenin, kod noktalarının karşılaştırmasını temel alarak 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, IComparable IComparable<T> sınıfı için ve uygulamalarını sağlar String .The CompareTo(String) method provides the IComparable and IComparable<T> implementations for the String class.

Eşitlik için test dizeleriTest strings for equality

Equalsİki dizenin eşit olup olmadığını anlamak için yöntemini çağırabilirsiniz.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üklemeler, karşılaştırmanın kültüre duyarlı veya sıralı olup olmadığını ve büyük/küçük harf olarak kabul edilip edilmeyeceğini 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.

Dizedeki karakterleri bulmaFind characters in a string

StringSı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.

Dizeyi değiştirmeModify a string

StringSı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 örneğe bir dize ekler String .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 örnekten bir alt dizeyi siler String .Remove deletes a substring from the current String instance.

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

  • ToLower ve ToLowerInvariant 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 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 itibaren 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 nesne 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.

Dizeden alt dizeleri AyıklaExtract substrings from a string

String.SplitYö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ığı alt dizelerin sayısını sınırlamak, alt dizelerin içindeki boşlukları kırpmak ve döndürülen dizeler arasında boş dizeler (sınırlayıcılar bitişik olduğunda meydana gelir) belirtmek için birden çok sınırlayıcı belirtmenize olanak tanır.Overloads of the method allow you to specify multiple delimiters, to limit the number of substrings that the method extracts, to trim white space from substrings, and to specify whether empty strings (which occur when delimiters are adjacent) are included among the returned strings.

Dizeleri BirleştirCombine strings

Aşağıdaki String Yöntemler 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 dize olarak birleştirir.Concat combines one or more substrings into a single string.

  • Join bir veya daha fazla alt dizeyi tek bir öğe halinde 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.

Biçim değerleriFormat values

String.FormatYöntemi, bir dizedeki bir veya daha fazla yer tutucuyu, bazı nesne veya değer dize gösterimiyle 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. FormatYö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 arabirimi destekleyen bazı nesnenin dize temsilini eklemek için IFormattable .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 KopyalaCopy a string

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

  • Clone Varolan bir nesneye bir başvuru döndürür String .Clone returns a reference to an existing String object.

  • Copy Varolan 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.

Dizeyi NormalleştirNormalize 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.NormalizeYöntemi, String.IsNormalized normalleştirmeyi gerçekleştirir ve yöntemi bir dizenin normalleştirilmiş olup olmadığını 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*)

Sınıfın yeni bir örneğini String , belirtilen 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)

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

Belirtilen String sayıda yinelenen belirtilen Unicode karakteri tarafından belirtilen değere sınıfının yeni bir örneğini başlatır.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[])

StringBelirtilen karakter dizisinde belirtilen Unicode karakterlerine sınıfının yeni bir örneğini 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)

Bir String Unicode karakter dizisi, bu dizideki başlangıç karakter konumu ve uzunluğu ile belirtilen değere sınıfının yeni bir örneğini başlatır.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>)

StringBelirtilen salt-tanımlı yayılma alanında belirtilen Unicode karakterlerine sınıfının yeni bir örneğini başlatır.Initializes a new instance of the String class to the Unicode characters indicated in the specified read-only span.

String(SByte*)

Sınıfının yeni bir örneğini String , 8 bit işaretli tamsayılar dizisinin bir işaretçisi tarafından belirtilen değere başlatır.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)

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

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

CharGeçerli nesnede belirtilen konumdaki nesneyi alır String .Gets the Char object at a specified position in the current String object.

Length

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

Yöntemler

Clone()

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

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

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

StringKarşılaştırmayı etkilemek için belirtilen karşılaştırma seçeneklerini ve kültüre özgü bilgileri kullanarak belirtilen iki nesnenin alt dizelerini karşılaştırır ve sıralama düzeninde iki alt dizenin birbirlerine ilişkisini gösteren bir tamsayı döndürür.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 nesnenin alt dizelerini karşılaştırır String ve sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.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 nesneyi 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 nesneyi karşılaştırır, durumlarını yoksayar veya dikkate alarak sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.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 nesneyi 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 konumlarını 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)

String, Karşılaştırmayı etkilemek için belirtilen karşılaştırma seçeneklerini ve kültüre özgü bilgileri kullanarak belirtilen iki nesneyi karşılaştırır ve sıralama düzeninde iki dizenin birbirlerine 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)

StringBelirtilen kuralları kullanarak belirtilen iki nesneyi karşılaştırır ve sıralama düzeninde göreli konumlarını gösteren bir tamsayı döndürür.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)

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

CompareOrdinal(String, String)

StringHer dizedeki karşılık gelen nesnelerin sayısal değerlerini değerlendirerek belirtilen iki nesneyi karşılaştırır Char .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 ile karşılaştırır Object ve belirtilen şekilde sıralama düzeninde aynı konumda olup olmadığını, bu örneği takip edip etmeyeceğini veya göründüğünü gösterir Object .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 nesne ile karşılaştırır String ve belirtilen dize olarak sıralama düzeninde aynı konumda, bu örneğin ne kadar önce kullanılacağını, aşağıda veya göründüğünü gösterir.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>)

Oluşturulmuş bir koleksiyon türündeki üyeleri birleştirir IEnumerable<T> String .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 dizideki öğelerin dize gösterimlerini birleştirir Object .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)

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

Concat(String, String, String)

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

Concat(String, String, String, String)

Belirtilen dört örneği birleştirir String .Concatenates four specified instances of String.

Concat(String[])

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

Concat<T>(IEnumerable<T>)

Bir uygulamanın üyelerini birleştirir IEnumerable<T> .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)
Kullanımdan kalktı.

StringBelirtilen değerle aynı değere sahip yeni bir örneğini oluşturur String .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 bir sabit listesi döndürür Rune .Returns an enumeration of Rune from this string.

Equals(Object)

Bu örneğin ve aynı zamanda bir nesne olması gereken belirtilen nesnenin String 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 nesnenin 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 nesnenin 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 nesnenin 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 nesnenin 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()

TypeGeçerli örneği alır.Gets the Type of the current instance.

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

TypeCodeSınıfı için döndürür String .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 nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini bildirir String .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 nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini bildirir String .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 nesnede belirtilen dizenin ilk oluşumunun sıfır tabanlı dizinini bildirir String .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)

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

IsInterned(String)

Belirtilen bir başvuruyu alır String .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ş, boş veya yalnızca boşluk karakterlerinden oluşan bir dize 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, value konumda bulunan öğeden başlayarak startIndex ve öğeleri yukarı birleştirerek bir dizi dizeyi birleştirir count .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>)

IEnumerable<T> String Her üye arasında belirtilen ayırıcıyı kullanarak, oluşturulmuş bir tür koleksiyonunun ü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 nesne içindeki belirli bir dizenin son oluşumunun sıfır tabanlı dizinini raporlar String .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 nesne içindeki belirli bir dizenin son oluşumunun sıfır tabanlı dizinini raporlar String .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 bir basit kopyasını oluşturur Object .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 sınırlandırma karakteri ve isteğe bağlı olarak seçenekler temelinde en fazla sayıda alt dize olarak böler.Splits a string into a maximum number of substrings based on a specified delimiting character and, optionally, options. Bir dizeyi, belirtilen karakter ayırıcısına göre, isteğe bağlı olarak sonuçtan boş alt dizeleri atlayarak en fazla sayıda alt dize olarak böler.Splits a string into a maximum number of substrings based on the provided character separator, optionally omitting empty substrings from the result.

Split(Char, StringSplitOptions)

Belirtilen sınırlandırma karakteri ve isteğe bağlı olarak seçenekleri temel alarak bir dizeyi alt dizelere böler.Splits a string into substrings based on a specified delimiting character and, optionally, options.

Split(Char[])

Belirtilen sınırlandırma karakterlerine göre bir dizeyi alt dizelere böler.Splits a string into substrings based on specified delimiting characters.

Split(Char[], Int32)

Bir dizeyi, belirtilen sınırlandırma karakterlere göre en fazla sayıda alt dize olarak böler.Splits a string into a maximum number of substrings based on specified delimiting characters.

Split(Char[], Int32, StringSplitOptions)

Bir dizeyi, belirtilen sınırlandırma karakterlerine ve isteğe bağlı olarak seçeneklere göre en fazla alt dize sayısına böler.Splits a string into a maximum number of substrings based on specified delimiting characters and, optionally, options.

Split(Char[], StringSplitOptions)

Belirtilen sınırlandırma karakter ve seçeneklerine göre bir dizeyi alt dizelere böler.Splits a string into substrings based on specified delimiting characters and options.

Split(String, Int32, StringSplitOptions)

Bir dizeyi, belirtilen sınırlandırma dizesine ve isteğe bağlı olarak seçeneklere göre en fazla sayıda alt dize olarak böler.Splits a string into a maximum number of substrings based on a specified delimiting string and, optionally, options.

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, belirtilen sınırlandırma dizelerine ve isteğe bağlı olarak seçeneklere bağlı olarak en fazla alt dize sayısına böler.Splits a string into a maximum number of substrings based on specified delimiting strings and, optionally, options.

Split(String[], StringSplitOptions)

Belirtilen sınırlandırma dizesine ve isteğe bağlı olarak seçeneklere göre bir dizeyi alt dizelere böler.Splits a string into substrings based on a specified delimiting string and, optionally, options.

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()

Bu String nesnenin, sabit kültürün büyük/küçük harf kuralları kullanılarak 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 örneğini döndürür String ; gerçek dönüştürme gerçekleştirilmez.Returns this instance of String; no actual conversion is performed.

ToString(IFormatProvider)

Bu örneğini döndürür String ; 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()

StringSabit kültürün büyük/küçük harf kuralları kullanılarak bu nesnenin 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 ile karşılaştırır Object ve belirtilen şekilde sıralama düzeninde aynı konumda olup olmadığını, bu örneği takip edip etmeyeceğini veya göründüğünü gösterir Object .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()

TypeCodeSınıfı için döndürür String .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 nesne boyunca yinelenen bir Numaralandırıcı döndürür String .Returns an enumerator that iterates through the current String object.

IEnumerable<Char>.GetEnumerator()

Geçerli nesne boyunca yinelenen bir Numaralandırıcı döndürür String .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>)

DataTable DataRow Genel parametrenin bulunduğu bir giriş nesnesi verildiğinde, nesnelerin kopyalarını içeren bir döndürür IEnumerable<T> T DataRow .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)

DataRowNesneleri DataTable , IEnumerable<T> genel parametresinin bulunduğu bir giriş nesnesi verildiğinde, belirtilen öğesine kopyalar T DataRow .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)

DataRowNesneleri DataTable , IEnumerable<T> genel parametresinin bulunduğu bir giriş nesnesi verildiğinde, belirtilen öğesine kopyalar T DataRow .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>)

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

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

DecimalGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir değer 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>)

DoubleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir değer 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>)

Int32Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir değer 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>)

Int64Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir değer 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>>)

DecimalGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir null yapılabilir değerler 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>>)

DoubleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir null yapılabilir değerler 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>>)

Int32Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir null yapılabilir değerler 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>>)

Int64Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir null yapılabilir değerler 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>>)

SingleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir null yapılabilir değerler 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>)

SingleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen bir değer 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)

Öğesinin öğelerini IEnumerable 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ıyı 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 öğeyi kullanarak bir sıranın belirtilen öğeyi içerip içermediğini belirler IEqualityComparer<T> .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 ' i kullanarak bir dizideki ayrı öğeleri döndürür IEqualityComparer<T> .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 ' i kullanarak iki sıranın ayarlama farkını üretir IEqualityComparer<T> .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. IEqualityComparer<T>Anahtarları karşılaştırmak için belirtilen bir 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 ' i kullanarak iki sıranın küme kesişimini üretir IEqualityComparer<T> .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. IEqualityComparer<T>Anahtarları karşılaştırmak için belirtilen bir 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>)

Int64Bir dizideki toplam öğe sayısını temsil eden bir 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 Int64 dizideki kaç öğenin bir koşulu karşılayıp karşılamadığını temsil eden bir 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 değeri döndürür Decimal .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 değeri döndürür Double .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 değeri döndürür Int32 .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 değeri döndürür Int64 .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 boş değer 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 boş değer 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 boş değer 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 boş değer 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 boş değer 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 değeri döndürür Single .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 küçük değeri döndürür Decimal .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 küçük değeri döndürür Double .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 küçük değeri döndürür Int32 .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 küçük değeri döndürür Int64 .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 boş değer 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 boş değer 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 boş değer 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 boş değer 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 boş değer 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 küçük değeri döndürür Single .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)

Öğesinin öğelerini IEnumerable 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 bir öğesini bir öğesine IEnumerable<T> 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 bir öğesini bir öğesine IEnumerable<T> 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 dizinin her bir öğesi için olan projeler IEnumerable<T> , 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 dizinin her bir öğesi için olan projeler IEnumerable<T> , 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>)

İki sıranın, öğelerini belirtilen bir kullanarak karşılaştırarak eşit olup olmadığını belirler IEqualityComparer<T> .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)

sourceKaynak koleksiyonun son öğeleriyle öğesinden öğeleri içeren yeni bir sıralanabilir koleksiyon döndürür count .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>)

DecimalGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen değer 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>)

DoubleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen değer 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>)

Int32Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen değer 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>)

Int64Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen değer 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>>)

DecimalGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir değerler 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>>)

DoubleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir değerler 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>>)

Int32Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir değerler 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>>)

Int64Giriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir değerler 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>>)

SingleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen null yapılabilir değerler 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>)

SingleGiriş dizisinin her öğesinde bir Transform işlevi çağırarak elde edilen değer 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)

Öğesinden son öğeleri içeren yeni bir sıralanabilir koleksiyon döndürür count source .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>)

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

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

Dictionary<TKey,TValue> IEnumerable<T> Belirtilen anahtar Seçici işlevine göre bir öğesinden bir 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>)

Dictionary<TKey,TValue> IEnumerable<T> Belirtilen anahtar Seçici işlevine ve anahtar karşılaştırıcısı 'na göre bir öğesinden bir 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>)

Dictionary<TKey,TValue> IEnumerable<T> Belirtilen anahtar seçicisine ve öğe Seçici işlevlerine göre bir öğesinden bir 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>)

Dictionary<TKey,TValue> IEnumerable<T> Belirtilen anahtar Seçici işlevine, karşılaştırıcının ve öğe Seçici işlevine göre bir öğesinden bir 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>)

Kaynağından bir oluşturur HashSet<T> IEnumerable<T> .Creates a HashSet<T> from an IEnumerable<T>.

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

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

ToList<TSource>(IEnumerable<TSource>)

Kaynağından bir oluşturur List<T> IEnumerable<T> .Creates a List<T> from an IEnumerable<T>.

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

Lookup<TKey,TElement> IEnumerable<T> Belirtilen anahtar Seçici işlevine göre bir öğesinden bir 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>)

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

Lookup<TKey,TElement> IEnumerable<T> Belirtilen anahtar seçicisine ve öğe Seçici işlevlerine göre bir öğesinden bir 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 Lookup<TKey,TElement> IEnumerable<T> karşılaştırıcı ve bir öğe Seçici işlevi olan belirtilen bir anahtar Seçici işlevine göre bir ile 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 kullanarak iki sıranın set birleşimini üretir IEqualityComparer<T> .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 öğesine dönüştürür IQueryable .Converts an IEnumerable to an IQueryable.

AsQueryable<TElement>(IEnumerable<TElement>)

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

AsMemory(String)

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

AsMemory(String, Index)

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

AsMemory(String, Int32)

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

AsMemory(String, Int32, Int32)

ReadOnlyMemory<Char>Belirtilen konumdan başlayarak, hedef dizenin bir bölümü üzerinde yeni bir karakter 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)

ReadOnlyMemory<Char>Hedef dizenin belirtilen aralığında yeni bir 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 öğeler XName 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 öğeler XName 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 öğeler XName 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.