Int64 Struktur

Referenz

Definition

Namespace:: System

Assembly:: System.Runtime.dll

Assembly:: netstandard.dll

Assembly:: mscorlib.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.

Stellt eine 64-Bit-Ganzzahl mit Vorzeichen dar.

public value class long : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable

public value class long : IComparable, IComparable<long>, IConvertible, IEquatable<long>, ISpanFormattable

public value class long : IComparable, IConvertible, IFormattable

public value class long : IComparable, IComparable<long>, IEquatable<long>, IFormattable

public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable

public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, ISpanFormattable

[System.Serializable]
public struct Int64 : IComparable, IConvertible, IFormattable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable

public struct Int64 : IComparable, IComparable<long>, IEquatable<long>, IFormattable

type int64 = struct
    interface IConvertible
    interface IFormattable

type int64 = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable

[<System.Serializable>]
type int64 = struct
    interface IFormattable
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type int64 = struct
    interface IFormattable
    interface IConvertible

type int64 = struct
    interface IFormattable

Public Structure Int64
Implements IComparable, IComparable(Of Long), IConvertible, IEquatable(Of Long), IFormattable

Public Structure Int64
Implements IComparable, IComparable(Of Long), IConvertible, IEquatable(Of Long), ISpanFormattable

Public Structure Int64
Implements IComparable, IConvertible, IFormattable

Public Structure Int64
Implements IComparable, IComparable(Of Long), IEquatable(Of Long), IFormattable

Vererbung: Object

ValueType
Int64

Attribute: SerializableAttribute ComVisibleAttribute

Implementiert: IComparable IComparable<Int64> IConvertible IEquatable<Int64> IFormattable ISpanFormattable

Hinweise

Int64 ist ein unveränderbarer Werttyp, der ganze Zahlen mit Vorzeichen mit Werten darstellt, die von negativen 9.223.372.036.854.775.808 (dargestellt durch die Konstante) bis zu positiven Int64.MinValue 9.223.372.036.854.775.807 (dargestellt durch die Konstante) Int64.MaxValue reichen. Der .NET Framework enthält auch einen ganzzahligen 64-Bit-Werttyp ohne Vorzeichen, , der Werte zwischen 0 und UInt64 18.446.744.073.709.551.615 darstellt.

Instanziieren eines Int64-Werts

Sie können einen Wert auf Int64 verschiedene Weise instanziieren:

Sie können eine Variable deklarieren und ihr einen ganzzahligen Literalwert zuweisen, der innerhalb des Int64 Bereichs des Int64 Datentyps liegt. Im folgenden Beispiel werden zwei Int64 Variablen deklariert und auf diese Weise Werte zugewiesen.
```
long number1 = -64301728;
long number2 = 255486129307;
```
```
let number1 = -64301728L
let number2 = 255486129307L
```
```
Dim number1 As Long = -64301728
Dim number2 As Long = 255486129307
```

Sie können den Wert eines integralen Typs zuweisen, dessen Bereich eine Teilmenge des Typs Int64 ist. Dies ist eine sich ausweitende Konvertierung, die keinen Umwandlungsoperator in C# oder eine Konvertierungsmethode in Visual Basic. In F# kann nur Int32 der Typ automatisch verbreitert werden.

sbyte value1 = 124;
short value2 = 1618;
int value3 = Int32.MaxValue;

long number1 = value1;
long number2 = value2;
long number3 = value3;

let value1 = 124y
let value2 = 1618s
let value3 = Int32.MaxValue

let number1 = int64 value1
let number2 = int64 value2
let number3: int64 = value3

Dim value1 As SByte = 124
Dim value2 As Int16 = 1618
Dim value3 As Int32 = Int32.MaxValue

Dim number1 As Long = value1
Dim number2 As Long = value2
Dim number3 As Long = value3

