Структура System.Int64

Статья
2025-04-04

В этой статье приводятся дополнительные замечания к справочной документации по этому API.

Int64 — это неизменяемый тип значения, представляющий целые числа со знаком со значениями, которые варьируются от отрицательных 9223 372 036 854 775 808 (который представлен Int64.MinValue константой) до положительных 9 223 372 036 854 775 807 (который представлен Int64.MaxValue константой). .NET также включает 64-разрядный целочисленный тип без знака, UInt64который представляет значения, которые варьируются от 0 до 18 446 744 073 709 551 615.

Создание экземпляра значения Int64

Создать экземпляр Int64 значения можно несколькими способами:

Можно объявить Int64 переменную и назначить ей литеральное целочисленное значение, которое находится в диапазоне Int64 типа данных. В следующем примере объявляется две переменные Int64 и присваивают им значения таким образом.
```
long number1 = -64301728;
long number2 = 255486129307;
```
```
let number1 = -64301728L
let number2 = 255486129307L
```
```
Dim number1 As Long = -64301728
Dim number2 As Long = 255486129307
```
Можно назначить значение целочисленного типа, диапазон которого является подмножеством Int64 типа. Это расширяющее преобразование, которое не требует оператора преобразования в C# или метода преобразования в Visual Basic. В F# только этот Int32 тип можно автоматически расширить.
```
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
```

Можно присвоить значение числового типа, диапазон которого превышает диапазон типа Int64. Это сужающее преобразование, поэтому для этого требуется оператор приведения в C# или F# и метод преобразования в Visual Basic, если Option Strict он включен. Если числовое значение имеет Singleзначение или Double Decimal значение, которое включает дробный компонент, обработка его дробной части зависит от компилятора, выполняющего преобразование. В следующем примере выполняются сужающие преобразования для назначения нескольких числовых значений Int64 переменным.

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.

Можно вызвать метод Convert класса для преобразования любого поддерживаемого Int64 типа в значение. Это возможно, так как Int64 поддерживает интерфейс IConvertible. Следующий пример иллюстрирует преобразование массива значений Decimal в значения Int64.

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.

Можно вызвать метод Parse или TryParse для преобразования представления строкового значения Int64 в объект Int64. Строка может содержать десятичные или шестнадцатеричные цифры. В следующем примере показана операция синтаксического анализа с помощью десятичной и шестнадцатеричной строки.

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

Выполнение операций со значениями Int64

Тип Int64 поддерживает стандартные математические операции, такие как добавление, вычитание, деление, умножение, отрицание и унарное отрицание. Как и другие целочисленные типы, тип Int64 также поддерживает побитовые AND, OR, XOR, операторы сдвига влево и вправо.

Стандартные числовые операторы можно использовать для сравнения двух значений Int64 или вызова метода CompareTo или Equals.

Можно также вызвать члены Math класса для выполнения широких числовых операций, включая получение абсолютного значения числа, вычисление кворента и остатка от целого деления, определение максимального или минимального значения двух длинных целых чисел, получение знака числа и округление числа.

Представление int64 в виде строки

Тип Int64 обеспечивает полную поддержку стандартных и пользовательских строк числовых форматов. (Дополнительные сведения см. в разделе "Типы форматирования", "Стандартные числовые строки" и "Строки настраиваемого числового формата".)

Чтобы отформатировать значение как целочисленную Int64 строку без начальных нулей, можно вызвать метод без ToString() параметров. Используя описатель формата "D", можно также включить указанное число начальных нулей в строковое представление. Используя описатель формата N, можно включить разделители групп и указать число десятичных цифр, которые будут отображаться в строковом представлении числа. Используя описатель формата "X", можно представить Int64 значение в виде шестнадцатеричной строки. В следующем примере элементы в массиве значений Int64 форматируется четырьмя способами.

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

Можно также отформатировать Int64 значение как двоичную, восьмеричную, десятичную или шестнадцатеричную строку, вызвав ToString(Int64, Int32) метод и указав базу в качестве второго параметра метода. В следующем примере этот метод вызывается для отображения двоичных, восьмимерных и шестнадцатеричных представлений массива целых значений.

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

Работа с не десятичными 32-разрядными целыми числами

Помимо работы с отдельными длинными целыми числами в виде десятичных значений, может потребоваться выполнять побитовые операции с длинными целыми значениями или работать с двоичными или шестнадцатеричными представлениями длинных целочисленных значений. Int64 значения представлены в 63 битах с шестьдесят четвертым битом, используемым в качестве бита знака. Положительные значения представлены с помощью представления знака и величины. Отрицательные значения находятся в двухкомплементарном представлении. Это важно учитывать при выполнении побитовых операций с значениями Int64 или при работе с отдельными битами. Чтобы выполнить числовые, логические или операции сравнения для двух не десятичных значений, оба значения должны использовать одно и то же представление.