BigInteger.Equals Método

Definición

Devuelve un valor que indica si dos valores numéricos son iguales.Returns a value that indicates whether two numeric values are equal.

Sobrecargas

Equals(Int64)

Devuelve un valor que indica si la instancia actual y un entero de 64 bits con signo tienen el mismo valor.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(BigInteger)

Devuelve un valor que indica si la instancia actual y un objeto BigInteger especificado tienen el mismo valor.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Object)

Devuelve un valor que indica si la instancia actual y un objeto especificado tienen el mismo valor.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64)

Devuelve un valor que indica si la instancia actual y un entero de 64 bits sin signo tienen el mismo valor.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

Equals(Int64)

Devuelve un valor que indica si la instancia actual y un entero de 64 bits con signo tienen el mismo valor.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

public:
 bool Equals(long other);
public bool Equals (long other);
override this.Equals : int64 -> bool
Public Function Equals (other As Long) As Boolean

Parámetros

other
Int64

Valor entero de 64 bits con signo que se va a comparar.The signed 64-bit integer value to compare.

Devoluciones

Es true si el entero de 64 bits con signo y la instancia actual tienen el mismo valor; de lo contrario, es false.true if the signed 64-bit integer and the current instance have the same value; otherwise, false.

Ejemplos

En el ejemplo siguiente se crea una instancia de un objeto BigInteger a partir de cada tipo entero excepto UInt64.The following example instantiates a BigInteger object from each integral type except UInt64. A continuación, llama al método Equals(Int64) para comparar el valor de BigInteger con el valor entero original que se pasó al constructor BigInteger.It then calls the Equals(Int64) method to compare the BigInteger value with the original integer value that was passed to the BigInteger constructor. Como se muestra en el resultado, los valores son iguales en cada caso.As the output shows, the values are equal in each case.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;

void main()
{
   BigInteger bigIntValue;

   Byte byteValue = 16;
   bigIntValue = BigInteger(byteValue);
   Console::WriteLine("{0} {1} = {2} {3} : {4}",
      bigIntValue.GetType()->Name, bigIntValue,
      byteValue.GetType()->Name, byteValue,
      bigIntValue.Equals((Int64)byteValue));

   SByte sbyteValue = -16;
   bigIntValue = BigInteger(sbyteValue);
   Console::WriteLine("{0} {1} = {2} {3} : {4}",
      bigIntValue.GetType()->Name, bigIntValue,
      sbyteValue.GetType()->Name, sbyteValue,
      bigIntValue.Equals((Int64)sbyteValue));

   Int16 shortValue = 1233;
   bigIntValue = BigInteger(shortValue);
   Console::WriteLine("{0} {1} = {2} {3} : {4}",
      bigIntValue.GetType()->Name, bigIntValue,
      shortValue.GetType()->Name, shortValue,
      bigIntValue.Equals((Int64)shortValue));

   UInt16 ushortValue = 64000;
   bigIntValue = BigInteger(ushortValue);
   Console::WriteLine("{0} {1} = {2} {3} : {4}",
      bigIntValue.GetType()->Name, bigIntValue,
      ushortValue.GetType()->Name, ushortValue,
      bigIntValue.Equals((Int64)ushortValue));

   int intValue = -1603854;
   bigIntValue = BigInteger(intValue);
   Console::WriteLine("{0} {1} = {2} {3} : {4}",
      bigIntValue.GetType()->Name, bigIntValue,
      intValue.GetType()->Name, intValue,
      bigIntValue.Equals((Int64)intValue));

   UInt32 uintValue = 1223300;
   bigIntValue = BigInteger(uintValue);
   Console::WriteLine("{0} {1} = {2} {3} : {4}",
      bigIntValue.GetType()->Name, bigIntValue,
      uintValue.GetType()->Name, uintValue,
      bigIntValue.Equals((Int64)uintValue));

   Int64 longValue = -123822229012;
   bigIntValue = BigInteger(longValue);
   Console::WriteLine("{0} {1} = {2} {3} : {4}",
      bigIntValue.GetType()->Name, bigIntValue,
      longValue.GetType()->Name, longValue,
      bigIntValue.Equals((Int64)longValue));
}
/* 
The example displays output like the following:
      BigInteger 16 = Byte 16 : True
      BigInteger -16 = SByte -16 : True
      BigInteger 1233 = Int16 1233 : True
      BigInteger 64000 = UInt16 64000 : True
      BigInteger -1603854 = Int32 -1603854 : True
      BigInteger 1223300 = UInt32 1223300 : True
      BigInteger -123822229012 = Int64 -123822229012 : True
*/
BigInteger bigIntValue; 

