CompareInfo.Compare Yöntem

Başvuru

Tanım

Ad Alanı:: System.Globalization

Bütünleştirilmiş Kod:: System.Globalization.dll

Bütünleştirilmiş Kod:: System.Runtime.dll

Bütünleştirilmiş Kod:: mscorlib.dll

Bütünleştirilmiş Kod:: netstandard.dll

Önemli

Bazı bilgiler ürünün ön sürümüyle ilgilidir ve sürüm öncesinde önemli değişiklikler yapılmış olabilir. Burada verilen bilgilerle ilgili olarak Microsoft açık veya zımni hiçbir garanti vermez.

İki dizeyi karşılaştırır.

Aşırı Yüklemeler

Compare(String, String)	İki dizeyi karşılaştırır.
Compare(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions)	İki salt okunur karakter aralığını karşılaştırır.
Compare(String, String, CompareOptions)	Belirtilen CompareOptions değeri kullanarak iki dizeyi karşılaştırır.
Compare(String, Int32, String, Int32)	Bir dizenin bitiş bölümünü başka bir dizenin bitiş bölümüyle karşılaştırır.
Compare(String, Int32, String, Int32, CompareOptions)	Belirtilen CompareOptions değeri kullanarak bir dizenin end bölümünü başka bir dizenin end bölümüyle karşılaştırır.
Compare(String, Int32, Int32, String, Int32, Int32)	Bir dizenin bölümünü başka bir dizenin bölümüyle karşılaştırır.
Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions)	Belirtilen CompareOptions değeri kullanarak bir dizenin bölümünü başka bir dizenin bölümüyle karşılaştırır.

Compare(String, String)

İki dizeyi karşılaştırır.

public:
 virtual int Compare(System::String ^ string1, System::String ^ string2);

public:
 int Compare(System::String ^ string1, System::String ^ string2);

public virtual int Compare (string string1, string string2);

public int Compare (string? string1, string? string2);

public virtual int Compare (string? string1, string? string2);

abstract member Compare : string * string -> int
override this.Compare : string * string -> int

member this.Compare : string * string -> int

Public Overridable Function Compare (string1 As String, string2 As String) As Integer

Public Function Compare (string1 As String, string2 As String) As Integer

Parametreler

string1: String

Karşılaştırılacak ilk dize.

string2: String

Karşılaştırılacak ikinci dize.

Döndürülenler

Int32

İki karşılaştırma ve arasındaki sözcük temelli ilişkiyi gösteren 32 bit işaretli bir tamsayı.

Değer	Koşul
sıfır	İki dize eşittir.
sıfırdan küçük	`string1` değerinden küçüktür `string2`.
sıfırdan büyük	`string1` değerinden büyüktür `string2`.

Örnekler

Aşağıdaki örnek, farklı CompareInfo nesneleri kullanarak iki dizenin bölümlerini karşılaştırır:

CompareInfo uluslararası sıralama ile İspanyolca (İspanya) kültürü ile ilişkili nesne
CompareInfo geleneksel sıralama ile İspanyolca (İspanya) kültürü ile ilişkili nesne
CompareInfo ile ilişkili nesne InvariantCulture

// The following code example compares two strings using the different CompareInfo instances:
//    a CompareInfo instance associated with the S"Spanish - Spain" culture with international sort,
//    a CompareInfo instance associated with the S"Spanish - Spain" culture with traditional sort, and
//    a CompareInfo instance associated with the InvariantCulture.
using namespace System;
using namespace System::Globalization;
int main()
{
   
   // Defines the strings to compare.
   String^ myStr1 = "calle";
   String^ myStr2 = "calor";
   
   // Uses GetCompareInfo to create the CompareInfo that 
   // uses the S"es-ES" culture with international sort.
   CompareInfo^ myCompIntl = CompareInfo::GetCompareInfo( "es-ES" );
   
   // Uses GetCompareInfo to create the CompareInfo that 
   // uses the S"es-ES" culture with traditional sort.
   CompareInfo^ myCompTrad = CompareInfo::GetCompareInfo( 0x040A );
   
   // Uses the CompareInfo property of the InvariantCulture.
   CompareInfo^ myCompInva = CultureInfo::InvariantCulture->CompareInfo;
   
   // Compares two strings using myCompIntl.
   Console::WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1, myStr2 );
   Console::WriteLine( "   With myCompIntl::Compare: {0}", myCompIntl->Compare( myStr1, myStr2 ) );
   Console::WriteLine( "   With myCompTrad::Compare: {0}", myCompTrad->Compare( myStr1, myStr2 ) );
   Console::WriteLine( "   With myCompInva::Compare: {0}", myCompInva->Compare( myStr1, myStr2 ) );
}

/*
This code produces the following output.

Comparing "calle" and "calor"
   With myCompIntl::Compare: -1
   With myCompTrad::Compare: 1
   With myCompInva::Compare: -1
*/

// The following code example compares two strings using the different CompareInfo instances:
//    a CompareInfo instance associated with the "Spanish - Spain" culture with international sort,
//    a CompareInfo instance associated with the "Spanish - Spain" culture with traditional sort, and
//    a CompareInfo instance associated with the InvariantCulture.

using System;
using System.Globalization;

public class SamplesCompareInfo  {

   public static void Main()  {

      // Defines the strings to compare.
      String myStr1 = "calle";
      String myStr2 = "calor";

      // Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
      CompareInfo myCompIntl = CompareInfo.GetCompareInfo( "es-ES" );

      // Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
      CompareInfo myCompTrad = CompareInfo.GetCompareInfo( 0x040A );

      // Uses the CompareInfo property of the InvariantCulture.
      CompareInfo myCompInva = CultureInfo.InvariantCulture.CompareInfo;

      // Compares two strings using myCompIntl.
      Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1, myStr2 );
      Console.WriteLine( "   With myCompIntl.Compare: {0}", myCompIntl.Compare( myStr1, myStr2 ) );
      Console.WriteLine( "   With myCompTrad.Compare: {0}", myCompTrad.Compare( myStr1, myStr2 ) );
      Console.WriteLine( "   With myCompInva.Compare: {0}", myCompInva.Compare( myStr1, myStr2 ) );
   }
}


/*
This code produces the following output.

Comparing "calle" and "calor"
   With myCompIntl.Compare: -1
   With myCompTrad.Compare: 1
   With myCompInva.Compare: -1

*/

' The following code example compares two strings using the different CompareInfo instances:
'    a CompareInfo instance associated with the "Spanish - Spain" culture with international sort,
'    a CompareInfo instance associated with the "Spanish - Spain" culture with traditional sort, and
'    a CompareInfo instance associated with the InvariantCulture.

Imports System.Globalization

Public Class SamplesCompareInfo

   Public Shared Sub Main()

      ' Defines the strings to compare.
      Dim myStr1 As [String] = "calle"
      Dim myStr2 As [String] = "calor"

      ' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
      Dim myCompIntl As CompareInfo = CompareInfo.GetCompareInfo("es-ES")

      ' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
      Dim myCompTrad As CompareInfo = CompareInfo.GetCompareInfo(&H40A)

      ' Uses the CompareInfo property of the InvariantCulture.
      Dim myCompInva As CompareInfo = CultureInfo.InvariantCulture.CompareInfo

      ' Compares two strings using myCompIntl.
      Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1, myStr2)
      Console.WriteLine("   With myCompIntl.Compare: {0}", myCompIntl.Compare(myStr1, myStr2))
      Console.WriteLine("   With myCompTrad.Compare: {0}", myCompTrad.Compare(myStr1, myStr2))
      Console.WriteLine("   With myCompInva.Compare: {0}", myCompInva.Compare(myStr1, myStr2))

   End Sub

End Class


