Compartilhar via


BigInteger.Implicit Operador

Definição

Define uma conversão implícita entre um objeto BigInteger e outro tipo.

Sobrecargas

Implicit(UInt16 to BigInteger)

Define uma conversão implícita de um inteiro sem sinal de 16 bits em um valor BigInteger.

Esta API não compatível com CLS. A alternativa em conformidade é Implicit(Int32 to BigInteger).

Implicit(UInt32 to BigInteger)

Define uma conversão implícita de um inteiro sem sinal de 32 bits em um valor BigInteger.

Esta API não compatível com CLS. A alternativa em conformidade é Implicit(Int64 to BigInteger).

Implicit(UInt128 to BigInteger)

Converte implicitamente um UInt128 valor em um inteiro grande.

Implicit(UIntPtr to BigInteger)

Converte implicitamente um UIntPtr valor em um inteiro grande.

Implicit(UInt64 to BigInteger)

Define uma conversão implícita de um inteiro sem sinal de 64 bits em um valor BigInteger.

Esta API não compatível com CLS. A alternativa em conformidade é Double.

Implicit(SByte to BigInteger)

Define uma conversão implícita de um inteiro com sinal de 8 bits em um valor BigInteger.

Esta API não compatível com CLS. A alternativa em conformidade é BigInteger(Int32).

Implicit(Int128 to BigInteger)

Converte implicitamente um Int128 valor em um inteiro grande.

Implicit(Int64 to BigInteger)

Define uma conversão implícita de um inteiro com sinal de 64 bits em um valor BigInteger.

Implicit(Int32 to BigInteger)

Define uma conversão implícita de um inteiro com sinal de 32 bits em um valor BigInteger.

Implicit(Int16 to BigInteger)

Define uma conversão implícita de um inteiro com sinal de 16 bits em um valor BigInteger.

Implicit(IntPtr to BigInteger)

Converte implicitamente um IntPtr valor em um inteiro grande.

Implicit(Char to BigInteger)

Converte implicitamente um Char valor em um inteiro grande.

Implicit(Byte to BigInteger)

Define uma conversão implícita de um byte sem sinal em um valor BigInteger.