byte byteValue = 16;
bigIntValue = new BigInteger(byteValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  byteValue.GetType().Name, byteValue, 
                  bigIntValue.Equals(byteValue));
                  
sbyte sbyteValue = -16;
bigIntValue = new BigInteger(sbyteValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  sbyteValue.GetType().Name, sbyteValue,
                  bigIntValue.Equals(sbyteValue));

short shortValue = 1233;
bigIntValue = new BigInteger(shortValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  shortValue.GetType().Name, shortValue, 
                  bigIntValue.Equals(shortValue));
      
ushort ushortValue = 64000;
bigIntValue = new BigInteger(ushortValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  ushortValue.GetType().Name, ushortValue, 
                  bigIntValue.Equals(ushortValue));

int intValue = -1603854;
bigIntValue = new BigInteger(intValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  intValue.GetType().Name, intValue, 
                  bigIntValue.Equals(intValue));

uint uintValue = 1223300;
bigIntValue = new BigInteger(uintValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  uintValue.GetType().Name, uintValue, 
                  bigIntValue.Equals(uintValue));

long longValue = -123822229012;
bigIntValue = new BigInteger(longValue);
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  longValue.GetType().Name, longValue, 
                  bigIntValue.Equals(longValue));
// The example displays the following output:
//    BigInteger 16 = Byte 16 : True
//    BigInteger -16 = SByte -16 : True
//    BigInteger 1233 = Int16 1233 : True
//    BigInteger 64000 = UInt16 64000 : True
//    BigInteger -1603854 = Int32 -1603854 : True
//    BigInteger 1223300 = UInt32 1223300 : True
//    BigInteger -123822229012 = Int64 -123822229012 : True
Dim bigIntValue As BigInteger 

Dim byteValue As Byte = 16
bigIntValue = New BigInteger(byteValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  byteValue.GetType().Name, byteValue, 
                  bigIntValue.Equals(byteValue))
                  
Dim sbyteValue As SByte = -16
bigIntValue = New BigInteger(sbyteValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  sbyteValue.GetType().Name, sbyteValue,
                  bigIntValue.Equals(sbyteValue))

Dim shortValue As Short = 1233
bigIntValue = New BigInteger(shortValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  shortValue.GetType().Name, shortValue, 
                  bigIntValue.Equals(shortValue))
      
Dim ushortValue As UShort = 64000
bigIntValue = New BigInteger(ushortValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  ushortValue.GetType().Name, ushortValue, 
                  bigIntValue.Equals(ushortValue))

Dim intValue As Integer = -1603854
bigIntValue = New BigInteger(intValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  intValue.GetType().Name, intValue, 
                  bigIntValue.Equals(intValue))

Dim uintValue As UInteger = 1223300
bigIntValue = New BigInteger(uintValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  uintValue.GetType().Name, uintValue, 
                  bigIntValue.Equals(uintValue))

Dim longValue As Long = -123822229012
bigIntValue = New BigInteger(longValue)
Console.WriteLine("{0} {1} = {2} {3} : {4}", 
                  bigIntValue.GetType().Name, bigIntValue,
                  longValue.GetType().Name, longValue, 
                  bigIntValue.Equals(longValue))