'This code produces the following output.
'
'Comparing "calle" and "calor"
'   With myCompIntl.Compare: -1
'   With myCompTrad.Compare: 1
'   With myCompInva.Compare: -1

Aşağıdaki örnekte yönteminin çağrılması gösterilmektedir Compare .

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

int main()
{
    array<String^>^ sign = gcnew array<String^> { "<", "=", ">" };

    // The code below demonstrates how strings compare
    // differently for different cultures.
    String^ s1 = "Coté"; 
    String^ s2 = "coté";
    String^ s3 = "côte";

    // Set sort order of strings for French in France.
    CompareInfo^ ci = (gcnew CultureInfo("fr-FR"))->CompareInfo;
    Console::WriteLine(L"The LCID for {0} is {1}.", ci->Name, ci->LCID);

    // Display the result using fr-FR Compare of Coté = coté.
    Console::WriteLine(L"fr-FR Compare: {0} {2} {1}",
        s1, s2, sign[ci->Compare(s1, s2, CompareOptions::IgnoreCase) + 1]);

    // Display the result using fr-FR Compare of coté > côte.
    Console::WriteLine(L"fr-FR Compare: {0} {2} {1}",
        s2, s3, sign[ci->Compare(s2, s3, CompareOptions::None) + 1]);

    // Set sort order of strings for Japanese as spoken in Japan.
    ci = (gcnew CultureInfo("ja-JP"))->CompareInfo;
    Console::WriteLine(L"The LCID for {0} is {1}.", ci->Name, ci->LCID);

    // Display the result using ja-JP Compare of coté < côte.
    Console::WriteLine("ja-JP Compare: {0} {2} {1}",
        s2, s3, sign[ci->Compare(s2, s3) + 1]);
}

// This code produces the following output.
//
// The LCID for fr-FR is 1036.
// fr-FR Compare: Coté = coté
// fr-FR Compare: coté > côte
// The LCID for ja-JP is 1041.
// ja-JP Compare: coté < côte

using System;
using System.Text;
using System.Globalization;

public sealed class App
{
    static void Main(string[] args)
    {
        String[] sign = new String[] { "<", "=", ">" };

        // The code below demonstrates how strings compare
        // differently for different cultures.
        String s1 = "Coté", s2 = "coté", s3 = "côte";

        // Set sort order of strings for French in France.
        CompareInfo ci = new CultureInfo("fr-FR").CompareInfo;
        Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID);

        // Display the result using fr-FR Compare of Coté = coté.  	
        Console.WriteLine("fr-FR Compare: {0} {2} {1}",
            s1, s2, sign[ci.Compare(s1, s2, CompareOptions.IgnoreCase) + 1]);

        // Display the result using fr-FR Compare of coté > côte.
        Console.WriteLine("fr-FR Compare: {0} {2} {1}",
            s2, s3, sign[ci.Compare(s2, s3, CompareOptions.None) + 1]);

        // Set sort order of strings for Japanese as spoken in Japan.
        ci = new CultureInfo("ja-JP").CompareInfo;
        Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID);

        // Display the result using ja-JP Compare of coté < côte.
        Console.WriteLine("ja-JP Compare: {0} {2} {1}",
            s2, s3, sign[ci.Compare(s2, s3) + 1]);
    }
}

// This code produces the following output.
//
// The LCID for fr-FR is 1036.
// fr-FR Compare: Coté = coté
// fr-FR Compare: coté > côte
// The LCID for ja-JP is 1041.
// ja-JP Compare: coté < côte

Imports System.Text
Imports System.Globalization

NotInheritable Public Class App
    Shared Sub Main(ByVal args() As String) 
        Dim sign() As String = {"<", "=", ">"}
        
        ' The code below demonstrates how strings compare 
        ' differently for different cultures.
        Dim s1 As String = "Coté"
        Dim s2 As String = "coté"
        Dim s3 As String = "côte"
        
        ' Set sort order of strings for French in France.
        Dim ci As CompareInfo = New CultureInfo("fr-FR").CompareInfo
        Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID)
        
        ' Display the result using fr-FR Compare of Coté = coté.  	
        Console.WriteLine("fr-FR Compare: {0} {2} {1}", _
                          s1, s2, sign((ci.Compare(s1, s2, CompareOptions.IgnoreCase) + 1)))
        
        ' Display the result using fr-FR Compare of coté > côte.
        Console.WriteLine("fr-FR Compare: {0} {2} {1}", _
                          s2, s3, sign((ci.Compare(s2, s3, CompareOptions.None) + 1)))
        
        ' Set sort order of strings for Japanese as spoken in Japan.
        ci = New CultureInfo("ja-JP").CompareInfo
        Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID)
        
        ' Display the result using ja-JP Compare of coté < côte. 
        Console.WriteLine("ja-JP Compare: {0} {2} {1}", _
                          s2, s3, sign((ci.Compare(s2, s3) + 1)))
    End Sub
End Class

' This code produces the following output.
' 
' The LCID for fr-FR is 1036.
' fr-FR Compare: Coté = coté
' fr-FR Compare: coté > côte
' The LCID for ja-JP is 1041.
' ja-JP Compare: coté < côte

Açıklamalar

Varsayılan olarak, karşılaştırma kullanılarak CompareOptions.Nonegerçekleştirilir. Bir güvenlik kararı bir dize karşılaştırmasına veya büyük/küçük harf değişikliğine bağlıysa, işletim sisteminin kültür ayarlarından bağımsız olarak davranışın tutarlı olduğundan emin olmak için özelliğini kullanmanız InvariantCulture gerekir.

Not

Mümkün olduğunda, beklenen karşılaştırma türünü belirtmek için türünde CompareOptions bir parametresi olan dize karşılaştırma yöntemlerini çağırmanız gerekir. Genel bir kural olarak, kullanıcı arabiriminde görüntülenen dizeleri karşılaştırmak ve Ordinal OrdinalIgnoreCase veya güvenlik karşılaştırmaları için dilsel seçenekleri (geçerli kültürü kullanarak) kullanın.

Arayanlara Notlar

Karakter kümeleri, dilbilimsel veya kültüre duyarlı bir karşılaştırma yapılırken dikkate alınmayan karakterler olan yok sayılabilir karakterler içerir. yöntemi Compare(String, String) kültüre duyarlı bir karşılaştırma gerçekleştirirken bu tür karakterleri dikkate almaz. Örneğin, "hayvan" ile "ani-mal" (yumuşak kısa çizgi veya U+00AD kullanarak) kültüre duyarlı karşılaştırma, aşağıdaki örnekte gösterildiği gibi iki dizenin eşdeğer olduğunu gösterir.

Imports System.Globalization

Module Example
   Public Sub Main()
      Dim ci As CompareInfo = CultureInfo.CurrentCulture.CompareInfo
      Dim s1 As String = "ani" + ChrW(&h00AD) + "mal"
      Dim s2 As String = "animal"
      
      Console.WriteLine("Comparison of '{0}' and '{1}': {2}", 
                        s1, s2, ci.Compare(s1, s2))
  End Sub
End Module
' The example displays the following output:
'       Comparison of 'ani-mal' and 'animal': 0

Dize karşılaştırmasında yoksayılabilir karakterleri tanımak için yöntemini çağırın Compare(String, String, CompareOptions) ve parametresi için options veya OrdinalIgnoreCase değerini Ordinal sağlayın.

Şunlara uygulanır

Compare(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions)

İki salt okunur karakter aralığını karşılaştırır.

public int Compare (ReadOnlySpan<char> string1, ReadOnlySpan<char> string2, System.Globalization.CompareOptions options = System.Globalization.CompareOptions.None);

