BigInteger.Implicit Operador

Referencia

Definición

Espacio de nombres:: System.Numerics

Ensamblado:: System.Runtime.Numerics.dll

Ensamblado:: System.Numerics.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Define una conversión implícita entre un objeto BigInteger y otro tipo.

Sobrecargas

Implicit(UInt16 to BigInteger)	Define una conversión implícita de un entero de 16 bits sin signo en un valor BigInteger. Esta API no es conforme a CLS. La alternativa conforme es Implicit(Int32 to BigInteger).
Implicit(UInt32 to BigInteger)	Define una conversión implícita de un entero de 32 bits sin signo en un valor BigInteger. Esta API no es conforme a CLS. La alternativa conforme es Implicit(Int64 to BigInteger).
Implicit(UInt128 to BigInteger)	Convierte implícitamente un UInt128 valor en un entero grande.
Implicit(UIntPtr to BigInteger)	Convierte implícitamente un UIntPtr valor en un entero grande.
Implicit(UInt64 to BigInteger)	Define una conversión implícita de un entero de 64 bits sin signo en un valor BigInteger. Esta API no es conforme a CLS. La alternativa conforme es Double.
Implicit(SByte to BigInteger)	Define una conversión implícita de un entero de 8 bits con signo en un valor BigInteger. Esta API no es conforme a CLS. La alternativa conforme es BigInteger(Int32).
Implicit(Int128 to BigInteger)	Convierte implícitamente un Int128 valor en un entero grande.
Implicit(Int64 to BigInteger)	Define una conversión implícita de un entero de 64 bits con signo en un valor BigInteger.
Implicit(Int32 to BigInteger)	Define una conversión implícita de un entero de 32 bits con signo en un valor BigInteger.
Implicit(Int16 to BigInteger)	Define una conversión implícita de un entero de 16 bits con signo en un valor BigInteger.
Implicit(IntPtr to BigInteger)	Convierte implícitamente un IntPtr valor en un entero grande.
Implicit(Char to BigInteger)	Convierte implícitamente un Char valor en un entero grande.
Implicit(Byte to BigInteger)	Define una conversión implícita de un byte sin signo en un valor BigInteger.