' The example displays the following output:
'    BigInteger 16 = Byte 16 : True
'    BigInteger -16 = SByte -16 : True
'    BigInteger 1233 = Int16 1233 : True
'    BigInteger 64000 = UInt16 64000 : True
'    BigInteger -1603854 = Int32 -1603854 : True
'    BigInteger 1223300 = UInt32 1223300 : True
'    BigInteger -123822229012 = Int64 -123822229012 : True

Comentarios

Si other es un valor Byte, Int16, Int32, SByte, UInt16o UInt32, se convierte implícitamente en un valor Int64 cuando se llama al método.If other is a Byte, Int16, Int32, SByte, UInt16, or UInt32 value, it is implicitly converted to an Int64 value when the method is called.

Para determinar la relación entre los dos objetos en lugar de solo probar la igualdad, llame al método BigInteger.CompareTo(Int64).To determine the relationship between the two objects instead of just testing for equality, call the BigInteger.CompareTo(Int64) method.

Equals(BigInteger)

Devuelve un valor que indica si la instancia actual y un objeto BigInteger especificado tienen el mismo valor.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

public:
 virtual bool Equals(System::Numerics::BigInteger other);
public bool Equals (System.Numerics.BigInteger other);
override this.Equals : System.Numerics.BigInteger -> bool
Public Function Equals (other As BigInteger) As Boolean

Parámetros

other
BigInteger

Objeto que se va a comparar.The object to compare.

Devoluciones

Es true si este objeto BigInteger y other tienen el mismo valor; de lo contrario, es false.true if this BigInteger object and other have the same value; otherwise, false.

Implementaciones

Ejemplos

En el ejemplo siguiente se compara la distancia aproximada de varias estrellas desde tierra con la distancia de épsilon indi de la tierra para determinar si son iguales.The following example compares the approximate distance of several stars from Earth with the distance of Epsilon Indi from Earth to determine whether they are equal. En el ejemplo se usa cada sobrecarga del método Equals para comprobar la igualdad.The example uses each overload of the Equals method to test for equality.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;


