CompareInfo.Compare Metod

Definition

Namnområde:: System.Globalization

Sammansättningar:: mscorlib.dll, System.Globalization.dll

Sammansättning:: mscorlib.dll

Sammansättning:: System.Globalization.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Jämför två strängar.

Överlagringar

Name	Description
Compare(String, String)	Jämför två strängar.
Compare(String, String, CompareOptions)	Jämför två strängar med det angivna CompareOptions värdet.
Compare(String, Int32, String, Int32)	Jämför slutet av en sträng med slutet av en annan sträng.
Compare(String, Int32, String, Int32, CompareOptions)	Jämför slutet av en sträng med slutet av en annan sträng med det angivna CompareOptions värdet.
Compare(String, Int32, Int32, String, Int32, Int32)	Jämför ett avsnitt i en sträng med ett avsnitt i en annan sträng.
Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions)	Jämför ett avsnitt i en sträng med ett avsnitt i en annan sträng med det angivna CompareOptions värdet.

Compare(String, String)

Jämför två strängar.

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

Parametrar

string1: String

Den första strängen som ska jämföras.

string2: String

Den andra strängen att jämföra.

Returer

Int32

Ett 32-bitars signerat heltal som anger den lexikala relationen mellan de två jämförelsetalen.

Värde	Tillstånd
Noll	De två strängarna är lika med.
mindre än noll	`string1` är mindre än `string2`.
större än noll	`string1` är större än `string2`.

Exempel

I följande exempel jämförs delar av två strängar med hjälp av de olika CompareInfo objekten:

CompareInfo objekt som är associerat med den spanska kulturen (Spanien) med internationell sortering
CompareInfo objekt som är associerat med den spanska kulturen (Spanien) med traditionell sortering
CompareInfo objekt som är associerat med 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

I följande exempel visas hur du anropar Compare metoden.

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

Kommentarer

Som standard utförs jämförelsen med hjälp CompareOptions.Noneav . Om ett säkerhetsbeslut beror på en strängjämförelse eller en skiftlägesändring bör du använda InvariantCulture egenskapen för att säkerställa att beteendet är konsekvent oavsett operativsystemets kulturinställningar.

Note

När det är möjligt bör du anropa metoder för strängjämförelse som har en parameter av typen CompareOptions för att ange vilken typ av jämförelse som förväntas. Som en allmän regel använder du språkalternativ (med den aktuella kulturen) för att jämföra strängar som visas i användargränssnittet och ange Ordinal eller OrdinalIgnoreCase för säkerhetsjämförelser.

Anteckningar till anropare

Teckenuppsättningar innehåller ignorerbara tecken, som är tecken som inte beaktas när man utför en språklig eller kulturspecifik jämförelse. Metoden Compare(String, String) tar inte hänsyn till sådana tecken när den utför en kulturkänslig jämförelse. En kulturkänslig jämförelse av "djur" med "ani-mal" (med ett mjukt bindestreck eller U+00AD) indikerar till exempel att de två strängarna är likvärdiga, vilket visas i följande exempel.

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

Om du vill känna igen okunniga tecken i en strängjämförelse anropar du Compare(String, String, CompareOptions) metoden och anger ett värde för antingen Ordinal eller OrdinalIgnoreCase för parametern options .

Gäller för

Compare(String, String, CompareOptions)

Jämför två strängar med det angivna CompareOptions värdet.

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

Parametrar

string1: String

Den första strängen som ska jämföras.

string2: String

Den andra strängen att jämföra.

options: CompareOptions

Ett värde som definierar hur string1 och string2 ska jämföras. options är antingen uppräkningsvärdet Ordinaleller en bitvis kombination av ett eller flera av följande värden: IgnoreCase, IgnoreSymbols, IgnoreNonSpace, IgnoreWidth, IgnoreKanaType, NumericOrderingoch StringSort.

Returer

Int32

Ett 32-bitars signerat heltal som anger den lexikala relationen mellan de två jämförelsetalen.

Värde	Tillstånd
Noll	De två strängarna är lika med.
mindre än noll	`string1` är mindre än `string2`.
större än noll	`string1` är större än `string2`.

Undantag

ArgumentException

options innehåller ett ogiltigt CompareOptions värde.

Exempel

I följande exempel jämförs två strängar med olika CompareOptions inställningar.

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

I följande exempel visas hur du anropar Compare metoden.

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

Kommentarer

