CompareInfo.Compare Metódus

Definíció

Névtér:: System.Globalization

Szerelvények:: mscorlib.dll, System.Globalization.dll

Szerelvény:: mscorlib.dll

Szerelvény:: System.Globalization.dll

Szerelvény:: netstandard.dll

Fontos

Egyes információk olyan, kiadás előtti termékekre vonatkoznak, amelyek a kiadásig még jelentősen módosulhatnak. A Microsoft nem vállal kifejezett vagy törvényi garanciát az itt megjelenő információért.

Két sztringet hasonlít össze.

Túlterhelések

Name	Description
Compare(String, String)	Két sztringet hasonlít össze.
Compare(String, String, CompareOptions)	Két sztringet hasonlít össze a megadott CompareOptions érték használatával.
Compare(String, Int32, String, Int32)	Egy sztring záró szakaszát hasonlítja össze egy másik sztring záró szakaszával.
Compare(String, Int32, String, Int32, CompareOptions)	Egy sztring záró szakaszát hasonlítja össze egy másik sztring záró szakaszával a megadott CompareOptions érték használatával.
Compare(String, Int32, Int32, String, Int32, Int32)	Egy sztring egy szakaszát hasonlítja össze egy másik sztring egy szakaszával.
Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions)	Egy sztring egy szakaszát hasonlítja össze egy másik sztring egy szakaszával a megadott CompareOptions érték használatával.

Compare(String, String)

Két sztringet hasonlít össze.

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

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

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

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

Paraméterek

string1: String

Az első összehasonlítandó sztring.

string2: String

A második összehasonlítandó sztring.

Válaszok

Int32

32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nulla	A két sztring egyenlő.
kisebb, mint nulla	`string1` kisebb, mint `string2`.
nagyobb, mint nulla	`string1` nagyobb, mint `string2`.

Példák

Az alábbi példa két sztring részeit hasonlítja össze a különböző CompareInfo objektumok használatával:

CompareInfo a spanyol (spanyolországi) kultúrához kapcsolódó objektum nemzetközi rendezéssel
CompareInfo a spanyol (spanyolországi) kultúrához kapcsolódó, hagyományos rendezésű objektum
CompareInfo objektum a következőhöz társítva: InvariantCulture

// 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

Az alábbi példa a metódus meghívását Compare mutatja be.

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

Megjegyzések

Alapértelmezés szerint az összehasonlítás a következő használatával CompareOptions.Nonetörténik: . Ha egy biztonsági döntés sztring-összehasonlítástól vagy esetmódosítástól függ, a InvariantCulture tulajdonság használatával győződjön meg arról, hogy a viselkedés az operációs rendszer kulturális beállításaitól függetlenül konzisztens.

Note

Ha lehetséges, olyan sztring-összehasonlító metódusokat kell meghívnia, amelyek típusparaméterrel CompareOptions rendelkeznek a várt összehasonlítás típusának megadásához. Általános szabályként használjon nyelvi beállításokat (az aktuális kultúrát használva) a felhasználói felületen megjelenő sztringek összehasonlításához, és adja meg a Ordinal vagy OrdinalIgnoreCase lehetőséget biztonsági összehasonlításokhoz.

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak, amelyek nyelvi vagy kulturális szempontból érzékeny összehasonlítások során nem figyelembe vett karakterek. A Compare(String, String) metódus nem veszi figyelembe az ilyen karaktereket, ha kulturális szempontból érzékeny összehasonlítást végez. Például az "állat" és az "ani-mal" kultúraérzékeny összehasonlítása (puha kötőjel vagy U+00AD használatával) azt jelzi, hogy a két sztring egyenértékű, ahogy az alábbi példa is mutatja.

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

A sztring-összehasonlításban figyelmen kívül hagyható karakterek felismeréséhez hívja meg a Compare(String, String, CompareOptions) metódust, és adjon meg egy értéket vagy Ordinal OrdinalIgnoreCase a options paramétert.

A következőre érvényes:

Compare(String, String, CompareOptions)

Két sztringet hasonlít össze a megadott CompareOptions érték használatával.

