System.Int64 结构

项目
01/11/2024

本文提供了此 API 参考文档的补充说明。

Int64 是一个不可变值类型，表示有符号整数，其值范围为负 9,223,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("{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.

可以调用类的方法 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 {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.

可以调用 Parse 或 TryParse 方法将值的字符串表示形式 Int64 转换为 Int64。该字符串可以包含十进制或十六进制数字。以下示例使用十进制字符串和十六进制字符串演示了分析操作。

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

对 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

还可以通过调用ToString(Int64, Int32)方法并提供基作为方法的第二个参数，将值格式化Int64为二进制、八进制、十六进制或十六进制字符串。以下示例调用此方法以显示整数值的数组的二进制、八进制和十六进制表示形式。

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

使用非十进制 32 位整数值

除了将单个长整数用作十进制值之外，你可能还希望使用长整数值执行按位运算，或者使用长整数值的二进制或十六进制表示形式。 Int64 值以 63 位表示，第 64 位用作符号位。正值使用符号和数量级表示形式表示。负值采用两个补补表示形式。在对 Int64 值执行按位操作或处理单个位时，请务必记住这一点。若要对任何两个非十进制值执行数值、布尔值或比较运算，这两个值都必须使用相同的表示形式。

通过

System.Int64 结构

实例化 Int64 值

对 Int64 值执行操作

将 Int64 表示为字符串

使用非十进制 32 位整数值

其他资源