Teilen über

String.CompareOrdinal Methode

  • Referenz

Definition

Namespace:
System
Assembly:
System.Runtime.dll
Assembly:
mscorlib.dll
Assembly:
netstandard.dll

Vergleicht zwei String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Zeichenfolgen ausgewertet werden.

Überlädt

CompareOrdinal(String, String)

Vergleicht zwei String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Zeichenfolgen ausgewertet werden.
CompareOrdinal(String, Int32, String, Int32, Int32)

Vergleicht Teilzeichenfolgen zweier angegebener String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Teilzeichenfolgen ausgewertet werden.

CompareOrdinal(String, String)

Quelle:
String.Comparison.cs
Quelle:
String.Comparison.cs
Quelle:
String.Comparison.cs

Vergleicht zwei String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Zeichenfolgen ausgewertet werden.

public:
 static int CompareOrdinal(System::String ^ strA, System::String ^ strB);
public static int CompareOrdinal (string strA, string strB);
public static int CompareOrdinal (string? strA, string? strB);
static member CompareOrdinal : string * string -> int
Public Shared Function CompareOrdinal (strA As String, strB As String) As Integer

Parameter

strA
String

Die erste zu vergleichende Zeichenfolge.

strB
String

Die zweite zu vergleichende Zeichenfolge.

Gibt zurück

Int32

Eine ganze Zahl, die die lexikalische Beziehung zwischen den beiden Vergleichswerten angibt.

Wert Bedingung
Kleiner als 0 (null) strA ist kleiner als strB.
Zero strA und strB sind gleich.
Größer als 0 (null) strA ist größer als strB.

Beispiele

Im folgenden Beispiel wird ein Ordinalvergleich von zwei Zeichenfolgen durchgeführt, die sich nur in der Groß- und Kleinschreibung unterscheiden.

// Sample for String::CompareOrdinal(String, String)
using namespace System;
int main()
{
   String^ str1 = "ABCD";
   String^ str2 = "abcd";
   String^ str;
   int result;
   Console::WriteLine();
   Console::WriteLine( "Compare the numeric values of the corresponding Char objects in each string." );
   Console::WriteLine( "str1 = '{0}', str2 = '{1}'", str1, str2 );
   result = String::CompareOrdinal( str1, str2 );
   str = ((result < 0) ? "less than" : ((result > 0) ? (String^)"greater than" : "equal to"));
   Console::Write( "String '{0}' is ", str1 );
   Console::Write( "{0} ", str );
   Console::WriteLine( "String '{0}'.", str2 );
}

/*
This example produces the following results:

Compare the numeric values of the corresponding Char objects in each string.
str1 = 'ABCD', str2 = 'abcd'
String 'ABCD' is less than String 'abcd'.
*/

// Sample for String.CompareOrdinal(String, String)
using System;

class Sample {
    public static void Main() {
    String str1 = "ABCD";
    String str2 = "abcd";
    String str;
    int result;

    Console.WriteLine();
    Console.WriteLine("Compare the numeric values of the corresponding Char objects in each string.");
    Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2);
    result = String.CompareOrdinal(str1, str2);
    str = ((result < 0) ? "less than" : ((result > 0) ? "greater than" : "equal to"));
    Console.Write("String '{0}' is ", str1);
    Console.Write("{0} ", str);
    Console.WriteLine("String '{0}'.", str2);
    }
}
/*
This example produces the following results:

Compare the numeric values of the corresponding Char objects in each string.
str1 = 'ABCD', str2 = 'abcd'
String 'ABCD' is less than String 'abcd'.
*/

// Sample for String.CompareOrdinal(String, String)
open System

let str1 = "ABCD"
let str2 = "abcd"

printfn "\nCompare the numeric values of the corresponding Char objects in each string."
printfn $"str1 = '{str1}', str2 = '{str2}'"
let result = String.CompareOrdinal(str1, str2)
let str = if result < 0 then "less than" elif result > 0 then "greater than" else "equal to"
printf $"String '{str1}' is "
printf $"{str} "
printfn $"String '{str2}'."

(*
This example produces the following results:

Compare the numeric values of the corresponding Char objects in each string.
str1 = 'ABCD', str2 = 'abcd'
String 'ABCD' is less than String 'abcd'.
*)

' Sample for String.CompareOrdinal(String, String)
Class Sample
   Public Shared Sub Main()
      Dim str1 As [String] = "ABCD"
      Dim str2 As [String] = "abcd"
      Dim str As [String]
      Dim result As Integer
      
      Console.WriteLine()
      Console.WriteLine("Compare the numeric values of the corresponding Char objects in each string.")
      Console.WriteLine("str1 = '{0}', str2 = '{1}'", str1, str2)
      result = [String].CompareOrdinal(str1, str2)
      str = IIf(result < 0, "less than", IIf(result > 0, "greater than", "equal to"))
      Console.Write("String '{0}' is ", str1)
      Console.Write("{0} ", str)
      Console.WriteLine("String '{0}'.", str2)
   End Sub