Implicit(UInt16 to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS
System.Numerics.BigInteger.Implicit(Int32 to BigInteger)

Define uma conversão implícita de um inteiro sem sinal de 16 bits em um valor BigInteger.

Esta API não compatível com CLS. A alternativa em conformidade é 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

O valor a ser convertido para um BigInteger.

Retornos

Um objeto que contém o valor do parâmetro value.

Atributos

Comentários

Para idiomas que não dão suporte a operadores implícitos, o método alternativo é BigInteger.BigInteger(UInt32).

As sobrecargas do Implicit(Byte to BigInteger) método definem os tipos para os quais um compilador pode converter automaticamente um BigInteger valor sem um operador de conversão explícito (em C#) ou uma chamada para uma função de conversão (no Visual Basic). Elas estão ampliando conversões que não envolvem perda de dados e não lançam um OverflowException. Essa sobrecarga permite que o compilador manipule conversões de um UInt16 valor em um BigInteger valor, como mostra o exemplo a seguir.

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

Aplica-se a

Implicit(UInt32 to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS
System.Numerics.BigInteger.Implicit(Int64 to BigInteger)

Define uma conversão implícita de um inteiro sem sinal de 32 bits em um valor BigInteger.

Esta API não compatível com CLS. A alternativa em conformidade é 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

O valor a ser convertido para um BigInteger.

Retornos

Um objeto que contém o valor do parâmetro value.

Atributos

Comentários

Para idiomas que não dão suporte a operadores implícitos, o método alternativo é BigInteger.BigInteger(UInt32).

As sobrecargas do Implicit(Byte to BigInteger) método definem os tipos para os quais um compilador pode converter automaticamente um BigInteger valor sem um operador de conversão explícito (em C#) ou uma chamada para uma função de conversão (no Visual Basic). Elas estão ampliando conversões que não envolvem perda de dados e não lançam um OverflowException. Essa sobrecarga permite que o compilador manipule conversões de um UInt32 valor em um BigInteger valor, como mostra o exemplo a seguir.

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

Aplica-se a

Implicit(UInt128 to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Importante

Esta API não está em conformidade com CLS.

Converte implicitamente um UInt128 valor em um inteiro 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

O valor a ser convertido.

Retornos

value convertido em um inteiro grande.

Atributos

Aplica-se a

Implicit(UIntPtr to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Importante

Esta API não está em conformidade com CLS.

Converte implicitamente um UIntPtr valor em um inteiro 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

O valor a ser convertido.

Retornos

value convertido em um inteiro grande.

Atributos

Aplica-se a

Implicit(UInt64 to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS
System.Double

Define uma conversão implícita de um inteiro sem sinal de 64 bits em um valor BigInteger.

Esta API não compatível com CLS. A alternativa em conformidade é 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

O valor a ser convertido para um BigInteger.

Retornos

Um objeto que contém o valor do parâmetro value.

Atributos

Comentários

Para idiomas que não dão suporte a operadores implícitos, o método alternativo é BigInteger.BigInteger(UInt64).

As sobrecargas do Implicit(Byte to BigInteger) método definem os tipos para os quais um compilador pode converter automaticamente um BigInteger valor sem um operador de conversão explícito (em C#) ou uma chamada para uma função de conversão (no Visual Basic). Elas estão ampliando conversões que não envolvem perda de dados e não lançam um OverflowException. Essa sobrecarga permite que o compilador manipule conversões de um UInt64 valor em um BigInteger valor, como mostra o exemplo a seguir.

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

Aplica-se a

Implicit(SByte to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Importante

Esta API não está em conformidade com CLS.

Alternativa em conformidade com CLS
System.Numerics.BigInteger.BigInteger(Int32)

Define uma conversão implícita de um inteiro com sinal de 8 bits em um valor BigInteger.

Esta API não compatível com CLS. A alternativa em conformidade é 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

O valor a ser convertido para um BigInteger.

Retornos

Um objeto que contém o valor do parâmetro value.

Atributos

Comentários

Para idiomas que não dão suporte a operadores implícitos, o método alternativo é BigInteger.BigInteger(Int32).

As sobrecargas do Implicit(Byte to BigInteger) método definem os tipos para os quais um compilador pode converter automaticamente um BigInteger valor sem um operador de conversão explícito (em C#) ou uma chamada para uma função de conversão (no Visual Basic). Elas estão ampliando conversões que não envolvem perda de dados e não lançam um OverflowException. Essa sobrecarga permite que o compilador manipule conversões de um SByte valor em um BigInteger valor, como mostra o exemplo a seguir.

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

Aplica-se a

Implicit(Int128 to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Converte implicitamente um Int128 valor em um inteiro 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

O valor a ser convertido.

Retornos

value convertido em um inteiro grande.

Aplica-se a

Implicit(Int64 to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Define uma conversão implícita de um inteiro com sinal de 64 bits em um 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

O valor a ser convertido para um BigInteger.

Retornos

Um objeto que contém o valor do parâmetro value.

Comentários

Para idiomas que não dão suporte a operadores implícitos, o método alternativo é BigInteger.BigInteger(Int64).

As sobrecargas do Implicit(Byte to BigInteger) método definem os tipos para os quais um compilador pode converter automaticamente um BigInteger valor sem um operador de conversão explícito (em C#) ou uma chamada para uma função de conversão (no Visual Basic). Elas estão ampliando conversões que não envolvem perda de dados e não lançam um OverflowException. Essa sobrecarga permite que o compilador manipule conversões de um Int64 valor em um BigInteger valor, como mostra o exemplo a seguir.

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

Aplica-se a

Implicit(Int32 to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Define uma conversão implícita de um inteiro com sinal de 32 bits em um 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

O valor a ser convertido para um BigInteger.

Retornos

Um objeto que contém o valor do parâmetro value.

Comentários

Para idiomas que não dão suporte a operadores implícitos, o método alternativo é BigInteger.BigInteger(Int32).

As sobrecargas do Implicit(Byte to BigInteger) método definem os tipos para os quais um compilador pode converter automaticamente um BigInteger valor sem um operador de conversão explícito (em C#) ou uma chamada para uma função de conversão (no Visual Basic). Elas estão ampliando conversões que não envolvem perda de dados e não lançam um OverflowException. Essa sobrecarga permite que o compilador manipule conversões de um Int32 valor em um BigInteger valor, como mostra o exemplo a seguir.

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

Aplica-se a

Implicit(Int16 to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Define uma conversão implícita de um inteiro com sinal de 16 bits em um 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

O valor a ser convertido para um BigInteger.

Retornos

Um objeto que contém o valor do parâmetro value.

Comentários

Para idiomas que não dão suporte a operadores implícitos, o método alternativo é BigInteger.BigInteger(Int32).

As sobrecargas do Implicit(Byte to BigInteger) método definem os tipos para os quais um compilador pode converter automaticamente um BigInteger valor sem um operador de conversão explícito (em C#) ou uma chamada para uma função de conversão (no Visual Basic). Elas estão ampliando conversões que não envolvem perda de dados e não lançam um OverflowException. Essa sobrecarga permite que o compilador manipule conversões de um Int16 valor em um BigInteger valor, como mostra o exemplo a seguir.

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

Aplica-se a

Implicit(IntPtr to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Converte implicitamente um IntPtr valor em um inteiro 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

O valor a ser convertido.

Retornos

value convertido em um inteiro grande.

Aplica-se a

Implicit(Char to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Converte implicitamente um Char valor em um inteiro 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

O valor a ser convertido.

Retornos

value convertido em um inteiro grande.

Aplica-se a

Implicit(Byte to BigInteger)

Origem:
BigInteger.cs
Origem:
BigInteger.cs
Origem:
BigInteger.cs

Define uma conversão implícita de um byte sem sinal em um 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

O valor a ser convertido para um BigInteger.

Retornos

Um objeto que contém o valor do parâmetro value.

Comentários

Qualquer parte fracionária do value parâmetro é truncada antes da conversão.

Para idiomas que não dão suporte a operadores implícitos, o método alternativo é BigInteger.BigInteger(Int32).

As sobrecargas do Implicit(Byte to BigInteger) método definem os tipos para os quais um compilador pode converter automaticamente um BigInteger valor sem um operador de conversão explícito (em C#) ou uma chamada para uma função de conversão (no Visual Basic). Elas estão ampliando conversões que não envolvem perda de dados e não lançam um OverflowException. Essa sobrecarga permite que o compilador manipule conversões de um Byte valor em um BigInteger valor, como mostra o exemplo a seguir.

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

Aplica-se a