Om ett säkerhetsbeslut beror på en strängjämförelse eller en skiftlägesändring bör du använda InvariantCulture egenskapen för att säkerställa att beteendet är konsekvent oavsett operativsystemets kulturinställningar.

Note

Anteckningar till anropare

Teckenuppsättningar innehåller ignorerbara tecken, som är tecken som inte beaktas när man utför en språklig eller kulturspecifik jämförelse. Metoden Compare(String, String, CompareOptions) tar inte hänsyn till sådana tecken när den utför en kulturkänslig jämförelse. Om du vill identifiera okunniga tecken i jämförelsen anger du ett värde för Ordinal eller OrdinalIgnoreCase för parametern options .

Se även

CompareOptions

Gäller för

Compare(String, Int32, String, Int32)

Jämför slutet av en sträng med slutet av en annan sträng.

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

Parametrar

string1: String

Den första strängen som ska jämföras.

offset1: Int32

Det nollbaserade indexet för tecknet string1 där du kan börja jämföra.

string2: String

Den andra strängen att jämföra.

offset2: Int32

Det nollbaserade indexet för tecknet string2 där du kan börja jämföra.

Returer

Int32

Ett 32-bitars signerat heltal som anger den lexikala relationen mellan de två jämförelsetalen.

Värde	Tillstånd
Noll	De två strängarna är lika med.
mindre än noll	Det angivna avsnittet i `string1` är mindre än det angivna avsnittet i `string2`.
större än noll	Det angivna avsnittet i `string1` är större än det angivna avsnittet i `string2`.

Undantag

ArgumentOutOfRangeException

offset1 eller offset2 är mindre än noll.

-eller-

offset1 är större än eller lika med antalet tecken i string1.

-eller-

offset2 är större än eller lika med antalet tecken i string2.

Exempel

I följande exempel jämförs delar av två strängar med hjälp av de olika CompareInfo objekten:

CompareInfo objekt som är associerat med den spanska kulturen (Spanien) med internationell sortering
CompareInfo objekt som är associerat med den spanska kulturen (Spanien) med traditionell sortering
CompareInfo objekt som är associerat med 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

Kommentarer

Note

Anteckningar till anropare

Teckenuppsättningar innehåller okunniga tecken. Metoden Compare(String, Int32, String, Int32) tar inte hänsyn till dessa tecken när den utför en språklig eller kulturkänslig jämförelse. Om du vill känna igen okunniga tecken i jämförelsen Compare(String, Int32, String, Int32, CompareOptions) anropar du metoden och anger ett värde för Ordinal eller OrdinalIgnoreCase för parametern options .

Gäller för

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

Jämför slutet av en sträng med slutet av en annan sträng med det angivna CompareOptions värdet.

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

Parametrar

string1: String

Den första strängen som ska jämföras.

offset1: Int32

Det nollbaserade indexet för tecknet string1 där du kan börja jämföra.

string2: String

Den andra strängen att jämföra.

offset2: Int32

Det nollbaserade indexet för tecknet string2 där du kan börja jämföra.

options: CompareOptions

Returer

Int32

Ett 32-bitars signerat heltal som anger den lexikala relationen mellan de två jämförelsetalen.

Värde	Tillstånd
Noll	De två strängarna är lika med.
mindre än noll	Det angivna avsnittet i `string1` är mindre än det angivna avsnittet i `string2`.
större än noll	Det angivna avsnittet i `string1` är större än det angivna avsnittet i `string2`.

Undantag

ArgumentOutOfRangeException

offset1 eller offset2 är mindre än noll.

-eller-

offset1 är större än eller lika med antalet tecken i string1.

-eller-

offset2 är större än eller lika med antalet tecken i string2.

ArgumentException

options innehåller ett ogiltigt CompareOptions värde.

Exempel

I följande exempel jämförs delar av två strängar med olika CompareOptions inställningar.

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

Kommentarer

Note

Anteckningar till anropare

Teckenuppsättningar innehåller ignorerbara tecken, som är tecken som inte beaktas när man utför en språklig eller kulturspecifik jämförelse. Metoden Compare(String, Int32, String, Int32, CompareOptions) tar inte hänsyn till sådana tecken när du utför en kulturkänslig jämförelse. Om du vill identifiera okunniga tecken i jämförelsen anger du ett värde för Ordinal eller OrdinalIgnoreCase för parametern options .

Se även

CompareOptions

Gäller för

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

Jämför ett avsnitt i en sträng med ett avsnitt i en annan sträng.

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

Parametrar

string1: String

Den första strängen som ska jämföras.

offset1: Int32

Det nollbaserade indexet för tecknet string1 där du kan börja jämföra.

length1: Int32

Antalet tecken i string1 följd som ska jämföras.

string2: String

Den andra strängen att jämföra.

offset2: Int32

Det nollbaserade indexet för tecknet string2 där du kan börja jämföra.

length2: Int32

Antalet tecken i string2 följd som ska jämföras.

Returer

Int32

Ett 32-bitars signerat heltal som anger den lexikala relationen mellan de två jämförelsetalen.

Värde	Tillstånd
Noll	De två strängarna är lika med.
mindre än noll	Det angivna avsnittet i `string1` är mindre än det angivna avsnittet i `string2`.
större än noll	Det angivna avsnittet i `string1` är större än det angivna avsnittet i `string2`.

Undantag

ArgumentOutOfRangeException

offset1 eller length1 eller offset2length2 är mindre än noll.

-eller-

offset1 är större än eller lika med antalet tecken i string1.

-eller-

offset2 är större än eller lika med antalet tecken i string2.

-eller-

length1 är större än antalet tecken från offset1 till slutet av string1.

-eller-

length2 är större än antalet tecken från offset2 till slutet av string2.

Exempel

I följande exempel jämförs delar av två strängar med hjälp av de olika CompareInfo objekten:

CompareInfo objekt som är associerat med den spanska kulturen (Spanien) med internationell sortering
CompareInfo objekt som är associerat med den spanska kulturen (Spanien) med traditionell sortering
CompareInfo objekt som är associerat med 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

Kommentarer

Note

När det är möjligt bör du använda strängjämförelsemetoder som har en parameter av typen CompareOptions för att ange vilken typ av jämförelse som förväntas. Som en allmän regel använder du språkalternativ (med den aktuella kulturen) för att jämföra strängar som visas i användargränssnittet och ange Ordinal eller OrdinalIgnoreCase för säkerhetsjämförelser.

Anteckningar till anropare

Teckenuppsättningar innehåller okunniga tecken. Metoden Compare(String, Int32, Int32, String, Int32, Int32) tar inte hänsyn till dessa tecken när den utför en språklig eller kulturkänslig jämförelse. Om du vill känna igen okunniga tecken i jämförelsen Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) anropar du metoden och anger ett värde för Ordinal eller OrdinalIgnoreCase för parametern options .

Gäller för

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

Jämför ett avsnitt i en sträng med ett avsnitt i en annan sträng med det angivna CompareOptions värdet.

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

Parametrar

string1: String

Den första strängen som ska jämföras.

offset1: Int32

Det nollbaserade indexet för tecknet string1 där du kan börja jämföra.

length1: Int32

Antalet tecken i string1 följd som ska jämföras.

string2: String

Den andra strängen att jämföra.

offset2: Int32

Det nollbaserade indexet för tecknet string2 där du kan börja jämföra.

length2: Int32

Antalet tecken i string2 följd som ska jämföras.

options: CompareOptions

Returer

Int32

Ett 32-bitars signerat heltal som anger den lexikala relationen mellan de två jämförelsetalen.

Värde	Tillstånd
Noll	De två strängarna är lika med.
mindre än noll	Det angivna avsnittet i `string1` är mindre än det angivna avsnittet i `string2`.
större än noll	Det angivna avsnittet i `string1` är större än det angivna avsnittet i `string2`.

Undantag

ArgumentOutOfRangeException

offset1 eller length1 eller offset2length2 är mindre än noll.

-eller-

offset1 är större än eller lika med antalet tecken i string1.

-eller-

offset2 är större än eller lika med antalet tecken i string2.

-eller-

length1 är större än antalet tecken från offset1 till slutet av string1.

-eller-

length2 är större än antalet tecken från offset2 till slutet av string2.

ArgumentException

options innehåller ett ogiltigt CompareOptions värde.

Exempel

I följande exempel jämförs delar av två strängar med olika CompareOptions inställningar.

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

Kommentarer

Note

Anteckningar till anropare

Teckenuppsättningar innehåller okunniga tecken. Metoden Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) tar inte hänsyn till dessa tecken när den utför en kulturkänslig jämförelse. Om du vill identifiera okunniga tecken i jämförelsen anger du ett värde för Ordinal eller OrdinalIgnoreCase för parametern options .

Se även

CompareOptions

Gäller för

Feedback

Var den här sidan till hjälp?