Sie können den Wert eines numerischen Typs zuweisen, dessen Bereich den des Typs Int64 überschreitet. Dies ist eine schmale Konvertierung, daher erfordert sie einen Umwandlungsoperator in C# oder F# und eine Konvertierungsmethode in Visual Basic wenn Option Strict ein ist. Wenn der numerische Wert ein -, - oder -Wert ist, der eine Bruchkomponente enthält, hängt die Verarbeitung des Bruchanteils davon ab, ob der Compiler Single Double die Konvertierung Decimal vorn hat. Im folgenden Beispiel werden einschneidende Konvertierungen zum Zuweisen mehrerer numerischer Werte zu Int64 Variablen durchführt.

ulong ulNumber = 163245617943825;
try {
   long number1 = (long) ulNumber;
   Console.WriteLine(number1);
}
catch (OverflowException) {
   Console.WriteLine("{0} is out of range of an Int64.", ulNumber);
}

double dbl2 = 35901.997;
try {
   long number2 = (long) dbl2;
   Console.WriteLine(number2);
}
catch (OverflowException) {
   Console.WriteLine("{0} is out of range of an Int64.", dbl2);
}

BigInteger bigNumber = (BigInteger) 1.63201978555e30;
try {
   long number3 = (long) bigNumber;
   Console.WriteLine(number3);
}
catch (OverflowException) {
   Console.WriteLine("{0} is out of range of an Int64.", bigNumber);
}
// The example displays the following output:
//    163245617943825
//    35902
//    1,632,019,785,549,999,969,612,091,883,520 is out of range of an Int64.

let ulNumber = 163245617943825uL
try
    let number1 = int64 ulNumber
    printfn $"{number1}"
with :? OverflowException ->
    printfn $"{ulNumber} is out of range of an Int64."

let dbl2 = 35901.997
try
    let number2 = int64 dbl2
    printfn $"{number2}"
with :? OverflowException ->
    printfn $"{dbl2} is out of range of an Int64."

let bigNumber = BigInteger 1.63201978555e30
try
    let number3 = int64 bigNumber
    printfn $"{number3}"
with :? OverflowException ->
    printfn $"{bigNumber} is out of range of an Int64."

// The example displays the following output:
//    163245617943825
//    35902
//    1,632,019,785,549,999,969,612,091,883,520 is out of range of an Int64.

Dim ulNumber As ULong = 163245617943825
Try
   Dim number1 As Long = CLng(ulNumber)
   Console.WriteLine(number1)
Catch e As OverflowException
   Console.WriteLine("{0} is out of range of an Int64.", ulNumber)
End Try

Dim dbl2 As Double = 35901.997
Try
   Dim number2 As Long = CLng(dbl2)
   Console.WriteLine(number2)
Catch e As OverflowException
   Console.WriteLine("{0} is out of range of an Int64.", dbl2)
End Try
   
Dim bigNumber As BigInteger = 1.63201978555e30
Try
   Dim number3 As Long = CLng(bigNumber)
   Console.WriteLine(number3)
Catch e As OverflowException
   Console.WriteLine("{0:N0} is out of range of an Int64.", bigNumber)
End Try    
' The example displays the following output:
'    163245617943825
'    35902
'    1,632,019,785,549,999,969,612,091,883,520 is out of range of an Int64.

Sie können eine Methode der -Klasse Convert aufrufen, um jeden unterstützten Typ in einen Wert zu Int64 konvertieren. Dies ist möglich, Int64 da die -Schnittstelle IConvertible unterstützt. Das folgende Beispiel veranschaulicht die Konvertierung eines Arrays von Decimal -Werten in Int64 -Werte.

decimal[] values= { Decimal.MinValue, -1034.23m, -12m, 0m, 147m,
                    199.55m, 9214.16m, Decimal.MaxValue };
long result;

