BigInteger.Equals 메서드

정의

두 개의 숫자 값이 같은지를 나타내는 값을 반환합니다.Returns a value that indicates whether two numeric values are equal.

오버로드

Equals(Int64)

현재 인스턴스와 부호 있는 64비트 정수의 값이 같은지를 나타내는 값을 반환합니다.Returns a value that indicates whether the current instance and a signed 64-bit integer have the same value.

Equals(BigInteger)

현재 인스턴스와 지정된 BigInteger 개체의 값이 같은지 여부를 나타내는 값을 반환합니다.Returns a value that indicates whether the current instance and a specified BigInteger object have the same value.

Equals(Object)

현재 인스턴스와 지정된 개체의 값이 같은지를 나타내는 값을 반환합니다.Returns a value that indicates whether the current instance and a specified object have the same value.

Equals(UInt64)

현재 인스턴스와 부호 없는 64비트 정수의 값이 같은지를 나타내는 값을 반환합니다.Returns a value that indicates whether the current instance and an unsigned 64-bit integer have the same value.

Equals(Int64)

현재 인스턴스와 부호 있는 64비트 정수의 값이 같은지를 나타내는 값을 반환합니다.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

매개 변수

other
Int64

비교할 부호 있는 64비트 정수 값입니다.The signed 64-bit integer value to compare.

반환

부호 있는 64비트 정수와 현재 인스턴스의 값이 같으면 true이고, 그렇지 않으면 false입니다.true if the signed 64-bit integer and the current instance have the same value; otherwise, false.

예제

다음 예제에서는 UInt64를 제외 하 고 각 정수 계열 형식에서 BigInteger 개체를 인스턴스화합니다.The following example instantiates a BigInteger object from each integral type except UInt64. 그런 다음 Equals(Int64) 메서드를 호출 하 여 BigInteger 값을 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. 출력에서 볼 수 있듯이 각 사례에서 값은 동일 합니다.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

설명

other Byte, Int16, Int32, SByte, UInt16또는 UInt32 값 이면 메서드가 호출 될 때 암시적으로 Int64 값으로 변환 됩니다.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.

같음 여부를 테스트 하는 대신 두 개체 간의 관계를 확인 하려면 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)

현재 인스턴스와 지정된 BigInteger 개체의 값이 같은지 여부를 나타내는 값을 반환합니다.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

매개 변수

other
BigInteger

비교할 개체입니다.The object to compare.

반환

BigInteger 개체와 other의 값이 같으면 true이고, 그렇지 않으면 false입니다.true if this BigInteger object and other have the same value; otherwise, false.

구현

예제

다음 예에서는 지구에서 몇 개의 별 근사 거리를 지구에서 엡실론의 거리와 비교 하 여 같은지 여부를 확인 합니다.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. 이 예제에서는 Equals 메서드의 각 오버 로드를 사용 하 여 같은지 테스트 합니다.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

설명

이 메서드는 IEquatable<T> 인터페이스를 구현 하 고 other 매개 변수를 BigInteger 개체로 변환할 필요가 없기 때문에 Equals(Object) 보다 약간 더 잘 수행 됩니다.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.

같음 여부를 테스트 하는 대신 두 BigInteger 개체 간의 관계를 확인 하려면 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)

현재 인스턴스와 지정된 개체의 값이 같은지를 나타내는 값을 반환합니다.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

매개 변수

obj
Object

비교할 개체입니다.The object to compare.

반환

obj 인수가 BigInteger 개체이고 값이 현재 BigInteger 인스턴스의 값과 같으면 true이고, 그렇지 않으면 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.

예제

다음 예에서는 병렬 ObjectBigInteger 배열을 정의 합니다.The following example defines parallel Object and BigInteger arrays. 한 배열의 각 요소는 두 번째 배열의 해당 요소와 같은 값을 갖습니다.Each element of one array has the same value as the corresponding element of the second array. 예제의 출력에 표시 된 것 처럼 BigInteger 배열의 인스턴스는 후자가 BigInteger이 고 값이 같은 경우에만 Object 배열의 인스턴스와 동일 하 게 간주 됩니다.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

설명

obj 인수가 BigInteger 값이 아닌 경우 메서드는 false를 반환 합니다.If the obj argument is not a BigInteger value, the method returns false. 이 메서드는 obj가 값이 현재 인스턴스와 같은 BigInteger 인스턴스인 경우에만 true을 반환 합니다.The method returns true only if obj is a BigInteger instance whose value is equal to the current instance.

같음 여부를 테스트 하는 대신 두 개체 간의 관계를 확인 하려면 CompareTo(Object) 메서드를 호출 합니다.To determine the relationship between the two objects instead of just testing for equality, call the CompareTo(Object) method.

Equals(UInt64)

중요

이 API는 CLS 규격이 아닙니다.

현재 인스턴스와 부호 없는 64비트 정수의 값이 같은지를 나타내는 값을 반환합니다.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

매개 변수

other
UInt64

비교할 부호 없는 64비트 정수입니다.The unsigned 64-bit integer to compare.

반환

현재 인스턴스와 부호 없는 64비트 정수의 값이 같으면 true이고, 그렇지 않으면 false입니다.true if the current instance and the unsigned 64-bit integer have the same value; otherwise, false.

특성

예제

다음 예에서는 지구에서 몇 개의 별 근사 거리를 지구에서 엡실론의 거리와 비교 하 여 같은지 여부를 확인 합니다.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. 이 예제에서는 Equals 메서드의 각 오버 로드를 사용 하 여 같은지 테스트 합니다.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

설명

같음 여부를 테스트 하는 대신 두 개체 간의 관계를 확인 하려면 BigInteger.CompareTo(UInt64) 메서드를 호출 합니다.To determine the relationship between the two objects instead of just testing for equality, call the BigInteger.CompareTo(UInt64) method.

적용 대상