BigInteger.Implicit Opérateur

Définition

Espace de noms:: System.Numerics

Assemblys:: netstandard.dll, System.Runtime.Numerics.dll

Assemblys:: System.Numerics.dll, System.Runtime.Numerics.dll

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Important

Certaines informations portent sur la préversion du produit qui est susceptible d’être en grande partie modifiée avant sa publication. Microsoft exclut toute garantie, expresse ou implicite, concernant les informations fournies ici.

Définit une conversion implicite entre un BigInteger objet et un autre type.

Surcharges

Nom	Description
Implicit(UInt128 to BigInteger)	Convertit implicitement une UInt128 valeur en entier volumineux.
Implicit(UIntPtr to BigInteger)	Convertit implicitement une UIntPtr valeur en entier volumineux.
Implicit(UInt64 to BigInteger)	Définit une conversion implicite d’un entier non signé 64 bits en valeur BigInteger . Cette API n’est pas conforme CLS. L’alternative conforme est Double.
Implicit(UInt32 to BigInteger)	Définit une conversion implicite d’un entier non signé 32 bits en valeur BigInteger . Cette API n’est pas conforme CLS. L’alternative conforme est Implicit(Int64 to BigInteger).
Implicit(UInt16 to BigInteger)	Définit une conversion implicite d’un entier non signé 16 bits en valeur BigInteger . Cette API n’est pas conforme CLS. L’alternative conforme est Implicit(Int32 to BigInteger).
Implicit(SByte to BigInteger)	Définit une conversion implicite d’un entier signé 8 bits en valeur BigInteger . Cette API n’est pas conforme CLS. L’alternative conforme est BigInteger(Int32).
Implicit(Int32 to BigInteger)	Définit une conversion implicite d’un entier 32 bits signé en valeur BigInteger .
Implicit(Int64 to BigInteger)	Définit une conversion implicite d’un entier 64 bits signé en valeur BigInteger .
Implicit(IntPtr to BigInteger)	Convertit implicitement une IntPtr valeur en entier volumineux.
Implicit(Int16 to BigInteger)	Définit une conversion implicite d’un entier 16 bits signé en valeur BigInteger .
Implicit(Int128 to BigInteger)	Convertit implicitement une Int128 valeur en entier volumineux.
Implicit(Char to BigInteger)	Convertit implicitement une Char valeur en entier volumineux.
Implicit(Byte to BigInteger)	Définit une conversion implicite d’un octet non signé en valeur BigInteger .