foreach (decimal value in values)
{
   try {
      result = Convert.ToInt64(value);
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.",
                        value.GetType().Name, value,
                        result.GetType().Name, result);
   }
   catch (OverflowException) {
      Console.WriteLine("{0} is outside the range of the Int64 type.",
                        value);
   }
}
// The example displays the following output:
//    -79228162514264337593543950335 is outside the range of the Int64 type.
//    Converted the Decimal value '-1034.23' to the Int64 value -1034.
//    Converted the Decimal value '-12' to the Int64 value -12.
//    Converted the Decimal value '0' to the Int64 value 0.
//    Converted the Decimal value '147' to the Int64 value 147.
//    Converted the Decimal value '199.55' to the Int64 value 200.
//    Converted the Decimal value '9214.16' to the Int64 value 9214.
//    79228162514264337593543950335 is outside the range of the Int64 type.

let values= 
    [| Decimal.MinValue; -1034.23M; -12M; 0M; 147M
       199.55M; 9214.16M; Decimal.MaxValue |]

for value in values do
    try
        let result = Convert.ToInt64 value
        printfn $"Converted the {value.GetType().Name} value '{value}' to the {result.GetType().Name} value {result}." 
    with :? OverflowException ->
        printfn $"{value} is outside the range of the Int64 type."
    
// The example displays the following output:
//    -79228162514264337593543950335 is outside the range of the Int64 type.
//    Converted the Decimal value '-1034.23' to the Int64 value -1034.
//    Converted the Decimal value '-12' to the Int64 value -12.
//    Converted the Decimal value '0' to the Int64 value 0.
//    Converted the Decimal value '147' to the Int64 value 147.
//    Converted the Decimal value '199.55' to the Int64 value 200.
//    Converted the Decimal value '9214.16' to the Int64 value 9214.
//    79228162514264337593543950335 is outside the range of the Int64 type.

Dim values() As Decimal = { Decimal.MinValue, -1034.23d, -12d, 0d, 147d, _
                            199.55d, 9214.16d, Decimal.MaxValue }
Dim result As Long

For Each value As Decimal In values
   Try
      result = Convert.ToInt64(value)
      Console.WriteLine("Converted the {0} value '{1}' to the {2} value {3}.", _
                        value.GetType().Name, value, _
                        result.GetType().Name, result)
   Catch e As OverflowException
      Console.WriteLine("{0} is outside the range of the Int64 type.", _
                        value)
   End Try
Next
' The example displays the following output:
'    -79228162514264337593543950335 is outside the range of the Int64 type.
'    Converted the Decimal value '-1034.23' to the Int64 value -1034.
'    Converted the Decimal value '-12' to the Int64 value -12.
'    Converted the Decimal value '0' to the Int64 value 0.
'    Converted the Decimal value '147' to the Int64 value 147.
'    Converted the Decimal value '199.55' to the Int64 value 200.
'    Converted the Decimal value '9214.16' to the Int64 value 9214.
'    79228162514264337593543950335 is outside the range of the Int64 type.

Sie können die - oder Parse TryParse -Methode aufrufen, um die Zeichenfolgendarstellung eines Int64 Werts in einen zu Int64 konvertieren. Die Zeichenfolge kann dezimale oder hexadezimale Ziffern enthalten. Das folgende Beispiel veranschaulicht den Analysevorgang mithilfe einer dezimalen und einer hexadezimalen Zeichenfolge.

string string1 = "244681903147";
try {
   long number1 = Int64.Parse(string1);
   Console.WriteLine(number1);
}
catch (OverflowException) {
   Console.WriteLine("'{0}' is out of range of a 64-bit integer.", string1);
}
catch (FormatException) {
   Console.WriteLine("The format of '{0}' is invalid.", string1);
}

string string2 = "F9A3CFF0A";
try {
   long number2 = Int64.Parse(string2,
                              System.Globalization.NumberStyles.HexNumber);
   Console.WriteLine(number2);
}
catch (OverflowException) {
   Console.WriteLine("'{0}' is out of range of a 64-bit integer.", string2);
}
catch (FormatException) {
   Console.WriteLine("The format of '{0}' is invalid.", string2);
}
// The example displays the following output:
//    244681903147
//    67012198154

let string1 = "244681903147"
try
    let number1 = Int64.Parse string1
    printfn $"{number1}"
with
| :? OverflowException ->
    printfn $"'{string1}' is out of range of a 64-bit integer."
| :? FormatException ->
    printfn $"The format of '{string1}' is invalid."

let string2 = "F9A3CFF0A"
try
    let number2 = Int64.Parse(string2, NumberStyles.HexNumber)
    printfn $"{number2}"

with
| :? OverflowException ->
    printfn $"'{string2}' is out of range of a 64-bit integer."
| :? FormatException ->
    printfn $"The format of '{string2}' is invalid."

// The example displays the following output:
//    244681903147
//    67012198154

Dim string1 As String = "244681903147"
Try
   Dim number1 As Long = Int64.Parse(string1)
   Console.WriteLine(number1)
Catch e As OverflowException
   Console.WriteLine("'{0}' is out of range of a 64-bit integer.", string1)
Catch e As FormatException
   Console.WriteLine("The format of '{0}' is invalid.", string1)
End Try

Dim string2 As String = "F9A3CFF0A"
Try
   Dim number2 As Long = Int64.Parse(string2,
                            System.Globalization.NumberStyles.HexNumber)
   Console.WriteLine(number2)
Catch e As OverflowException
   Console.WriteLine("'{0}' is out of range of a 64-bit integer.", string2)
Catch e As FormatException
   Console.WriteLine("The format of '{0}' is invalid.", string2)
End Try
' The example displays the following output:
'    244681903147
'    67012198154

Ausführen von Vorgängen für Int64-Werte

Der Typ unterstützt mathematische Standardoperationen wie Int64 Addition, Subtraktion, Division, Multiplikation, Negation und unäre Negation. Wie die anderen integralen Typen unterstützt der Typ auch die Int64 bitweise AND Operatoren OR , , , left shift und right XOR shift.

Sie können die numerischen Standardoperatoren verwenden, um zwei Werte zu Int64 vergleichen, oder Sie können die - oder CompareTo -Methode Equals aufrufen.

Sie können auch die Member der -Klasse aufrufen, um eine Vielzahl von numerischen Vorgängen durchzuführen. Dazu gehören das Abrufen des absoluten Werts einer Zahl, das Berechnen des Quotienten und des Rests aus der ganzzahligen Division, das Bestimmen des Höchst- oder Mindestwerts von zwei langen ganzen Zahlen, das Abrufen des Vorzeichens einer Zahl und das Runden Math einer Zahl.

Darstellen eines Int64-Werts als Zeichenfolge

Der Int64 -Typ bietet vollständige Unterstützung für standardmäßige und benutzerdefinierte numerische Formatzeichenfolgen. (Weitere Informationen finden Sie unter Formatieren von Typen,Standardmäßige numerische Formatzeichenfolgenund benutzerdefinierte numerische Formatzeichenfolgen.)

Um einen Wert als integrale Zeichenfolge ohne führende Nullen zu formatieren, können Int64 Sie die parameterlose Methode ToString() aufrufen. Mithilfe des Formatbezeichners "D" können Sie auch eine angegebene Anzahl führender Nullen in die Zeichenfolgendarstellung einzahlen. Mithilfe des Formatbezeichners "N" können Sie Gruppentrennzeichen angeben und die Anzahl der Dezimalstellen angeben, die in der Zeichenfolgendarstellung der Zahl angezeigt werden sollen. Mit dem Formatbezeichner "X" können Sie einen Wert Int64 als hexadezimale Zeichenfolge darstellen. Im folgenden Beispiel werden die Elemente auf diese vier Arten in einem Array Int64 von Werten formatiert.

