Int32.CompareTo Método
Definição
Importante
Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.
Compara essa instância com um inteiro com sinal de 32 bits especificado e retorna uma indicação dos valores relativos.
Sobrecargas
CompareTo(Int32) |
Compara essa instância com um inteiro com sinal de 32 bits especificado e retorna uma indicação dos valores relativos. |
CompareTo(Object) |
Compara essa instância com um objeto especificado e retorna uma indicação dos valores relativos. |
CompareTo(Int32)
- Origem:
- Int32.cs
- Origem:
- Int32.cs
- Origem:
- Int32.cs
Compara essa instância com um inteiro com sinal de 32 bits especificado e retorna uma indicação dos valores relativos.
public:
virtual int CompareTo(int value);
public int CompareTo (int value);
abstract member CompareTo : int -> int
override this.CompareTo : int -> int
Public Function CompareTo (value As Integer) As Integer
Parâmetros
- value
- Int32
Um inteiro para comparação.
Retornos
Um número assinado que indica os valores relativos dessa instância e de value
.
Valor de retorno | Descrição |
---|---|
Menor que zero | Esta instância é menor que value .
|
Zero | Esta instância é igual a value .
|
Maior que zero | Esta instância é maior que value .
|
Implementações
Exemplos
O exemplo a seguir demonstra o Int32.CompareTo(Int32) método. Além de exibir o valor retornado pelo método para quatro comparações diferentes, ele converte o valor retornado em um membro da enumeração personalizada Comparison
, cujo valor também é exibido.
using System;
enum Comparison {
LessThan=-1, Equal=0, GreaterThan=1};
public class ValueComparison
{
public static void Main()
{
int mainValue = 16325;
int zeroValue = 0;
int negativeValue = -1934;
int positiveValue = 903624;
int sameValue = 16325;
Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
mainValue, zeroValue,
mainValue.CompareTo(zeroValue),
(Comparison) mainValue.CompareTo(zeroValue));
Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
mainValue, sameValue,
mainValue.CompareTo(sameValue),
(Comparison) mainValue.CompareTo(sameValue));
Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
mainValue, negativeValue,
mainValue.CompareTo(negativeValue),
(Comparison) mainValue.CompareTo(negativeValue));
Console.WriteLine("Comparing {0} and {1}: {2} ({3}).",
mainValue, positiveValue,
mainValue.CompareTo(positiveValue),
(Comparison) mainValue.CompareTo(positiveValue));
}
}
// The example displays the following output:
// Comparing 16325 and 0: 1 (GreaterThan).
// Comparing 16325 and 16325: 0 (Equal).
// Comparing 16325 and -1934: 1 (GreaterThan).
// Comparing 16325 and 903624: -1 (LessThan).
open System
type Comparison =
| LessThan = -1
| Equal = 0
| GreaterThan = 1
let mainValue = 16325
let zeroValue = 0
let negativeValue = -1934
let positiveValue = 903624
let sameValue = 16325
printfn $"Comparing {mainValue} and {zeroValue}: {mainValue.CompareTo zeroValue} ({enum<Comparison>(mainValue.CompareTo zeroValue)})."
printfn $"Comparing {mainValue} and {sameValue}: {mainValue.CompareTo sameValue} ({enum<Comparison>(mainValue.CompareTo sameValue)})."
printfn $"Comparing {mainValue} and {negativeValue}: {mainValue.CompareTo negativeValue} ({enum<Comparison>(mainValue.CompareTo negativeValue)})."
printfn $"Comparing {mainValue} and {positiveValue}: {mainValue.CompareTo positiveValue} ({enum<Comparison>(mainValue.CompareTo positiveValue)})."
// The example displays the following output:
// Comparing 16325 and 0: 1 (GreaterThan).
// Comparing 16325 and 16325: 0 (Equal).
// Comparing 16325 and -1934: 1 (GreaterThan).
// Comparing 16325 and 903624: -1 (LessThan).
Public Enum Comparison As Integer
LessThan = -1
Equal = 0
GreaterThan = 1
End Enum
Module ValueComparison
Public Sub Main()
Dim mainValue As Integer = 16325
Dim zeroValue As Integer = 0
Dim negativeValue As Integer = -1934
Dim positiveValue As Integer = 903624
Dim sameValue As Integer = 16325
Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _
mainValue, zeroValue, _
mainValue.CompareTo(zeroValue), _
CType(mainValue.CompareTo(zeroValue), Comparison))
Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _
mainValue, sameValue, _
mainValue.CompareTo(sameValue), _
CType(mainValue.CompareTo(sameValue), Comparison))
Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _
mainValue, negativeValue, _
mainValue.CompareTo(negativeValue), _
CType(mainValue.CompareTo(negativeValue), Comparison))
Console.WriteLine("Comparing {0} and {1}: {2} ({3}).", _
mainValue, positiveValue, _
mainValue.CompareTo(positiveValue), _
CType(mainValue.CompareTo(positiveValue), Comparison))
End Sub
End Module
' The example displays the following output:
' Comparing 16325 and 0: 1 (GreaterThan).
' Comparing 16325 and 16325: 0 (Equal).
' Comparing 16325 and -1934: 1 (GreaterThan).
' Comparing 16325 and 903624: -1 (LessThan).
Comentários
Esse método implementa a System.IComparable<T> interface e tem um desempenho ligeiramente melhor do que o Int32.CompareTo método porque não precisa converter o value
parâmetro em um objeto .
Dependendo da linguagem de programação, pode ser possível codificar um CompareTo método em que o tipo de parâmetro tenha menos bits (é mais estreito) do que o tipo de instância. Isso é possível porque algumas linguagens de programação executam uma conversão de ampliação implícita que representa o parâmetro como um tipo com tantos bit quanto a instância.
Por exemplo, suponha que o tipo de instância seja Int32 e o tipo de parâmetro seja Byte. O compilador Microsoft C# gera instruções para representar o valor do parâmetro como um Int32, em seguida, gera um Int32.CompareTo método que compara os valores da Int32 instância e a representação de Int32 parâmetro.
Consulte a documentação da linguagem de programação para determinar se o compilador realiza conversões de ampliação implícitas em tipos numéricos.
Confira também
Aplica-se a
CompareTo(Object)
- Origem:
- Int32.cs
- Origem:
- Int32.cs
- Origem:
- Int32.cs
Compara essa instância com um objeto especificado e retorna uma indicação dos valores relativos.
public:
virtual int CompareTo(System::Object ^ value);
public int CompareTo (object? value);
public int CompareTo (object value);
abstract member CompareTo : obj -> int
override this.CompareTo : obj -> int
Public Function CompareTo (value As Object) As Integer
Parâmetros
- value
- Object
Um objeto a ser comparado ou null
.
Retornos
Um número assinado que indica os valores relativos dessa instância e de value
.
Valor de retorno | Descrição |
---|---|
Menor que zero | Esta instância é menor que value .
|
Zero | Esta instância é igual a value .
|
Maior que zero | Esta instância é maior do que value ou value é null .
|
Implementações
Exceções
value
não é um Int32.
Comentários
Qualquer instância de Int32, independentemente de seu valor, é considerada maior que null
.
value
deve ser null
ou uma instância de Int32; caso contrário, uma exceção é gerada.