Implicit(UInt128 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Cette API n’est pas conforme CLS.

Convertit implicitement une UInt128 valeur en entier volumineux.

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ètres

value: UInt128

Valeur à convertir.

Retours

BigInteger

value converti en entier volumineux.

Attributs: CLSCompliantAttribute

S’applique à

Implicit(UIntPtr to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Cette API n’est pas conforme CLS.

Convertit implicitement une UIntPtr valeur en entier volumineux.

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ètres

value: UIntPtr
unativeint

Valeur à convertir.

Retours

BigInteger

value converti en entier volumineux.

Attributs: CLSCompliantAttribute

S’applique à

Implicit(UInt64 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS: System.Double

Définit une conversion implicite d’un entier non signé 64 bits en valeur BigInteger .

Cette API n’est pas conforme CLS. L’alternative conforme est 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ètres

value: UInt64

Valeur à convertir en BigInteger.

Retours

BigInteger

Objet qui contient la valeur du value paramètre.

Attributs: CLSCompliantAttribute

Remarques

Pour les langages qui ne prennent pas en charge les opérateurs implicites, la méthode alternative est BigInteger.BigInteger(UInt64).

Les surcharges de la Implicit(Byte to BigInteger) méthode définissent les types vers lesquels ou à partir desquels un compilateur peut convertir automatiquement une BigInteger valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Ils sont des conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas un OverflowException. Cette surcharge permet au compilateur de gérer les conversions d’une UInt64 valeur en valeur BigInteger , comme l’illustre l’exemple suivant.

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

S’applique à

Implicit(UInt32 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS: System.Numerics.BigInteger.Implicit(Int64 to BigInteger)

Définit une conversion implicite d’un entier non signé 32 bits en valeur BigInteger .

Cette API n’est pas conforme CLS. L’alternative conforme est 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ètres

value: UInt32

Valeur à convertir en BigInteger.

Retours

BigInteger

Objet qui contient la valeur du value paramètre.

Attributs: CLSCompliantAttribute

Remarques

Pour les langages qui ne prennent pas en charge les opérateurs implicites, la méthode alternative est BigInteger.BigInteger(UInt32).

Les surcharges de la Implicit(Byte to BigInteger) méthode définissent les types vers lesquels ou à partir desquels un compilateur peut convertir automatiquement une BigInteger valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Ils sont des conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas un OverflowException. Cette surcharge permet au compilateur de gérer les conversions d’une UInt32 valeur en valeur BigInteger , comme l’illustre l’exemple suivant.

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

S’applique à

Implicit(UInt16 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS: System.Numerics.BigInteger.Implicit(Int32 to BigInteger)

Définit une conversion implicite d’un entier non signé 16 bits en valeur BigInteger .

Cette API n’est pas conforme CLS. L’alternative conforme est 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ètres

value: UInt16

Valeur à convertir en BigInteger.

Retours

BigInteger

Objet qui contient la valeur du value paramètre.

Attributs: CLSCompliantAttribute

Remarques

Pour les langages qui ne prennent pas en charge les opérateurs implicites, la méthode alternative est BigInteger.BigInteger(UInt32).

Les surcharges de la Implicit(Byte to BigInteger) méthode définissent les types vers lesquels ou à partir desquels un compilateur peut convertir automatiquement une BigInteger valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Ils sont des conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas un OverflowException. Cette surcharge permet au compilateur de gérer les conversions d’une UInt16 valeur en valeur BigInteger , comme l’illustre l’exemple suivant.

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

S’applique à

Implicit(SByte to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Important

Cette API n’est pas conforme CLS.

Alternative à la conformité CLS: System.Numerics.BigInteger.BigInteger(Int32)

Définit une conversion implicite d’un entier signé 8 bits en valeur BigInteger .

Cette API n’est pas conforme CLS. L’alternative conforme est 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ètres

value: SByte

Valeur à convertir en BigInteger.

Retours

BigInteger

Objet qui contient la valeur du value paramètre.

Attributs: CLSCompliantAttribute

Remarques

Pour les langages qui ne prennent pas en charge les opérateurs implicites, la méthode alternative est BigInteger.BigInteger(Int32).

Les surcharges de la Implicit(Byte to BigInteger) méthode définissent les types vers lesquels ou à partir desquels un compilateur peut convertir automatiquement une BigInteger valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Ils sont des conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas un OverflowException. Cette surcharge permet au compilateur de gérer les conversions d’une SByte valeur en valeur BigInteger , comme l’illustre l’exemple suivant.

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

S’applique à

Implicit(Int32 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Définit une conversion implicite d’un entier 32 bits signé en valeur 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ètres

value: Int32

Valeur à convertir en BigInteger.

Retours

BigInteger

Objet qui contient la valeur du value paramètre.

Remarques

Pour les langages qui ne prennent pas en charge les opérateurs implicites, la méthode alternative est BigInteger.BigInteger(Int32).

Les surcharges de la Implicit(Byte to BigInteger) méthode définissent les types vers lesquels ou à partir desquels un compilateur peut convertir automatiquement une BigInteger valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Ils sont des conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas un OverflowException. Cette surcharge permet au compilateur de gérer les conversions d’une Int32 valeur en valeur BigInteger , comme l’illustre l’exemple suivant.

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

S’applique à

Implicit(Int64 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Définit une conversion implicite d’un entier 64 bits signé en valeur 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ètres

value: Int64

Valeur à convertir en BigInteger.

Retours

BigInteger

Objet qui contient la valeur du value paramètre.

Remarques

Pour les langages qui ne prennent pas en charge les opérateurs implicites, la méthode alternative est BigInteger.BigInteger(Int64).

Les surcharges de la Implicit(Byte to BigInteger) méthode définissent les types vers lesquels ou à partir desquels un compilateur peut convertir automatiquement une BigInteger valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Ils sont des conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas un OverflowException. Cette surcharge permet au compilateur de gérer les conversions d’une Int64 valeur en valeur BigInteger , comme l’illustre l’exemple suivant.

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

S’applique à

Implicit(IntPtr to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Convertit implicitement une IntPtr valeur en entier volumineux.

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ètres

value: IntPtr
nativeint

Valeur à convertir.

Retours

BigInteger

value converti en entier volumineux.

S’applique à

Implicit(Int16 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Définit une conversion implicite d’un entier 16 bits signé en valeur 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ètres

value: Int16

Valeur à convertir en BigInteger.

Retours

BigInteger

Objet qui contient la valeur du value paramètre.

Remarques

Pour les langages qui ne prennent pas en charge les opérateurs implicites, la méthode alternative est BigInteger.BigInteger(Int32).

Les surcharges de la Implicit(Byte to BigInteger) méthode définissent les types vers lesquels ou à partir desquels un compilateur peut convertir automatiquement une BigInteger valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Ils sont des conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas un OverflowException. Cette surcharge permet au compilateur de gérer les conversions d’une Int16 valeur en valeur BigInteger , comme l’illustre l’exemple suivant.

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

S’applique à

Implicit(Int128 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Convertit implicitement une Int128 valeur en entier volumineux.

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ètres

value: Int128

Valeur à convertir.

Retours

BigInteger

value converti en entier volumineux.

S’applique à

Implicit(Char to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Convertit implicitement une Char valeur en entier volumineux.

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ètres

value: Char

Valeur à convertir.

Retours

BigInteger

value converti en entier volumineux.

S’applique à

Implicit(Byte to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Définit une conversion implicite d’un octet non signé en valeur 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

Paramètres

value: Byte

Valeur à convertir en BigInteger.

Retours

BigInteger

Objet qui contient la valeur du value paramètre.

Remarques

Toute partie fractionnaire du value paramètre est tronquée avant la conversion.

Pour les langages qui ne prennent pas en charge les opérateurs implicites, la méthode alternative est BigInteger.BigInteger(Int32).

Les surcharges de la Implicit(Byte to BigInteger) méthode définissent les types vers lesquels ou à partir desquels un compilateur peut convertir automatiquement une BigInteger valeur sans opérateur de cast explicite (en C#) ou un appel à une fonction de conversion (en Visual Basic). Ils sont des conversions étendues qui n’impliquent pas de perte de données et ne lèvent pas un OverflowException. Cette surcharge permet au compilateur de gérer les conversions d’une Byte valeur en valeur BigInteger , comme l’illustre l’exemple suivant.

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

S’applique à

Rétroaction

Cette page a-t-elle été utile ?

Partager via

BigInteger.Implicit Opérateur

Définition

Surcharges

Implicit(UInt128 to BigInteger)

Paramètres

Retours

S’applique à

Implicit(UIntPtr to BigInteger)

Paramètres

Retours

S’applique à

Implicit(UInt64 to BigInteger)

Paramètres

Retours

Remarques

S’applique à

Implicit(UInt32 to BigInteger)

Paramètres

Retours

Remarques

S’applique à

Implicit(UInt16 to BigInteger)

Paramètres

Retours

Remarques

S’applique à

Implicit(SByte to BigInteger)

Paramètres

Retours

Remarques

S’applique à

Implicit(Int32 to BigInteger)

Paramètres

Retours

Remarques

S’applique à

Implicit(Int64 to BigInteger)

Paramètres

Retours

Remarques

S’applique à

Implicit(IntPtr to BigInteger)

Paramètres

Retours

S’applique à

Implicit(Int16 to BigInteger)

Paramètres

Retours

Remarques

S’applique à

Implicit(Int128 to BigInteger)

Paramètres

Retours

S’applique à

Implicit(Char to BigInteger)

Paramètres

Retours

S’applique à

Implicit(Byte to BigInteger)

Paramètres

Retours

Remarques

S’applique à

Rétroaction