member this.Compare : ReadOnlySpan<char> * ReadOnlySpan<char> * System.Globalization.CompareOptions -> int

Public Function Compare (string1 As ReadOnlySpan(Of Char), string2 As ReadOnlySpan(Of Char), Optional options As CompareOptions = System.Globalization.CompareOptions.None) As Integer

Parametreler

string1: ReadOnlySpan<Char>

Karşılaştırılacak ilk salt okunur karakter aralığı.

string2: ReadOnlySpan<Char>

Karşılaştırılacak karakterlerin ikinci salt okunur aralığı.

options: CompareOptions

Karşılaştırma sırasında kullanılacak isteğe bağlı sabit listesi değerleri birleşimi CompareOptions . None varsayılan değerdir.

Döndürülenler

Int32

ve eşitse string1 sıfır; önce string2sıralanırsa negatif bir değer string1 veya sonra string2sıralanırsa pozitif bir değerstring1.string2

Özel durumlar

ArgumentException

options desteklenmeyen bir bayrak bileşimi içerir.

Şunlara uygulanır

Compare(String, String, CompareOptions)

Belirtilen CompareOptions değeri kullanarak iki dizeyi karşılaştırır.

public:
 virtual int Compare(System::String ^ string1, System::String ^ string2, System::Globalization::CompareOptions options);

public:
 int Compare(System::String ^ string1, System::String ^ string2, System::Globalization::CompareOptions options);

public virtual int Compare (string string1, string string2, System.Globalization.CompareOptions options);

public int Compare (string? string1, string? string2, System.Globalization.CompareOptions options);

public virtual int Compare (string? string1, string? string2, System.Globalization.CompareOptions options);

abstract member Compare : string * string * System.Globalization.CompareOptions -> int
override this.Compare : string * string * System.Globalization.CompareOptions -> int

member this.Compare : string * string * System.Globalization.CompareOptions -> int

Public Overridable Function Compare (string1 As String, string2 As String, options As CompareOptions) As Integer

Public Function Compare (string1 As String, string2 As String, options As CompareOptions) As Integer

Parametreler

string1: String

Karşılaştırılacak ilk dize.

string2: String

Karşılaştırılacak ikinci dize.

options: CompareOptions

Nasıl string1 ve string2 karşılaştırılması gerektiğini tanımlayan bir değer. options sabit listesi değeridir Ordinalveya aşağıdaki değerlerden birinin veya daha fazlasının bit düzeyinde birleşimidir: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, IgnoreKanaTypeve StringSort.

Döndürülenler

Int32

İki karşılaştırma ve arasındaki sözcük temelli ilişkiyi gösteren 32 bit işaretli bir tamsayı.

Değer	Koşul
sıfır	İki dize eşittir.
sıfırdan küçük	`string1` değerinden küçüktür `string2`.
sıfırdan büyük	`string1` değerinden büyüktür `string2`.

Özel durumlar

ArgumentException

options geçersiz CompareOptions bir değer içeriyor.

Örnekler

Aşağıdaki örnek, farklı CompareOptions ayarlar kullanan iki dizeyi karşılaştırır.

using namespace System;
using namespace System::Globalization;
int main()
{
   
   // Defines the strings to compare.
   String^ myStr1 = "My Uncle Bill's clients";
   String^ myStr2 = "My uncle bills clients";
   
   // Creates a CompareInfo which uses the InvariantCulture.
   CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
   
   // Compares two strings using myComp.
   Console::WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1, myStr2 );
   Console::WriteLine( "   With no CompareOptions            : {0}", myComp->Compare( myStr1, myStr2 ) );
   Console::WriteLine( "   With None                         : {0}", myComp->Compare( myStr1, myStr2, CompareOptions::None ) );
   Console::WriteLine( "   With Ordinal                      : {0}", myComp->Compare( myStr1, myStr2, CompareOptions::Ordinal ) );
   Console::WriteLine( "   With StringSort                   : {0}", myComp->Compare( myStr1, myStr2, CompareOptions::StringSort ) );
   Console::WriteLine( "   With IgnoreCase                   : {0}", myComp->Compare( myStr1, myStr2, CompareOptions::IgnoreCase ) );
   Console::WriteLine( "   With IgnoreSymbols                : {0}", myComp->Compare( myStr1, myStr2, CompareOptions::IgnoreSymbols ) );
   Console::WriteLine( "   With IgnoreCase and IgnoreSymbols : {0}", myComp->Compare( myStr1, myStr2, static_cast<CompareOptions>(CompareOptions::IgnoreCase | CompareOptions::IgnoreSymbols) ) );
}

/*
This code produces the following output.

Comparing "My Uncle Bill's clients" and "My uncle bills clients"
   With no CompareOptions            : 1
   With None                         : 1
   With Ordinal                      : -32
   With StringSort                   : -1
   With IgnoreCase                   : 1
   With IgnoreSymbols                : 1
   With IgnoreCase and IgnoreSymbols : 0
*/

using System;
using System.Globalization;

public class SamplesCompareInfo  {

