BigInteger.Equals Methode

Referenz

Definition

Namespace:: System.Numerics

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Gibt einen Wert zurück, der angibt, ob zwei numerische Werte gleich sind.

Überlädt

Equals(UInt64)	Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine 64-Bit-Ganzzahl ohne Vorzeichen über den gleichen Wert verfügen.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes Objekt über den gleichen Wert verfügen.
Equals(BigInteger)	Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes BigInteger-Objekt über den gleichen Wert verfügen.
Equals(Int64)	Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine 64-Bit-Ganzzahl mit Vorzeichen über den gleichen Wert verfügen.

Equals(UInt64)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine 64-Bit-Ganzzahl ohne Vorzeichen über den gleichen Wert verfügen.

public:
 bool Equals(System::UInt64 other);

[System.CLSCompliant(false)]
public bool Equals (ulong other);

[<System.CLSCompliant(false)>]
override this.Equals : uint64 -> bool

Public Function Equals (other As ULong) As Boolean

Parameter

other: UInt64

Die 64-Bit-Ganzzahl ohne Vorzeichen für den Vergleich.

Gibt zurück

Boolean

true, wenn die aktuelle Instanz und die 64-Bit-Ganzzahl ohne Vorzeichen über den gleichen Wert verfügen, andernfalls false.

Attribute: CLSCompliantAttribute

Beispiele

Im folgenden Beispiel wird die ungefähre Entfernung mehrerer Sterne von der Erde mit der Entfernung von Epsilon Indi von der Erde verglichen, um zu bestimmen, ob sie gleich sind. Im Beispiel wird jede Überladung der Equals Methode verwendet, um auf Gleichheit zu testen.

#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

let LIGHT_YEAR = 5878625373183L

let altairDistance = 17I * bigint LIGHT_YEAR
let epsilonIndiDistance = 12I * bigint LIGHT_YEAR
let ursaeMajoris47Distance = 46I * bigint LIGHT_YEAR
let tauCetiDistance = 12L * LIGHT_YEAR
let procyon2Distance = 12uL * uint64 LIGHT_YEAR
let wolf424ABDistance = 14L * LIGHT_YEAR

printfn "Approx. equal distances from Epsilon Indi to:"
printfn $"   Altair: {epsilonIndiDistance.Equals(altairDistance)}"
printfn $"   Ursae Majoris 47: {epsilonIndiDistance.Equals(ursaeMajoris47Distance)}"
printfn $"   TauCeti: {epsilonIndiDistance.Equals(tauCetiDistance)}"
printfn $"   Procyon 2: {epsilonIndiDistance.Equals(procyon2Distance)}"
printfn $"   Wolf 424 AB: {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

Hinweise

Rufen Sie die -Methode auf, um die Beziehung zwischen den beiden Objekten zu bestimmen, BigInteger.CompareTo(UInt64) anstatt nur auf Gleichheit zu testen.

Gilt für:

Equals(Object)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes Objekt über den gleichen Wert verfügen.

public:
 override bool Equals(System::Object ^ obj);

public override bool Equals (object obj);

public override bool Equals (object? obj);

override this.Equals : obj -> bool

Public Overrides Function Equals (obj As Object) As Boolean

Parameter

obj: Object

Das zu vergleichende Objekt.

Gibt zurück

Boolean

true, wenn das obj-Argument ein BigInteger-Objekt darstellt und dessen Wert der aktuellen BigInteger-Instanz entspricht, andernfalls false.

Beispiele

Im folgenden Beispiel werden Parallele Object und BigInteger Arrays definiert. Jedes Element eines Arrays hat den gleichen Wert wie das entsprechende Element des zweiten Arrays. Wie die Ausgabe des Beispiels zeigt, wird die instance im BigInteger Array nur dann als gleich dem instance im Object Array angesehen, wenn letzteres ein BigInteger ist und ihre Werte gleich sind.

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

open System.Numerics

let obj: obj[] = [| 0; 10; 100; BigInteger 1000; -10 |]

let bi =
    [| BigInteger.Zero
       BigInteger 10
       BigInteger 100
       BigInteger 1000
       BigInteger -10 |]

for ctr = 0 to bi.Length - 1 do
    printfn $"{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

Hinweise

Wenn das obj Argument kein BigInteger Wert ist, gibt die -Methode zurück false. Die Methode gibt nur zurücktrue, wenn obj es sich um einen BigInteger instance handelt, dessen Wert dem aktuellen instance entspricht.

Rufen Sie die -Methode auf, um die Beziehung zwischen den beiden Objekten zu bestimmen, CompareTo(Object) anstatt nur auf Gleichheit zu testen.

Gilt für:

Equals(BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und ein angegebenes BigInteger-Objekt über den gleichen Wert verfügen.

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

Parameter

other: BigInteger

Das zu vergleichende Objekt.

Gibt zurück

Boolean

true, wenn dieses BigInteger-Objekt und other über den gleichen Wert verfügen, andernfalls false.

Implementiert

Equals(T)

Beispiele

#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

let LIGHT_YEAR = 5878625373183L

let altairDistance = 17I * bigint LIGHT_YEAR
let epsilonIndiDistance = 12I * bigint LIGHT_YEAR
let ursaeMajoris47Distance = 46I * bigint LIGHT_YEAR
let tauCetiDistance = 12L * LIGHT_YEAR
let procyon2Distance = 12uL * uint64 LIGHT_YEAR
let wolf424ABDistance = 14L * LIGHT_YEAR

printfn "Approx. equal distances from Epsilon Indi to:"
printfn $"   Altair: {epsilonIndiDistance.Equals(altairDistance)}"
printfn $"   Ursae Majoris 47: {epsilonIndiDistance.Equals(ursaeMajoris47Distance)}"
printfn $"   TauCeti: {epsilonIndiDistance.Equals(tauCetiDistance)}"
printfn $"   Procyon 2: {epsilonIndiDistance.Equals(procyon2Distance)}"
printfn $"   Wolf 424 AB: {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

Hinweise

Diese Methode implementiert die IEquatable<T> Schnittstelle und schneidet etwas besser ab, als Equals(Object) weil sie den other Parameter nicht in ein BigInteger Objekt konvertieren muss.

Rufen Sie die -Methode auf, um die Beziehung zwischen den beiden BigInteger Objekten zu bestimmen, BigInteger.CompareTo(BigInteger) anstatt nur auf Gleichheit zu testen.

Gilt für:

Equals(Int64)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Gibt einen Wert zurück, der angibt, ob die aktuelle Instanz und eine 64-Bit-Ganzzahl mit Vorzeichen über den gleichen Wert verfügen.

public:
 bool Equals(long other);

public bool Equals (long other);

override this.Equals : int64 -> bool

Public Function Equals (other As Long) As Boolean

Parameter

other: Int64

Der Wert der 64-Bit-Ganzzahl mit Vorzeichen für den Vergleich.

Gibt zurück

Boolean

true, wenn die 64-Bit-Ganzzahl mit Vorzeichen und die aktuelle Instanz über den gleichen Wert verfügen, andernfalls false.

Beispiele

Im folgenden Beispiel instanziiert ein BigInteger -Objekt aus jedem integralen Typ mit Ausnahme UInt64von . Anschließend wird die Equals(Int64) -Methode aufgerufen, um den Wert mit dem BigInteger ursprünglichen ganzzahligen Wert zu vergleichen, der an den BigInteger Konstruktor übergeben wurde. Wie die Ausgabe zeigt, sind die Werte jeweils gleich.

#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

let byteValue = 16uy
let bigIntValue = BigInteger byteValue

printfn
    $"{bigIntValue.GetType().Name} {bigIntValue} = {byteValue.GetType().Name} {byteValue} : {bigIntValue.Equals(byteValue)}"

let sbyteValue = -16y
let bigIntValue = BigInteger sbyteValue

printfn
    $"{bigIntValue.GetType().Name} {bigIntValue} = {sbyteValue.GetType().Name} {sbyteValue} : {bigIntValue.Equals(sbyteValue)}"

let shortValue = 1233s
let bigIntValue = BigInteger shortValue

printfn
    $"{bigIntValue.GetType().Name} {bigIntValue} = {shortValue.GetType().Name} {shortValue} : {bigIntValue.Equals(shortValue)}"

let ushortValue = 64000us
let bigIntValue = BigInteger ushortValue

printfn
    $"{bigIntValue.GetType().Name} {bigIntValue} = {ushortValue.GetType().Name} {ushortValue} : {bigIntValue.Equals(ushortValue)}"

let intValue = -1603854
let bigIntValue = BigInteger intValue

printfn
    $"{bigIntValue.GetType().Name} {bigIntValue} = {intValue.GetType().Name} {intValue} : {bigIntValue.Equals(intValue)}"

let uintValue = 1223300u
let bigIntValue = BigInteger uintValue

printfn
    $"{bigIntValue.GetType().Name} {bigIntValue} = {uintValue.GetType().Name} {uintValue} : {bigIntValue.Equals(uintValue)}"

let longValue = -123822229012L
let bigIntValue = BigInteger longValue

printfn
    $"{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

Hinweise

Wenn other es sich um einen ByteWert von , Int16, Int32, SByte, UInt16oder UInt32 handelt, wird er implizit in einen Int64 Wert konvertiert, wenn die Methode aufgerufen wird.

Rufen Sie die -Methode auf, um die Beziehung zwischen den beiden Objekten zu bestimmen, BigInteger.CompareTo(Int64) anstatt nur auf Gleichheit zu testen.

Gilt für:

Teilen über

BigInteger.Equals Methode

Definition

Überlädt

Equals(UInt64)

Parameter

Gibt zurück

Beispiele

Hinweise

Gilt für:

Equals(Object)

Parameter

Gibt zurück

Beispiele

Hinweise

Gilt für:

Equals(BigInteger)

Parameter

Gibt zurück

Implementiert

Beispiele

Hinweise

Gilt für:

Equals(Int64)

Parameter

Gibt zurück

Beispiele

Hinweise

Gilt für:

Zusätzliche Ressourcen