BigInteger.Implicit Operatore
Definizione
Importante
Alcune informazioni sono relative alla release non definitiva del prodotto, che potrebbe subire modifiche significative prima della release definitiva. Microsoft non riconosce alcuna garanzia, espressa o implicita, in merito alle informazioni qui fornite.
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
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As UShort) As BigIntegerParametri
- value
- UInt16
Valore da convertire in un BigInteger.
Restituisce
Oggetto contenente il valore del parametro value.
- Attributi
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
Si applica a
Implicit(UInt32 to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As UInteger) As BigIntegerParametri
- value
- UInt32
Valore da convertire in un BigInteger.
Restituisce
Oggetto contenente il valore del parametro value.
- Attributi
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
Si applica a
Implicit(UInt128 to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As UInt128) As BigIntegerParametri
- value
- UInt128
Valore da convertire.
Restituisce
value convertito in un numero intero grande.
- Attributi
Si applica a
Implicit(UIntPtr to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As UIntPtr) As BigIntegerParametri
- value
-
UIntPtr
unativeint
Valore da convertire.
Restituisce
value convertito in un numero intero grande.
- Attributi
Si applica a
Implicit(UInt64 to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
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.BigIntegerPublic Shared Widening Operator CType (value As ULong) As BigIntegerParametri
- value
- UInt64
Valore da convertire in un BigInteger.
Restituisce
Oggetto contenente il valore del parametro value.
- Attributi
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
Si applica a
Implicit(SByte to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As SByte) As BigIntegerParametri
- value
- SByte
Valore da convertire in un BigInteger.
Restituisce
Oggetto contenente il valore del parametro value.
- Attributi
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
Si applica a
Implicit(Int128 to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As Int128) As BigIntegerParametri
- value
- Int128
Valore da convertire.
Restituisce
value convertito in un numero intero grande.
Si applica a
Implicit(Int64 to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As Long) As BigIntegerParametri
- value
- Int64
Valore da convertire in un BigInteger.
Restituisce
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
Si applica a
Implicit(Int32 to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As Integer) As BigIntegerParametri
- value
- Int32
Valore da convertire in un BigInteger.
Restituisce
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
Si applica a
Implicit(Int16 to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As Short) As BigIntegerParametri
- value
- Int16
Valore da convertire in un BigInteger.
Restituisce
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
Si applica a
Implicit(IntPtr to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As IntPtr) As BigIntegerParametri
- value
-
IntPtr
nativeint
Valore da convertire.
Restituisce
value convertito in un numero intero grande.
Si applica a
Implicit(Char to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As Char) As BigIntegerParametri
- value
- Char
Valore da convertire.
Restituisce
value convertito in un numero intero grande.
Si applica a
Implicit(Byte to BigInteger)
- Origine:
- BigInteger.cs
- Origine:
- BigInteger.cs
- 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.BigIntegerPublic Shared Widening Operator CType (value As Byte) As BigIntegerParametri
- value
- Byte
Valore da convertire in un BigInteger.
Restituisce
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