   public static void Main()  {

      // Defines the strings to compare.
      String myStr1 = "My Uncle Bill's clients";
      String myStr2 = "My uncle bills clients";

      // Creates a CompareInfo that uses the InvariantCulture.
      CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;

      // Compares two strings using myComp.
      Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1, myStr2 );
      Console.WriteLine( "   With no CompareOptions            : {0}", myComp.Compare( myStr1, myStr2 ) );
      Console.WriteLine( "   With None                         : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.None ) );
      Console.WriteLine( "   With Ordinal                      : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.Ordinal ) );
      Console.WriteLine( "   With StringSort                   : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.StringSort ) );
      Console.WriteLine( "   With IgnoreCase                   : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.IgnoreCase ) );
      Console.WriteLine( "   With IgnoreSymbols                : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.IgnoreSymbols ) );
      Console.WriteLine( "   With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare( myStr1, myStr2, CompareOptions.IgnoreCase | CompareOptions.IgnoreSymbols ) );
   }
}


/*
This code produces the following output.

Comparing "My Uncle Bill's clients" and "My uncle bills clients"
   With no CompareOptions            : 1
   With None                         : 1
   With Ordinal                      : -32
   With StringSort                   : -1
   With IgnoreCase                   : 1
   With IgnoreSymbols                : 1
   With IgnoreCase and IgnoreSymbols : 0

*/

Imports System.Globalization

Public Class SamplesCompareInfo

   Public Shared Sub Main()

      ' Defines the strings to compare.
      Dim myStr1 As [String] = "My Uncle Bill's clients"
      Dim myStr2 As [String] = "My uncle bills clients"

      ' Creates a CompareInfo that uses the InvariantCulture.
      Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo

      ' Compares two strings using myComp.
      Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1, myStr2)
      Console.WriteLine("   With no CompareOptions            : {0}", myComp.Compare(myStr1, myStr2))
      Console.WriteLine("   With None                         : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.None))
      Console.WriteLine("   With Ordinal                      : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.Ordinal))
      Console.WriteLine("   With StringSort                   : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.StringSort))
      Console.WriteLine("   With IgnoreCase                   : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.IgnoreCase))
      Console.WriteLine("   With IgnoreSymbols                : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.IgnoreSymbols))
      Console.WriteLine("   With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare(myStr1, myStr2, CompareOptions.IgnoreCase Or CompareOptions.IgnoreSymbols))

   End Sub

End Class


'This code produces the following output.
'
'Comparing "My Uncle Bill's clients" and "My uncle bills clients"
'   With no CompareOptions            : 1
'   With None                         : 1
'   With Ordinal                      : -32
'   With StringSort                   : -1
'   With IgnoreCase                   : 1
'   With IgnoreSymbols                : 1
'   With IgnoreCase and IgnoreSymbols : 0

Aşağıdaki örnekte yönteminin çağrılması gösterilmektedir Compare .

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

int main()
{
    array<String^>^ sign = gcnew array<String^> { "<", "=", ">" };

    // The code below demonstrates how strings compare
    // differently for different cultures.
    String^ s1 = "Coté"; 
    String^ s2 = "coté";
    String^ s3 = "côte";

    // Set sort order of strings for French in France.
    CompareInfo^ ci = (gcnew CultureInfo("fr-FR"))->CompareInfo;
    Console::WriteLine(L"The LCID for {0} is {1}.", ci->Name, ci->LCID);

    // Display the result using fr-FR Compare of Coté = coté.
    Console::WriteLine(L"fr-FR Compare: {0} {2} {1}",
        s1, s2, sign[ci->Compare(s1, s2, CompareOptions::IgnoreCase) + 1]);

    // Display the result using fr-FR Compare of coté > côte.
    Console::WriteLine(L"fr-FR Compare: {0} {2} {1}",
        s2, s3, sign[ci->Compare(s2, s3, CompareOptions::None) + 1]);

    // Set sort order of strings for Japanese as spoken in Japan.
    ci = (gcnew CultureInfo("ja-JP"))->CompareInfo;
    Console::WriteLine(L"The LCID for {0} is {1}.", ci->Name, ci->LCID);

    // Display the result using ja-JP Compare of coté < côte.
    Console::WriteLine("ja-JP Compare: {0} {2} {1}",
        s2, s3, sign[ci->Compare(s2, s3) + 1]);
}

// This code produces the following output.
//
// The LCID for fr-FR is 1036.
// fr-FR Compare: Coté = coté
// fr-FR Compare: coté > côte
// The LCID for ja-JP is 1041.
// ja-JP Compare: coté < côte

using System;
using System.Text;
using System.Globalization;

public sealed class App
{
    static void Main(string[] args)
    {
        String[] sign = new String[] { "<", "=", ">" };

        // The code below demonstrates how strings compare
        // differently for different cultures.
        String s1 = "Coté", s2 = "coté", s3 = "côte";

        // Set sort order of strings for French in France.
        CompareInfo ci = new CultureInfo("fr-FR").CompareInfo;
        Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID);

        // Display the result using fr-FR Compare of Coté = coté.  	
        Console.WriteLine("fr-FR Compare: {0} {2} {1}",
            s1, s2, sign[ci.Compare(s1, s2, CompareOptions.IgnoreCase) + 1]);

        // Display the result using fr-FR Compare of coté > côte.
        Console.WriteLine("fr-FR Compare: {0} {2} {1}",
            s2, s3, sign[ci.Compare(s2, s3, CompareOptions.None) + 1]);

        // Set sort order of strings for Japanese as spoken in Japan.
        ci = new CultureInfo("ja-JP").CompareInfo;
        Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID);

        // Display the result using ja-JP Compare of coté < côte.
        Console.WriteLine("ja-JP Compare: {0} {2} {1}",
            s2, s3, sign[ci.Compare(s2, s3) + 1]);
    }
}

// This code produces the following output.
//
// The LCID for fr-FR is 1036.
// fr-FR Compare: Coté = coté
// fr-FR Compare: coté > côte
// The LCID for ja-JP is 1041.
// ja-JP Compare: coté < côte

Imports System.Text
Imports System.Globalization

NotInheritable Public Class App
    Shared Sub Main(ByVal args() As String) 
        Dim sign() As String = {"<", "=", ">"}
        
        ' The code below demonstrates how strings compare 
        ' differently for different cultures.
        Dim s1 As String = "Coté"
        Dim s2 As String = "coté"
        Dim s3 As String = "côte"
        
        ' Set sort order of strings for French in France.
        Dim ci As CompareInfo = New CultureInfo("fr-FR").CompareInfo
        Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID)
        
        ' Display the result using fr-FR Compare of Coté = coté.  	
        Console.WriteLine("fr-FR Compare: {0} {2} {1}", _
                          s1, s2, sign((ci.Compare(s1, s2, CompareOptions.IgnoreCase) + 1)))
        
        ' Display the result using fr-FR Compare of coté > côte.
        Console.WriteLine("fr-FR Compare: {0} {2} {1}", _
                          s2, s3, sign((ci.Compare(s2, s3, CompareOptions.None) + 1)))
        
        ' Set sort order of strings for Japanese as spoken in Japan.
        ci = New CultureInfo("ja-JP").CompareInfo
        Console.WriteLine("The LCID for {0} is {1}.", ci.Name, ci.LCID)
        
        ' Display the result using ja-JP Compare of coté < côte. 
        Console.WriteLine("ja-JP Compare: {0} {2} {1}", _
                          s2, s3, sign((ci.Compare(s2, s3) + 1)))
    End Sub
End Class

' This code produces the following output.
' 
' The LCID for fr-FR is 1036.
' fr-FR Compare: Coté = coté
' fr-FR Compare: coté > côte
' The LCID for ja-JP is 1041.
' ja-JP Compare: coté < côte

Açıklamalar

Bir güvenlik kararı bir dize karşılaştırmasına veya büyük/küçük harf değişikliğine bağlıysa, işletim sisteminin kültür ayarlarından bağımsız olarak davranışın tutarlı olduğundan emin olmak için özelliğini kullanmanız InvariantCulture gerekir.

Not

Arayanlara Notlar

Karakter kümeleri, dilbilimsel veya kültüre duyarlı bir karşılaştırma yapılırken dikkate alınmayan karakterler olan yok sayılabilir karakterler içerir. yöntemi Compare(String, String, CompareOptions) kültüre duyarlı bir karşılaştırma gerçekleştirirken bu tür karakterleri dikkate almaz. Karşılaştırmanızda yoksayılabilir karakterleri tanımak için parametresi için options veya OrdinalIgnoreCase değerini Ordinal sağlayın.

Ayrıca bkz.

CompareOptions

Şunlara uygulanır

Compare(String, Int32, String, Int32)

Bir dizenin bitiş bölümünü başka bir dizenin bitiş bölümüyle karşılaştırır.

public:
 virtual int Compare(System::String ^ string1, int offset1, System::String ^ string2, int offset2);

public:
 int Compare(System::String ^ string1, int offset1, System::String ^ string2, int offset2);

public virtual int Compare (string string1, int offset1, string string2, int offset2);

public int Compare (string? string1, int offset1, string? string2, int offset2);

public virtual int Compare (string? string1, int offset1, string? string2, int offset2);

abstract member Compare : string * int * string * int -> int
override this.Compare : string * int * string * int -> int

member this.Compare : string * int * string * int -> int

Public Overridable Function Compare (string1 As String, offset1 As Integer, string2 As String, offset2 As Integer) As Integer

Public Function Compare (string1 As String, offset1 As Integer, string2 As String, offset2 As Integer) As Integer

Parametreler

string1: String

Karşılaştırılacak ilk dize.

offset1: Int32

Karşılaştırmaya başlanması gereken karakterin string1 sıfır tabanlı dizini.

string2: String

Karşılaştırılacak ikinci dize.

offset2: Int32

Karşılaştırmaya başlanması gereken karakterin string2 sıfır tabanlı dizini.

Döndürülenler

Int32

İki karşılaştırma ve arasındaki sözcük temelli ilişkiyi gösteren 32 bit işaretli bir tamsayı.

Değer	Koşul
sıfır	İki dize eşittir.
sıfırdan küçük	belirtilen bölümü `string1` belirtilen bölümünden `string2`küçüktür.
sıfırdan büyük	belirtilen bölümü `string1` , öğesinin belirtilen bölümünden `string2`büyük.

Özel durumlar

ArgumentOutOfRangeException

offset1 veya offset2 sıfırdan küçüktür.

-veya-

offset1 , içindeki string1karakter sayısından büyük veya buna eşittir.

-veya-

offset2 , içindeki string2karakter sayısından büyük veya buna eşittir.

Örnekler

Aşağıdaki örnek, farklı CompareInfo nesneleri kullanarak iki dizenin bölümlerini karşılaştırır:

CompareInfo uluslararası sıralama ile İspanyolca (İspanya) kültürü ile ilişkili nesne
CompareInfo geleneksel sıralama ile İspanyolca (İspanya) kültürü ile ilişkili nesne
CompareInfo ile ilişkili nesne InvariantCulture

using namespace System;
using namespace System::Globalization;
int main()
{
   
   // Defines the strings to compare.
   String^ myStr1 = "calle";
   String^ myStr2 = "calor";
   
   // Uses GetCompareInfo to create the CompareInfo that 
   // uses the S"es-ES" culture with international sort.
   CompareInfo^ myCompIntl = CompareInfo::GetCompareInfo( "es-ES" );
   
   // Uses GetCompareInfo to create the CompareInfo that 
   // uses the S"es-ES" culture with traditional sort.
   CompareInfo^ myCompTrad = CompareInfo::GetCompareInfo( 0x040A );
   
   // Uses the CompareInfo property of the InvariantCulture.
   CompareInfo^ myCompInva = CultureInfo::InvariantCulture->CompareInfo;
   
   // Compares two strings using myCompIntl.
   Console::WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1->Substring( 2 ), myStr2->Substring( 2 ) );
   Console::WriteLine( "   With myCompIntl::Compare: {0}", myCompIntl->Compare( myStr1, 2, myStr2, 2 ) );
   Console::WriteLine( "   With myCompTrad::Compare: {0}", myCompTrad->Compare( myStr1, 2, myStr2, 2 ) );
   Console::WriteLine( "   With myCompInva::Compare: {0}", myCompInva->Compare( myStr1, 2, myStr2, 2 ) );
}

/*
This code produces the following output.

Comparing "lle" and "lor"
   With myCompIntl::Compare: -1
   With myCompTrad::Compare: 1
   With myCompInva::Compare: -1
*/

using System;
using System.Globalization;

public class SamplesCompareInfo  {

   public static void Main()  {

      // Defines the strings to compare.
      String myStr1 = "calle";
      String myStr2 = "calor";

      // Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
      CompareInfo myCompIntl = CompareInfo.GetCompareInfo( "es-ES" );

      // Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
      CompareInfo myCompTrad = CompareInfo.GetCompareInfo( 0x040A );

      // Uses the CompareInfo property of the InvariantCulture.
      CompareInfo myCompInva = CultureInfo.InvariantCulture.CompareInfo;

      // Compares two strings using myCompIntl.
      Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1.Substring( 2 ), myStr2.Substring( 2 ) );
      Console.WriteLine( "   With myCompIntl.Compare: {0}", myCompIntl.Compare( myStr1, 2, myStr2, 2 ) );
      Console.WriteLine( "   With myCompTrad.Compare: {0}", myCompTrad.Compare( myStr1, 2, myStr2, 2 ) );
      Console.WriteLine( "   With myCompInva.Compare: {0}", myCompInva.Compare( myStr1, 2, myStr2, 2 ) );
   }
}


/*
This code produces the following output.

Comparing "lle" and "lor"
   With myCompIntl.Compare: -1
   With myCompTrad.Compare: 1
   With myCompInva.Compare: -1

*/

Imports System.Globalization

Public Class SamplesCompareInfo

   Public Shared Sub Main()

      ' Defines the strings to compare.
      Dim myStr1 As [String] = "calle"
      Dim myStr2 As [String] = "calor"

      ' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
      Dim myCompIntl As CompareInfo = CompareInfo.GetCompareInfo("es-ES")

      ' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
      Dim myCompTrad As CompareInfo = CompareInfo.GetCompareInfo(&H40A)

      ' Uses the CompareInfo property of the InvariantCulture.
      Dim myCompInva As CompareInfo = CultureInfo.InvariantCulture.CompareInfo

      ' Compares two strings using myCompIntl.
      Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1.Substring(2), myStr2.Substring(2))
      Console.WriteLine("   With myCompIntl.Compare: {0}", myCompIntl.Compare(myStr1, 2, myStr2, 2))
      Console.WriteLine("   With myCompTrad.Compare: {0}", myCompTrad.Compare(myStr1, 2, myStr2, 2))
      Console.WriteLine("   With myCompInva.Compare: {0}", myCompInva.Compare(myStr1, 2, myStr2, 2))

   End Sub

End Class


'This code produces the following output.
'
'Comparing "lle" and "lor"
'   With myCompIntl.Compare: -1
'   With myCompTrad.Compare: 1
'   With myCompInva.Compare: -1

Açıklamalar

Not

Arayanlara Notlar

Karakter kümeleri yoksayılabilir karakterler içerir. Compare(String, Int32, String, Int32) yöntemi, dilsel veya kültüre duyarlı bir karşılaştırma gerçekleştirirken bu karakterleri dikkate almaz. Karşılaştırmanızda yoksayılabilir karakterleri tanımak için yöntemini çağırın Compare(String, Int32, String, Int32, CompareOptions) ve parametresi için options veya OrdinalIgnoreCase değerini Ordinal sağlayın.

Şunlara uygulanır

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

Belirtilen CompareOptions değeri kullanarak bir dizenin end bölümünü başka bir dizenin end bölümüyle karşılaştırır.

public:
 virtual int Compare(System::String ^ string1, int offset1, System::String ^ string2, int offset2, System::Globalization::CompareOptions options);

public:
 int Compare(System::String ^ string1, int offset1, System::String ^ string2, int offset2, System::Globalization::CompareOptions options);

public virtual int Compare (string string1, int offset1, string string2, int offset2, System.Globalization.CompareOptions options);

public int Compare (string? string1, int offset1, string? string2, int offset2, System.Globalization.CompareOptions options);

public virtual int Compare (string? string1, int offset1, string? string2, int offset2, System.Globalization.CompareOptions options);

abstract member Compare : string * int * string * int * System.Globalization.CompareOptions -> int
override this.Compare : string * int * string * int * System.Globalization.CompareOptions -> int

member this.Compare : string * int * string * int * System.Globalization.CompareOptions -> int

Public Overridable Function Compare (string1 As String, offset1 As Integer, string2 As String, offset2 As Integer, options As CompareOptions) As Integer

Public Function Compare (string1 As String, offset1 As Integer, string2 As String, offset2 As Integer, options As CompareOptions) As Integer

Parametreler

string1: String

Karşılaştırılacak ilk dize.

offset1: Int32

Karşılaştırmaya başlanması gereken karakterin string1 sıfır tabanlı dizini.

string2: String

Karşılaştırılacak ikinci dize.

offset2: Int32

Karşılaştırmaya başlanması gereken karakterin string2 sıfır tabanlı dizini.

options: CompareOptions

Döndürülenler

Int32

İki karşılaştırma ve arasındaki sözcük temelli ilişkiyi gösteren 32 bit işaretli bir tamsayı.

Değer	Koşul
sıfır	İki dize eşittir.
sıfırdan küçük	belirtilen bölümü `string1` belirtilen bölümünden `string2`küçüktür.
sıfırdan büyük	belirtilen bölümü `string1` , öğesinin belirtilen bölümünden `string2`büyük.

Özel durumlar

ArgumentOutOfRangeException

offset1 veya offset2 sıfırdan küçüktür.

-veya-

offset1 , içindeki string1karakter sayısından büyük veya buna eşittir.

-veya-

offset2 , içindeki string2karakter sayısından büyük veya buna eşittir.

ArgumentException

options geçersiz CompareOptions bir değer içeriyor.

Örnekler

Aşağıdaki örnek, farklı CompareOptions ayarlar kullanarak iki dizenin bölümlerini karşılaştırır.

using namespace System;
using namespace System::Globalization;
int main()
{
   
   // Defines the strings to compare.
   String^ myStr1 = "My Uncle Bill's clients";
   String^ myStr2 = "My uncle bills clients";
   
   // Creates a CompareInfo that uses the InvariantCulture.
   CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
   
   // Compares two strings using myComp.
   Console::WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1->Substring( 10 ), myStr2->Substring( 10 ) );
   Console::WriteLine( "   With no CompareOptions            : {0}", myComp->Compare( myStr1, 10, myStr2, 10 ) );
   Console::WriteLine( "   With None                         : {0}", myComp->Compare( myStr1, 10, myStr2, 10, CompareOptions::None ) );
   Console::WriteLine( "   With Ordinal                      : {0}", myComp->Compare( myStr1, 10, myStr2, 10, CompareOptions::Ordinal ) );
   Console::WriteLine( "   With StringSort                   : {0}", myComp->Compare( myStr1, 10, myStr2, 10, CompareOptions::StringSort ) );
   Console::WriteLine( "   With IgnoreCase                   : {0}", myComp->Compare( myStr1, 10, myStr2, 10, CompareOptions::IgnoreCase ) );
   Console::WriteLine( "   With IgnoreSymbols                : {0}", myComp->Compare( myStr1, 10, myStr2, 10, CompareOptions::IgnoreSymbols ) );
   Console::WriteLine( "   With IgnoreCase and IgnoreSymbols : {0}", myComp->Compare( myStr1, 10, myStr2, 10, static_cast<CompareOptions>(CompareOptions::IgnoreCase | CompareOptions::IgnoreSymbols) ) );
}

/*
This code produces the following output.

Comparing "ill's clients" and "ills clients"
   With no CompareOptions            : 1
   With None                         : 1
   With Ordinal                      : -76
   With StringSort                   : -1
   With IgnoreCase                   : 1
   With IgnoreSymbols                : 0
   With IgnoreCase and IgnoreSymbols : 0
*/

using System;
using System.Globalization;

public class SamplesCompareInfo  {

   public static void Main()  {

      // Defines the strings to compare.
      String myStr1 = "My Uncle Bill's clients";
      String myStr2 = "My uncle bills clients";

      // Creates a CompareInfo that uses the InvariantCulture.
      CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;

      // Compares two strings using myComp.
      Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1.Substring( 10 ), myStr2.Substring( 10 ) );
      Console.WriteLine( "   With no CompareOptions            : {0}", myComp.Compare( myStr1, 10, myStr2, 10 ) );
      Console.WriteLine( "   With None                         : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.None ) );
      Console.WriteLine( "   With Ordinal                      : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.Ordinal ) );
      Console.WriteLine( "   With StringSort                   : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.StringSort ) );
      Console.WriteLine( "   With IgnoreCase                   : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.IgnoreCase ) );
      Console.WriteLine( "   With IgnoreSymbols                : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.IgnoreSymbols ) );
      Console.WriteLine( "   With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare( myStr1, 10, myStr2, 10, CompareOptions.IgnoreCase | CompareOptions.IgnoreSymbols ) );
   }
}


/*
This code produces the following output.

Comparing "ill's clients" and "ills clients"
   With no CompareOptions            : 1
   With None                         : 1
   With Ordinal                      : -76
   With StringSort                   : -1
   With IgnoreCase                   : 1
   With IgnoreSymbols                : 0
   With IgnoreCase and IgnoreSymbols : 0

*/

Imports System.Globalization

Public Class SamplesCompareInfo

   Public Shared Sub Main()

      ' Defines the strings to compare.
      Dim myStr1 As [String] = "My Uncle Bill's clients"
      Dim myStr2 As [String] = "My uncle bills clients"

      ' Creates a CompareInfo that uses the InvariantCulture.
      Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo

      ' Compares two strings using myComp.
      Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1.Substring(10), myStr2.Substring(10))
      Console.WriteLine("   With no CompareOptions            : {0}", myComp.Compare(myStr1, 10, myStr2, 10))
      Console.WriteLine("   With None                         : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.None))
      Console.WriteLine("   With Ordinal                      : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.Ordinal))
      Console.WriteLine("   With StringSort                   : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.StringSort))
      Console.WriteLine("   With IgnoreCase                   : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.IgnoreCase))
      Console.WriteLine("   With IgnoreSymbols                : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.IgnoreSymbols))
      Console.WriteLine("   With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare(myStr1, 10, myStr2, 10, CompareOptions.IgnoreCase Or CompareOptions.IgnoreSymbols))

   End Sub

End Class


'This code produces the following output.
'
'Comparing "ill's clients" and "ills clients"
'   With no CompareOptions            : 1
'   With None                         : 1
'   With Ordinal                      : -76
'   With StringSort                   : -1
'   With IgnoreCase                   : 1
'   With IgnoreSymbols                : 0
'   With IgnoreCase and IgnoreSymbols : 0

Açıklamalar

Not

Arayanlara Notlar

Karakter kümeleri, dilbilimsel veya kültüre duyarlı bir karşılaştırma yapılırken dikkate alınmayan karakterler olan yok sayılabilir karakterler içerir. yöntemi Compare(String, Int32, String, Int32, CompareOptions) , kültüre duyarlı bir karşılaştırma gerçekleştirirken bu tür karakterleri dikkate almaz. Karşılaştırmanızda yoksayılabilir karakterleri tanımak için parametresi için options veya OrdinalIgnoreCase değerini Ordinal sağlayın.

Ayrıca bkz.

CompareOptions

Şunlara uygulanır

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

Bir dizenin bölümünü başka bir dizenin bölümüyle karşılaştırır.

public:
 virtual int Compare(System::String ^ string1, int offset1, int length1, System::String ^ string2, int offset2, int length2);

public:
 int Compare(System::String ^ string1, int offset1, int length1, System::String ^ string2, int offset2, int length2);

public virtual int Compare (string string1, int offset1, int length1, string string2, int offset2, int length2);

public int Compare (string? string1, int offset1, int length1, string? string2, int offset2, int length2);

public virtual int Compare (string? string1, int offset1, int length1, string? string2, int offset2, int length2);

abstract member Compare : string * int * int * string * int * int -> int
override this.Compare : string * int * int * string * int * int -> int

member this.Compare : string * int * int * string * int * int -> int

Public Overridable Function Compare (string1 As String, offset1 As Integer, length1 As Integer, string2 As String, offset2 As Integer, length2 As Integer) As Integer

Public Function Compare (string1 As String, offset1 As Integer, length1 As Integer, string2 As String, offset2 As Integer, length2 As Integer) As Integer

Parametreler

string1: String

Karşılaştırılacak ilk dize.

offset1: Int32

Karşılaştırmaya başlanması gereken karakterin string1 sıfır tabanlı dizini.

length1: Int32

karşılaştıracak ardışık karakter string1 sayısı.

string2: String

Karşılaştırılacak ikinci dize.

offset2: Int32

Karşılaştırmaya başlanması gereken karakterin string2 sıfır tabanlı dizini.

length2: Int32

karşılaştıracak ardışık karakter string2 sayısı.

Döndürülenler

Int32

İki karşılaştırma ve arasındaki sözcük temelli ilişkiyi gösteren 32 bit işaretli bir tamsayı.

Değer	Koşul
sıfır	İki dize eşittir.
sıfırdan küçük	belirtilen bölümü `string1` belirtilen bölümünden `string2`küçüktür.
sıfırdan büyük	belirtilen bölümü `string1` , öğesinin belirtilen bölümünden `string2`büyük.

Özel durumlar

ArgumentOutOfRangeException

offset1 veya length1 veya offset2 length2 sıfırdan küçüktür.

-veya-

offset1 , içindeki string1karakter sayısından büyük veya buna eşittir.

-veya-

offset2 , içindeki string2karakter sayısından büyük veya buna eşittir.

-veya-

length1 , içindeki karakter sayısından sonuna kadar olan karakter offset1 sayısından string1büyüktür.

-veya-

length2 , içindeki karakter sayısından sonuna kadar olan karakter offset2 sayısından string2büyüktür.

Örnekler

Aşağıdaki örnek, farklı CompareInfo nesneleri kullanarak iki dizenin bölümlerini karşılaştırır:

CompareInfo uluslararası sıralama ile İspanyolca (İspanya) kültürü ile ilişkili nesne
CompareInfo geleneksel sıralama ile İspanyolca (İspanya) kültürü ile ilişkili nesne
CompareInfo ile ilişkili nesne InvariantCulture

using namespace System;
using namespace System::Globalization;
int main()
{
   
   // Defines the strings to compare.
   String^ myStr1 = "calle";
   String^ myStr2 = "calor";
   
   // Uses GetCompareInfo to create the CompareInfo that uses the S"es-ES" culture with international sort.
   CompareInfo^ myCompIntl = CompareInfo::GetCompareInfo( "es-ES" );
   
   // Uses GetCompareInfo to create the CompareInfo that uses the S"es-ES" culture with traditional sort.
   CompareInfo^ myCompTrad = CompareInfo::GetCompareInfo( 0x040A );
   
   // Uses the CompareInfo property of the InvariantCulture.
   CompareInfo^ myCompInva = CultureInfo::InvariantCulture->CompareInfo;
   
   // Compares two strings using myCompIntl.
   Console::WriteLine( "Comparing \" {0}\" and \" {1}\"", myStr1->Substring( 2, 2 ), myStr2->Substring( 2, 2 ) );
   Console::WriteLine( "   With myCompIntl->Compare: {0}", myCompIntl->Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
   Console::WriteLine( "   With myCompTrad->Compare: {0}", myCompTrad->Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
   Console::WriteLine( "   With myCompInva->Compare: {0}", myCompInva->Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
}

/*
This code produces the following output.

Comparing S"ll" and S"lo"
With myCompIntl.Compare: -1
With myCompTrad.Compare: 1
With myCompInva.Compare: -1

*/

using System;
using System.Globalization;

public class SamplesCompareInfo  {

   public static void Main()  {

      // Defines the strings to compare.
      String myStr1 = "calle";
      String myStr2 = "calor";

      // Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
      CompareInfo myCompIntl = CompareInfo.GetCompareInfo( "es-ES" );

      // Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
      CompareInfo myCompTrad = CompareInfo.GetCompareInfo( 0x040A );

      // Uses the CompareInfo property of the InvariantCulture.
      CompareInfo myCompInva = CultureInfo.InvariantCulture.CompareInfo;

      // Compares two strings using myCompIntl.
      Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1.Substring( 2, 2 ), myStr2.Substring( 2, 2 ) );
      Console.WriteLine( "   With myCompIntl.Compare: {0}", myCompIntl.Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
      Console.WriteLine( "   With myCompTrad.Compare: {0}", myCompTrad.Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
      Console.WriteLine( "   With myCompInva.Compare: {0}", myCompInva.Compare( myStr1, 2, 2, myStr2, 2, 2 ) );
   }
}


/*
This code produces the following output.

Comparing "ll" and "lo"
   With myCompIntl.Compare: -1
   With myCompTrad.Compare: 1
   With myCompInva.Compare: -1

*/

Imports System.Globalization

Public Class SamplesCompareInfo

   Public Shared Sub Main()

      ' Defines the strings to compare.
      Dim myStr1 As [String] = "calle"
      Dim myStr2 As [String] = "calor"

      ' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with international sort.
      Dim myCompIntl As CompareInfo = CompareInfo.GetCompareInfo("es-ES")

      ' Uses GetCompareInfo to create the CompareInfo that uses the "es-ES" culture with traditional sort.
      Dim myCompTrad As CompareInfo = CompareInfo.GetCompareInfo(&H40A)

      ' Uses the CompareInfo property of the InvariantCulture.
      Dim myCompInva As CompareInfo = CultureInfo.InvariantCulture.CompareInfo

      ' Compares two strings using myCompIntl.
      Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1.Substring(2, 2), myStr2.Substring(2, 2))
      Console.WriteLine("   With myCompIntl.Compare: {0}", myCompIntl.Compare(myStr1, 2, 2, myStr2, 2, 2))
      Console.WriteLine("   With myCompTrad.Compare: {0}", myCompTrad.Compare(myStr1, 2, 2, myStr2, 2, 2))
      Console.WriteLine("   With myCompInva.Compare: {0}", myCompInva.Compare(myStr1, 2, 2, myStr2, 2, 2))

   End Sub

End Class


'This code produces the following output.
'
'Comparing "ll" and "lo"
'   With myCompIntl.Compare: -1
'   With myCompTrad.Compare: 1
'   With myCompInva.Compare: -1

Açıklamalar

Not

Mümkün olduğunda, beklenen karşılaştırma türünü belirtmek için türünde CompareOptions bir parametreye sahip dize karşılaştırma yöntemlerini kullanmanız gerekir. Genel bir kural olarak, kullanıcı arabiriminde görüntülenen dizeleri karşılaştırmak ve Ordinal OrdinalIgnoreCase veya güvenlik karşılaştırmaları için dilsel seçenekleri (geçerli kültürü kullanarak) kullanın.

Arayanlara Notlar

Karakter kümeleri yoksayılabilir karakterler içerir. Compare(String, Int32, Int32, String, Int32, Int32) yöntemi, dilsel veya kültüre duyarlı bir karşılaştırma gerçekleştirirken bu karakterleri dikkate almaz. Karşılaştırmanızda yoksayılabilir karakterleri tanımak için yöntemini çağırın Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) ve parametresi için options veya OrdinalIgnoreCase değerini Ordinal sağlayın.

Şunlara uygulanır

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

Belirtilen CompareOptions değeri kullanarak bir dizenin bölümünü başka bir dizenin bölümüyle karşılaştırır.

public:
 virtual int Compare(System::String ^ string1, int offset1, int length1, System::String ^ string2, int offset2, int length2, System::Globalization::CompareOptions options);

public:
 int Compare(System::String ^ string1, int offset1, int length1, System::String ^ string2, int offset2, int length2, System::Globalization::CompareOptions options);

public virtual int Compare (string string1, int offset1, int length1, string string2, int offset2, int length2, System.Globalization.CompareOptions options);

public int Compare (string? string1, int offset1, int length1, string? string2, int offset2, int length2, System.Globalization.CompareOptions options);

public virtual int Compare (string? string1, int offset1, int length1, string? string2, int offset2, int length2, System.Globalization.CompareOptions options);

abstract member Compare : string * int * int * string * int * int * System.Globalization.CompareOptions -> int
override this.Compare : string * int * int * string * int * int * System.Globalization.CompareOptions -> int

member this.Compare : string * int * int * string * int * int * System.Globalization.CompareOptions -> int

Public Overridable Function Compare (string1 As String, offset1 As Integer, length1 As Integer, string2 As String, offset2 As Integer, length2 As Integer, options As CompareOptions) As Integer

Public Function Compare (string1 As String, offset1 As Integer, length1 As Integer, string2 As String, offset2 As Integer, length2 As Integer, options As CompareOptions) As Integer

Parametreler

string1: String

Karşılaştırılacak ilk dize.

offset1: Int32

Karşılaştırmaya başlanması gereken karakterin string1 sıfır tabanlı dizini.

length1: Int32

karşılaştıracak ardışık karakter string1 sayısı.

string2: String

Karşılaştırılacak ikinci dize.

offset2: Int32

Karşılaştırmaya başlanması gereken karakterin string2 sıfır tabanlı dizini.

length2: Int32

karşılaştıracak ardışık karakter string2 sayısı.

options: CompareOptions

Döndürülenler

Int32

İki karşılaştırma ve arasındaki sözcük temelli ilişkiyi gösteren 32 bit işaretli bir tamsayı.

Değer	Koşul
sıfır	İki dize eşittir.
sıfırdan küçük	belirtilen bölümü `string1` belirtilen bölümünden `string2`küçüktür.
sıfırdan büyük	belirtilen bölümü `string1` , öğesinin belirtilen bölümünden `string2`büyük.

Özel durumlar

ArgumentOutOfRangeException

offset1 veya length1 veya offset2 length2 sıfırdan küçüktür.

-veya-

offset1 içindeki karakter string1sayısından büyük veya buna eşittir.

-veya-

offset2 içindeki karakter string2sayısından büyük veya buna eşittir.

-veya-

length1 , 'den sonuna kadar olan karakter offset1 sayısından string1büyüktür.

-veya-

length2 , 'den sonuna kadar olan karakter offset2 sayısından string2büyüktür.

ArgumentException

options geçersiz CompareOptions bir değer içeriyor.

Örnekler

Aşağıdaki örnek, farklı CompareOptions ayarlar kullanarak iki dizenin bölümlerini karşılaştırır.

using namespace System;
using namespace System::Globalization;
int main()
{
   
   // Defines the strings to compare.
   String^ myStr1 = "My Uncle Bill's clients";
   String^ myStr2 = "My uncle bills clients";
   
   // Creates a CompareInfo that uses the InvariantCulture.
   CompareInfo^ myComp = CultureInfo::InvariantCulture->CompareInfo;
   
   // Compares two strings using myComp.
   Console::WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1->Substring( 3, 10 ), myStr2->Substring( 3, 10 ) );
   Console::WriteLine( "   With no CompareOptions            : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10 ) );
   Console::WriteLine( "   With None                         : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions::None ) );
   Console::WriteLine( "   With Ordinal                      : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions::Ordinal ) );
   Console::WriteLine( "   With StringSort                   : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions::StringSort ) );
   Console::WriteLine( "   With IgnoreCase                   : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions::IgnoreCase ) );
   Console::WriteLine( "   With IgnoreSymbols                : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions::IgnoreSymbols ) );
   Console::WriteLine( "   With IgnoreCase and IgnoreSymbols : {0}", myComp->Compare( myStr1, 3, 10, myStr2, 3, 10, static_cast<CompareOptions>(CompareOptions::IgnoreCase | CompareOptions::IgnoreSymbols) ) );
}

/*
This code produces the following output.

Comparing "Uncle Bill" and "uncle bill"
   With no CompareOptions            : 1
   With None                         : 1
   With Ordinal                      : -32
   With StringSort                   : 1
   With IgnoreCase                   : 0
   With IgnoreSymbols                : 1
   With IgnoreCase and IgnoreSymbols : 0

*/

using System;
using System.Globalization;

public class SamplesCompareInfo  {

   public static void Main()  {

      // Defines the strings to compare.
      String myStr1 = "My Uncle Bill's clients";
      String myStr2 = "My uncle bills clients";

      // Creates a CompareInfo that uses the InvariantCulture.
      CompareInfo myComp = CultureInfo.InvariantCulture.CompareInfo;

      // Compares two strings using myComp.
      Console.WriteLine( "Comparing \"{0}\" and \"{1}\"", myStr1.Substring( 3, 10 ), myStr2.Substring( 3, 10 ) );
      Console.WriteLine( "   With no CompareOptions            : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10 ) );
      Console.WriteLine( "   With None                         : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.None ) );
      Console.WriteLine( "   With Ordinal                      : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.Ordinal ) );
      Console.WriteLine( "   With StringSort                   : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.StringSort ) );
      Console.WriteLine( "   With IgnoreCase                   : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreCase ) );
      Console.WriteLine( "   With IgnoreSymbols                : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreSymbols ) );
      Console.WriteLine( "   With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare( myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreCase | CompareOptions.IgnoreSymbols ) );
   }
}


/*
This code produces the following output.

Comparing "Uncle Bill" and "uncle bill"
   With no CompareOptions            : 1
   With None                         : 1
   With Ordinal                      : -32
   With StringSort                   : 1
   With IgnoreCase                   : 0
   With IgnoreSymbols                : 1
   With IgnoreCase and IgnoreSymbols : 0

*/

Imports System.Globalization

Public Class SamplesCompareInfo

   Public Shared Sub Main()

      ' Defines the strings to compare.
      Dim myStr1 As [String] = "My Uncle Bill's clients"
      Dim myStr2 As [String] = "My uncle bills clients"

      ' Creates a CompareInfo that uses the InvariantCulture.
      Dim myComp As CompareInfo = CultureInfo.InvariantCulture.CompareInfo

      ' Compares two strings using myComp.
      Console.WriteLine("Comparing ""{0}"" and ""{1}""", myStr1.Substring(3, 10), myStr2.Substring(3, 10))
      Console.WriteLine("   With no CompareOptions            : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10))
      Console.WriteLine("   With None                         : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.None))
      Console.WriteLine("   With Ordinal                      : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.Ordinal))
      Console.WriteLine("   With StringSort                   : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.StringSort))
      Console.WriteLine("   With IgnoreCase                   : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreCase))
      Console.WriteLine("   With IgnoreSymbols                : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreSymbols))
      Console.WriteLine("   With IgnoreCase and IgnoreSymbols : {0}", myComp.Compare(myStr1, 3, 10, myStr2, 3, 10, CompareOptions.IgnoreCase Or CompareOptions.IgnoreSymbols))

   End Sub

End Class


'This code produces the following output.
'
'Comparing "Uncle Bill" and "uncle bill"
'   With no CompareOptions            : 1
'   With None                         : 1
'   With Ordinal                      : -32
'   With StringSort                   : 1
'   With IgnoreCase                   : 0
'   With IgnoreSymbols                : 1
'   With IgnoreCase and IgnoreSymbols : 0

Açıklamalar

Not

Arayanlara Notlar

Karakter kümeleri yoksayılabilir karakterler içerir. yöntemi Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) , kültüre duyarlı bir karşılaştırma gerçekleştirirken bu karakterleri dikkate almaz. Karşılaştırmanızdaki yoksayılabilir karakterleri tanımak için parametresi için options veya OrdinalIgnoreCase değerini Ordinal sağlayın.

Ayrıca bkz.

CompareOptions

Şunlara uygulanır

CompareInfo.Compare Yöntem

Tanım

Aşırı Yüklemeler

Compare(String, String)

Parametreler

Döndürülenler

Örnekler

Açıklamalar

Arayanlara Notlar

Şunlara uygulanır

Compare(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions)

Parametreler

Döndürülenler

Özel durumlar

Şunlara uygulanır

Compare(String, String, CompareOptions)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

Compare(String, Int32, String, Int32)

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Şunlara uygulanır

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

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

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

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Şunlara uygulanır

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

Parametreler

Döndürülenler

Özel durumlar

Örnekler

Açıklamalar

Arayanlara Notlar

Ayrıca bkz.

Şunlara uygulanır

Ek kaynaklar