BigInteger.Implicit Operator

Definition

Namnområde:: System.Numerics

Sammansättningar:: netstandard.dll, System.Runtime.Numerics.dll

Sammansättningar:: System.Numerics.dll, System.Runtime.Numerics.dll

Sammansättning:: System.Runtime.Numerics.dll

Sammansättning:: System.Numerics.dll

Sammansättning:: netstandard.dll

Viktigt

En del information gäller för förhandsversionen av en produkt och kan komma att ändras avsevärt innan produkten blir allmänt tillgänglig. Microsoft lämnar inga garantier, uttryckliga eller underförstådda, avseende informationen som visas här.

Definierar en implicit konvertering mellan ett BigInteger objekt och en annan typ.

Överlagringar

Name	Description
Implicit(UInt128 to BigInteger)	Konverterar implicit ett UInt128 värde till ett stort heltal.
Implicit(UIntPtr to BigInteger)	Konverterar implicit ett UIntPtr värde till ett stort heltal.
Implicit(UInt64 to BigInteger)	Definierar en implicit konvertering av ett 64-bitars osignerat heltal till ett BigInteger värde. Detta API uppfyller inte CLS. Det kompatibla alternativet är Double.
Implicit(UInt32 to BigInteger)	Definierar en implicit konvertering av ett 32-bitars osignerat heltal till ett BigInteger värde. Detta API uppfyller inte CLS. Det kompatibla alternativet är Implicit(Int64 to BigInteger).
Implicit(UInt16 to BigInteger)	Definierar en implicit konvertering av ett 16-bitars osignerat heltal till ett BigInteger värde. Detta API uppfyller inte CLS. Det kompatibla alternativet är Implicit(Int32 to BigInteger).
Implicit(SByte to BigInteger)	Definierar en implicit konvertering av ett 8-bitars signerat heltal till ett BigInteger värde. Detta API uppfyller inte CLS. Det kompatibla alternativet är BigInteger(Int32).
Implicit(Int64 to BigInteger)	Definierar en implicit konvertering av ett signerat 64-bitars heltal till ett BigInteger värde.
Implicit(Int32 to BigInteger)	Definierar en implicit konvertering av ett signerat 32-bitars heltal till ett BigInteger värde.
Implicit(Int16 to BigInteger)	Definierar en implicit konvertering av ett signerat 16-bitars heltal till ett BigInteger värde.
Implicit(Int128 to BigInteger)	Konverterar implicit ett Int128 värde till ett stort heltal.
Implicit(Char to BigInteger)	Konverterar implicit ett Char värde till ett stort heltal.
Implicit(Byte to BigInteger)	Definierar en implicit konvertering av en osignerad byte till ett BigInteger värde.
Implicit(IntPtr to BigInteger)	Konverterar implicit ett IntPtr värde till ett stort heltal.