End Class
'
'This example produces the following results:
'
'Compare the numeric values of the corresponding Char objects in each string.
'str1 = 'ABCD', str2 = 'abcd'
'String 'ABCD' is less than String 'abcd'.
'

Hinweise

Diese Methode führt einen Vergleich zwischen Groß- und Kleinschreibung mithilfe von Ordnungssortierungsregeln durch. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordnungssortierungen finden Sie unter System.Globalization.CompareOptions. Um einen Vergleich ohne Berücksichtigung der Groß-/Kleinschreibung mithilfe von Ordnungssortierungsregeln durchzuführen, rufen Sie die Compare(String, String, StringComparison) -Methode auf, wobei das comparisonType Argument auf StringComparison.OrdinalIgnoreCasefestgelegt ist.

Da CompareOrdinal(String, String) ist eine statische Methode strA und strB kann sein null. Wenn beide Werte sind null, gibt die Methode 0 (Null) zurück, was angibt, dass strA und strB gleich sind. Wenn nur einer der Werte ist null, betrachtet die -Methode den Ungleich-NULL-Wert als größer.

Weitere Informationen

Gilt für:

CompareOrdinal(String, Int32, String, Int32, Int32)

Quelle:
String.Comparison.cs
Quelle:
String.Comparison.cs
Quelle:
String.Comparison.cs

Vergleicht Teilzeichenfolgen zweier angegebener String-Objekte, indem die numerischen Werte der entsprechenden Char-Objekte in den Teilzeichenfolgen ausgewertet werden.

public:
 static int CompareOrdinal(System::String ^ strA, int indexA, System::String ^ strB, int indexB, int length);
public static int CompareOrdinal (string strA, int indexA, string strB, int indexB, int length);
public static int CompareOrdinal (string? strA, int indexA, string? strB, int indexB, int length);
static member CompareOrdinal : string * int * string * int * int -> int
Public Shared Function CompareOrdinal (strA As String, indexA As Integer, strB As String, indexB As Integer, length As Integer) As Integer

Parameter

strA
String

Die erste im Vergleich zu verwendende Zeichenfolge.

indexA
Int32

Der Anfangsindex der Teilzeichenfolge in strA.

strB
String

Die zweite im Vergleich zu verwendende Zeichenfolge.

indexB
Int32

Der Anfangsindex der Teilzeichenfolge in strB.

length
Int32

Die maximale Anzahl der zu vergleichenden Zeichen der Teilzeichenfolgen.

Gibt zurück

Int32

Eine 32-Bit-Ganzzahl mit Vorzeichen, die die lexikalische Beziehung der beiden verglichenen Elemente angibt.

Wert Bedingung
Kleiner als 0 (null) Die Teilzeichenfolge in strA ist kleiner als die Teilzeichenfolge in strB.
Zero Die Teilzeichenfolgen sind gleich, oder length ist 0.
Größer als 0 (null) Die Teilzeichenfolge in strA ist größer als die Teilzeichenfolge in strB.

Ausnahmen

ArgumentOutOfRangeException

strA ist nicht null und indexA ist größer als strA.Length.

- oder -

strB ist nicht null und indexB ist größer als strB.Length.

- oder -

indexA, indexB oder length ist ein negativer Wert.

Beispiele

Im folgenden Beispiel wird veranschaulicht, dass CompareOrdinalCompare unterschiedliche Sortierreihenfolgen verwendet werden.

using namespace System;
using namespace System::Globalization;
int main()
{
   String^ strLow = "abc";
   String^ strCap = "ABC";
   String^ result = "equal to ";
   int x = 0;
   int pos = 1;
   
   // The Unicode codepoint for 'b' is greater than the codepoint for 'B'.
   x = String::CompareOrdinal( strLow, pos, strCap, pos, 1 );
   if ( x < 0 )
      result = "less than";

   if ( x > 0 )
      result = "greater than";

   Console::WriteLine( "CompareOrdinal(\"{0}\"[{2}], \"{1}\"[{2}]):", strLow, strCap, pos );
   Console::WriteLine( "   '{0}' is {1} '{2}'", strLow[ pos ], result, strCap[ pos ] );

   // In U.S. English culture, 'b' is linguistically less than 'B'.
   x = String::Compare( strLow, pos, strCap, pos, 1, false, gcnew CultureInfo( "en-US" ) );
   if ( x < 0 )
      result = "less than";
   else
   if ( x > 0 )
      result = "greater than";

   Console::WriteLine( "Compare(\"{0}\"[{2}], \"{1}\"[{2}]):", strLow, strCap, pos );
   Console::WriteLine( "   '{0}' is {1} '{2}'", strLow[ pos ], result, strCap[ pos ] );
}

using System;
using System.Globalization;