void main()
{
   const Int64 LIGHT_YEAR = 5878625373183;

   BigInteger altairDistance = 17 * LIGHT_YEAR;
   BigInteger epsilonIndiDistance = 12 * LIGHT_YEAR;
   BigInteger ursaeMajoris47Distance = 46 * LIGHT_YEAR;
   Int64 tauCetiDistance = 12 * LIGHT_YEAR;
   UInt64 procyon2Distance = 12 * LIGHT_YEAR;
   Object^ wolf424ABDistance = 14 * LIGHT_YEAR;

   Console::WriteLine("Approx. equal distances from Epsilon Indi to:");
   Console::WriteLine("   Altair: {0}",
      epsilonIndiDistance.Equals(altairDistance));
   Console::WriteLine("   Ursae Majoris 47: {0}",
      epsilonIndiDistance.Equals(ursaeMajoris47Distance));
   Console::WriteLine("   TauCeti: {0}",
      epsilonIndiDistance.Equals(tauCetiDistance));
   Console::WriteLine("   Procyon 2: {0}",
      epsilonIndiDistance.Equals(procyon2Distance));
   Console::WriteLine("   Wolf 424 AB: {0}",
      epsilonIndiDistance.Equals(wolf424ABDistance));
}
/*
The example displays output like the following:
      Approx. equal distances from Epsilon Indi to:
      Altair: False
      Ursae Majoris 47: False
      TauCeti: True
      Procyon 2: True
      Wolf 424 AB: False
*/
   const long LIGHT_YEAR = 5878625373183;

   BigInteger altairDistance = 17 * LIGHT_YEAR;
   BigInteger epsilonIndiDistance = 12 * LIGHT_YEAR;
   BigInteger ursaeMajoris47Distance = 46 * LIGHT_YEAR;
   long tauCetiDistance = 12 * LIGHT_YEAR;
   ulong procyon2Distance = 12 * LIGHT_YEAR;
   object wolf424ABDistance = 14 * LIGHT_YEAR;
   
   Console.WriteLine("Approx. equal distances from Epsilon Indi to:");
   Console.WriteLine("   Altair: {0}", 
                     epsilonIndiDistance.Equals(altairDistance));
   Console.WriteLine("   Ursae Majoris 47: {0}", 
                     epsilonIndiDistance.Equals(ursaeMajoris47Distance));
   Console.WriteLine("   TauCeti: {0}", 
                     epsilonIndiDistance.Equals(tauCetiDistance));
   Console.WriteLine("   Procyon 2: {0}", 
                     epsilonIndiDistance.Equals(procyon2Distance));
   Console.WriteLine("   Wolf 424 AB: {0}", 
                     epsilonIndiDistance.Equals(wolf424ABDistance));
   // The example displays the following output:
   //    Approx. equal distances from Epsilon Indi to:
   //       Altair: False
   //       Ursae Majoris 47: False
   //       TauCeti: True
   //       Procyon 2: True
   //       Wolf 424 AB: False      
   Const LIGHT_YEAR As Long = 5878625373183

   Dim altairDistance As BigInteger = 17 * LIGHT_YEAR
   Dim epsilonIndiDistance As BigInteger = 12 * LIGHT_YEAR
   Dim ursaeMajoris47Distance As BigInteger = 46 * LIGHT_YEAR
   Dim tauCetiDistance As BigInteger = 12 * LIGHT_YEAR
   Dim procyon2Distance As Long = 12 * LIGHT_YEAR
   Dim wolf424ABDistance As Object = 14 * LIGHT_YEAR
   
   Console.WriteLine("Approx. equal distances from Epsilon Indi to:")
   Console.WriteLine("   Altair: {0}", _
                     epsilonIndiDistance.Equals(altairDistance))
   Console.WriteLine("   Ursae Majoris 47: {0}", _
                     epsilonIndiDistance.Equals(ursaeMajoris47Distance))
   Console.WriteLine("   TauCeti: {0}", _
                     epsilonIndiDistance.Equals(tauCetiDistance))
   Console.WriteLine("   Procyon 2: {0}", _
                     epsilonIndiDistance.Equals(procyon2Distance))
   Console.WriteLine("   Wolf 424 AB: {0}", _
                     epsilonIndiDistance.Equals(wolf424ABDistance))
   ' The example displays the following output:
   '    Approx. equal distances from Epsilon Indi to:
   '       Altair: False
   '       Ursae Majoris 47: False
   '       TauCeti: True
   '       Procyon 2: True
   '       Wolf 424 AB: False

Comentarios

Este método implementa la interfaz IEquatable<T> y se ejecuta ligeramente mejor que Equals(Object) porque no tiene que convertir el parámetro other en un objeto BigInteger.This method implements the IEquatable<T> interface and performs slightly better than Equals(Object) because it does not have to convert the other parameter to a BigInteger object.

Para determinar la relación entre los dos objetos BigInteger en lugar de comprobar la igualdad, llame al método BigInteger.CompareTo(BigInteger).To determine the relationship between the two BigInteger objects instead of just testing for equality, call the BigInteger.CompareTo(BigInteger) method.

Equals(Object)

Devuelve un valor que indica si la instancia actual y un objeto especificado tienen el mismo valor.Returns a value that indicates whether the current instance and a specified object have the same value.

public:
 override bool Equals(System::Object ^ obj);
public override bool Equals (object obj);
override this.Equals : obj -> bool
Public Overrides Function Equals (obj As Object) As Boolean

Parámetros

obj
Object

Objeto que se va a comparar.The object to compare.

Devoluciones

true si el argumento obj es un objeto BigInteger y su valor es igual al valor de la instancia BigInteger actual; en caso contrario, false.true if the obj argument is a BigInteger object, and its value is equal to the value of the current BigInteger instance; otherwise, false.

Ejemplos

En el ejemplo siguiente se definen matrices Object y BigInteger paralelas.The following example defines parallel Object and BigInteger arrays. Cada elemento de una matriz tiene el mismo valor que el elemento correspondiente de la segunda matriz.Each element of one array has the same value as the corresponding element of the second array. Como muestra la salida del ejemplo, la instancia de la matriz BigInteger se considera que es igual a la instancia de la matriz Object solo si el último es un BigInteger y sus valores son iguales.As the output from the example shows, the instance in the BigInteger array is considered to be equal to the instance in the Object array only if the latter is a BigInteger and their values are equal.