Implicit(UInt16 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS: System.Numerics.BigInteger.Implicit(Int32 to BigInteger)

Define una conversión implícita de un entero de 16 bits sin signo en un valor BigInteger.

Esta API no es conforme a CLS. La alternativa conforme es 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

Parámetros

value: UInt16

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Atributos: CLSCompliantAttribute

Comentarios

En el caso de los lenguajes que no admiten operadores implícitos, el método alternativo es BigInteger.BigInteger(UInt32).

Las sobrecargas del Implicit(Byte to BigInteger) método definen los tipos a los que o desde los que un compilador puede convertir automáticamente un BigInteger valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowExceptionexcepción . Esta sobrecarga permite que el compilador controle las conversiones de un UInt16 valor a un BigInteger valor, como se muestra en el ejemplo siguiente.

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

Se aplica a

Implicit(UInt32 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS: System.Numerics.BigInteger.Implicit(Int64 to BigInteger)

Define una conversión implícita de un entero de 32 bits sin signo en un valor BigInteger.

Esta API no es conforme a CLS. La alternativa conforme es 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

Parámetros

value: UInt32

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Atributos: CLSCompliantAttribute

Comentarios

En el caso de los lenguajes que no admiten operadores implícitos, el método alternativo es BigInteger.BigInteger(UInt32).

Las sobrecargas del Implicit(Byte to BigInteger) método definen los tipos a los que o desde los que un compilador puede convertir automáticamente un BigInteger valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowExceptionexcepción . Esta sobrecarga permite que el compilador controle las conversiones de un UInt32 valor a un BigInteger valor, como se muestra en el ejemplo siguiente.

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

Se aplica a

Implicit(UInt128 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Importante

Esta API no es conforme a CLS.

Convierte implícitamente un UInt128 valor en un entero 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

Parámetros

value: UInt128

Valor que se va a convertir.

Devoluciones

BigInteger

value convertido en un entero grande.

Atributos: CLSCompliantAttribute

Se aplica a

Implicit(UIntPtr to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Importante

Esta API no es conforme a CLS.

Convierte implícitamente un UIntPtr valor en un entero 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

Parámetros

value: UIntPtr
unativeint

Valor que se va a convertir.

Devoluciones

BigInteger

value convertido en un entero grande.

Atributos: CLSCompliantAttribute

Se aplica a

Implicit(UInt64 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS: System.Double

Define una conversión implícita de un entero de 64 bits sin signo en un valor BigInteger.

Esta API no es conforme a CLS. La alternativa conforme es 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

Parámetros

value: UInt64

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Atributos: CLSCompliantAttribute

Comentarios

En el caso de los lenguajes que no admiten operadores implícitos, el método alternativo es BigInteger.BigInteger(UInt64).

Las sobrecargas del Implicit(Byte to BigInteger) método definen los tipos a los que o desde los que un compilador puede convertir automáticamente un BigInteger valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowExceptionexcepción . Esta sobrecarga permite que el compilador controle las conversiones de un UInt64 valor a un BigInteger valor, como se muestra en el ejemplo siguiente.

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

Se aplica a

Implicit(SByte to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Importante

Esta API no es conforme a CLS.

Alternativa conforme a CLS: System.Numerics.BigInteger.BigInteger(Int32)

Define una conversión implícita de un entero de 8 bits con signo en un valor BigInteger.

Esta API no es conforme a CLS. La alternativa conforme es 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

Parámetros

value: SByte

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Atributos: CLSCompliantAttribute

Comentarios

En el caso de los lenguajes que no admiten operadores implícitos, el método alternativo es BigInteger.BigInteger(Int32).

Las sobrecargas del Implicit(Byte to BigInteger) método definen los tipos a los que o desde los que un compilador puede convertir automáticamente un BigInteger valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowExceptionexcepción . Esta sobrecarga permite que el compilador controle las conversiones de un SByte valor a un BigInteger valor, como se muestra en el ejemplo siguiente.

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

Se aplica a

Implicit(Int128 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Convierte implícitamente un Int128 valor en un entero 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

Parámetros

value: Int128

Valor que se va a convertir.

Devoluciones

BigInteger

value convertido en un entero grande.

Se aplica a

Implicit(Int64 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Define una conversión implícita de un entero de 64 bits con signo en un valor 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

Parámetros

value: Int64

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Comentarios

En el caso de los lenguajes que no admiten operadores implícitos, el método alternativo es BigInteger.BigInteger(Int64).

Las sobrecargas del Implicit(Byte to BigInteger) método definen los tipos a los que o desde los que un compilador puede convertir automáticamente un BigInteger valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician una OverflowExceptionexcepción . Esta sobrecarga permite que el compilador controle las conversiones de un Int64 valor a un BigInteger valor, como se muestra en el ejemplo siguiente.

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

Se aplica a

Implicit(Int32 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Define una conversión implícita de un entero de 32 bits con signo en un valor 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

Parámetros

value: Int32

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Comentarios

En el caso de los lenguajes que no admiten operadores implícitos, el método alternativo es BigInteger.BigInteger(Int32).

Las sobrecargas del Implicit(Byte to BigInteger) método definen los tipos a los que o desde los cuales un compilador puede convertir automáticamente un BigInteger valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician .OverflowException Esta sobrecarga permite que el compilador controle las conversiones de un Int32 valor a un BigInteger valor, como se muestra en el ejemplo siguiente.

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

Se aplica a

Implicit(Int16 to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Define una conversión implícita de un entero de 16 bits con signo en un valor 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

Parámetros

value: Int16

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Comentarios

En el caso de los lenguajes que no admiten operadores implícitos, el método alternativo es BigInteger.BigInteger(Int32).

Las sobrecargas del Implicit(Byte to BigInteger) método definen los tipos a los que o desde los cuales un compilador puede convertir automáticamente un BigInteger valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician .OverflowException Esta sobrecarga permite que el compilador controle las conversiones de un Int16 valor a un BigInteger valor, como se muestra en el ejemplo siguiente.

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

Se aplica a

Implicit(IntPtr to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Convierte implícitamente un IntPtr valor en un entero 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

Parámetros

value: IntPtr
nativeint

Valor que se va a convertir.

Devoluciones

BigInteger

value convertido en un entero grande.

Se aplica a

Implicit(Char to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Convierte implícitamente un Char valor en un entero 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

Parámetros

value: Char

Valor que se va a convertir.

Devoluciones

BigInteger

value convertido en un entero grande.

Se aplica a

Implicit(Byte to BigInteger)

Source:: BigInteger.cs

Source:: BigInteger.cs

Source:: BigInteger.cs

Define una conversión implícita de un byte sin signo en un valor 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

Parámetros

value: Byte

Valor que se va a convertir en un tipo BigInteger.

Devoluciones

BigInteger

Objeto que contiene el valor del parámetro value.

Comentarios

Cualquier parte fraccionarcional del value parámetro se trunca antes de la conversión.

En el caso de los lenguajes que no admiten operadores implícitos, el método alternativo es BigInteger.BigInteger(Int32).

Las sobrecargas del Implicit(Byte to BigInteger) método definen los tipos a los que o desde los cuales un compilador puede convertir automáticamente un BigInteger valor sin un operador de conversión explícito (en C#) o una llamada a una función de conversión (en Visual Basic). Son conversiones de ampliación que no implican pérdida de datos y no inician .OverflowException Esta sobrecarga permite que el compilador controle las conversiones de un Byte valor a un BigInteger valor, como se muestra en el ejemplo siguiente.

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

Se aplica a

Compartir a través de

BigInteger.Implicit Operador

Definición

Sobrecargas

Implicit(UInt16 to BigInteger)

Parámetros

Devoluciones

Comentarios

Se aplica a

Implicit(UInt32 to BigInteger)

Parámetros

Devoluciones

Comentarios

Se aplica a

Implicit(UInt128 to BigInteger)

Parámetros

Devoluciones

Se aplica a

Implicit(UIntPtr to BigInteger)

Parámetros

Devoluciones

Se aplica a

Implicit(UInt64 to BigInteger)

Parámetros

Devoluciones

Comentarios

Se aplica a

Implicit(SByte to BigInteger)

Parámetros

Devoluciones

Comentarios

Se aplica a

Implicit(Int128 to BigInteger)

Parámetros

Devoluciones

Se aplica a

Implicit(Int64 to BigInteger)

Parámetros

Devoluciones

Comentarios

Se aplica a

Implicit(Int32 to BigInteger)

Parámetros

Devoluciones

Comentarios

Se aplica a

Implicit(Int16 to BigInteger)

Parámetros

Devoluciones

Comentarios

Se aplica a

Implicit(IntPtr to BigInteger)

Parámetros

Devoluciones

Se aplica a

Implicit(Char to BigInteger)

Parámetros

Devoluciones

Se aplica a

Implicit(Byte to BigInteger)

Parámetros

Devoluciones

Comentarios

Se aplica a

Recursos adicionales