String.IComparable.CompareTo(Object) Methode

Definition

Vergleicht diese Instanz mit einem angegebenen Object und gibt an, ob diese Instanz in der Sortierreihenfolge an einer früheren, späteren oder derselben Position wie das angegebene Object aufgeführt wird.Compares this instance with a specified Object and indicates whether this instance precedes, follows, or appears in the same position in the sort order as the specified Object.

 virtual int System.IComparable.CompareTo(System::Object ^ value) = IComparable::CompareTo;
int IComparable.CompareTo (object value);
Function CompareTo (value As Object) As Integer Implements IComparable.CompareTo

Parameter

value
Object

Ein Objekt, das als String ausgewertet wird.An object that evaluates to a String.

Gibt zurück

Eine 32-Bit-Ganzzahl mit Vorzeichen, die angibt, ob diese Instanz in der Sortierreihenfolge an einer früheren, späteren oder derselben Position wie der value-Parameter aufgeführt wird.A 32-bit signed integer that indicates whether this instance precedes, follows, or appears in the same position in the sort order as the value parameter.

WertValueBedingungCondition
Kleiner als 0 (null)Less than zeroDiese Instanz geht value voran.This instance precedes value.
ZeroZeroDiese Instanz hat in der Sortierreihenfolge dieselbe Position wie value.This instance has the same position in the sort order as value.
Größer als 0 (null)Greater than zeroDiese Instanz folgt value.This instance follows value.

- oder --or-

value ist null.value is null.

Implementiert

Ausnahmen

value ist keine String.value is not a String.

Beispiele

Im folgenden Beispiel wird die CompareTo-Methode mit einem-Objectverwendet.The following example uses the CompareTo method with an Object. Da versucht wird, eine String Instanz mit einem TestClass-Objekt zu vergleichen, löst die Methode eine ArgumentExceptionaus.Because it attempts to compare a String instance to a TestClass object, the method throws an ArgumentException.

using namespace System;

public ref class TestClass{};

int main()
{
   TestClass^ test = gcnew TestClass;
   array<Object^>^ objectsToCompare = { test, test->ToString(), 123,
                                        (123).ToString(), "some text",
                                        "Some Text" };
   String^ s = "some text";
   for each (Object^ objectToCompare in objectsToCompare) {
      try {
         Int32 i = s->CompareTo(objectToCompare);
         Console::WriteLine("Comparing '{0}' with '{1}': {2}",
                            s, objectToCompare, i);
      }
      catch (ArgumentException^ e) {
         Console::WriteLine("Bad argument: {0} (type {1})",
                            objectToCompare,
                            objectToCompare->GetType()->Name);
      }
   }
}
// The example displays the following output:
//    Bad argument: TestClass (type TestClass)
//    Comparing 'some text' with 'TestClass': -1
//    Bad argument: 123 (type Int32)
//    Comparing 'some text' with '123': 1
//    Comparing 'some text' with 'some text': 0
//    Comparing 'some text' with 'Some Text': -1
using System;

public class TestClass
{}

public class Example 
{
   public static void Main()
   {
      var test = new TestClass();
      Object[] objectsToCompare = { test, test.ToString(), 123,
                                    123.ToString(), "some text",
                                    "Some Text" };
      string s = "some text";
      foreach (var objectToCompare in objectsToCompare) {
         try {
            int i = s.CompareTo(objectToCompare);
            Console.WriteLine("Comparing '{0}' with '{1}': {2}",
                              s, objectToCompare, i);
         }
         catch (ArgumentException) {
            Console.WriteLine("Bad argument: {0} (type {1})",
                              objectToCompare,
                              objectToCompare.GetType().Name);
         }
      }
   }
}
// The example displays the following output:
//    Bad argument: TestClass (type TestClass)
//    Comparing 'some text' with 'TestClass': -1
//    Bad argument: 123 (type Int32)
//    Comparing 'some text' with '123': 1
//    Comparing 'some text' with 'some text': 0
//    Comparing 'some text' with 'Some Text': -1
Public Class TestClass
End Class 


Public Class Example
   Public Shared Sub Main()
      Dim test As New TestClass()
      Dim objectsToCompare() As Object = { test, test.ToString(), 123,
                                           123.ToString(), "some text",
                                           "Some Text" }
      Dim s As String = "some text"
      For Each objectToCompare In objectsToCompare
         Try
            Dim i As Integer = s.CompareTo(objectToCompare)
            Console.WriteLine("Comparing '{0}' with '{1}': {2}",
                              s, objectToCompare, i)
         Catch e As ArgumentException
            Console.WriteLine("Bad argument: {0} (type {1})",
                              objectToCompare,
                              objectToCompare.GetType().Name)
         End Try
      Next
   End Sub 
End Class 
' The example displays the following output:
'       Bad argument: TestClass (type TestClass)
'       Comparing 'some text' with 'TestClass': -1
'       Bad argument: 123 (type Int32)
'       Comparing 'some text' with '123': 1
'       Comparing 'some text' with 'some text': 0
'       Comparing 'some text' with 'Some Text': -1

Hinweise

value muss ein String Objekt sein.value must be a String object.

Achtung

Die CompareTo-Methode wurde hauptsächlich für die Verwendung in Sortier-oder alphabetisierungsvorgängen entwickelt.The CompareTo method was designed primarily for use in sorting or alphabetizing operations. Er sollte nicht verwendet werden, wenn der primäre Zweck des Methoden Aufrufes ist, zu bestimmen, ob zwei Zeichen folgen äquivalent sind.It should not be used when the primary purpose of the method call is to determine whether two strings are equivalent. Um zu ermitteln, ob zwei Zeichen folgen äquivalent sind, müssen Sie die Equals-Methode abrufen.To determine whether two strings are equivalent, call the Equals method.

Diese Methode führt einen Vergleich mit der aktuellen Kultur durch (Unterscheidung nach Groß-/Kleinschreibung und Kultur sensitiv).This method performs a word (case-sensitive and culture-sensitive) comparison using the current culture. Weitere Informationen zu Wort-, Zeichen folgen-und ordinalsortierungen finden Sie unter System.Globalization.CompareOptions.For more information about word, string, and ordinal sorts, see System.Globalization.CompareOptions.

Weitere Informationen zum Verhalten dieser Methode finden Sie im Abschnitt "Hinweise" der String.Compare(String, String)-Methode.For more information about the behavior of this method, see the Remarks section of the String.Compare(String, String) method.

Gilt für: