BigInteger.Implicit Operatore

Definizione

Spazio dei nomi:

System.Numerics

Assembly:

System.Runtime.Numerics.dll

Definisce una conversione implicita tra un oggetto BigInteger e un altro tipo.

Overload

Implicit(UInt16 to BigInteger)	Definisce una conversione implicita di un Unsigned Integer a 16 bit in un valore BigInteger. Questa API non è conforme a CLS. L'alternativa conforme è Implicit(Int32 to BigInteger).
Implicit(UInt32 to BigInteger)	Definisce una conversione implicita di un intero senza segno a 32 bit in un valore BigInteger. Questa API non è conforme a CLS. L'alternativa conforme è Implicit(Int64 to BigInteger).
Implicit(UInt128 to BigInteger)	Converte in modo implicito un UInt128 valore in un numero intero grande.
Implicit(UIntPtr to BigInteger)	Converte in modo implicito un UIntPtr valore in un numero intero grande.
Implicit(UInt64 to BigInteger)	Definisce una conversione implicita di un intero senza segno a 64 bit in un valore BigInteger. Questa API non è conforme a CLS. L'alternativa conforme è Double.
Implicit(SByte to BigInteger)	Definisce una conversione implicita di un Signed Integer a 8 bit in un valore BigInteger. Questa API non è conforme a CLS. L'alternativa conforme è BigInteger(Int32).
Implicit(Int128 to BigInteger)	Converte in modo implicito un Int128 valore in un numero intero grande.
Implicit(Int64 to BigInteger)	Definisce una conversione implicita di un intero con segno a 64 bit in un valore BigInteger.
Implicit(Int32 to BigInteger)	Definisce una conversione implicita di un intero con segno a 32 bit in un valore BigInteger.
Implicit(Int16 to BigInteger)	Definisce una conversione implicita di un Signed Integer a 16 bit in un valore BigInteger.
Implicit(IntPtr to BigInteger)	Converte in modo implicito un IntPtr valore in un numero intero grande.
Implicit(Char to BigInteger)	Converte in modo implicito un Char valore in un numero intero grande.
Implicit(Byte to BigInteger)	Definisce una conversione implicita di un byte senza segno in un valore BigInteger.

Implicit(UInt16 to BigInteger)

Origine:

BigInteger.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

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

Definisce una conversione implicita di un Unsigned Integer a 16 bit in un valore BigInteger.

Questa API non è conforme a CLS. L'alternativa conforme è 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

Parametri

value

UInt16

Valore da convertire in un BigInteger.

Restituisce

BigInteger

Oggetto contenente il valore del parametro value.

Attributi

CLSCompliantAttribute

Commenti

Per i linguaggi che non supportano operatori impliciti, il metodo alternativo è BigInteger.BigInteger(UInt32).

