Struct System.Int64

  • Articolo

Questo articolo fornisce osservazioni supplementari alla documentazione di riferimento per questa API.

Int64 è un tipo di valore non modificabile che rappresenta numeri interi con segno con valori compresi tra 9.223.372.036.854.775.808 (rappresentato dalla costante) fino a 9.223.372.036.854.775.807 (rappresentato dalla Int64.MinValueInt64.MaxValue costante). .NET include anche un tipo valore intero senza segno a 64 bit, UInt64, che rappresenta i valori compresi tra 0 e 18.446.744.073.709.551.615.

Creare un'istanza di un valore Int64

È possibile creare un'istanza di un Int64 valore in diversi modi:

  • È possibile dichiarare una Int64 variabile e assegnargli un valore intero letterale compreso nell'intervallo del Int64 tipo di dati. L'esempio seguente dichiara due Int64 variabili e le assegna in questo modo ai valori.

    long number1 = -64301728;
long number2 = 255486129307;

    let number1 = -64301728L
let number2 = 255486129307L

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

  • È possibile assegnare il valore di un tipo integrale il cui intervallo è un subset del Int64 tipo. Si tratta di una conversione più ampia che non richiede un operatore cast in C# o un metodo di conversione in Visual Basic. In F#, solo il Int32 tipo può essere ampliato automaticamente.

    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

  • È possibile assegnare il valore di un tipo numerico il cui intervallo supera quello del Int64 tipo. Si tratta di una conversione di tipo narrowing, quindi richiede un operatore cast in C# o F# e un metodo di conversione in Visual Basic, se Option Strict è attivo. Se il valore numerico è un Singlevalore , Doubleo Decimal che include un componente frazionaria, la gestione della relativa parte frazionaria dipende dal compilatore che esegue la conversione. Nell'esempio seguente vengono eseguite conversioni di tipo narrowing per assegnare diversi valori numerici alle Int64 variabili.

    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.

  • È possibile chiamare un metodo della Convert classe per convertire qualsiasi tipo supportato in un Int64 valore. Ciò è possibile perché Int64 supporta l'interfaccia IConvertible . Nell'esempio seguente viene illustrata la conversione di una matrice di Decimal valori in Int64 valori.

    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.

  • È possibile chiamare il Parse metodo o TryParse per convertire la rappresentazione di stringa di un Int64 valore in un oggetto Int64. La stringa può contenere cifre decimali o esadecimali. Nell'esempio seguente viene illustrata l'operazione di analisi usando sia una stringa decimale che una stringa esadecimale.

    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

Eseguire operazioni sui valori Int64

Il Int64 tipo supporta operazioni matematiche standard, ad esempio addizione, sottrazione, divisione, moltiplicazione, negazione e negazione unaria. Analogamente agli altri tipi integrali, il Int64 tipo supporta anche gli operatori bit per ANDbit , OR, XOR, spostamento sinistro e spostamento a destra.

È possibile usare gli operatori numerici standard per confrontare due Int64 valori oppure chiamare il CompareTo metodo o Equals .

È anche possibile chiamare i membri della Math classe per eseguire un'ampia gamma di operazioni numeriche, tra cui ottenere il valore assoluto di un numero, calcolare il quoziente e il resto dalla divisione integrale, determinare il valore massimo o minimo di due interi lunghi, ottenere il segno di un numero e arrotondare un numero.

Rappresentare un oggetto Int64 come stringa

Il Int64 tipo fornisce il supporto completo per le stringhe di formato numerico standard e personalizzato. Per altre informazioni, vedere Tipi di formattazione, stringhe di formato numerico standard e stringhe di formato numerico personalizzato.

Per formattare un Int64 valore come stringa integrale senza zeri iniziali, è possibile chiamare il metodo senza ToString() parametri. Usando l'identificatore di formato "D", è anche possibile includere un numero specificato di zeri iniziali nella rappresentazione di stringa. Usando l'identificatore di formato "N", è possibile includere separatori di gruppo e specificare il numero di cifre decimali da visualizzare nella rappresentazione di stringa del numero. Usando l'identificatore di formato "X", è possibile rappresentare un Int64 valore come stringa esadecimale. L'esempio seguente formatta gli elementi in una matrice di Int64 valori in questi quattro modi.

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

È anche possibile formattare un Int64 valore come stringa binaria, ottale, decimale o esadecimale chiamando il ToString(Int64, Int32) metodo e specificando la base come secondo parametro del metodo. Nell'esempio seguente viene chiamato questo metodo per visualizzare le rappresentazioni binarie, ottali ed esadecimali di una matrice di valori integer.

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

Usare valori interi non decimali a 32 bit

Oltre a usare singoli numeri interi lunghi come valori decimali, è possibile eseguire operazioni bit per bit con valori integer lunghi oppure usare le rappresentazioni binarie o esadecimali dei valori integer lunghi. Int64 i valori sono rappresentati in 63 bit, con il sessantaquattr bit usato come bit di segno. I valori positivi sono rappresentati usando la rappresentazione di segno e grandezza. I valori negativi sono nella rappresentazione di complemento di due. Questo aspetto è importante da tenere presente quando si eseguono operazioni bit per bit sui Int64 valori o quando si lavora con singoli bit. Per eseguire un'operazione numerica, booleana o di confronto su due valori non decimali, entrambi i valori devono usare la stessa rappresentazione.