System.Int64-Struktur
Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.
Int64 ist ein unveränderlicher Werttyp, der signierte ganze Zahlen mit Werten darstellt, die von negativen 9.223.372.036.854.775.808 (dargestellt durch die Int64.MinValue Konstante) bis zu positiven 9.223.372.036.854.775.807 (dargestellt durch die Int64.MaxValue Konstante) liegen. .NET enthält auch einen ganzzahligen 64-Bit-Werttyp ohne Vorzeichen, der Werte darstellt, UInt64die zwischen 0 und 18.446.744.073.709.551.615 liegen.
Instanziieren eines Int64-Werts
Sie können einen Int64 Wert auf verschiedene Arten instanziieren:
Sie können eine Int64 Variable deklarieren und ihm einen literalen ganzzahligen Wert zuweisen, der sich im Bereich des Int64 Datentyps befindet. 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 Int64 Typs ist. Dies ist eine Erweiterungskonvertierung, die keinen Umwandlungsoperator in C# oder eine Konvertierungsmethode in Visual Basic erfordert. In F# kann nur der Int32 Typ automatisch erweitert 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 Wert des Int64 Typs überschreitet. Dies ist eine schmale Konvertierung, daher ist ein Umwandlungsoperator in C# oder F# und eine Konvertierungsmethode in Visual Basic erforderlich, falls
Option Strict
aktiviert. Wenn es sich bei dem numerischen Wert um einen Single, Doubleoder Decimal einen Wert handelt, der eine Bruchkomponente enthält, hängt die Behandlung des Bruchteils vom Compiler ab, der die Konvertierung ausführt. Im folgenden Beispiel werden Konvertierungen eingeschränkt, um Variablen mehrere numerische Werte zuzuweisen Int64 .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 Convert Klasse aufrufen, um jeden unterstützten Typ in einen Int64 Wert zu konvertieren. Dies ist möglich, da Int64 die IConvertible Schnittstelle unterstützt wird. Im folgenden Beispiel wird die Konvertierung eines Arrays von Decimal Werten in Int64 Werte veranschaulicht.
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 ParseTryParse Zeichenfolgendarstellung eines Werts in eine Int64Int64Zeichenfolge konvertieren. Die Zeichenfolge kann entweder dezimale oder hexadezimale Ziffern enthalten. Im folgenden Beispiel wird der Analysevorgang mithilfe einer dezimalen und einer hexadezimalen Zeichenfolge veranschaulicht.
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 Int64 Typ unterstützt standardmäßige mathematische Operationen wie Addition, Subtraktion, Division, Multiplikation, Negation und unäre Negation. Wie bei den anderen integralen Typen unterstützt der Int64 Typ auch die bitweisen AND
, OR
, XOR
linken Schicht- und Rechtsverschiebungsoperatoren.
Sie können die standardmäßigen numerischen Operatoren verwenden, um zwei Int64 Werte zu vergleichen, oder Sie können die CompareTo Methode aufrufen Equals .
Sie können auch die Member der Math Klasse aufrufen, um eine breite Palette numerischer Vorgänge auszuführen, einschließlich des Abrufens des Absoluten Werts einer Zahl, berechnen des Quotienten und des Re Standard der aus integraler Division, Bestimmen des Höchst- oder Minimalwerts von zwei langen Ganzzahlen, Abrufen des Vorzeichens einer Zahl und Runden einer Zahl.
Darstellen eines Int64 als Zeichenfolge
Der Int64 Typ bietet vollständige Unterstützung für Standard- und benutzerdefinierte zahlenformatische Zeichenfolgen. (Weitere Informationen finden Sie unter Formatierungstypen, Standardmäßige numerische Formatzeichenfolgen und benutzerdefinierte Zahlenformatzeichenfolgen.)
Um einen Int64 Wert als integrale Zeichenfolge ohne führende Nullen zu formatieren, können Sie die parameterlose ToString() Methode aufrufen. Mithilfe des Formatbezeichners "D" können Sie auch eine angegebene Anzahl von führenden Nullen in die Zeichenfolgendarstellung einschließen. Mithilfe des N-Formatbezeichners können Sie Gruppentrennzeichen einschließen und die Anzahl der Dezimalziffern angeben, die in der Zeichenfolgendarstellung der Zahl angezeigt werden sollen. Mit dem Formatbezeichner "X" können Sie einen Int64 Wert als hexadezimale Zeichenfolge darstellen. Im folgenden Beispiel werden die Elemente in einem Array von Int64 Werten auf diese vier Arten 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 Int64 Wert auch als binäre, oktale, dezimale oder hexadezimale Zeichenfolge formatieren, indem Sie die ToString(Int64, Int32) Methode aufrufen und die Basis als zweiten Parameter der Methode angeben. Im folgenden Beispiel wird diese Methode aufgerufen, um die binäre, oktale und hexadezimale Darstellung eines Arrays ganzzahliger Werte 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
Neben der Arbeit mit einzelnen langen ganzzahlen als Dezimalwerte können Sie bitweise Vorgänge mit langen ganzzahligen Werten ausführen oder mit den binären oder hexadezimalen Darstellungen langer ganzzahliger Werte arbeiten. Int64 Werte werden in 63 Bits dargestellt, wobei das sechzig-vierte Bit als Zeichenbit verwendet wird. Positive Werte werden mithilfe einer Zeichen- und Größendarstellung dargestellt. Negative Werte befinden sich in der Ergänzungsdarstellung von zwei. Dies ist wichtig, wenn Sie bitweise Vorgänge für Int64 Werte ausführen oder wenn Sie mit einzelnen Bits arbeiten. Um einen numerischen, booleschen oder Vergleichsvorgang für zwei nicht dezimale Werte auszuführen, müssen beide Werte dieselbe Darstellung verwenden.