class Test
{
    public static void Main(String[] args)
    {
    String strLow = "abc";
    String strCap = "ABC";
    String result = "equal to ";
    int x = 0;
    int pos = 1;

// The Unicode codepoint for 'b' is greater than the codepoint for 'B'.
    x = String.CompareOrdinal(strLow, pos, strCap, pos, 1);
    if (x < 0) result = "less than";
    if (x > 0) result = "greater than";
    Console.WriteLine("CompareOrdinal(\"{0}\"[{2}], \"{1}\"[{2}]):", strLow, strCap, pos);
    Console.WriteLine("   '{0}' is {1} '{2}'", strLow[pos], result, strCap[pos]);

// In U.S. English culture, 'b' is linguistically less than 'B'.
    x = String.Compare(strLow, pos, strCap, pos, 1, false, new CultureInfo("en-US"));
    if (x < 0) result = "less than";
    else if (x > 0) result = "greater than";
    Console.WriteLine("Compare(\"{0}\"[{2}], \"{1}\"[{2}]):", strLow, strCap, pos);
    Console.WriteLine("   '{0}' is {1} '{2}'", strLow[pos], result, strCap[pos]);
    }
}

open System
open System.Globalization

[<EntryPoint>]
let main _ =
    let strLow = "abc"
    let strCap = "ABC"
    let result = "equal to "
    let pos = 1

    // The Unicode codepoint for 'b' is greater than the codepoint for 'B'.
    let x = String.CompareOrdinal(strLow, pos, strCap, pos, 1)
    let result =
        if x < 0 then "less than"
        elif x > 0 then "greater than"
        else "equal to"
    printfn $"CompareOrdinal(\"{strLow}\"[{pos}], \"{strCap}\"[{pos}]):"
    printfn $"   '{strLow[pos]}' is {result} '{strCap[pos]}'"

    // In U.S. English culture, 'b' is linguistically less than 'B'.
    let x = String.Compare(strLow, pos, strCap, pos, 1, false, new CultureInfo("en-US"))
    let result =
        if x < 0 then "less than"
        elif x > 0 then "greater than"
        else "equal to"
    printfn $"Compare(\"{strLow}\"[{pos}], \"{strCap}\"[{pos}]):"
    printfn $"   '{strLow[pos]}' is {result} '{strCap[pos]}'"
    0

Imports System.Globalization

Class Test
   
  Public Shared Sub Main(args() As [String])
      Dim strLow As [String] = "abc"
      Dim strCap As [String] = "ABC"
      Dim result As [String] = "equal to "
      Dim x As Integer = 0
      Dim pos As Integer = 1

' The Unicode codepoint for 'b' is greater than the codepoint for 'B'.      
      x = [String].CompareOrdinal(strLow, pos, strCap, pos, 1)
      If x < 0 Then
         result = "less than"
      End If
      If x > 0 Then
         result = "greater than"
      End If

' In U.S. English culture, 'b' is linguistically less than 'B'.
      Console.WriteLine("CompareOrdinal(""{0}"".Chars({2}), ""{1}"".Chars({2})):", strLow, strCap, pos)
      
      Console.WriteLine("   '{0}' is {1} '{2}'", strLow.Chars(pos), result, strCap.Chars(pos))
      
      x = [String].Compare(strLow, pos, strCap, pos, 1, False, New CultureInfo("en-US"))
      If x < 0 Then
         result = "less than"
      ElseIf x > 0 Then
         result = "greater than"
      End If
      Console.WriteLine("Compare(""{0}"".Chars({2}), ""{1}"".Chars({2})):", strLow, strCap, pos)
      Console.WriteLine("   '{0}' is {1} '{2}'", strLow.Chars(pos), result, strCap.Chars(pos))
   End Sub
End Class

Hinweise

Die indexAParameter , indexBund length müssen nicht negativ sein.

Die Anzahl der verglichenen Zeichen ist die geringere Länge von strA weniger indexA, die Länge von strB weniger indexB, und length.

Diese Methode führt einen Vergleich zwischen Groß- und Kleinschreibung mithilfe von Ordnungssortierungsregeln durch. Weitere Informationen zu Wort-, Zeichenfolgen- und Ordnungssortierungen finden Sie unter System.Globalization.CompareOptions. Um einen Vergleich ohne Berücksichtigung der Groß-/Kleinschreibung mithilfe von Ordnungssortierungsregeln durchzuführen, rufen Sie die Compare(String, Int32, String, Int32, Int32, StringComparison) -Methode auf, wobei das comparisonType Argument auf StringComparison.OrdinalIgnoreCasefestgelegt ist.

Da CompareOrdinal(String, String) ist eine statische Methode strA und strB kann sein null. Wenn beide Werte sind null, gibt die Methode 0 (Null) zurück, was angibt, dass strA und strB gleich sind. Wenn nur einer der Werte ist null, betrachtet die -Methode den Ungleich-NULL-Wert als größer.

Weitere Informationen

Gilt für: