BigInteger.Implicit Operátor

Definíció

Névtér:

System.Numerics

Szerelvények:

netstandard.dll, System.Runtime.Numerics.dll

Implicit átalakítást határoz meg egy objektum és egy BigInteger másik típus között.

Túlterhelések

Name	Description
Implicit(UInt128 to BigInteger)	Implicit módon konvertál egy UInt128 értéket nagy egész számmá.
Implicit(UIntPtr to BigInteger)	Implicit módon konvertál egy UIntPtr értéket nagy egész számmá.
Implicit(UInt64 to BigInteger)	Egy 64 bites aláíratlan egész szám implicit konvertálását határozza meg értékké BigInteger . Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Double
Implicit(UInt32 to BigInteger)	Egy 32 bites aláíratlan egész szám implicit konvertálását határozza meg értékké BigInteger . Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Implicit(Int64 to BigInteger)
Implicit(UInt16 to BigInteger)	Egy 16 bites aláíratlan egész szám implicit konvertálását határozza meg egy BigInteger értékre. Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Implicit(Int32 to BigInteger)
Implicit(SByte to BigInteger)	Egy 8 bites aláírt egész szám implicit konvertálását határozza meg értékké BigInteger . Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .BigInteger(Int32)
Implicit(IntPtr to BigInteger)	Implicit módon konvertál egy IntPtr értéket nagy egész számmá.
Implicit(Int64 to BigInteger)	Egy aláírt 64 bites egész szám implicit konvertálását határozza meg értékké BigInteger .
Implicit(Int32 to BigInteger)	Egy aláírt 32 bites egész szám implicit konvertálását határozza meg értékké BigInteger .
Implicit(Int16 to BigInteger)	Egy aláírt 16 bites egész szám implicit konvertálását határozza meg értékké BigInteger .
Implicit(Int128 to BigInteger)	Implicit módon konvertál egy Int128 értéket nagy egész számmá.
Implicit(Char to BigInteger)	Implicit módon konvertál egy Char értéket nagy egész számmá.
Implicit(Byte to BigInteger)	Egy aláíratlan bájt implicit konvertálását határozza meg egy BigInteger értékké.

Implicit(UInt128 to BigInteger)

Forrás:

BigInteger.cs

Fontos

Ez az API nem CLS-kompatibilis.

Implicit módon konvertál egy UInt128 értéket nagy egész számmá.

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

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

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

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

Paraméterek

value

UInt128

Az átalakítandó érték.

Válaszok

BigInteger

value nagy egész számmá konvertálva.

Attribútumok

CLSCompliantAttribute

Implicit(UIntPtr to BigInteger)

Forrás:

BigInteger.cs

Fontos

Ez az API nem CLS-kompatibilis.

Implicit módon konvertál egy UIntPtr értéket nagy egész számmá.

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

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

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

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

Paraméterek

value

UIntPtr

unativeint

Az átalakítandó érték.

Válaszok

BigInteger

value nagy egész számmá konvertálva.

Attribútumok

CLSCompliantAttribute

Implicit(UInt64 to BigInteger)

Forrás:

BigInteger.cs

Fontos

Ez az API nem CLS-kompatibilis.

CLS-kompatibilis alternatíva

System.Double

Egy 64 bites aláíratlan egész szám implicit konvertálását határozza meg értékké BigInteger .

Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Double

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

Paraméterek

value

UInt64

Az átalakítandó BigIntegerérték.

Válaszok

BigInteger

A paraméter értékét value tartalmazó objektum.

Attribútumok

CLSCompliantAttribute

Megjegyzések

Az implicit operátorokat nem támogató nyelvek esetében a másik módszer a BigInteger.BigInteger(UInt64).

A Implicit(Byte to BigInteger) metódus túlterhelései határozzák meg azokat a típusokat, amelyekbe a fordító automatikusan átalakíthat BigInteger értéket explicit öntési operátor (C#-ban) vagy konverziós függvény hívása nélkül (Visual Basic). Olyan átalakításokat szélesítenek, amelyek nem járnak adatvesztéssel, és nem adnak ki OverflowException. Ez a túlterhelés lehetővé teszi, hogy a fordító kezelje az értékről UInt64 értékre BigInteger történő átalakításokat, ahogyan az az alábbi példában is látható.

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

Implicit(UInt32 to BigInteger)

Forrás:

BigInteger.cs

Fontos

Ez az API nem CLS-kompatibilis.

CLS-kompatibilis alternatíva

System.Numerics.BigInteger.Implicit(Int64 to BigInteger)

Egy 32 bites aláíratlan egész szám implicit konvertálását határozza meg értékké BigInteger .

Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Implicit(Int64 to BigInteger)

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

Paraméterek

value

UInt32

Az átalakítandó BigIntegerérték.

Válaszok

BigInteger

A paraméter értékét value tartalmazó objektum.

Attribútumok

CLSCompliantAttribute

Megjegyzések

Az implicit operátorokat nem támogató nyelvek esetében a másik módszer a BigInteger.BigInteger(UInt32).

A Implicit(Byte to BigInteger) metódus túlterhelései határozzák meg azokat a típusokat, amelyekbe a fordító automatikusan átalakíthat BigInteger értéket explicit öntési operátor (C#-ban) vagy konverziós függvény hívása nélkül (Visual Basic). Olyan átalakításokat szélesítenek, amelyek nem járnak adatvesztéssel, és nem adnak ki OverflowException. Ez a túlterhelés lehetővé teszi, hogy a fordító kezelje az értékről UInt32 értékre BigInteger történő átalakításokat, ahogyan az az alábbi példában is látható.

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

Implicit(UInt16 to BigInteger)

Forrás:

BigInteger.cs

Fontos

Ez az API nem CLS-kompatibilis.

CLS-kompatibilis alternatíva

System.Numerics.BigInteger.Implicit(Int32 to BigInteger)

Egy 16 bites aláíratlan egész szám implicit konvertálását határozza meg egy BigInteger értékre.

Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .Implicit(Int32 to BigInteger)

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

Paraméterek

value

UInt16

Az átalakítandó BigIntegerérték.

Válaszok

BigInteger

A paraméter értékét value tartalmazó objektum.

Attribútumok

CLSCompliantAttribute

Megjegyzések

Az implicit operátorokat nem támogató nyelvek esetében a másik módszer a BigInteger.BigInteger(UInt32).

A Implicit(Byte to BigInteger) metódus túlterhelései határozzák meg azokat a típusokat, amelyekbe a fordító automatikusan átalakíthat BigInteger értéket explicit öntési operátor (C#-ban) vagy konverziós függvény hívása nélkül (Visual Basic). Olyan átalakításokat szélesítenek, amelyek nem járnak adatvesztéssel, és nem adnak ki OverflowException. Ez a túlterhelés lehetővé teszi, hogy a fordító kezelje az értékről UInt16 értékre BigInteger történő átalakításokat, ahogyan az az alábbi példában is látható.

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

Implicit(SByte to BigInteger)

Forrás:

BigInteger.cs

Fontos

Ez az API nem CLS-kompatibilis.

CLS-kompatibilis alternatíva

System.Numerics.BigInteger.BigInteger(Int32)

Egy 8 bites aláírt egész szám implicit konvertálását határozza meg értékké BigInteger .

Ez az API nem CLS-kompatibilis. A megfelelő alternatíva a .BigInteger(Int32)

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

Paraméterek

value

SByte

Az átalakítandó BigIntegerérték.

Válaszok

BigInteger

A paraméter értékét value tartalmazó objektum.

Attribútumok

CLSCompliantAttribute

Megjegyzések

Az implicit operátorokat nem támogató nyelvek esetében a másik módszer a BigInteger.BigInteger(Int32).

A Implicit(Byte to BigInteger) metódus túlterhelései határozzák meg azokat a típusokat, amelyekbe a fordító automatikusan átalakíthat BigInteger értéket explicit öntési operátor (C#-ban) vagy konverziós függvény hívása nélkül (Visual Basic). Olyan átalakításokat szélesítenek, amelyek nem járnak adatvesztéssel, és nem adnak ki OverflowException. Ez a túlterhelés lehetővé teszi, hogy a fordító kezelje az értékről SByte értékre BigInteger történő átalakításokat, ahogyan az az alábbi példában is látható.

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

Implicit(IntPtr to BigInteger)

Forrás:

BigInteger.cs

Implicit módon konvertál egy IntPtr értéket nagy egész számmá.

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

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

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

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

Paraméterek

value

IntPtr

nativeint

Az átalakítandó érték.

Válaszok

BigInteger

value nagy egész számmá konvertálva.

Implicit(Int64 to BigInteger)

Forrás:

BigInteger.cs

Egy aláírt 64 bites egész szám implicit konvertálását határozza meg értékké BigInteger .

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

Paraméterek

value

Int64

Az átalakítandó BigIntegerérték.

Válaszok

BigInteger

A paraméter értékét value tartalmazó objektum.

Megjegyzések

Az implicit operátorokat nem támogató nyelvek esetében a másik módszer a BigInteger.BigInteger(Int64).

A Implicit(Byte to BigInteger) metódus túlterhelései határozzák meg azokat a típusokat, amelyekbe a fordító automatikusan átalakíthat BigInteger értéket explicit öntési operátor (C#-ban) vagy konverziós függvény hívása nélkül (Visual Basic). Olyan átalakításokat szélesítenek, amelyek nem járnak adatvesztéssel, és nem adnak ki OverflowException. Ez a túlterhelés lehetővé teszi, hogy a fordító kezelje az értékről Int64 értékre BigInteger történő átalakításokat, ahogyan az az alábbi példában is látható.

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

Implicit(Int32 to BigInteger)

Forrás:

BigInteger.cs

Egy aláírt 32 bites egész szám implicit konvertálását határozza meg értékké BigInteger .

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

Paraméterek

value

Int32

Az átalakítandó BigIntegerérték.

Válaszok

BigInteger

A paraméter értékét value tartalmazó objektum.

Megjegyzések

Az implicit operátorokat nem támogató nyelvek esetében a másik módszer a BigInteger.BigInteger(Int32).

A Implicit(Byte to BigInteger) metódus túlterhelései határozzák meg azokat a típusokat, amelyekbe a fordító automatikusan átalakíthat BigInteger értéket explicit öntési operátor (C#-ban) vagy konverziós függvény hívása nélkül (Visual Basic). Olyan átalakításokat szélesítenek, amelyek nem járnak adatvesztéssel, és nem adnak ki OverflowException. Ez a túlterhelés lehetővé teszi, hogy a fordító kezelje az értékről Int32 értékre BigInteger történő átalakításokat, ahogyan az az alábbi példában is látható.

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

Implicit(Int16 to BigInteger)

Forrás:

BigInteger.cs

Egy aláírt 16 bites egész szám implicit konvertálását határozza meg értékké BigInteger .

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

Paraméterek

value

Int16

Az átalakítandó BigIntegerérték.

Válaszok

BigInteger

A paraméter értékét value tartalmazó objektum.

Megjegyzések

Az implicit operátorokat nem támogató nyelvek esetében a másik módszer a BigInteger.BigInteger(Int32).

A Implicit(Byte to BigInteger) metódus túlterhelései határozzák meg azokat a típusokat, amelyekbe a fordító automatikusan átalakíthat BigInteger értéket explicit öntési operátor (C#-ban) vagy konverziós függvény hívása nélkül (Visual Basic). Olyan átalakításokat szélesítenek, amelyek nem járnak adatvesztéssel, és nem adnak ki OverflowException. Ez a túlterhelés lehetővé teszi, hogy a fordító kezelje az értékről Int16 értékre BigInteger történő átalakításokat, ahogyan az az alábbi példában is látható.

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

Implicit(Int128 to BigInteger)

Forrás:

BigInteger.cs

Implicit módon konvertál egy Int128 értéket nagy egész számmá.

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

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

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

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

Paraméterek

value

Int128

Az átalakítandó érték.

Válaszok

BigInteger

value nagy egész számmá konvertálva.

Implicit(Char to BigInteger)

Forrás:

BigInteger.cs

Implicit módon konvertál egy Char értéket nagy egész számmá.

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

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

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

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

Paraméterek

value

Char

Az átalakítandó érték.

Válaszok

BigInteger

value nagy egész számmá konvertálva.

Implicit(Byte to BigInteger)

Forrás:

BigInteger.cs

Egy aláíratlan bájt implicit konvertálását határozza meg egy BigInteger értékké.

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

Paraméterek

value

Byte

Az átalakítandó BigIntegerérték.

Válaszok

BigInteger

A paraméter értékét value tartalmazó objektum.

Megjegyzések

A paraméter bármely törtrészét value csonkolja a konvertálás előtt.

Az implicit operátorokat nem támogató nyelvek esetében a másik módszer a BigInteger.BigInteger(Int32).

A Implicit(Byte to BigInteger) metódus túlterhelései határozzák meg azokat a típusokat, amelyekbe a fordító automatikusan átalakíthat BigInteger értéket explicit öntési operátor (C#-ban) vagy konverziós függvény hívása nélkül (Visual Basic). Olyan átalakításokat szélesítenek, amelyek nem járnak adatvesztéssel, és nem adnak ki OverflowException. Ez a túlterhelés lehetővé teszi, hogy a fordító kezelje az értékről Byte értékre BigInteger történő átalakításokat, ahogyan az az alábbi példában is látható.

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