BigInteger.Implicit Operator

Definition

Namespace:: System.Numerics

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

Assemblys:: System.Numerics.dll, System.Runtime.Numerics.dll

Assembly:: System.Runtime.Numerics.dll

Assembly:: System.Numerics.dll

Assembly:: netstandard.dll

Wichtig

Einige Informationen beziehen sich auf Vorabversionen, die vor dem Release ggf. grundlegend überarbeitet werden. Microsoft übernimmt hinsichtlich der hier bereitgestellten Informationen keine Gewährleistungen, seien sie ausdrücklich oder konkludent.

Definiert eine implizite Konvertierung zwischen einem BigInteger Objekt und einem anderen Typ.

Überlädt

Name	Beschreibung
Implicit(UInt128 to BigInteger)	Wandelt implizit einen UInt128 Wert in eine große ganze Zahl um.
Implicit(UIntPtr to BigInteger)	Wandelt implizit einen UIntPtr Wert in eine große ganze Zahl um.
Implicit(UInt64 to BigInteger)	Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger Wert. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Double.
Implicit(UInt32 to BigInteger)	Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger Wert. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Implicit(Int64 to BigInteger).
Implicit(UInt16 to BigInteger)	Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger Wert. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist Implicit(Int32 to BigInteger).
Implicit(SByte to BigInteger)	Definiert eine implizite Konvertierung einer 8-Bit-ganzzahligen Vorzeichen in einen BigInteger Wert. Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist BigInteger(Int32).
Implicit(Int32 to BigInteger)	Definiert eine implizite Konvertierung einer signierten 32-Bit-Ganzzahl in einen BigInteger Wert.
Implicit(Int64 to BigInteger)	Definiert eine implizite Konvertierung einer signierten 64-Bit-Ganzzahl in einen BigInteger Wert.
Implicit(IntPtr to BigInteger)	Wandelt implizit einen IntPtr Wert in eine große ganze Zahl um.
Implicit(Int16 to BigInteger)	Definiert eine implizite Konvertierung einer signierten 16-Bit-Ganzzahl in einen BigInteger Wert.
Implicit(Int128 to BigInteger)	Wandelt implizit einen Int128 Wert in eine große ganze Zahl um.
Implicit(Char to BigInteger)	Wandelt implizit einen Char Wert in eine große ganze Zahl um.
Implicit(Byte to BigInteger)	Definiert eine implizite Konvertierung eines nicht signierten Bytes in einen BigInteger Wert.