public:
 virtual int Compare(System::String ^ string1, System::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

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

Paraméterek

string1: String

Az első összehasonlítandó sztring.

string2: String

A második összehasonlítandó sztring.

options: CompareOptions

Egy érték, amely meghatározza, hogyan string1 és string2 hogyan kell összehasonlítani. optionsaz enumerálási értékOrdinal, vagy az alábbi értékek közül egy vagy több bitenkénti kombinációja: IgnoreCase, , IgnoreSymbols, IgnoreNonSpace IgnoreWidth, , IgnoreKanaType NumericOrderingés StringSort.

Válaszok

Int32

32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nulla	A két sztring egyenlő.
kisebb, mint nulla	`string1` kisebb, mint `string2`.
nagyobb, mint nulla	`string1` nagyobb, mint `string2`.

Kivételek

ArgumentException

options érvénytelen CompareOptions értéket tartalmaz.

Példák

Az alábbi példa két sztringet hasonlít össze különböző CompareOptions beállításokkal.

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

Az alábbi példa a metódus meghívását Compare mutatja be.

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

Megjegyzések

Ha egy biztonsági döntés sztring-összehasonlítástól vagy esetmódosítástól függ, a InvariantCulture tulajdonság használatával győződjön meg arról, hogy a viselkedés az operációs rendszer kulturális beállításaitól függetlenül konzisztens.

Note

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak, amelyek nyelvi vagy kulturális szempontból érzékeny összehasonlítások során nem figyelembe vett karakterek. A Compare(String, String, CompareOptions) metódus nem veszi figyelembe az ilyen karaktereket, ha kulturális szempontból érzékeny összehasonlítást végez. Ha az összehasonlításban figyelmen kívül hagyható karaktereket szeretne felismerni, adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét options .

Lásd még

CompareOptions

A következőre érvényes:

Compare(String, Int32, String, Int32)

Egy sztring záró szakaszát hasonlítja össze egy másik sztring záró szakaszával.

public:
 virtual int Compare(System::String ^ string1, int offset1, System::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

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

Paraméterek

string1: String

Az első összehasonlítandó sztring.

offset1: Int32

Annak a karakternek string1 a nullaalapú indexe, amelyben az összehasonlítás elkezdhető.

string2: String

A második összehasonlítandó sztring.

offset2: Int32

Annak a karakternek string2 a nullaalapú indexe, amelyben az összehasonlítás elkezdhető.

Válaszok

Int32

32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nulla	A két sztring egyenlő.
kisebb, mint nulla	A megadott szakasz `string1` kisebb, mint a megadott szakasz.`string2`
nagyobb, mint nulla	A megadott szakasz `string1` nagyobb, mint a megadott szakasz.`string2`

Kivételek

ArgumentOutOfRangeException

offset1 vagy offset2 kisebb, mint nulla.

-vagy-

offset1 nagyobb vagy egyenlő a karakterek string1számával.

-vagy-

offset2 nagyobb vagy egyenlő a karakterek string2számával.

Példák

Az alábbi példa két sztring részeit hasonlítja össze a különböző CompareInfo objektumok használatával:

CompareInfo a spanyol (spanyolországi) kultúrához kapcsolódó objektum nemzetközi rendezéssel
CompareInfo a spanyol (spanyolországi) kultúrához kapcsolódó, hagyományos rendezésű objektum
CompareInfo objektum a következőhöz társítva: 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.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

Megjegyzések

Note

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, Int32, String, Int32) metódus nem veszi figyelembe ezeket a karaktereket, ha nyelvi vagy kulturális szempontból érzékeny összehasonlítást végez. Az összehasonlításban figyelmen kívül hagyható karakterek felismeréséhez hívja meg a metódust Compare(String, Int32, String, Int32, CompareOptions) , és adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét options .

A következőre érvényes:

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

Egy sztring záró szakaszát hasonlítja össze egy másik sztring záró szakaszával a megadott CompareOptions érték használatával.

public:
 virtual 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);

abstract member Compare : string * int * string * int * System.Globalization.CompareOptions -> int
override 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

Paraméterek

string1: String

Az első összehasonlítandó sztring.

offset1: Int32

Annak a karakternek string1 a nullaalapú indexe, amelyben az összehasonlítás elkezdhető.

string2: String

A második összehasonlítandó sztring.

offset2: Int32

Annak a karakternek string2 a nullaalapú indexe, amelyben az összehasonlítás elkezdhető.

options: CompareOptions

Válaszok

Int32

32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nulla	A két sztring egyenlő.
kisebb, mint nulla	A megadott szakasz `string1` kisebb, mint a megadott szakasz.`string2`
nagyobb, mint nulla	A megadott szakasz `string1` nagyobb, mint a megadott szakasz.`string2`

Kivételek

ArgumentOutOfRangeException

offset1 vagy offset2 kisebb, mint nulla.

-vagy-

offset1 nagyobb vagy egyenlő a karakterek string1számával.

-vagy-

offset2 nagyobb vagy egyenlő a karakterek string2számával.

ArgumentException

options érvénytelen CompareOptions értéket tartalmaz.

Példák

Az alábbi példa két sztring különböző beállításokat használó CompareOptions részeit hasonlítja össze.

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

Megjegyzések

Note

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak, amelyek nyelvi vagy kulturális szempontból érzékeny összehasonlítások során nem figyelembe vett karakterek. A Compare(String, Int32, String, Int32, CompareOptions) metódus nem veszi figyelembe az ilyen karaktereket a kultúraérzékeny összehasonlítás végrehajtásakor. Ha az összehasonlításban figyelmen kívül hagyható karaktereket szeretne felismerni, adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét options .

Lásd még

CompareOptions

A következőre érvényes:

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

Egy sztring egy szakaszát hasonlítja össze egy másik sztring egy szakaszával.

public:
 virtual 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);

abstract member Compare : string * int * int * string * int * int -> int
override 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

Paraméterek

