BigInteger.Implicit Operador

Definição

Espaço de Nomes:: System.Numerics

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

Assemblagens:: System.Numerics.dll, System.Runtime.Numerics.dll

Assemblagem:: System.Runtime.Numerics.dll

Assemblagem:: System.Numerics.dll

Assemblagem:: netstandard.dll

Importante

Algumas informações dizem respeito a um produto pré-lançado que pode ser substancialmente modificado antes de ser lançado. A Microsoft não faz garantias, de forma expressa ou implícita, em relação à informação aqui apresentada.

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

Sobrecargas

Name	Description
Implicit(UInt128 to BigInteger)	Implicitamente converte um UInt128 valor num inteiro grande.
Implicit(UIntPtr to BigInteger)	Implicitamente converte um UIntPtr valor num inteiro grande.
Implicit(UInt64 to BigInteger)	Define uma conversão implícita de um inteiro sem sinal de 64 bits para um BigInteger valor. Esta API não está em conformidade com CLS. A alternativa conforme é Double.
Implicit(UInt32 to BigInteger)	Define uma conversão implícita de um inteiro sem sinal de 32 bits para um BigInteger valor. Esta API não está em conformidade com CLS. A alternativa conforme é Implicit(Int64 to BigInteger).
Implicit(UInt16 to BigInteger)	Define uma conversão implícita de um inteiro sem sinal de 16 bits para um BigInteger valor. Esta API não está em conformidade com CLS. A alternativa conforme é Implicit(Int32 to BigInteger).
Implicit(SByte to BigInteger)	Define uma conversão implícita de um inteiro com sinal de 8 bits num BigInteger valor. Esta API não está em conformidade com CLS. A alternativa conforme é BigInteger(Int32).
Implicit(Int64 to BigInteger)	Define uma conversão implícita de um inteiro assinado de 64 bits num BigInteger valor.
Implicit(Int32 to BigInteger)	Define uma conversão implícita de um inteiro de 32 bits assinados num BigInteger valor.
Implicit(Int16 to BigInteger)	Define uma conversão implícita de um inteiro assinado de 16 bits num BigInteger valor.
Implicit(Int128 to BigInteger)	Implicitamente converte um Int128 valor num inteiro grande.
Implicit(Char to BigInteger)	Implicitamente converte um Char valor num inteiro grande.
Implicit(Byte to BigInteger)	Define uma conversão implícita de um byte sem assinatura num BigInteger valor.
Implicit(IntPtr to BigInteger)	Implicitamente converte um IntPtr valor num inteiro grande.

Implicit(UInt128 to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Importante

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

Implicitamente converte um UInt128 valor num 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 converter.

Devoluções

BigInteger

value convertido num inteiro grande.

Atributos: CLSCompliantAttribute

Aplica-se a

Implicit(UIntPtr to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Importante

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

Implicitamente converte um UIntPtr valor num 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 converter.

Devoluções

BigInteger

value convertido num inteiro grande.

Atributos: CLSCompliantAttribute

Aplica-se a

Implicit(UInt64 to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

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 para um BigInteger valor.

Esta API não está em conformidade com CLS. A 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.BigInteger

Public Shared Widening Operator CType (value As ULong) As BigInteger

Parâmetros

value: UInt64

O valor a converter para um BigInteger.

Devoluções

BigInteger

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

Aplica-se a

Implicit(UInt32 to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

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 para um BigInteger valor.

Esta API não está em conformidade com CLS. A 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.BigInteger

Public Shared Widening Operator CType (value As UInteger) As BigInteger

Parâmetros

value: UInt32

O valor a converter para um BigInteger.

Devoluções

BigInteger

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

Aplica-se a

Implicit(UInt16 to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

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 para um BigInteger valor.

Esta API não está em conformidade com CLS. A 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.BigInteger

Public Shared Widening Operator CType (value As UShort) As BigInteger

Parâmetros

value: UInt16

O valor a converter para um BigInteger.

Devoluções

BigInteger

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

Aplica-se a

Implicit(SByte to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

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 num BigInteger valor.

Esta API não está em conformidade com CLS. A 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.BigInteger

Public Shared Widening Operator CType (value As SByte) As BigInteger

Parâmetros

value: SByte

O valor a converter para um BigInteger.

Devoluções

BigInteger

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

Aplica-se a

Implicit(Int64 to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Define uma conversão implícita de um inteiro assinado de 64 bits num BigInteger valor.

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 converter para um BigInteger.

Devoluções

BigInteger

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

Aplica-se a

Implicit(Int32 to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Define uma conversão implícita de um inteiro de 32 bits assinados num BigInteger valor.

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 converter para um BigInteger.

Devoluções

BigInteger

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

Aplica-se a

Implicit(Int16 to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Define uma conversão implícita de um inteiro assinado de 16 bits num BigInteger valor.

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 converter para um BigInteger.

Devoluções

BigInteger

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

Aplica-se a

Implicit(Int128 to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Implicitamente converte um Int128 valor num 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 converter.

Devoluções

BigInteger

value convertido num inteiro grande.

Aplica-se a

Implicit(Char to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Implicitamente converte um Char valor num 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 converter.

Devoluções

BigInteger

value convertido num inteiro grande.

Aplica-se a

Implicit(Byte to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Define uma conversão implícita de um byte sem assinatura num BigInteger valor.

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 converter para um BigInteger.

Devoluções

BigInteger

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

Aplica-se a

Implicit(IntPtr to BigInteger)

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Origem:: BigInteger.cs

Implicitamente converte um IntPtr valor num 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 converter.

Devoluções

BigInteger

value convertido num inteiro grande.

Aplica-se a

Comentários

Esta página foi útil?