Implicit(UInt128 to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Wandelt implizit einen UInt128 Wert in eine große ganze Zahl um.

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

Parameter

value: UInt128

Der zu konvertierende Wert.

Gibt zurück

BigInteger

value in eine große ganze Zahl konvertiert.

Attribute: CLSCompliantAttribute

Gilt für:

Implicit(UIntPtr to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

Wandelt implizit einen UIntPtr Wert in eine große ganze Zahl um.

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

Parameter

value: UIntPtr
unativeint

Der zu konvertierende Wert.

Gibt zurück

BigInteger

value in eine große ganze Zahl konvertiert.

Attribute: CLSCompliantAttribute

Gilt für:

Implicit(UInt64 to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Double

Definiert eine implizite Konvertierung einer 64-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger Wert.

Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist 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

Parameter

value: UInt64

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Attribute: CLSCompliantAttribute

Hinweise

Für Sprachen, die implizite Operatoren nicht unterstützen, lautet BigInteger.BigInteger(UInt64)die alternative Methode .

Die Überladungen der Implicit(Byte to BigInteger) Methode definieren die Typen, in die bzw. von denen ein Compiler automatisch einen BigInteger Wert ohne expliziten Umwandlungsoperator (in C#) oder einen Aufruf einer Konvertierungsfunktion (in Visual Basic) konvertieren kann. Sie erweitern Konvertierungen, die keinen Datenverlust beinhalten und keinen Auslösen eines OverflowException. Mit dieser Überladung kann der Compiler Konvertierungen von einem UInt64 Wert in einen BigInteger Wert verarbeiten, wie im folgenden Beispiel gezeigt.

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

Gilt für:

Implicit(UInt32 to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Numerics.BigInteger.Implicit(Int64 to BigInteger)

Definiert eine implizite Konvertierung einer 32-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger Wert.

Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist 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

Parameter

value: UInt32

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Attribute: CLSCompliantAttribute

Hinweise

Für Sprachen, die implizite Operatoren nicht unterstützen, lautet BigInteger.BigInteger(UInt32)die alternative Methode .

Die Überladungen der Implicit(Byte to BigInteger) Methode definieren die Typen, in die bzw. von denen ein Compiler automatisch einen BigInteger Wert ohne expliziten Umwandlungsoperator (in C#) oder einen Aufruf einer Konvertierungsfunktion (in Visual Basic) konvertieren kann. Sie erweitern Konvertierungen, die keinen Datenverlust beinhalten und keinen Auslösen eines OverflowException. Mit dieser Überladung kann der Compiler Konvertierungen von einem UInt32 Wert in einen BigInteger Wert verarbeiten, wie im folgenden Beispiel gezeigt.

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

Gilt für:

Implicit(UInt16 to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Numerics.BigInteger.Implicit(Int32 to BigInteger)

Definiert eine implizite Konvertierung einer 16-Bit-Ganzzahl ohne Vorzeichen in einen BigInteger Wert.

Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist 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

Parameter

value: UInt16

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Attribute: CLSCompliantAttribute

Hinweise

Für Sprachen, die implizite Operatoren nicht unterstützen, lautet BigInteger.BigInteger(UInt32)die alternative Methode .

Die Überladungen der Implicit(Byte to BigInteger) Methode definieren die Typen, in die bzw. von denen ein Compiler automatisch einen BigInteger Wert ohne expliziten Umwandlungsoperator (in C#) oder einen Aufruf einer Konvertierungsfunktion (in Visual Basic) konvertieren kann. Sie erweitern Konvertierungen, die keinen Datenverlust beinhalten und keinen Auslösen eines OverflowException. Mit dieser Überladung kann der Compiler Konvertierungen von einem UInt16 Wert in einen BigInteger Wert verarbeiten, wie im folgenden Beispiel gezeigt.

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

Gilt für:

Implicit(SByte to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wichtig

Diese API ist nicht CLS-kompatibel.

CLS-kompatible Alternative: System.Numerics.BigInteger.BigInteger(Int32)

Definiert eine implizite Konvertierung einer 8-Bit-ganzzahligen Vorzeichen in einen BigInteger Wert.

Diese API ist nicht CLS-kompatibel. Die kompatible Alternative ist 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

Parameter

value: SByte

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Attribute: CLSCompliantAttribute

Hinweise

Für Sprachen, die implizite Operatoren nicht unterstützen, lautet BigInteger.BigInteger(Int32)die alternative Methode .

Die Überladungen der Implicit(Byte to BigInteger) Methode definieren die Typen, in die bzw. von denen ein Compiler automatisch einen BigInteger Wert ohne expliziten Umwandlungsoperator (in C#) oder einen Aufruf einer Konvertierungsfunktion (in Visual Basic) konvertieren kann. Sie erweitern Konvertierungen, die keinen Datenverlust beinhalten und keinen Auslösen eines OverflowException. Mit dieser Überladung kann der Compiler Konvertierungen von einem SByte Wert in einen BigInteger Wert verarbeiten, wie im folgenden Beispiel gezeigt.

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

Gilt für:

Implicit(Int32 to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine implizite Konvertierung einer signierten 32-Bit-Ganzzahl in einen BigInteger Wert.

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

Parameter

value: Int32

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Hinweise

Für Sprachen, die implizite Operatoren nicht unterstützen, lautet BigInteger.BigInteger(Int32)die alternative Methode .

Die Überladungen der Implicit(Byte to BigInteger) Methode definieren die Typen, in die bzw. von denen ein Compiler automatisch einen BigInteger Wert ohne expliziten Umwandlungsoperator (in C#) oder einen Aufruf einer Konvertierungsfunktion (in Visual Basic) konvertieren kann. Sie erweitern Konvertierungen, die keinen Datenverlust beinhalten und keinen Auslösen eines OverflowException. Mit dieser Überladung kann der Compiler Konvertierungen von einem Int32 Wert in einen BigInteger Wert verarbeiten, wie im folgenden Beispiel gezeigt.

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

Gilt für:

Implicit(Int64 to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine implizite Konvertierung einer signierten 64-Bit-Ganzzahl in einen BigInteger Wert.

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

Parameter

value: Int64

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Hinweise

Für Sprachen, die implizite Operatoren nicht unterstützen, lautet BigInteger.BigInteger(Int64)die alternative Methode .

Die Überladungen der Implicit(Byte to BigInteger) Methode definieren die Typen, in die bzw. von denen ein Compiler automatisch einen BigInteger Wert ohne expliziten Umwandlungsoperator (in C#) oder einen Aufruf einer Konvertierungsfunktion (in Visual Basic) konvertieren kann. Sie erweitern Konvertierungen, die keinen Datenverlust beinhalten und keinen Auslösen eines OverflowException. Mit dieser Überladung kann der Compiler Konvertierungen von einem Int64 Wert in einen BigInteger Wert verarbeiten, wie im folgenden Beispiel gezeigt.

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

Gilt für:

Implicit(IntPtr to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wandelt implizit einen IntPtr Wert in eine große ganze Zahl um.

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

Parameter

value: IntPtr
nativeint

Der zu konvertierende Wert.

Gibt zurück

BigInteger

value in eine große ganze Zahl konvertiert.

Gilt für:

Implicit(Int16 to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine implizite Konvertierung einer signierten 16-Bit-Ganzzahl in einen BigInteger Wert.

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

Parameter

value: Int16

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Hinweise

Für Sprachen, die implizite Operatoren nicht unterstützen, lautet BigInteger.BigInteger(Int32)die alternative Methode .

Die Überladungen der Implicit(Byte to BigInteger) Methode definieren die Typen, in die bzw. von denen ein Compiler automatisch einen BigInteger Wert ohne expliziten Umwandlungsoperator (in C#) oder einen Aufruf einer Konvertierungsfunktion (in Visual Basic) konvertieren kann. Sie erweitern Konvertierungen, die keinen Datenverlust beinhalten und keinen Auslösen eines OverflowException. Mit dieser Überladung kann der Compiler Konvertierungen von einem Int16 Wert in einen BigInteger Wert verarbeiten, wie im folgenden Beispiel gezeigt.

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

Gilt für:

Implicit(Int128 to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wandelt implizit einen Int128 Wert in eine große ganze Zahl um.

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

Parameter

value: Int128

Der zu konvertierende Wert.

Gibt zurück

BigInteger

value in eine große ganze Zahl konvertiert.

Gilt für:

Implicit(Char to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Wandelt implizit einen Char Wert in eine große ganze Zahl um.

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

Parameter

value: Char

Der zu konvertierende Wert.

Gibt zurück

BigInteger

value in eine große ganze Zahl konvertiert.

Gilt für:

Implicit(Byte to BigInteger)

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Quelle:: BigInteger.cs

Definiert eine implizite Konvertierung eines nicht signierten Bytes in einen BigInteger Wert.

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

Parameter

value: Byte

Der Wert, der in ein BigInteger.

Gibt zurück

BigInteger

Ein Objekt, das den Wert des value Parameters enthält.

Hinweise

Jeder Bruchteil des value Parameters wird vor der Konvertierung abgeschnitten.

Für Sprachen, die implizite Operatoren nicht unterstützen, lautet BigInteger.BigInteger(Int32)die alternative Methode .

Die Überladungen der Implicit(Byte to BigInteger) Methode definieren die Typen, in die bzw. von denen ein Compiler automatisch einen BigInteger Wert ohne expliziten Umwandlungsoperator (in C#) oder einen Aufruf einer Konvertierungsfunktion (in Visual Basic) konvertieren kann. Sie erweitern Konvertierungen, die keinen Datenverlust beinhalten und keinen Auslösen eines OverflowException. Mit dieser Überladung kann der Compiler Konvertierungen von einem Byte Wert in einen BigInteger Wert verarbeiten, wie im folgenden Beispiel gezeigt.

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

Gilt für:

Feedback

War diese Seite hilfreich?

Teilen über

BigInteger.Implicit Operator

Definition

Überlädt

Implicit(UInt128 to BigInteger)

Parameter

Gibt zurück

Gilt für:

Implicit(UIntPtr to BigInteger)

Parameter

Gibt zurück

Gilt für:

Implicit(UInt64 to BigInteger)

Parameter

Gibt zurück

Hinweise

Gilt für:

Implicit(UInt32 to BigInteger)

Parameter

Gibt zurück

Hinweise

Gilt für:

Implicit(UInt16 to BigInteger)

Parameter

Gibt zurück

Hinweise

Gilt für:

Implicit(SByte to BigInteger)

Parameter

Gibt zurück

Hinweise

Gilt für:

Implicit(Int32 to BigInteger)

Parameter

Gibt zurück

Hinweise

Gilt für:

Implicit(Int64 to BigInteger)

Parameter

Gibt zurück

Hinweise

Gilt für:

Implicit(IntPtr to BigInteger)

Parameter

Gibt zurück

Gilt für:

Implicit(Int16 to BigInteger)

Parameter

Gibt zurück

Hinweise

Gilt für:

Implicit(Int128 to BigInteger)

Parameter

Gibt zurück

Gilt für:

Implicit(Char to BigInteger)

Parameter

Gibt zurück

Gilt für:

Implicit(Byte to BigInteger)

Parameter

Gibt zurück

Hinweise

Gilt für:

Feedback