long[] numbers = { -1403, 0, 169, 1483104 };
foreach (var number in numbers) {
   // Display value using default formatting.
   Console.Write("{0,-8}  -->   ", number.ToString());
   // Display value with 3 digits and leading zeros.
   Console.Write("{0,8:D3}", number);
   // Display value with 1 decimal digit.
   Console.Write("{0,13:N1}", number);
   // Display value as hexadecimal.
   Console.Write("{0,18:X2}", number);
   // Display value with eight hexadecimal digits.
   Console.WriteLine("{0,18:X8}", number);
}
// The example displays the following output:
//    -1403     -->      -1403     -1,403.0  FFFFFFFFFFFFFA85  FFFFFFFFFFFFFA85
//    0         -->        000          0.0                00          00000000
//    169       -->        169        169.0                A9          000000A9
//    1483104   -->    1483104  1,483,104.0            16A160          0016A160

let numbers = [| -1403L; 0L; 169L; 1483104L |]
for number in numbers do
    // Display value using default formatting.
    printf $"{number.ToString(),-8}  -->   "
    // Display value with 3 digits and leading zeros.
    printf $"{number,8:D3}"
    // Display value with 1 decimal digit.
    printf $"{number,13:N1}"
    // Display value as hexadecimal.
    printf $"{number,18:X2}"
    // Display value with eight hexadecimal digits.
    printfn $"{number,18:X8}"

// The example displays the following output:
//    -1403     -->      -1403     -1,403.0  FFFFFFFFFFFFFA85  FFFFFFFFFFFFFA85
//    0         -->        000          0.0                00          00000000
//    169       -->        169        169.0                A9          000000A9
//    1483104   -->    1483104  1,483,104.0            16A160          0016A160

Dim numbers() As Long = { -1403, 0, 169, 1483104 }
For Each number In numbers
   ' Display value using default formatting.
   Console.Write("{0,-8}  -->   ", number.ToString())
   ' Display value with 3 digits and leading zeros.
   Console.Write("{0,8:D3}", number)
   ' Display value with 1 decimal digit.
   Console.Write("{0,13:N1}", number) 
   ' Display value as hexadecimal.
   Console.Write("{0,18:X2}", number)
   ' Display value with eight hexadecimal digits.
   Console.WriteLine("{0,18:X8}", number)
Next   
' The example displays the following output:
'    -1403     -->      -1403     -1,403.0  FFFFFFFFFFFFFA85  FFFFFFFFFFFFFA85
'    0         -->        000          0.0                00          00000000
'    169       -->        169        169.0                A9          000000A9
'    1483104   -->    1483104  1,483,104.0            16A160          0016A160

Sie können einen Wert auch als binäre, oktale, dezimale oder hexadezimale Zeichenfolge formatieren, indem Sie die -Methode aufrufen und die Basis als zweiten Parameter der Int64 ToString(Int64, Int32) Methode angeben. Das folgende Beispiel ruft diese Methode auf, um die binären, oktalen und hexadezimalen Darstellungen eines Arrays von ganzzahligen Werten anzuzeigen.

long[] numbers = { -146, 11043, 2781913 };
foreach (var number in numbers) {
   Console.WriteLine("{0} (Base 10):", number);
   Console.WriteLine("   Binary:  {0}", Convert.ToString(number, 2));
   Console.WriteLine("   Octal:   {0}", Convert.ToString(number, 8));
   Console.WriteLine("   Hex:     {0}\n", Convert.ToString(number, 16));
}
// The example displays the following output:
//    -146 (Base 10):
//       Binary:  1111111111111111111111111111111111111111111111111111111101101110
//       Octal:   1777777777777777777556
//       Hex:     ffffffffffffff6e
//
//    11043 (Base 10):
//       Binary:  10101100100011
//       Octal:   25443
//       Hex:     2b23
//
//    2781913 (Base 10):
//       Binary:  1010100111001011011001
//       Octal:   12471331
//       Hex:     2a72d9

