System.Int64-struct

Opmerking

In dit artikel vindt u aanvullende opmerkingen in de referentiedocumentatie voor deze API.

Int64 is een onveranderbaar waardetype dat gehele getallen met teken vertegenwoordigt met waarden die variëren van negatief 9.223.372.036.854.775.808 (dat wordt vertegenwoordigd door de Int64.MinValue constante) tot positief 9.223.372.036.854.775.807 (dat wordt vertegenwoordigd door de Int64.MaxValue constante). .NET bevat ook een niet-ondertekend 64-bits geheel getal, UInt64, dat waarden vertegenwoordigt tussen 0 en 18.446.744.073.709.551.615.

Een int64-waarde instantiëren

U kunt een Int64 waarde op verschillende manieren instantiëren:

  • U kunt een Int64 variabele declareren en deze toewijzen aan een letterlijk geheel getal dat zich binnen het bereik van het Int64 gegevenstype bevindt. In het volgende voorbeeld worden twee Int64 variabelen gede declareert en op deze manier waarden toegewezen.

    long number1 = -64301728;
long number2 = 255486129307;

    let number1 = -64301728L
let number2 = 255486129307L

    Dim number1 As Long = -64301728
Dim number2 As Long = 255486129307

  • U kunt de waarde van een integraal type toewijzen waarvan het bereik een subset is van het Int64 type. Dit is een widening conversie waarvoor geen cast-operator in C# of een conversiemethode in Visual Basic is vereist. In F# kan alleen het Int32 type automatisch worden uitgebreid.

    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

  • U kunt de waarde van een numeriek type toewijzen waarvan het bereik groter is dan dat van het Int64 type. Dit is een vernauwende conversie, dus is een cast-operator nodig in C# of F#, en een conversiemethode in Visual Basic indien Option Strict is ingeschakeld. Als de numerieke waarde een Single, Doubleof Decimal waarde is die een breukonderdeel bevat, is de verwerking van het breukgedeelte afhankelijk van de compiler die de conversie uitvoert. In het volgende voorbeeld worden narrowing conversies uitgevoerd om verschillende numerieke waarden toe te wijzen aan de Int64-variabelen.

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

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

BigInteger bigNumber = (BigInteger) 1.63201978555e30;
try {
   long number3 = (long) bigNumber;
   Console.WriteLine(number3);
}
catch (OverflowException) {
   Console.WriteLine($"{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.

    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.

  • U kunt een methode van de Convert-klasse aanroepen om elk ondersteund type te converteren naar een Int64 waarde. Dit is mogelijk omdat Int64 de IConvertible-interface ondersteunt. In het volgende voorbeeld ziet u de conversie van een matrix met Decimal waarden naar Int64 waarden.

    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 {value.GetType().Name} value '{value}' to the {result.GetType().Name} value {result}.");
   }
   catch (OverflowException) {
      Console.WriteLine($"{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.

    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.

  • U kunt de methode Parse of TryParse aanroepen om de tekenreeksweergave van een Int64-waarde te converteren naar een Int64. De tekenreeks kan decimale of hexadecimale cijfers bevatten. Het volgende voorbeeld illustreert de parseringsbewerking met behulp van zowel een decimaalteken als een hexadecimale tekenreeks.

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

string string2 = "F9A3CFF0A";
try {
   long number2 = Int64.Parse(string2,
                              System.Globalization.NumberStyles.HexNumber);
   Console.WriteLine(number2);
}
catch (OverflowException) {
   Console.WriteLine($"'{string2}' is out of range of a 64-bit integer.");
}
catch (FormatException) {
   Console.WriteLine($"The format of '{string2}' is invalid.");
}
// 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

Bewerkingen uitvoeren op Int64-waarden

Het Int64 type ondersteunt standaard wiskundige bewerkingen, zoals optellen, aftrekken, delen, vermenigvuldigen, negatie en unaire negatie. Net als bij de andere integrale typen ondersteunt het Int64 type ook de bitsgewijze AND, OR, XOR, linker shift- en rechter shiftoperators.

U kunt de standaard numerieke operatoren gebruiken om twee Int64 waarden te vergelijken, of u kunt de methode CompareTo of Equals aanroepen.

U kunt ook de leden van de klasse Math aanroepen om een breed scala aan numerieke bewerkingen uit te voeren, waaronder het ophalen van de absolute waarde van een getal, het berekenen van het quotiënt en de rest van een integrale verdeling, het bepalen van de maximum- of minimumwaarde van twee lange gehele getallen, het ophalen van het teken van een getal en het afronden van een getal.

Een Int64 weergeven als een tekenreeks

Het Int64 type biedt volledige ondersteuning voor tekenreeksen met standaard- en aangepaste numerieke notatie. (Zie Opmaaktypen, Standaardtekenreeksen voor numerieke notatieen tekenreeksen voor aangepaste numerieke notatie.)

Als u een Int64-waarde wilt opmaken als een integrale tekenreeks zonder voorloopnullen, kunt u de parameterloze ToString() methode aanroepen. Met behulp van de notatieaanduiding D kunt u ook een opgegeven aantal voorloopnullen opnemen in de tekenreeksweergave. Met de notatieaanduiding N kunt u groepsscheidingstekens opnemen en het aantal decimalen opgeven dat moet worden weergegeven in de tekenreeksweergave van het getal. Met behulp van de notatieaanduiding X kunt u een Int64 waarde weergeven als een hexadecimale tekenreeks. In het volgende voorbeeld worden de elementen in een matrix met Int64 waarden op deze vier manieren opgemaakt.

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

U kunt een Int64 waarde ook opmaken als een binaire, octale, decimale of hexadecimale tekenreeks door de ToString(Int64, Int32) methode aan te roepen en de basis op te geven als de tweede parameter van de methode. In het volgende voorbeeld wordt deze methode aangeroepen om de binaire, octale en hexadecimale weergaven van een matrix met gehele getallen weer te geven.

long[] numbers = { -146, 11043, 2781913 };
foreach (var number in numbers)
{
    Console.WriteLine($"{number} (Base 10):");
    Console.WriteLine($"   Binary:  {Convert.ToString(number, 2)}");
    Console.WriteLine($"   Octal:   {Convert.ToString(number, 8)}");
    Console.WriteLine($"   Hex:     {Convert.ToString(number, 16)}{Environment.NewLine}");
}
// 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

Werken met niet-decimale 64-bits gehele getallen

Naast het werken met afzonderlijke lange gehele getallen als decimale waarden, kunt u bitsgewijze bewerkingen uitvoeren of werken met de binaire of hexadecimale weergaven van lange gehele getallen. Int64 waarden worden weergegeven in 63 bits, waarbij de vierenzestigste bit wordt gebruikt als tekenbit. Positieve waarden worden vertegenwoordigd door middel van een teken- en grootteweergave. Negatieve waarden bevinden zich in de complementweergave van twee. Dit is belangrijk om rekening mee te houden wanneer u bitsgewijze bewerkingen uitvoert op Int64 waarden of wanneer u met afzonderlijke bits werkt. Als u een numerieke, Booleaanse of vergelijkingsbewerking wilt uitvoeren op twee niet-decimale waarden, moeten beide waarden dezelfde weergave gebruiken.

  • Last updated on