using System;
using System.Numerics;

public class Example
{
   public static void Main()
   {
      object[] obj = { 0, 10, 100, new BigInteger(1000), -10 };
      BigInteger[] bi = { BigInteger.Zero, new BigInteger(10),
                          new BigInteger(100), new BigInteger(1000),
                          new BigInteger(-10) };
      for (int ctr = 0; ctr < bi.Length; ctr++)
         Console.WriteLine(bi[ctr].Equals(obj[ctr]));
   }
}
// The example displays the following output:
//       False
//       False
//       False
//       True
//       False
Imports System.Numerics

Module Example
   Public Sub Main()
      Dim obj() As object = { 0, 10, 100, New BigInteger(1000), -10 }
      Dim bi() As BigInteger = { BigInteger.Zero, New BigInteger(10),
                                 New BigInteger(100), New BigInteger(1000),
                                 New BigInteger(-10) }
      For ctr As Integer = 0 To bi.Length - 1
         Console.WriteLine(bi(ctr).Equals(obj(ctr)))
      Next                           
   End Sub
End Module
' The example displays the following output:
'       False
'       False
'       False
'       True
'       False

Comentarios

Si el argumento obj no es un valor BigInteger, el método devuelve false.If the obj argument is not a BigInteger value, the method returns false. El método solo devuelve true si obj es una instancia de BigInteger cuyo valor es igual a la instancia actual.The method returns true only if obj is a BigInteger instance whose value is equal to the current instance.

Para determinar la relación entre los dos objetos en lugar de solo probar la igualdad, llame al método CompareTo(Object).To determine the relationship between the two objects instead of just testing for equality, call the CompareTo(Object) method.

Equals(UInt64)

Importante

Esta API no es conforme a CLS.

Devuelve un valor que indica si la instancia actual y un entero de 64 bits sin signo tienen el mismo valor.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

public:
 bool Equals(System::UInt64 other);
[System.CLSCompliant(false)]
public bool Equals (ulong other);
override this.Equals : uint64 -> bool
Public Function Equals (other As ULong) As Boolean

Parámetros

other
UInt64

Entero de 64 bits sin signo que se va a comparar.The unsigned 64-bit integer to compare.

Devoluciones

Es true si la instancia actual y el entero de 64 bits sin signo tienen el mismo valor; de lo contrario, es false.true if the current instance and the unsigned 64-bit integer have the same value; otherwise, false.

Atributos

Ejemplos

En el ejemplo siguiente se compara la distancia aproximada de varias estrellas desde tierra con la distancia de épsilon indi de la tierra para determinar si son iguales.The following example compares the approximate distance of several stars from Earth with the distance of Epsilon Indi from Earth to determine whether they are equal. En el ejemplo se usa cada sobrecarga del método Equals para comprobar la igualdad.The example uses each overload of the Equals method to test for equality.

#using <System.Numerics.dll>

using namespace System;
using namespace System::Numerics;