let numbers = [| -146L; 11043L; 2781913L |]
for number in numbers do
    printfn $"{number} (Base 10):"
    printfn $"   Binary:  {Convert.ToString(number, 2)}"
    printfn $"   Octal:   {Convert.ToString(number, 8)}"
    printfn $"   Hex:     {Convert.ToString(number, 16)}\n"

// The example displays the following output:
//    -146 (Base 10):
//       Binary:  1111111111111111111111111111111111111111111111111111111101101110
//       Octal:   1777777777777777777556
//       Hex:     ffffffffffffff6e
//
//    11043 (Base 10):
//       Binary:  10101100100011
//       Octal:   25443
//       Hex:     2b23
//
//    2781913 (Base 10):
//       Binary:  1010100111001011011001
//       Octal:   12471331
//       Hex:     2a72d9

Dim numbers() As Long = { -146, 11043, 2781913 }
For Each number In numbers
   Console.WriteLine("{0} (Base 10):", number)
   Console.WriteLine("   Binary:  {0}", Convert.ToString(number, 2))
   Console.WriteLine("   Octal:   {0}", Convert.ToString(number, 8))
   Console.WriteLine("   Hex:     {0}", Convert.ToString(number, 16))
   Console.WriteLine()
Next      
' The example displays the following output:
'    -146 (Base 10):
'       Binary:  1111111111111111111111111111111111111111111111111111111101101110
'       Octal:   1777777777777777777556
'       Hex:     ffffffffffffff6e
'
'    11043 (Base 10):
'       Binary:  10101100100011
'       Octal:   25443
'       Hex:     2b23
'
'    2781913 (Base 10):
'       Binary:  1010100111001011011001
'       Octal:   12471331
'       Hex:     2a72d9

Arbeiten mit nicht dezimalen 32-Bit-Ganzzahlwerten

Zusätzlich zur Arbeit mit einzelnen langen ganzen Zahlen als Dezimalwerte sollten Sie bitweise Operationen mit langen ganzzahligen Werten ausführen oder mit den binären oder hexadezimalen Darstellungen von langen ganzzahligen Werten arbeiten. Int64 -Werte werden in 63 Bits dargestellt, und das 64. Bit wird als Vorzeichenbit verwendet. Positive Werte werden mithilfe der Sign-and-Magnitude-Darstellung dargestellt. Negative Werte befinden sich in der Komplementdarstellung von zwei. Dies ist wichtig zu beachten, wenn Sie bitweise Vorgänge für Werte ausführen oder Int64 wenn Sie mit einzelnen Bits arbeiten. Um einen numerischen, booleschen oder Vergleichsvorgang für zwei nicht dezimale Werte durchzuführen, müssen beide Werte dieselbe Darstellung verwenden.

Felder

MaxValue	Stellt den größtmöglichen Wert von Int64 dar. Dieses Feld ist konstant.
MinValue	Stellt den kleinstmöglichen Wert vom Typ Int64 dar. Dieses Feld ist konstant.

Methoden

CompareTo(Int64)	Vergleicht diese Instanz mit einer angegebenen 64-Bit-Ganzzahl mit Vorzeichen und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.
Equals(Int64)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Int64-Wert ist.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
GetTypeCode()	Gibt den TypeCode für den Werttyp Int64 zurück.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen.
ToString()	Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
ToString(String)	Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.
ToString(String, IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Instanz der langen Zahl in die angegebene Zeichenspanne zu formatieren.
TryParse(ReadOnlySpan<Char>, Int64)	Konvertiert die Spannendarstellung einer Zahl in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int64)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, Int64)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, NumberStyles, IFormatProvider, Int64)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

Explizite Schnittstellenimplementierungen

IComparable.CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.
IConvertible.GetTypeCode()	Gibt den TypeCode für den Werttyp Int64 zurück.
IConvertible.ToBoolean(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
IConvertible.ToDecimal(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).

Gilt für

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Member, die den Instanzzustand zu ändern scheinen, geben tatsächlich eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde. Wie bei jedem anderen Typ muss das Lesen und Schreiben in eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.