Sdílet prostřednictvím


BigInteger.Implicit Operátor

Definice

Definuje implicitní převod mezi objektem a jiným typem BigInteger .

Přetížení

Implicit(UInt16 to BigInteger)

Definuje implicitní převod 16bitového celého čísla bez znaménka BigInteger na hodnotu.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je Implicit(Int32 to BigInteger).

Implicit(UInt32 to BigInteger)

Definuje implicitní převod 32bitového celého čísla bez znaménka BigInteger na hodnotu.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je Implicit(Int64 to BigInteger).

Implicit(UInt128 to BigInteger)

Implicitně převede UInt128 hodnotu na velké celé číslo.

Implicit(UIntPtr to BigInteger)

Implicitně převede UIntPtr hodnotu na velké celé číslo.

Implicit(UInt64 to BigInteger)

Definuje implicitní převod 64bitového celého čísla bez znaménka BigInteger na hodnotu.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je Double.

Implicit(SByte to BigInteger)

Definuje implicitní převod 8bitového celého čísla se signoumm sadou BigInteger na hodnotu.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je BigInteger(Int32).

Implicit(Int128 to BigInteger)

Implicitně převede Int128 hodnotu na velké celé číslo.

Implicit(Int64 to BigInteger)

Definuje implicitní převod 64bitového 64bitového celého čísla na BigInteger hodnotu.

Implicit(Int32 to BigInteger)

Definuje implicitní převod 32bitového celého čísla se signedýmmm BigInteger hodnotou na hodnotu.

Implicit(Int16 to BigInteger)

Definuje implicitní převod 16bitového celého čísla se signoum sadou BigInteger na hodnotu.

Implicit(IntPtr to BigInteger)

Implicitně převede IntPtr hodnotu na velké celé číslo.

Implicit(Char to BigInteger)

Implicitně převede Char hodnotu na velké celé číslo.

Implicit(Byte to BigInteger)

Definuje implicitní převod bajtů bez znaménka BigInteger na hodnotu.

