BigInteger.Implicit Operador

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

Devoluções

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

Atributos

CLSCompliantAttribute

Observações

Para linguagens que não suportam operadores implícitos, o método alternativo é BigInteger.BigInteger(UInt32).

As sobrecargas do método Implicit(Byte to BigInteger) definem os tipos para os quais ou a partir dos quais um compilador pode converter automaticamente um valor BigInteger sem um operador de casting explícito (em C#) ou uma chamada a uma função de conversão (em Visual Basic). São conversões de alargamento que não envolvem perda de dados e não lançam um OverflowException. Esta sobrecarga permite ao compilador tratar de conversões de um UInt32 valor para um BigInteger valor, como mostra o exemplo seguinte.

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

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

Devoluções

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

Atributos

CLSCompliantAttribute

Observações

Para linguagens que não suportam operadores implícitos, o método alternativo é BigInteger.BigInteger(UInt32).

As sobrecargas do método Implicit(Byte to BigInteger) definem os tipos para os quais ou a partir dos quais um compilador pode converter automaticamente um valor BigInteger sem um operador de casting explícito (em C#) ou uma chamada a uma função de conversão (em Visual Basic). São conversões de alargamento que não envolvem perda de dados e não lançam um OverflowException. Esta sobrecarga permite ao compilador tratar de conversões de um UInt16 valor para um BigInteger valor, como mostra o exemplo seguinte.

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

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

Devoluções

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

Atributos

CLSCompliantAttribute

Observações

Para linguagens que não suportam operadores implícitos, o método alternativo é BigInteger.BigInteger(Int32).

As sobrecargas do método Implicit(Byte to BigInteger) definem os tipos para os quais ou a partir dos quais um compilador pode converter automaticamente um valor BigInteger sem um operador de casting explícito (em C#) ou uma chamada a uma função de conversão (em Visual Basic). São conversões de alargamento que não envolvem perda de dados e não lançam um OverflowException. Esta sobrecarga permite ao compilador tratar de conversões de um SByte valor para um BigInteger valor, como mostra o exemplo seguinte.

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

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

Devoluções

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

Atributos

CLSCompliantAttribute

Observações

Para linguagens que não suportam operadores implícitos, o método alternativo é BigInteger.BigInteger(UInt64).

As sobrecargas do método Implicit(Byte to BigInteger) definem os tipos para os quais ou a partir dos quais um compilador pode converter automaticamente um valor BigInteger sem um operador de casting explícito (em C#) ou uma chamada a uma função de conversão (em Visual Basic). São conversões de alargamento que não envolvem perda de dados e não lançam um OverflowException. Esta sobrecarga permite ao compilador tratar de conversões de um UInt64 valor para um BigInteger valor, como mostra o exemplo seguinte.

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

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

Devoluções

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

Observações

Para linguagens que não suportam operadores implícitos, o método alternativo é BigInteger.BigInteger(Int32).

As sobrecargas do método Implicit(Byte to BigInteger) definem os tipos para os quais ou a partir dos quais um compilador pode converter automaticamente um valor BigInteger sem um operador de casting explícito (em C#) ou uma chamada a uma função de conversão (em Visual Basic). São conversões de alargamento que não envolvem perda de dados e não lançam um OverflowException. Esta sobrecarga permite ao compilador tratar de conversões de um Int32 valor para um BigInteger valor, como mostra o exemplo seguinte.

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

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

Devoluções

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

Observações

Para linguagens que não suportam operadores implícitos, o método alternativo é BigInteger.BigInteger(Int32).

As sobrecargas do método Implicit(Byte to BigInteger) definem os tipos para os quais ou a partir dos quais um compilador pode converter automaticamente um valor BigInteger sem um operador de casting explícito (em C#) ou uma chamada a uma função de conversão (em Visual Basic). São conversões de alargamento que não envolvem perda de dados e não lançam um OverflowException. Esta sobrecarga permite ao compilador tratar de conversões de um Int16 valor para um BigInteger valor, como mostra o exemplo seguinte.

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

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

Devoluções

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

Observações

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

Para linguagens que não suportam operadores implícitos, o método alternativo é BigInteger.BigInteger(Int32).

As sobrecargas do método Implicit(Byte to BigInteger) definem os tipos para os quais ou a partir dos quais um compilador pode converter automaticamente um valor BigInteger sem um operador de casting explícito (em C#) ou uma chamada a uma função de conversão (em Visual Basic). São conversões de alargamento que não envolvem perda de dados e não lançam um OverflowException. Esta sobrecarga permite ao compilador tratar de conversões de um Byte valor para um BigInteger valor, como mostra o exemplo seguinte.

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

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

Devoluções

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

Observações

Para linguagens que não suportam operadores implícitos, o método alternativo é BigInteger.BigInteger(Int64).

As sobrecargas do método Implicit(Byte to BigInteger) definem os tipos para os quais ou a partir dos quais um compilador pode converter automaticamente um valor BigInteger sem um operador de casting explícito (em C#) ou uma chamada a uma função de conversão (em Visual Basic). São conversões de alargamento que não envolvem perda de dados e não lançam um OverflowException. Esta sobrecarga permite ao compilador tratar de conversões de um Int64 valor para um BigInteger valor, como mostra o exemplo seguinte.

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