System.Int64 struct

  • Article

This article provides supplementary remarks to the reference documentation for this API.

Int64 is an immutable value type that represents signed integers with values that range from negative 9,223,372,036,854,775,808 (which is represented by the Int64.MinValue constant) through positive 9,223,372,036,854,775,807 (which is represented by the Int64.MaxValue constant). .NET also includes an unsigned 64-bit integer value type, UInt64, which represents values that range from 0 to 18,446,744,073,709,551,615.

Instantiate an Int64 value

You can instantiate an Int64 value in several ways:

  • You can declare an Int64 variable and assign it a literal integer value that is within the range of the Int64 data type. The following example declares two Int64 variables and assigns them values in this way.

    long number1 = -64301728;
long number2 = 255486129307;

    let number1 = -64301728L
let number2 = 255486129307L

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

  • You can assign the value of an integral type whose range is a subset of the Int64 type. This is a widening conversion that does not require a cast operator in C# or a conversion method in Visual Basic. In F#, only the Int32 type can be widened automatically.

    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

  • You can assign the value of a numeric type whose range exceeds that of the Int64 type. This is a narrowing conversion, so it requires a cast operator in C# or F# and a conversion method in Visual Basic if Option Strict is on. If the numeric value is a Single, Double, or Decimal value that includes a fractional component, the handling of its fractional part depends on the compiler performing the conversion. The following example performs narrowing conversions to assign several numeric values to Int64 variables.

    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.

  • You can call a method of the Convert class to convert any supported type to an Int64 value. This is possible because Int64 supports the IConvertible interface. The following example illustrates the conversion of an array of Decimal values to Int64 values.

    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.

  • You can call the Parse or TryParse method to convert the string representation of an Int64 value to an Int64. The string can contain either decimal or hexadecimal digits. The following example illustrates the parse operation by using both a decimal and a hexadecimal string.

    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

Perform operations on Int64 values

The Int64 type supports standard mathematical operations such as addition, subtraction, division, multiplication, negation, and unary negation. Like the other integral types, the Int64 type also supports the bitwise AND, OR, XOR, left shift, and right shift operators.

You can use the standard numeric operators to compare two Int64 values, or you can call the CompareTo or Equals method.

You can also call the members of the Math class to perform a wide range of numeric operations, including getting the absolute value of a number, calculating the quotient and remainder from integral division, determining the maximum or minimum value of two long integers, getting the sign of a number, and rounding a number.

Represent an Int64 as a string

The Int64 type provides full support for standard and custom numeric format strings. (For more information, see Formatting Types, Standard Numeric Format Strings, and Custom Numeric Format Strings.)

To format an Int64 value as an integral string with no leading zeros, you can call the parameterless ToString() method. By using the "D" format specifier, you can also include a specified number of leading zeros in the string representation. By using the "N" format specifier, you can include group separators and specify the number of decimal digits to appear in the string representation of the number. By using the "X" format specifier, you can represent an Int64 value as a hexadecimal string. The following example formats the elements in an array of Int64 values in these four ways.

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

You can also format an Int64 value as a binary, octal, decimal, or hexadecimal string by calling the ToString(Int64, Int32) method and supplying the base as the method's second parameter. The following example calls this method to display the binary, octal, and hexadecimal representations of an array of integer values.

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

Work with non-decimal 32-bit integer values

In addition to working with individual long integers as decimal values, you may want to perform bitwise operations with long integer values, or work with the binary or hexadecimal representations of long integer values. Int64 values are represented in 63 bits, with the sixty-fourth bit used as a sign bit. Positive values are represented by using sign-and-magnitude representation. Negative values are in two's complement representation. This is important to keep in mind when you perform bitwise operations on Int64 values or when you work with individual bits. In order to perform a numeric, Boolean, or comparison operation on any two non-decimal values, both values must use the same representation.