BigInteger.Implicit Operator

public:
 static operator System::Numerics::BigInteger(System::UInt32 value);

[System.CLSCompliant(false)]
public static implicit operator System.Numerics.BigInteger(uint value);

[<System.CLSCompliant(false)>]
static member op_Implicit : uint32 -> System.Numerics.BigInteger

Public Shared Widening Operator CType (value As UInteger) As BigInteger

Parameters

Retouren

Een object dat de waarde van de value parameter bevat.

Kenmerken

CLSCompliantAttribute

Opmerkingen

Voor talen die geen impliciete operators ondersteunen, is BigInteger.BigInteger(UInt32)de alternatieve methode.

De overbelastingen van de methode Implicit(Byte to BigInteger) definiëren de typen waarnaar of van waaruit een compiler automatisch een BigInteger waarde kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen . Met deze overbelasting kan de compiler conversies van een UInt32 waarde naar een BigInteger waarde verwerken, zoals in het volgende voorbeeld wordt weergegeven.

uint uIntValue = 65000;
BigInteger number = uIntValue;
number = BigInteger.Multiply(number, uIntValue);
Console.WriteLine(number == uIntValue);           // Displays False

let uIntValue = 65000u
let number = BigInteger(uIntValue)
let mutable number = BigInteger.Multiply(number, uIntValue)
printfn $"{number = uIntValue}" // Displays "False

Dim uIntegerValue As UInteger = 65000
Dim number As BigInteger = uIntegerValue
number = BigInteger.Multiply(number, uIntegerValue)
Console.WriteLine(number = uIntegerValue)           ' Displays False

public:
 static operator System::Numerics::BigInteger(System::UInt16 value);

[System.CLSCompliant(false)]
public static implicit operator System.Numerics.BigInteger(ushort value);

[<System.CLSCompliant(false)>]
static member op_Implicit : uint16 -> System.Numerics.BigInteger

Public Shared Widening Operator CType (value As UShort) As BigInteger

Parameters

Retouren

Een object dat de waarde van de value parameter bevat.

Kenmerken

CLSCompliantAttribute

Opmerkingen

Voor talen die geen impliciete operators ondersteunen, is BigInteger.BigInteger(UInt32)de alternatieve methode.

De overbelastingen van de methode Implicit(Byte to BigInteger) definiëren de typen waarnaar of van waaruit een compiler automatisch een BigInteger waarde kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen . Met deze overbelasting kan de compiler conversies van een UInt16 waarde naar een BigInteger waarde verwerken, zoals in het volgende voorbeeld wordt weergegeven.

ushort uShortValue = 25064;
BigInteger number = uShortValue;
number += uShortValue;
Console.WriteLine(number < uShortValue);           // Displays False

let uShortValue = 25064us
let number = BigInteger(uShortValue)
let mutable number = BigInteger.Add(number, uShortValue)
printfn $"{number < uShortValue}" // Displays False

Dim uShortValue As UShort = 25064
Dim number As BigInteger = uShortValue
number += uShortValue
Console.WriteLine(number < uShortValue)           ' Displays False

public:
 static operator System::Numerics::BigInteger(System::SByte value);

[System.CLSCompliant(false)]
public static implicit operator System.Numerics.BigInteger(sbyte value);

[<System.CLSCompliant(false)>]
static member op_Implicit : sbyte -> System.Numerics.BigInteger

Public Shared Widening Operator CType (value As SByte) As BigInteger

Parameters

Retouren

Een object dat de waarde van de value parameter bevat.

Kenmerken

CLSCompliantAttribute

Opmerkingen

Voor talen die geen impliciete operators ondersteunen, is BigInteger.BigInteger(Int32)de alternatieve methode.

De overbelastingen van de methode Implicit(Byte to BigInteger) definiëren de typen waarnaar of van waaruit een compiler automatisch een BigInteger waarde kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen . Met deze overbelasting kan de compiler conversies van een SByte waarde naar een BigInteger waarde verwerken, zoals in het volgende voorbeeld wordt weergegeven.

sbyte sByteValue = -12;
BigInteger number = BigInteger.Pow(sByteValue, 3);
Console.WriteLine(number < sByteValue);            // Displays True

let sByteValue = -12y
let number = BigInteger.Pow(sByteValue, 3)
printfn $"{number < sByteValue}" // Displays True

Dim sByteValue As SByte = -12
Dim number As BigInteger = BigInteger.Pow(sByteValue, 3)
Console.WriteLine(number < sByteValue)  ' Displays True

public:
 static operator System::Numerics::BigInteger(System::UInt64 value);

[System.CLSCompliant(false)]
public static implicit operator System.Numerics.BigInteger(ulong value);

[<System.CLSCompliant(false)>]
static member op_Implicit : uint64 -> System.Numerics.BigInteger

Public Shared Widening Operator CType (value As ULong) As BigInteger

Parameters

Retouren

Een object dat de waarde van de value parameter bevat.

Kenmerken

CLSCompliantAttribute

Opmerkingen

Voor talen die geen impliciete operators ondersteunen, is BigInteger.BigInteger(UInt64)de alternatieve methode.

De overbelastingen van de methode Implicit(Byte to BigInteger) definiëren de typen waarnaar of van waaruit een compiler automatisch een BigInteger waarde kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen . Met deze overbelasting kan de compiler conversies van een UInt64 waarde naar een BigInteger waarde verwerken, zoals in het volgende voorbeeld wordt weergegeven.

ulong uLongValue = 1358754982;
BigInteger number = uLongValue;
number = number * 2 - uLongValue;
Console.WriteLine(number * uLongValue / uLongValue); // Displays 1358754982

let uLongValue = 1358754982UL
let number = BigInteger(uLongValue)
let mutable number = BigInteger.Add(number, uLongValue / 2UL |> bigint)
printfn $"{number * bigint uLongValue / bigint uLongValue}" // Displays 1358754982

Dim uLongValue As ULong = 1358754982
Dim number As BigInteger = uLongValue
number = number * 2 - uLongValue
Console.WriteLine(number * uLongValue / uLongValue)  ' Displays 1358754982

public:
 static operator System::Numerics::BigInteger(int value);

public static implicit operator System.Numerics.BigInteger(int value);

static member op_Implicit : int -> System.Numerics.BigInteger

Public Shared Widening Operator CType (value As Integer) As BigInteger

Parameters

Retouren

Een object dat de waarde van de value parameter bevat.

Opmerkingen

Voor talen die geen impliciete operators ondersteunen, is BigInteger.BigInteger(Int32)de alternatieve methode.

De overbelastingen van de methode Implicit(Byte to BigInteger) definiëren de typen waarnaar of van waaruit een compiler automatisch een BigInteger waarde kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen . Met deze overbelasting kan de compiler conversies van een Int32 waarde naar een BigInteger waarde verwerken, zoals in het volgende voorbeeld wordt weergegeven.

int intValue = 65000;
BigInteger number = intValue;
number = BigInteger.Multiply(number, intValue);
Console.WriteLine(number == intValue);            // Displays False

let intValue = 65000
let number = BigInteger(intValue)
let mutable number = BigInteger.Multiply(number, intValue)
printfn $"{number = intValue}" // Displays False

Dim integerValue As Integer = 65000
Dim number As BigInteger = integerValue
number = BigInteger.Multiply(number, integerValue)
Console.WriteLine(number = integerValue)           ' Displays False

public:
 static operator System::Numerics::BigInteger(short value);

public static implicit operator System.Numerics.BigInteger(short value);

static member op_Implicit : int16 -> System.Numerics.BigInteger

Public Shared Widening Operator CType (value As Short) As BigInteger

Parameters

Retouren

Een object dat de waarde van de value parameter bevat.

Opmerkingen

Voor talen die geen impliciete operators ondersteunen, is BigInteger.BigInteger(Int32)de alternatieve methode.

De overbelastingen van de methode Implicit(Byte to BigInteger) definiëren de typen waarnaar of van waaruit een compiler automatisch een BigInteger waarde kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen . Met deze overbelasting kan de compiler conversies van een Int16 waarde naar een BigInteger waarde verwerken, zoals in het volgende voorbeeld wordt weergegeven.

short shortValue = 25064;
BigInteger number = shortValue;
number += shortValue;
Console.WriteLine(number < shortValue);           // Displays False

let shortValue = 25064s
let number = BigInteger(shortValue)
let mutable number = BigInteger.Add(number, shortValue)
printfn $"{number > shortValue}" // Displays False

Dim shortValue As Short = 25064
Dim number As BigInteger = shortValue
number += shortValue
Console.WriteLine(number < shortValue)           ' Displays False

public:
 static operator System::Numerics::BigInteger(System::Byte value);

public static implicit operator System.Numerics.BigInteger(byte value);

static member op_Implicit : byte -> System.Numerics.BigInteger

Public Shared Widening Operator CType (value As Byte) As BigInteger

Parameters

Retouren

Een object dat de waarde van de value parameter bevat.

Opmerkingen

Een breukdeel van de value parameter wordt afgekapt vóór de conversie.

Voor talen die geen impliciete operators ondersteunen, is BigInteger.BigInteger(Int32)de alternatieve methode.

De overbelastingen van de methode Implicit(Byte to BigInteger) definiëren de typen waarnaar of van waaruit een compiler automatisch een BigInteger waarde kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen . Met deze overbelasting kan de compiler conversies van een Byte waarde naar een BigInteger waarde verwerken, zoals in het volgende voorbeeld wordt weergegeven.

byte byteValue = 254;
BigInteger number = byteValue;
number = BigInteger.Add(number, byteValue);
Console.WriteLine(number > byteValue);            // Displays True

let byteValue = 254uy
let number = BigInteger(byteValue)
let mutable number = BigInteger.Add(number, byteValue)
printfn $"{number > byteValue}" // Displays True

Dim byteValue As Byte = 254
Dim number As BigInteger = byteValue
number = BigInteger.Add(number, byteValue)
Console.WriteLine(number > byteValue)           ' Displays True

public:
 static operator System::Numerics::BigInteger(long value);

public static implicit operator System.Numerics.BigInteger(long value);

static member op_Implicit : int64 -> System.Numerics.BigInteger

Public Shared Widening Operator CType (value As Long) As BigInteger

Parameters

Retouren

Een object dat de waarde van de value parameter bevat.

Opmerkingen

Voor talen die geen impliciete operators ondersteunen, is BigInteger.BigInteger(Int64)de alternatieve methode.

De overbelastingen van de methode Implicit(Byte to BigInteger) definiëren de typen waarnaar of van waaruit een compiler automatisch een BigInteger waarde kan converteren zonder een expliciete cast-operator (in C#) of een aanroep naar een conversiefunctie (in Visual Basic). Ze zijn verbreed conversies die geen gegevensverlies met zich meebrengen en die OverflowExceptiongeen . Met deze overbelasting kan de compiler conversies van een Int64 waarde naar een BigInteger waarde verwerken, zoals in het volgende voorbeeld wordt weergegeven.

long longValue = 1358754982;
BigInteger number = longValue;
number = number + (longValue / 2);
Console.WriteLine(number * longValue / longValue); // Displays 2038132473

let longValue = 1358754982L
let number = BigInteger longValue
let mutable number = BigInteger.Add(number, longValue / 2L |> bigint)
printfn $"{((number * bigint longValue) / (bigint longValue))}" // Displays 2038132473

Dim longValue As Long = 1358754982
Dim number As BigInteger = longValue
number = number + (longValue \ 2)
Console.WriteLine(number * longValue / longValue)  ' Displays 2038132473