Implicit(UInt128 to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Viktigt!

Detta API uppfyller inte CLS.

Konverterar implicit ett UInt128 värde till ett stort heltal.

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

Parametrar

value: UInt128

Värdet som ska konverteras.

Returer

BigInteger

value konverteras till ett stort heltal.

Attribut: CLSCompliantAttribute

Gäller för

Implicit(UIntPtr to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Viktigt!

Detta API uppfyller inte CLS.

Konverterar implicit ett UIntPtr värde till ett stort heltal.

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

Parametrar

value: UIntPtr
unativeint

Värdet som ska konverteras.

Returer

BigInteger

value konverteras till ett stort heltal.

Attribut: CLSCompliantAttribute

Gäller för

Implicit(UInt64 to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Viktigt!

Detta API uppfyller inte CLS.

Alternativ som uppfyller CLS: System.Double

Definierar en implicit konvertering av ett 64-bitars osignerat heltal till ett BigInteger värde.

Detta API uppfyller inte CLS. Det kompatibla alternativet är 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

Parametrar

value: UInt64

Värdet som ska konverteras till en BigInteger.

Returer

BigInteger

Ett objekt som innehåller värdet för parametern value .

Attribut: CLSCompliantAttribute

Kommentarer

För språk som inte stöder implicita operatorer är BigInteger.BigInteger(UInt64)den alternativa metoden .

Överlagringarna av metoden Implicit(Byte to BigInteger) definierar till vilka typer eller från vilka en kompilator automatiskt kan konvertera ett BigInteger-värde utan en explicit gjutningsoperator (i C#) eller ett anrop till en konverteringsfunktion (i Visual Basic). De utvidgar konverteringar som inte innebär dataförlust och inte genererar en OverflowException. Med den här överlagringen kan kompilatorn hantera konverteringar från ett UInt64 värde till ett BigInteger värde, vilket visas i följande exempel.

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

Gäller för

Implicit(UInt32 to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Viktigt!

Detta API uppfyller inte CLS.

Alternativ som uppfyller CLS: System.Numerics.BigInteger.Implicit(Int64 to BigInteger)

Definierar en implicit konvertering av ett 32-bitars osignerat heltal till ett BigInteger värde.

Detta API uppfyller inte CLS. Det kompatibla alternativet är 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

Parametrar

value: UInt32

Värdet som ska konverteras till en BigInteger.

Returer

BigInteger

Ett objekt som innehåller värdet för parametern value .

Attribut: CLSCompliantAttribute

Kommentarer

För språk som inte stöder implicita operatorer är BigInteger.BigInteger(UInt32)den alternativa metoden .

Överlagringarna av metoden Implicit(Byte to BigInteger) definierar till vilka typer eller från vilka en kompilator automatiskt kan konvertera ett BigInteger-värde utan en explicit gjutningsoperator (i C#) eller ett anrop till en konverteringsfunktion (i Visual Basic). De utvidgar konverteringar som inte innebär dataförlust och inte genererar en OverflowException. Med den här överlagringen kan kompilatorn hantera konverteringar från ett UInt32 värde till ett BigInteger värde, vilket visas i följande exempel.

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

Gäller för

Implicit(UInt16 to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Viktigt!

Detta API uppfyller inte CLS.

Alternativ som uppfyller CLS: System.Numerics.BigInteger.Implicit(Int32 to BigInteger)

Definierar en implicit konvertering av ett 16-bitars osignerat heltal till ett BigInteger värde.

Detta API uppfyller inte CLS. Det kompatibla alternativet är 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

Parametrar

value: UInt16

Värdet som ska konverteras till en BigInteger.

Returer

BigInteger

Ett objekt som innehåller värdet för parametern value .

Attribut: CLSCompliantAttribute

Kommentarer

För språk som inte stöder implicita operatorer är BigInteger.BigInteger(UInt32)den alternativa metoden .

Överlagringarna av metoden Implicit(Byte to BigInteger) definierar till vilka typer eller från vilka en kompilator automatiskt kan konvertera ett BigInteger-värde utan en explicit gjutningsoperator (i C#) eller ett anrop till en konverteringsfunktion (i Visual Basic). De utvidgar konverteringar som inte innebär dataförlust och inte genererar en OverflowException. Med den här överlagringen kan kompilatorn hantera konverteringar från ett UInt16 värde till ett BigInteger värde, vilket visas i följande exempel.

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

Gäller för

Implicit(SByte to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Viktigt!

Detta API uppfyller inte CLS.

Alternativ som uppfyller CLS: System.Numerics.BigInteger.BigInteger(Int32)

Definierar en implicit konvertering av ett 8-bitars signerat heltal till ett BigInteger värde.

Detta API uppfyller inte CLS. Det kompatibla alternativet är 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

Parametrar

value: SByte

Värdet som ska konverteras till en BigInteger.

Returer

BigInteger

Ett objekt som innehåller värdet för parametern value .

Attribut: CLSCompliantAttribute

Kommentarer

För språk som inte stöder implicita operatorer är BigInteger.BigInteger(Int32)den alternativa metoden .

Överlagringarna av metoden Implicit(Byte to BigInteger) definierar till vilka typer eller från vilka en kompilator automatiskt kan konvertera ett BigInteger-värde utan en explicit gjutningsoperator (i C#) eller ett anrop till en konverteringsfunktion (i Visual Basic). De utvidgar konverteringar som inte innebär dataförlust och inte genererar en OverflowException. Med den här överlagringen kan kompilatorn hantera konverteringar från ett SByte värde till ett BigInteger värde, vilket visas i följande exempel.

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

Gäller för

Implicit(Int64 to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Definierar en implicit konvertering av ett signerat 64-bitars heltal till ett BigInteger värde.

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

Parametrar

value: Int64

Värdet som ska konverteras till en BigInteger.

Returer

BigInteger

Ett objekt som innehåller värdet för parametern value .

Kommentarer

För språk som inte stöder implicita operatorer är BigInteger.BigInteger(Int64)den alternativa metoden .

Överlagringarna av metoden Implicit(Byte to BigInteger) definierar till vilka typer eller från vilka en kompilator automatiskt kan konvertera ett BigInteger-värde utan en explicit gjutningsoperator (i C#) eller ett anrop till en konverteringsfunktion (i Visual Basic). De utvidgar konverteringar som inte innebär dataförlust och inte genererar en OverflowException. Med den här överlagringen kan kompilatorn hantera konverteringar från ett Int64 värde till ett BigInteger värde, vilket visas i följande exempel.

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

Gäller för

Implicit(Int32 to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Definierar en implicit konvertering av ett signerat 32-bitars heltal till ett BigInteger värde.

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

Parametrar

value: Int32

Värdet som ska konverteras till en BigInteger.

Returer

BigInteger

Ett objekt som innehåller värdet för parametern value .

Kommentarer

För språk som inte stöder implicita operatorer är BigInteger.BigInteger(Int32)den alternativa metoden .

Överlagringarna av metoden Implicit(Byte to BigInteger) definierar till vilka typer eller från vilka en kompilator automatiskt kan konvertera ett BigInteger-värde utan en explicit gjutningsoperator (i C#) eller ett anrop till en konverteringsfunktion (i Visual Basic). De utvidgar konverteringar som inte innebär dataförlust och inte genererar en OverflowException. Med den här överlagringen kan kompilatorn hantera konverteringar från ett Int32 värde till ett BigInteger värde, vilket visas i följande exempel.

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

Gäller för

Implicit(Int16 to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Definierar en implicit konvertering av ett signerat 16-bitars heltal till ett BigInteger värde.

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

Parametrar

value: Int16

Värdet som ska konverteras till en BigInteger.

Returer

BigInteger

Ett objekt som innehåller värdet för parametern value .

Kommentarer

För språk som inte stöder implicita operatorer är BigInteger.BigInteger(Int32)den alternativa metoden .

Överlagringarna av metoden Implicit(Byte to BigInteger) definierar till vilka typer eller från vilka en kompilator automatiskt kan konvertera ett BigInteger-värde utan en explicit gjutningsoperator (i C#) eller ett anrop till en konverteringsfunktion (i Visual Basic). De utvidgar konverteringar som inte innebär dataförlust och inte genererar en OverflowException. Med den här överlagringen kan kompilatorn hantera konverteringar från ett Int16 värde till ett BigInteger värde, vilket visas i följande exempel.

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

Gäller för

Implicit(Int128 to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Konverterar implicit ett Int128 värde till ett stort heltal.

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

Parametrar

value: Int128

Värdet som ska konverteras.

Returer

BigInteger

value konverteras till ett stort heltal.

Gäller för

Implicit(Char to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Konverterar implicit ett Char värde till ett stort heltal.

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

Parametrar

value: Char

Värdet som ska konverteras.

Returer

BigInteger

value konverteras till ett stort heltal.

Gäller för

Implicit(Byte to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Definierar en implicit konvertering av en osignerad byte till ett BigInteger värde.

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

Parametrar

value: Byte

Värdet som ska konverteras till en BigInteger.

Returer

BigInteger

Ett objekt som innehåller värdet för parametern value .

Kommentarer

Valfri del av parametern value trunkeras före konverteringen.

För språk som inte stöder implicita operatorer är BigInteger.BigInteger(Int32)den alternativa metoden .

Överlagringarna av metoden Implicit(Byte to BigInteger) definierar till vilka typer eller från vilka en kompilator automatiskt kan konvertera ett BigInteger-värde utan en explicit gjutningsoperator (i C#) eller ett anrop till en konverteringsfunktion (i Visual Basic). De utvidgar konverteringar som inte innebär dataförlust och inte genererar en OverflowException. Med den här överlagringen kan kompilatorn hantera konverteringar från ett Byte värde till ett BigInteger värde, vilket visas i följande exempel.

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

Gäller för

Implicit(IntPtr to BigInteger)

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Källa:: BigInteger.cs

Konverterar implicit ett IntPtr värde till ett stort heltal.

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

Parametrar

value: IntPtr
nativeint

Värdet som ska konverteras.

Returer

BigInteger

value konverteras till ett stort heltal.

Gäller för

Feedback

Var den här sidan till hjälp?