Gli overload del Implicit(Byte to BigInteger) metodo definiscono i tipi in cui o da cui un compilatore può convertire automaticamente un BigInteger valore senza un operatore di cast esplicito (in C#) o una chiamata a una funzione di conversione (in Visual Basic). Si stanno ampliando le conversioni che non comportano la perdita di dati e non generano un'eccezione OverflowException. Questo overload consente al compilatore di gestire le conversioni da un UInt16 valore a un BigInteger valore, come illustrato nell'esempio seguente.

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(UInt32 to BigInteger)

Origine:

BigInteger.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

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

Definisce una conversione implicita di un intero senza segno a 32 bit in un valore BigInteger.

Questa API non è conforme a CLS. L'alternativa conforme è 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

Parametri

value

UInt32

Valore da convertire in un BigInteger.

Restituisce

BigInteger

Oggetto contenente il valore del parametro value.

Attributi

CLSCompliantAttribute

Commenti

Per i linguaggi che non supportano operatori impliciti, il metodo alternativo è BigInteger.BigInteger(UInt32).

Gli overload del Implicit(Byte to BigInteger) metodo definiscono i tipi in cui o da cui un compilatore può convertire automaticamente un BigInteger valore senza un operatore di cast esplicito (in C#) o una chiamata a una funzione di conversione (in Visual Basic). Si stanno ampliando le conversioni che non comportano la perdita di dati e non generano un'eccezione OverflowException. Questo overload consente al compilatore di gestire le conversioni da un UInt32 valore a un BigInteger valore, come illustrato nell'esempio seguente.

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(UInt128 to BigInteger)

Origine:

BigInteger.cs

Importante

Questa API non è conforme a CLS.

Converte in modo implicito un UInt128 valore in un numero intero grande.

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

Parametri

value

UInt128

Valore da convertire.

Restituisce

BigInteger

value convertito in un numero intero grande.

Attributi

CLSCompliantAttribute

Implicit(UIntPtr to BigInteger)

Origine:

BigInteger.cs

Importante

Questa API non è conforme a CLS.

Converte in modo implicito un UIntPtr valore in un numero intero grande.

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

Parametri

value

UIntPtr

unativeint

Valore da convertire.

Restituisce

BigInteger

value convertito in un numero intero grande.

Attributi

CLSCompliantAttribute

Implicit(UInt64 to BigInteger)

Origine:

BigInteger.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Double

Definisce una conversione implicita di un intero senza segno a 64 bit in un valore BigInteger.

Questa API non è conforme a CLS. L'alternativa conforme è 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

Parametri

value

UInt64

Valore da convertire in un BigInteger.

Restituisce

BigInteger

Oggetto contenente il valore del parametro value.

Attributi

CLSCompliantAttribute

Commenti

Per i linguaggi che non supportano operatori impliciti, il metodo alternativo è BigInteger.BigInteger(UInt64).

Gli overload del Implicit(Byte to BigInteger) metodo definiscono i tipi in cui o da cui un compilatore può convertire automaticamente un BigInteger valore senza un operatore di cast esplicito (in C#) o una chiamata a una funzione di conversione (in Visual Basic). Si stanno ampliando le conversioni che non comportano la perdita di dati e non generano un'eccezione OverflowException. Questo overload consente al compilatore di gestire le conversioni da un UInt64 valore a un BigInteger valore, come illustrato nell'esempio seguente.

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(SByte to BigInteger)

Origine:

BigInteger.cs

Importante

Questa API non è conforme a CLS.

Alternativa conforme a CLS

System.Numerics.BigInteger.BigInteger(Int32)

Definisce una conversione implicita di un Signed Integer a 8 bit in un valore BigInteger.

Questa API non è conforme a CLS. L'alternativa conforme è 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

Parametri

value

SByte

Valore da convertire in un BigInteger.

Restituisce

BigInteger

Oggetto contenente il valore del parametro value.

Attributi

CLSCompliantAttribute

Commenti

Per i linguaggi che non supportano operatori impliciti, il metodo alternativo è BigInteger.BigInteger(Int32).

Gli overload del Implicit(Byte to BigInteger) metodo definiscono i tipi in cui o da cui un compilatore può convertire automaticamente un BigInteger valore senza un operatore di cast esplicito (in C#) o una chiamata a una funzione di conversione (in Visual Basic). Si stanno ampliando le conversioni che non comportano la perdita di dati e non generano un'eccezione OverflowException. Questo overload consente al compilatore di gestire le conversioni da un SByte valore a un BigInteger valore, come illustrato nell'esempio seguente.

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(Int128 to BigInteger)

Origine:

BigInteger.cs

Converte in modo implicito un Int128 valore in un numero intero grande.

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

Parametri

value

Int128

Valore da convertire.

Restituisce

BigInteger

value convertito in un numero intero grande.

Implicit(Int64 to BigInteger)

Origine:

BigInteger.cs

Definisce una conversione implicita di un intero con segno a 64 bit in un valore 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

Parametri

value

Int64

Valore da convertire in un BigInteger.

Restituisce

BigInteger

Oggetto contenente il valore del parametro value.

Commenti

Per i linguaggi che non supportano operatori impliciti, il metodo alternativo è BigInteger.BigInteger(Int64).

Gli overload del Implicit(Byte to BigInteger) metodo definiscono i tipi in cui o da cui un compilatore può convertire automaticamente un BigInteger valore senza un operatore di cast esplicito (in C#) o una chiamata a una funzione di conversione (in Visual Basic). Si stanno ampliando le conversioni che non comportano la perdita di dati e non generano un'eccezione OverflowException. Questo overload consente al compilatore di gestire le conversioni da un Int64 valore a un BigInteger valore, come illustrato nell'esempio seguente.

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)

Origine:

BigInteger.cs

Definisce una conversione implicita di un intero con segno a 32 bit in un valore 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

Parametri

value

Int32

Valore da convertire in un BigInteger.

Restituisce

BigInteger

Oggetto contenente il valore del parametro value.

Commenti

Per i linguaggi che non supportano operatori impliciti, il metodo alternativo è BigInteger.BigInteger(Int32).

Gli overload del Implicit(Byte to BigInteger) metodo definiscono i tipi in cui o da cui un compilatore può convertire automaticamente un BigInteger valore senza un operatore di cast esplicito (in C#) o una chiamata a una funzione di conversione (in Visual Basic). Si stanno ampliando le conversioni che non comportano la perdita di dati e non generano un'eccezione OverflowException. Questo overload consente al compilatore di gestire le conversioni da un Int32 valore a un BigInteger valore, come illustrato nell'esempio seguente.

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)

Origine:

BigInteger.cs

Definisce una conversione implicita di un Signed Integer a 16 bit in un valore 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

Parametri

value

Int16

Valore da convertire in un BigInteger.

Restituisce

BigInteger

Oggetto contenente il valore del parametro value.

Commenti

Per i linguaggi che non supportano operatori impliciti, il metodo alternativo è BigInteger.BigInteger(Int32).

Gli overload del Implicit(Byte to BigInteger) metodo definiscono i tipi in cui o da cui un compilatore può convertire automaticamente un BigInteger valore senza un operatore di cast esplicito (in C#) o una chiamata a una funzione di conversione (in Visual Basic). Si stanno ampliando le conversioni che non comportano la perdita di dati e non generano un'eccezione OverflowException. Questo overload consente al compilatore di gestire le conversioni da un Int16 valore a un BigInteger valore, come illustrato nell'esempio seguente.

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(IntPtr to BigInteger)

Origine:

BigInteger.cs

Converte in modo implicito un IntPtr valore in un numero intero grande.

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

Parametri

value

IntPtr

nativeint

Valore da convertire.

Restituisce

BigInteger

value convertito in un numero intero grande.

Implicit(Char to BigInteger)

Origine:

BigInteger.cs

Converte in modo implicito un Char valore in un numero intero grande.

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

Parametri

value

Char

Valore da convertire.

Restituisce

BigInteger

value convertito in un numero intero grande.

Implicit(Byte to BigInteger)

Origine:

BigInteger.cs

Definisce una conversione implicita di un byte senza segno in un valore BigInteger.

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

Parametri

value

Byte

Valore da convertire in un BigInteger.

Restituisce

BigInteger

Oggetto contenente il valore del parametro value.

Commenti

Qualsiasi parte frazionaria del parametro viene troncata prima della value conversione.

Per i linguaggi che non supportano operatori impliciti, il metodo alternativo è BigInteger.BigInteger(Int32).

Gli overload del Implicit(Byte to BigInteger) metodo definiscono i tipi in cui o da cui un compilatore può convertire automaticamente un BigInteger valore senza un operatore di cast esplicito (in C#) o una chiamata a una funzione di conversione (in Visual Basic). Si stanno ampliando le conversioni che non comportano la perdita di dati e non generano un'eccezione OverflowException. Questo overload consente al compilatore di gestire le conversioni da un Byte valore a un BigInteger valore, come illustrato nell'esempio seguente.

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