Struktur System.Int64

Artikel ini menyediakan keterangan tambahan untuk dokumentasi referensi untuk API ini.

Int64 adalah tipe nilai yang tidak dapat diubah yang mewakili bilangan bulat bertanda tangan dengan nilai berkisar antara 9.223.372.036.854.775.808 (yang diwakili oleh konstanta Int64.MinValue) melalui positif 9.223.372.036.854.775.807 (yang diwakili oleh konstanta Int64.MaxValue). .NET juga menyertakan jenis nilai bilangan bulat 64-bit yang tidak ditandatangani, UInt64, yang mewakili nilai yang berkisar antara 0 hingga 18.446.744.073.709.551.615.

Menginisialisasi nilai Int64

Anda dapat menginstansiasi nilai Int64 dengan beberapa cara:

• Anda dapat mendeklarasikan variabel Int64 dan menetapkannya nilai bilangan bulat harfiah yang berada dalam rentang jenis data Int64. Contoh berikut mendeklarasikan dua variabel Int64 dan menetapkan nilainya dengan cara ini.

  long number1 = -64301728;
  long number2 = 255486129307;
  

  let number1 = -64301728L
  let number2 = 255486129307L
  

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

• Anda dapat menetapkan nilai jenis integral yang rentangnya adalah subset dari jenis Int64. Ini adalah konversi yang melebar yang tidak memerlukan operator cast di C# atau metode konversi di Visual Basic. Di F#, hanya jenis Int32 yang dapat diperlebar secara otomatis.

  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
  

• Anda dapat menetapkan nilai jenis numerik yang rentangnya melebihi jenis Int64. Ini adalah konversi yang mempersempit, sehingga memerlukan operator cast di C# atau F# dan metode konversi di Visual Basic jika Option Strict aktif. Jika nilai numerik adalah nilai Single, Double, atau Decimal yang menyertakan komponen pecahan, penanganan bagian pecahannya tergantung pada pengkompilasi yang melakukan konversi. Contoh berikut melakukan konversi yang mempersempit untuk menetapkan beberapa nilai numerik ke variabel 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.
  

• Anda dapat memanggil metode kelas Convert untuk mengonversi jenis yang didukung menjadi nilai Int64. Ini dimungkinkan karena Int64 mendukung antarmuka IConvertible. Contoh berikut mengilustrasikan konversi array nilai Decimal ke nilai 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.
  

• Anda dapat memanggil metode Parse atau TryParse untuk mengonversi representasi string dari nilai Int64 menjadi Int64. String dapat berisi digit desimal atau heksadesimal. Contoh berikut mengilustrasikan operasi penguraian dengan menggunakan string desimal dan heksadesimal.

  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
  

Melakukan operasi pada nilai Int64

Jenis Int64 mendukung operasi matematika standar seperti penambahan, pengurangan, pembagian, perkalian, negasi, dan negasi unary. Seperti tipe integral lainnya, tipe Int64 juga mendukung operator bitwise AND, OR, XOR, shift kiri, dan shift kanan.

Anda dapat menggunakan operator numerik standar untuk membandingkan dua nilai Int64, atau Anda dapat memanggil metode CompareTo atau Equals.

Anda juga dapat memanggil anggota kelas Math untuk melakukan berbagai operasi numerik, termasuk mendapatkan nilai absolut angka, menghitung kuota dan sisanya dari pembagian integral, menentukan nilai maksimum atau minimum dari dua bilangan bulat panjang, mendapatkan tanda angka, dan membulatkan angka.

Mewakili Int64 sebagai string

Jenis Int64 menyediakan dukungan penuh untuk string format numerik standar dan kustom. (Untuk informasi selengkapnya, lihat Jenis Pemformatan, String Format Numerik Standar, dan String Format Numerik Kustom.)

Untuk memformat nilai Int64 sebagai string integral tanpa nol di depan, Anda dapat memanggil metode ToString() tanpa parameter. Dengan menggunakan penentu format "D", Anda juga dapat menyertakan jumlah nol di depan tertentu dalam representasi string. Dengan menggunakan penentu format "N", Anda dapat menyertakan pemisah grup dan menentukan jumlah digit desimal yang akan muncul dalam representasi string angka. Dengan menggunakan penentu format "X", Anda dapat mewakili nilai Int64 sebagai string heksadesimal. Contoh berikut memformat elemen dalam array nilai Int64 dengan empat cara ini.

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

Anda juga dapat memformat nilai Int64 sebagai string biner, oktal, desimal, atau heksadesimal dengan memanggil metode ToString(Int64, Int32) dan menyediakan basis sebagai parameter kedua metode. Contoh berikut memanggil metode ini untuk menampilkan representasi biner, oktal, dan heksadesimal dari array nilai bilangan bulat.

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

Bekerja dengan nilai bilangan bulat 32-bit non-desimal

Selain bekerja dengan bilangan bulat panjang individual sebagai nilai desimal, Anda mungkin ingin melakukan operasi bitwise dengan nilai bilangan bulat panjang, atau bekerja dengan representasi biner atau heksadesimal dari nilai bilangan bulat panjang. Int64 nilai diwakili dalam 63 bit, sementara bit ke-enam puluh empat digunakan sebagai bit tanda. Nilai positif diwakili dengan menggunakan representasi tanda dan besaran. Nilai negatif berada dalam representasi pelengkap dua. Ini penting untuk diingat ketika Anda melakukan operasi bitwise pada nilai Int64 atau ketika Anda bekerja dengan bit individual. Untuk melakukan operasi numerik, Boolean, atau perbandingan pada dua nilai non-desimal, kedua nilai harus menggunakan representasi yang sama.