string1: String

Az első összehasonlítandó sztring.

offset1: Int32

Annak a karakternek string1 a nullaalapú indexe, amelyben az összehasonlítás elkezdhető.

length1: Int32

Az összehasonlítandó egymást követő karakterek string1 száma.

string2: String

A második összehasonlítandó sztring.

offset2: Int32

Annak a karakternek string2 a nullaalapú indexe, amelyben az összehasonlítás elkezdhető.

length2: Int32

Az összehasonlítandó egymást követő karakterek string2 száma.

Válaszok

Int32

32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nulla	A két sztring egyenlő.
kisebb, mint nulla	A megadott szakasz `string1` kisebb, mint a megadott szakasz.`string2`
nagyobb, mint nulla	A megadott szakasz `string1` nagyobb, mint a megadott szakasz.`string2`

Kivételek

ArgumentOutOfRangeException

offset1 vagy length1offset2length2 kisebb, mint nulla.

-vagy-

offset1 nagyobb vagy egyenlő a karakterek string1számával.

-vagy-

offset2 nagyobb vagy egyenlő a karakterek string2számával.

-vagy-

length1 nagyobb, mint a karakterek száma a végétől offset1 a végéig string1.

-vagy-

length2 nagyobb, mint a karakterek száma a végétől offset2 a végéig string2.

Példák

Az alábbi példa két sztring részeit hasonlítja össze a különböző CompareInfo objektumok használatával:

CompareInfo a spanyol (spanyolországi) kultúrához kapcsolódó objektum nemzetközi rendezéssel
CompareInfo a spanyol (spanyolországi) kultúrához kapcsolódó, hagyományos rendezésű objektum
CompareInfo objektum a következőhöz társítva: 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.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

Megjegyzések

Note

Ha lehetséges, olyan sztring-összehasonlító módszereket kell használnia, amelyek típusparaméterrel CompareOptions rendelkeznek a várt összehasonlítás típusának megadásához. Általános szabályként használjon nyelvi beállításokat (az aktuális kultúrát használva) a felhasználói felületen megjelenő sztringek összehasonlításához, és adja meg a Ordinal vagy OrdinalIgnoreCase lehetőséget biztonsági összehasonlításokhoz.

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, Int32, Int32, String, Int32, Int32) metódus nem veszi figyelembe ezeket a karaktereket, ha nyelvi vagy kulturális szempontból érzékeny összehasonlítást végez. Az összehasonlításban figyelmen kívül hagyható karakterek felismeréséhez hívja meg a metódust Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) , és adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét options .

A következőre érvényes:

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

Egy sztring egy szakaszát hasonlítja össze egy másik sztring egy szakaszával a megadott CompareOptions érték használatával.

public:
 virtual 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);

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

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

Paraméterek

string1: String

Az első összehasonlítandó sztring.

offset1: Int32

Annak a karakternek string1 a nullaalapú indexe, amelyben az összehasonlítás elkezdhető.

length1: Int32

Az összehasonlítandó egymást követő karakterek string1 száma.

string2: String

A második összehasonlítandó sztring.

offset2: Int32

Annak a karakternek string2 a nullaalapú indexe, amelyben az összehasonlítás elkezdhető.

length2: Int32

Az összehasonlítandó egymást követő karakterek string2 száma.

options: CompareOptions

Válaszok

Int32

32 bites aláírt egész szám, amely a két összehasonlítás és a két összehasonlítás közötti lexikális kapcsolatot jelzi.

Érték	Feltétel
Nulla	A két sztring egyenlő.
kisebb, mint nulla	A megadott szakasz `string1` kisebb, mint a megadott szakasz.`string2`
nagyobb, mint nulla	A megadott szakasz `string1` nagyobb, mint a megadott szakasz.`string2`

Kivételek

ArgumentOutOfRangeException

offset1 vagy length1offset2length2 kisebb, mint nulla.

-vagy-

offset1 nagyobb vagy egyenlő a karakterek string1számával.

-vagy-

offset2 nagyobb vagy egyenlő a karakterek string2számával.

-vagy-

length1 nagyobb, mint a karakterek száma a végétől offset1 a végéig string1.

-vagy-

length2 nagyobb, mint a karakterek száma a végétől offset2 a végéig string2.

ArgumentException

options érvénytelen CompareOptions értéket tartalmaz.

Példák

Az alábbi példa két sztring különböző beállításokat használó CompareOptions részeit hasonlítja össze.

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

Megjegyzések

Note

Megjegyzések a hívókhoz

A karakterkészletek figyelmen kívül hagyható karaktereket tartalmaznak. A Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) metódus nem veszi figyelembe ezeket a karaktereket, ha kulturális szempontból érzékeny összehasonlítást végez. Ha az összehasonlításban figyelmen kívül hagyható karaktereket szeretne felismerni, adja meg a paraméter értékét Ordinal vagy OrdinalIgnoreCase értékét options .

Lásd még

CompareOptions

A következőre érvényes:

Visszajelzés

Hasznosnak találta ezt az oldalt?