String.IComparable.CompareTo(Object) Método

Definição

Namespace:

System

Assembly:

System.Runtime.dll

Compara essa instância com um Object especificado e indica se esta instância precede, segue ou aparece na mesma posição na ordem de classificação, conforme o Object especificado.

 virtual int System.IComparable.CompareTo(System::Object ^ value) = IComparable::CompareTo;

int IComparable.CompareTo (object value);

abstract member System.IComparable.CompareTo : obj -> int
override this.System.IComparable.CompareTo : obj -> int

Function CompareTo (value As Object) As Integer Implements IComparable.CompareTo

Parâmetros

value

Object

Um objeto avaliado como um String.

Retornos

Int32

Um inteiro com sinal de 32 bits que indica se esta instância precede, segue ou é exibida na mesma posição da ordem de classificação que o parâmetro value.

Valor	Condição
Menor que zero	Esta instância precede value.
Zero	Esta instância tem a mesma posição na ordem de classificação que value.
Maior que zero	Essa instância segue value ou value é null.

Implementações

CompareTo(Object)

Exceções

ArgumentException

value não é um String.

Exemplos

O exemplo a seguir usa o CompareTo método com um Object. Como ele tenta comparar uma String instância com um TestClass objeto , o método lança um 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

open System

type TestClass() = class end

let test = TestClass()
let objectsToCompare: obj list =
    [ test; string test; 123
      string 123; "some text"
      "Some Text" ]
let s = "some text"
for objectToCompare in objectsToCompare do
    try
        let i = s.CompareTo objectToCompare
        printfn $"Comparing '{s}' with '{objectToCompare}': {i}"
    with :? ArgumentException ->
        printfn $"Bad argument: {objectToCompare} (type {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

Comentários

value deve ser um String objeto .

Cuidado

O CompareTo método foi projetado principalmente para uso em operações de classificação ou alfabética. Ele não deve ser usado quando a principal finalidade da chamada de método é determinar se duas cadeias de caracteres são equivalentes. Para determinar se duas cadeias de caracteres são equivalentes, chame o método Equals.

Este método executa uma comparação de palavra (diferencia maiúsculas de minúsculas e sensível à cultura) usando a cultura atual. Para obter mais informações sobre a palavra, a cadeia de caracteres e os tipos ordinais, consulte System.Globalization.CompareOptions.

Para obter mais informações sobre o comportamento desse método, consulte a seção Comentários do String.Compare(String, String) método .