CompareInfo.Compare Methode

Definition

Namespace:: System.Globalization

Assemblys:: mscorlib.dll, System.Globalization.dll

Assemblys:: netstandard.dll, System.Runtime.dll

Assembly:: System.Globalization.dll

Assembly:: System.Runtime.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Vergleicht zwei Zeichenfolgen.

Überlädt

Name	Beschreibung
Compare(String, String)	Vergleicht zwei Zeichenfolgen.
Compare(ReadOnlySpan<Char>, ReadOnlySpan<Char>, CompareOptions)	Vergleicht zwei schreibgeschützte Zeichenspannen.
Compare(String, String, CompareOptions)	Vergleicht zwei Zeichenfolgen mithilfe des angegebenen CompareOptions Werts.
Compare(String, Int32, String, Int32)	Vergleicht den Endabschnitt einer Zeichenfolge mit dem Endabschnitt einer anderen Zeichenfolge.
Compare(String, Int32, String, Int32, CompareOptions)	Vergleicht den Endabschnitt einer Zeichenfolge mit dem Endabschnitt einer anderen Zeichenfolge mithilfe des angegebenen CompareOptions Werts.
Compare(String, Int32, Int32, String, Int32, Int32)	Vergleicht einen Abschnitt einer Zeichenfolge mit einem Abschnitt einer anderen Zeichenfolge.
Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions)	Vergleicht einen Abschnitt einer Zeichenfolge mit einem Abschnitt einer anderen Zeichenfolge mithilfe des angegebenen CompareOptions Werts.

Compare(String, String)

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Vergleicht zwei Zeichenfolgen.

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

Parameter

string1: String

Die erste zu vergleichende Zeichenfolge.

string2: String

Die zweite zu vergleichende Zeichenfolge.

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl, die die lexikalische Beziehung zwischen den beiden Vergleichszeichen angibt.

Wert:	Bedingung
Null	Die beiden Zeichenfolgen sind gleich.
kleiner als 0	`string1` ist kleiner als `string2`.
größer als 0	`string1` ist größer als `string2`.

Beispiele

Im folgenden Beispiel werden Teile von zwei Zeichenfolgen mit den verschiedenen CompareInfo Objekten verglichen:

CompareInfo Objekt, das der spanischen Kultur (Spanien) mit internationaler Sortierung zugeordnet ist
CompareInfo Objekt, das der spanischen Kultur (Spanien) mit der traditionellen Sortierung zugeordnet ist
CompareInfo objekt zugeordnet mit dem 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

Im folgenden Beispiel wird das Aufrufen der Compare Methode veranschaulicht.

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

Hinweise

Standardmäßig wird der Vergleich mithilfe CompareOptions.Nonevon . Wenn eine Sicherheitsentscheidung von einem Zeichenfolgenvergleich oder einer Falländerung abhängt, sollten Sie die InvariantCulture Eigenschaft verwenden, um sicherzustellen, dass das Verhalten unabhängig von den Kultureinstellungen des Betriebssystems konsistent ist.

Hinweis

Wenn möglich, sollten Sie Zeichenfolgenvergleichsmethoden aufrufen, die über einen Parameter vom Typ CompareOptions verfügen, um die Art des erwarteten Vergleichs anzugeben. Verwenden Sie in der Regel linguistische Optionen (unter Verwendung der aktuellen Kultur), um Zeichenfolgen zu vergleichen, die auf der Benutzeroberfläche angezeigt werden, und geben Ordinal Oder OrdinalIgnoreCase für Sicherheitsvergleiche an.

Hinweise für Aufrufer

Zeichensätze enthalten ignorierbare Zeichen, bei denen es sich um Zeichen handelt, die beim Durchführen eines sprachlichen oder kultursensitiven Vergleichs nicht berücksichtigt werden. Die Compare(String, String) Methode berücksichtigt solche Zeichen nicht, wenn sie einen kultursensitiven Vergleich durchführt. Beispielsweise gibt ein kultursensitiver Vergleich von "Tier" mit "ani-mal" (mit einem weichen Bindestrich oder U+00AD) an, dass die beiden Zeichenfolgen gleichwertig sind, wie im folgenden Beispiel gezeigt.

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

Um ignorierbare Zeichen in einem Zeichenfolgenvergleich zu erkennen, rufen Sie die Compare(String, String, CompareOptions) Methode auf, und geben Sie einen Wert entweder Ordinal oder OrdinalIgnoreCase für den options Parameter an.

Gilt für:

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

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Vergleicht zwei schreibgeschützte Zeichenspannen.

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

Parameter

string1: ReadOnlySpan<Char>

Die erste schreibgeschützte Spanne der zu vergleichenden Zeichen.

string2: ReadOnlySpan<Char>

Der zweite schreibgeschützte Bereich von Zeichen, die verglichen werden sollen.

options: CompareOptions

Eine optionale Kombination von CompareOptions Enumerationswerten, die während des Vergleichs verwendet werden sollen. Der Standardwert ist None.

Gibt zurück

Int32

Null wenn string1 und string2 gleich sind; oder ein negativer Wert, wenn string1 vor string2; oder ein positiver Wert, wenn string1 sortiert nach string2.

Ausnahmen

ArgumentException

options enthält eine nicht unterstützte Kombination von Flags.

Gilt für:

Compare(String, String, CompareOptions)

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Vergleicht zwei Zeichenfolgen mithilfe des angegebenen CompareOptions Werts.

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

Parameter

string1: String

Die erste zu vergleichende Zeichenfolge.

string2: String

Die zweite zu vergleichende Zeichenfolge.

options: CompareOptions

Ein Wert, der definiert, wie string1 und string2 wie verglichen werden soll. optionsist entweder der Enumerationswert Ordinaloder eine bitweise Kombination aus einem oder mehreren der folgenden Werte: IgnoreCase, , IgnoreSymbols IgnoreNonSpace, IgnoreWidth, IgnoreKanaType, NumericOrderingund StringSort.

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl, die die lexikalische Beziehung zwischen den beiden Vergleichszeichen angibt.

Wert:	Bedingung
Null	Die beiden Zeichenfolgen sind gleich.
kleiner als 0	`string1` ist kleiner als `string2`.
größer als 0	`string1` ist größer als `string2`.

Ausnahmen

ArgumentException

options enthält einen ungültigen CompareOptions Wert.

Beispiele

Im folgenden Beispiel werden zwei Zeichenfolgen mit unterschiedlichen CompareOptions Einstellungen verglichen.

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

Im folgenden Beispiel wird das Aufrufen der Compare Methode veranschaulicht.

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

Hinweise

Wenn eine Sicherheitsentscheidung von einem Zeichenfolgenvergleich oder einer Falländerung abhängt, sollten Sie die InvariantCulture Eigenschaft verwenden, um sicherzustellen, dass das Verhalten unabhängig von den Kultureinstellungen des Betriebssystems konsistent ist.

Hinweis

Hinweise für Aufrufer

Zeichensätze enthalten ignorierbare Zeichen, bei denen es sich um Zeichen handelt, die beim Durchführen eines sprachlichen oder kultursensitiven Vergleichs nicht berücksichtigt werden. Die Compare(String, String, CompareOptions) Methode berücksichtigt solche Zeichen nicht, wenn sie einen kultursensitiven Vergleich durchführt. Um ignorierbare Zeichen im Vergleich zu erkennen, geben Sie einen Wert von Ordinal oder OrdinalIgnoreCase für den options Parameter an.

Weitere Informationen

CompareOptions

Gilt für:

Compare(String, Int32, String, Int32)

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Vergleicht den Endabschnitt einer Zeichenfolge mit dem Endabschnitt einer anderen Zeichenfolge.

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

Parameter

string1: String

Die erste zu vergleichende Zeichenfolge.

offset1: Int32

Der nullbasierte Index des Zeichens, in string1 dem der Vergleich gestartet werden soll.

string2: String

Die zweite zu vergleichende Zeichenfolge.

offset2: Int32

Der nullbasierte Index des Zeichens, in string2 dem der Vergleich gestartet werden soll.

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl, die die lexikalische Beziehung zwischen den beiden Vergleichszeichen angibt.

Wert:	Bedingung
Null	Die beiden Zeichenfolgen sind gleich.
kleiner als 0	Der angegebene Abschnitt von `string1` ist kleiner als der angegebene Abschnitt von `string2`.
größer als 0	Der angegebene Abschnitt von `string1` ist größer als der angegebene Abschnitt von `string2`.

Ausnahmen

ArgumentOutOfRangeException

offset1 oder offset2 ist kleiner als Null.

- oder -

offset1 ist größer oder gleich der Anzahl von Zeichen in string1.

- oder -

offset2 ist größer oder gleich der Anzahl von Zeichen in string2.

Beispiele

Im folgenden Beispiel werden Teile von zwei Zeichenfolgen mit den verschiedenen CompareInfo Objekten verglichen:

CompareInfo Objekt, das der spanischen Kultur (Spanien) mit internationaler Sortierung zugeordnet ist
CompareInfo Objekt, das der spanischen Kultur (Spanien) mit der traditionellen Sortierung zugeordnet ist
CompareInfo objekt zugeordnet mit dem 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

Hinweise

Hinweis

Hinweise für Aufrufer

Zeichensätze enthalten ignorierbare Zeichen. Die Compare(String, Int32, String, Int32) Methode berücksichtigt diese Zeichen nicht, wenn sie einen sprachlichen oder kultursensitiven Vergleich durchführt. Um ignorierbare Zeichen in Ihrem Vergleich zu erkennen, rufen Sie die Compare(String, Int32, String, Int32, CompareOptions) Methode auf, und geben Sie einen Wert von Ordinal oder OrdinalIgnoreCase für den options Parameter an.

Gilt für:

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

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Vergleicht den Endabschnitt einer Zeichenfolge mit dem Endabschnitt einer anderen Zeichenfolge mithilfe des angegebenen CompareOptions Werts.

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

Parameter

string1: String

Die erste zu vergleichende Zeichenfolge.

offset1: Int32

Der nullbasierte Index des Zeichens, in string1 dem der Vergleich gestartet werden soll.

string2: String

Die zweite zu vergleichende Zeichenfolge.

offset2: Int32

Der nullbasierte Index des Zeichens, in string2 dem der Vergleich gestartet werden soll.

options: CompareOptions

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl, die die lexikalische Beziehung zwischen den beiden Vergleichszeichen angibt.

Wert:	Bedingung
Null	Die beiden Zeichenfolgen sind gleich.
kleiner als 0	Der angegebene Abschnitt von `string1` ist kleiner als der angegebene Abschnitt von `string2`.
größer als 0	Der angegebene Abschnitt von `string1` ist größer als der angegebene Abschnitt von `string2`.

Ausnahmen

ArgumentOutOfRangeException

offset1 oder offset2 ist kleiner als Null.

- oder -

offset1 ist größer oder gleich der Anzahl von Zeichen in string1.

- oder -

offset2 ist größer oder gleich der Anzahl von Zeichen in string2.

ArgumentException

options enthält einen ungültigen CompareOptions Wert.

Beispiele

Im folgenden Beispiel werden Teile von zwei Zeichenfolgen mit unterschiedlichen CompareOptions Einstellungen verglichen.

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

Hinweise

Hinweis

Hinweise für Aufrufer

Zeichensätze enthalten ignorierbare Zeichen, bei denen es sich um Zeichen handelt, die beim Durchführen eines sprachlichen oder kultursensitiven Vergleichs nicht berücksichtigt werden. Die Compare(String, Int32, String, Int32, CompareOptions) Methode berücksichtigt solche Zeichen nicht beim Ausführen eines kultursensitiven Vergleichs. Um ignorierbare Zeichen im Vergleich zu erkennen, geben Sie einen Wert von Ordinal oder OrdinalIgnoreCase für den options Parameter an.

Weitere Informationen

CompareOptions

Gilt für:

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

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Vergleicht einen Abschnitt einer Zeichenfolge mit einem Abschnitt einer anderen Zeichenfolge.

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

Parameter

string1: String

Die erste zu vergleichende Zeichenfolge.

offset1: Int32

Der nullbasierte Index des Zeichens, in string1 dem der Vergleich gestartet werden soll.

length1: Int32

Die Anzahl der aufeinander folgenden Zeichen, die verglichen werden string1 sollen.

string2: String

Die zweite zu vergleichende Zeichenfolge.

offset2: Int32

Der nullbasierte Index des Zeichens, in string2 dem der Vergleich gestartet werden soll.

length2: Int32

Die Anzahl der aufeinander folgenden Zeichen, die verglichen werden string2 sollen.

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl, die die lexikalische Beziehung zwischen den beiden Vergleichszeichen angibt.

Wert:	Bedingung
Null	Die beiden Zeichenfolgen sind gleich.
kleiner als 0	Der angegebene Abschnitt von `string1` ist kleiner als der angegebene Abschnitt von `string2`.
größer als 0	Der angegebene Abschnitt von `string1` ist größer als der angegebene Abschnitt von `string2`.

Ausnahmen

ArgumentOutOfRangeException

offset1 oder length1offset2length2 ist kleiner als Null.

- oder -

offset1 ist größer oder gleich der Anzahl von Zeichen in string1.

- oder -

offset2 ist größer oder gleich der Anzahl von Zeichen in string2.

- oder -

length1 ist größer als die Anzahl der Zeichen von offset1 bis zum Ende von string1.

- oder -

length2 ist größer als die Anzahl der Zeichen von offset2 bis zum Ende von string2.

Beispiele

Im folgenden Beispiel werden Teile von zwei Zeichenfolgen mit den verschiedenen CompareInfo Objekten verglichen:

CompareInfo Objekt, das der spanischen Kultur (Spanien) mit internationaler Sortierung zugeordnet ist
CompareInfo Objekt, das der spanischen Kultur (Spanien) mit der traditionellen Sortierung zugeordnet ist
CompareInfo objekt zugeordnet mit dem 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

Hinweise

Hinweis

Wenn möglich, sollten Sie Zeichenfolgenvergleichsmethoden verwenden, die über einen Parameter vom Typ CompareOptions verfügen, um die Art des erwarteten Vergleichs anzugeben. Verwenden Sie in der Regel linguistische Optionen (unter Verwendung der aktuellen Kultur), um Zeichenfolgen zu vergleichen, die auf der Benutzeroberfläche angezeigt werden, und geben Ordinal Oder OrdinalIgnoreCase für Sicherheitsvergleiche an.

Hinweise für Aufrufer

Zeichensätze enthalten ignorierbare Zeichen. Die Compare(String, Int32, Int32, String, Int32, Int32) Methode berücksichtigt diese Zeichen nicht, wenn sie einen sprachlichen oder kultursensitiven Vergleich durchführt. Um ignorierbare Zeichen in Ihrem Vergleich zu erkennen, rufen Sie die Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) Methode auf, und geben Sie einen Wert von Ordinal oder OrdinalIgnoreCase für den options Parameter an.

Gilt für:

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

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Quelle:: CompareInfo.cs

Vergleicht einen Abschnitt einer Zeichenfolge mit einem Abschnitt einer anderen Zeichenfolge mithilfe des angegebenen CompareOptions Werts.

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

Parameter

string1: String

Die erste zu vergleichende Zeichenfolge.

offset1: Int32

Der nullbasierte Index des Zeichens, in string1 dem der Vergleich gestartet werden soll.

length1: Int32

Die Anzahl der aufeinander folgenden Zeichen, die verglichen werden string1 sollen.

string2: String

Die zweite zu vergleichende Zeichenfolge.

offset2: Int32

Der nullbasierte Index des Zeichens, in string2 dem der Vergleich gestartet werden soll.

length2: Int32

Die Anzahl der aufeinander folgenden Zeichen, die verglichen werden string2 sollen.

options: CompareOptions

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl, die die lexikalische Beziehung zwischen den beiden Vergleichszeichen angibt.

Wert:	Bedingung
Null	Die beiden Zeichenfolgen sind gleich.
kleiner als 0	Der angegebene Abschnitt von `string1` ist kleiner als der angegebene Abschnitt von `string2`.
größer als 0	Der angegebene Abschnitt von `string1` ist größer als der angegebene Abschnitt von `string2`.

Ausnahmen

ArgumentOutOfRangeException

offset1 oder length1offset2length2 ist kleiner als Null.

- oder -

offset1 ist größer oder gleich der Anzahl von Zeichen in string1.

- oder -

offset2 ist größer oder gleich der Anzahl von Zeichen in string2.

- oder -

length1 ist größer als die Anzahl der Zeichen von offset1 bis zum Ende von string1.

- oder -

length2 ist größer als die Anzahl der Zeichen von offset2 bis zum Ende von string2.

ArgumentException

options enthält einen ungültigen CompareOptions Wert.

Beispiele

Im folgenden Beispiel werden Teile von zwei Zeichenfolgen mit unterschiedlichen CompareOptions Einstellungen verglichen.

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

Hinweise

Hinweis

Hinweise für Aufrufer

Zeichensätze enthalten ignorierbare Zeichen. Die Compare(String, Int32, Int32, String, Int32, Int32, CompareOptions) Methode berücksichtigt diese Zeichen nicht, wenn sie einen kultursensitiven Vergleich durchführt. Um ignorierbare Zeichen im Vergleich zu erkennen, geben Sie einen Wert von Ordinal oder OrdinalIgnoreCase für den options Parameter an.

Weitere Informationen

CompareOptions

Gilt für:

Feedback

War diese Seite hilfreich?

Freigeben über

CompareInfo.Compare Methode

Definition

Überlädt

Compare(String, String)

Parameter

Gibt zurück

Beispiele

Hinweise

Hinweise für Aufrufer

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Gilt für:

Compare(String, String, CompareOptions)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Compare(String, Int32, String, Int32)

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Gilt für:

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

Parameter

Gibt zurück

Ausnahmen

Beispiele

Hinweise

Hinweise für Aufrufer

Weitere Informationen

Gilt für:

Feedback