void main()
{
   const Int64 LIGHT_YEAR = 5878625373183;

   BigInteger altairDistance = 17 * LIGHT_YEAR;
   BigInteger epsilonIndiDistance = 12 * LIGHT_YEAR;
   BigInteger ursaeMajoris47Distance = 46 * LIGHT_YEAR;
   Int64 tauCetiDistance = 12 * LIGHT_YEAR;
   UInt64 procyon2Distance = 12 * LIGHT_YEAR;
   Object^ wolf424ABDistance = 14 * LIGHT_YEAR;

   Console::WriteLine("Approx. equal distances from Epsilon Indi to:");
   Console::WriteLine("   Altair: {0}",
      epsilonIndiDistance.Equals(altairDistance));
   Console::WriteLine("   Ursae Majoris 47: {0}",
      epsilonIndiDistance.Equals(ursaeMajoris47Distance));
   Console::WriteLine("   TauCeti: {0}",
      epsilonIndiDistance.Equals(tauCetiDistance));
   Console::WriteLine("   Procyon 2: {0}",
      epsilonIndiDistance.Equals(procyon2Distance));
   Console::WriteLine("   Wolf 424 AB: {0}",
      epsilonIndiDistance.Equals(wolf424ABDistance));
}
/*
The example displays output like the following:
      Approx. equal distances from Epsilon Indi to:
      Altair: False
      Ursae Majoris 47: False
      TauCeti: True
      Procyon 2: True
      Wolf 424 AB: False
*/
   const long LIGHT_YEAR = 5878625373183;

   BigInteger altairDistance = 17 * LIGHT_YEAR;
   BigInteger epsilonIndiDistance = 12 * LIGHT_YEAR;
   BigInteger ursaeMajoris47Distance = 46 * LIGHT_YEAR;
   long tauCetiDistance = 12 * LIGHT_YEAR;
   ulong procyon2Distance = 12 * LIGHT_YEAR;
   object wolf424ABDistance = 14 * LIGHT_YEAR;
   
   Console.WriteLine("Approx. equal distances from Epsilon Indi to:");
   Console.WriteLine("   Altair: {0}", 
                     epsilonIndiDistance.Equals(altairDistance));
   Console.WriteLine("   Ursae Majoris 47: {0}", 
                     epsilonIndiDistance.Equals(ursaeMajoris47Distance));
   Console.WriteLine("   TauCeti: {0}", 
                     epsilonIndiDistance.Equals(tauCetiDistance));
   Console.WriteLine("   Procyon 2: {0}", 
                     epsilonIndiDistance.Equals(procyon2Distance));
   Console.WriteLine("   Wolf 424 AB: {0}", 
                     epsilonIndiDistance.Equals(wolf424ABDistance));
   // The example displays the following output:
   //    Approx. equal distances from Epsilon Indi to:
   //       Altair: False
   //       Ursae Majoris 47: False
   //       TauCeti: True
   //       Procyon 2: True
   //       Wolf 424 AB: False      
   Const LIGHT_YEAR As Long = 5878625373183

   Dim altairDistance As BigInteger = 17 * LIGHT_YEAR
   Dim epsilonIndiDistance As BigInteger = 12 * LIGHT_YEAR
   Dim ursaeMajoris47Distance As BigInteger = 46 * LIGHT_YEAR
   Dim tauCetiDistance As BigInteger = 12 * LIGHT_YEAR
   Dim procyon2Distance As Long = 12 * LIGHT_YEAR
   Dim wolf424ABDistance As Object = 14 * LIGHT_YEAR
   
   Console.WriteLine("Approx. equal distances from Epsilon Indi to:")
   Console.WriteLine("   Altair: {0}", _
                     epsilonIndiDistance.Equals(altairDistance))
   Console.WriteLine("   Ursae Majoris 47: {0}", _
                     epsilonIndiDistance.Equals(ursaeMajoris47Distance))
   Console.WriteLine("   TauCeti: {0}", _
                     epsilonIndiDistance.Equals(tauCetiDistance))
   Console.WriteLine("   Procyon 2: {0}", _
                     epsilonIndiDistance.Equals(procyon2Distance))
   Console.WriteLine("   Wolf 424 AB: {0}", _
                     epsilonIndiDistance.Equals(wolf424ABDistance))
   ' The example displays the following output:
   '    Approx. equal distances from Epsilon Indi to:
   '       Altair: False
   '       Ursae Majoris 47: False
   '       TauCeti: True
   '       Procyon 2: True
   '       Wolf 424 AB: False

Comentarios

Para determinar la relación entre los dos objetos en lugar de solo probar la igualdad, llame al método BigInteger.CompareTo(UInt64).To determine the relationship between the two objects instead of just testing for equality, call the BigInteger.CompareTo(UInt64) method.

Se aplica a