Implicit(UInt16 to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS
System.Numerics.BigInteger.Implicit(Int32 to BigInteger)

Definuje implicitní převod 16bitového celého čísla bez znaménka BigInteger na hodnotu.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je 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

Parametry

value
UInt16

Hodnota, která se má převést na BigInteger.

Návraty

Objekt, který obsahuje hodnotu parametru value .

Atributy

Poznámky

Pro jazyky, které nepodporují implicitní operátory, je BigInteger.BigInteger(UInt32)alternativní metoda .

Přetížení Implicit(Byte to BigInteger) metody definují typy, na které nebo ze kterých může kompilátor automaticky převést BigInteger hodnotu bez explicitního operátoru přetypování (v jazyce C#) nebo volání převodní funkce (v jazyce Visual Basic). Jedná se o rozšiřující převody, které nezahrnují ztrátu dat a nevyvolají OverflowExceptionvýjimku . Toto přetížení umožňuje kompilátoru zpracovávat převody z UInt16 hodnoty na BigInteger hodnotu, jak ukazuje následující příklad.

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

Platí pro

Implicit(UInt32 to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS
System.Numerics.BigInteger.Implicit(Int64 to BigInteger)

Definuje implicitní převod 32bitového celého čísla bez znaménka BigInteger na hodnotu.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je 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

Parametry

value
UInt32

Hodnota, která se má převést na BigInteger.

Návraty

Objekt, který obsahuje hodnotu parametru value .

Atributy

Poznámky

Pro jazyky, které nepodporují implicitní operátory, je BigInteger.BigInteger(UInt32)alternativní metoda .

Přetížení Implicit(Byte to BigInteger) metody definují typy, na které nebo ze kterých může kompilátor automaticky převést BigInteger hodnotu bez explicitního operátoru přetypování (v jazyce C#) nebo volání převodní funkce (v jazyce Visual Basic). Jedná se o rozšiřující převody, které nezahrnují ztrátu dat a nevyvolají OverflowExceptionvýjimku . Toto přetížení umožňuje kompilátoru zpracovávat převody z UInt32 hodnoty na BigInteger hodnotu, jak ukazuje následující příklad.

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

Platí pro

Implicit(UInt128 to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Implicitně převede UInt128 hodnotu na velké celé číslo.

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

Parametry

value
UInt128

Hodnota, kterou chcete převést.

Návraty

value převedeno na velké celé číslo.

Atributy

Platí pro

Implicit(UIntPtr to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Implicitně převede UIntPtr hodnotu na velké celé číslo.

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

Parametry

value
UIntPtr

unativeint

Hodnota, kterou chcete převést.

Návraty

value převedeno na velké celé číslo.

Atributy

Platí pro

Implicit(UInt64 to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS
System.Double

Definuje implicitní převod 64bitového celého čísla bez znaménka BigInteger na hodnotu.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je 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

Parametry

value
UInt64

Hodnota, která se má převést na BigInteger.

Návraty

Objekt, který obsahuje hodnotu parametru value .

Atributy

Poznámky

Pro jazyky, které nepodporují implicitní operátory, je BigInteger.BigInteger(UInt64)alternativní metoda .

Přetížení Implicit(Byte to BigInteger) metody definují typy, na které nebo ze kterých může kompilátor automaticky převést BigInteger hodnotu bez explicitního operátoru přetypování (v jazyce C#) nebo volání převodní funkce (v jazyce Visual Basic). Jedná se o rozšiřující převody, které nezahrnují ztrátu dat a nevyvolají OverflowExceptionvýjimku . Toto přetížení umožňuje kompilátoru zpracovávat převody z UInt64 hodnoty na BigInteger hodnotu, jak ukazuje následující příklad.

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

Platí pro

Implicit(SByte to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Důležité

Toto rozhraní API neodpovídá specifikaci CLS.

Alternativa odpovídající specifikaci CLS
System.Numerics.BigInteger.BigInteger(Int32)

Definuje implicitní převod 8bitového celého čísla se signoumm sadou BigInteger na hodnotu.

Toto rozhraní API neodpovídá specifikaci CLS. Vyhovující alternativou je 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

Parametry

value
SByte

Hodnota, která se má převést na BigInteger.

Návraty

Objekt, který obsahuje hodnotu parametru value .

Atributy

Poznámky

Pro jazyky, které nepodporují implicitní operátory, je BigInteger.BigInteger(Int32)alternativní metoda .

Přetížení Implicit(Byte to BigInteger) metody definují typy, na které nebo ze kterých může kompilátor automaticky převést BigInteger hodnotu bez explicitního operátoru přetypování (v jazyce C#) nebo volání převodní funkce (v jazyce Visual Basic). Jedná se o rozšiřující převody, které nezahrnují ztrátu dat a nevyvolají OverflowExceptionvýjimku . Toto přetížení umožňuje kompilátoru zpracovávat převody z SByte hodnoty na BigInteger hodnotu, jak ukazuje následující příklad.

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

Platí pro

Implicit(Int128 to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Implicitně převede Int128 hodnotu na velké celé číslo.

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

Parametry

value
Int128

Hodnota, kterou chcete převést.

Návraty

value převedeno na velké celé číslo.

Platí pro

Implicit(Int64 to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Definuje implicitní převod 64bitového 64bitového celého čísla na BigInteger hodnotu.

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

Parametry

value
Int64

Hodnota, která se má převést na BigInteger.

Návraty

Objekt, který obsahuje hodnotu parametru value .

Poznámky

Pro jazyky, které nepodporují implicitní operátory, je BigInteger.BigInteger(Int64)alternativní metoda .

Přetížení Implicit(Byte to BigInteger) metody definují typy, na které nebo ze kterých může kompilátor automaticky převést BigInteger hodnotu bez explicitního operátoru přetypování (v jazyce C#) nebo volání převodní funkce (v jazyce Visual Basic). Jedná se o rozšiřující převody, které nezahrnují ztrátu dat a nevyvolají OverflowExceptionvýjimku . Toto přetížení umožňuje kompilátoru zpracovávat převody z Int64 hodnoty na BigInteger hodnotu, jak ukazuje následující příklad.

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

Platí pro

Implicit(Int32 to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Definuje implicitní převod 32bitového celého čísla se signedýmmm BigInteger hodnotou na hodnotu.

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

Parametry

value
Int32

Hodnota, která se má převést na BigInteger.

Návraty

Objekt, který obsahuje hodnotu parametru value .

Poznámky

Pro jazyky, které nepodporují implicitní operátory, je BigInteger.BigInteger(Int32)alternativní metoda .

Přetížení Implicit(Byte to BigInteger) metody definují typy, na které nebo ze kterých může kompilátor automaticky převést BigInteger hodnotu bez explicitního operátoru přetypování (v jazyce C#) nebo volání převodní funkce (v jazyce Visual Basic). Jedná se o rozšiřující převody, které nezahrnují ztrátu dat a nevyvolají OverflowExceptionvýjimku . Toto přetížení umožňuje kompilátoru zpracovávat převody z Int32 hodnoty na BigInteger hodnotu, jak ukazuje následující příklad.

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

Platí pro

Implicit(Int16 to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Definuje implicitní převod 16bitového celého čísla se signoum sadou BigInteger na hodnotu.

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

Parametry

value
Int16

Hodnota, která se má převést na BigInteger.

Návraty

Objekt, který obsahuje hodnotu parametru value .

Poznámky

Pro jazyky, které nepodporují implicitní operátory, je BigInteger.BigInteger(Int32)alternativní metoda .

Přetížení Implicit(Byte to BigInteger) metody definují typy, na které nebo ze kterých může kompilátor automaticky převést BigInteger hodnotu bez explicitního operátoru přetypování (v jazyce C#) nebo volání převodní funkce (v jazyce Visual Basic). Jedná se o rozšiřující převody, které nezahrnují ztrátu dat a nevyvolají OverflowExceptionvýjimku . Toto přetížení umožňuje kompilátoru zpracovávat převody z Int16 hodnoty na BigInteger hodnotu, jak ukazuje následující příklad.

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

Platí pro

Implicit(IntPtr to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Implicitně převede IntPtr hodnotu na velké celé číslo.

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

Parametry

value
IntPtr

nativeint

Hodnota, kterou chcete převést.

Návraty

value převedeno na velké celé číslo.

Platí pro

Implicit(Char to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Implicitně převede Char hodnotu na velké celé číslo.

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

Parametry

value
Char

Hodnota, kterou chcete převést.

Návraty

value převedeno na velké celé číslo.

Platí pro

Implicit(Byte to BigInteger)

Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs
Zdroj:
BigInteger.cs

Definuje implicitní převod bajtů bez znaménka BigInteger na hodnotu.

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

Parametry

value
Byte

Hodnota, která se má převést na BigInteger.

Návraty

Objekt, který obsahuje hodnotu parametru value .

Poznámky

Libovolná zlomková část parametru se před převodem value zkrátí.

Pro jazyky, které nepodporují implicitní operátory, je BigInteger.BigInteger(Int32)alternativní metoda .

Přetížení Implicit(Byte to BigInteger) metody definují typy, na které nebo ze kterých může kompilátor automaticky převést BigInteger hodnotu bez explicitního operátoru přetypování (v jazyce C#) nebo volání převodní funkce (v jazyce Visual Basic). Jedná se o rozšiřující převody, které nezahrnují ztrátu dat a nevyvolají OverflowExceptionvýjimku . Toto přetížení umožňuje kompilátoru zpracovávat převody z Byte hodnoty na BigInteger hodnotu, jak ukazuje následující příklad.

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

Platí pro