Int64 Struktura

Definicja

Przestrzeń nazw:

System

Zestawy:

netstandard.dll, System.Runtime.dll

Źródło:

Int64.cs

Reprezentuje 64-bitową liczbę całkowitą ze znakiem.

public value class long : IComparable<long>, IConvertible, IEquatable<long>, IParsable<long>, ISpanParsable<long>, IUtf8SpanParsable<long>, System::Numerics::IAdditionOperators<long, long, long>, System::Numerics::IAdditiveIdentity<long, long>, System::Numerics::IBinaryInteger<long>, System::Numerics::IBinaryNumber<long>, System::Numerics::IBitwiseOperators<long, long, long>, System::Numerics::IComparisonOperators<long, long, bool>, System::Numerics::IDecrementOperators<long>, System::Numerics::IDivisionOperators<long, long, long>, System::Numerics::IEqualityOperators<long, long, bool>, System::Numerics::IIncrementOperators<long>, System::Numerics::IMinMaxValue<long>, System::Numerics::IModulusOperators<long, long, long>, System::Numerics::IMultiplicativeIdentity<long, long>, System::Numerics::IMultiplyOperators<long, long, long>, System::Numerics::INumber<long>, System::Numerics::INumberBase<long>, System::Numerics::IShiftOperators<long, int, long>, System::Numerics::ISignedNumber<long>, System::Numerics::ISubtractionOperators<long, long, long>, System::Numerics::IUnaryNegationOperators<long, long>, System::Numerics::IUnaryPlusOperators<long, long>

public readonly struct Int64 : IComparable<long>, IConvertible, IEquatable<long>, IParsable<long>, ISpanParsable<long>, IUtf8SpanParsable<long>, System.Numerics.IAdditionOperators<long,long,long>, System.Numerics.IAdditiveIdentity<long,long>, System.Numerics.IBinaryInteger<long>, System.Numerics.IBinaryNumber<long>, System.Numerics.IBitwiseOperators<long,long,long>, System.Numerics.IComparisonOperators<long,long,bool>, System.Numerics.IDecrementOperators<long>, System.Numerics.IDivisionOperators<long,long,long>, System.Numerics.IEqualityOperators<long,long,bool>, System.Numerics.IIncrementOperators<long>, System.Numerics.IMinMaxValue<long>, System.Numerics.IModulusOperators<long,long,long>, System.Numerics.IMultiplicativeIdentity<long,long>, System.Numerics.IMultiplyOperators<long,long,long>, System.Numerics.INumber<long>, System.Numerics.INumberBase<long>, System.Numerics.IShiftOperators<long,int,long>, System.Numerics.ISignedNumber<long>, System.Numerics.ISubtractionOperators<long,long,long>, System.Numerics.IUnaryNegationOperators<long,long>, System.Numerics.IUnaryPlusOperators<long,long>

type int64 = struct
    interface IConvertible
    interface IFormattable
    interface IParsable<int64>
    interface ISpanFormattable
    interface ISpanParsable<int64>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<int64>
    interface IAdditionOperators<int64, int64, int64>
    interface IAdditiveIdentity<int64, int64>
    interface IBinaryInteger<int64>
    interface IBinaryNumber<int64>
    interface IBitwiseOperators<int64, int64, int64>
    interface IComparisonOperators<int64, int64, bool>
    interface IEqualityOperators<int64, int64, bool>
    interface IDecrementOperators<int64>
    interface IDivisionOperators<int64, int64, int64>
    interface IIncrementOperators<int64>
    interface IModulusOperators<int64, int64, int64>
    interface IMultiplicativeIdentity<int64, int64>
    interface IMultiplyOperators<int64, int64, int64>
    interface INumber<int64>
    interface INumberBase<int64>
    interface ISubtractionOperators<int64, int64, int64>
    interface IUnaryNegationOperators<int64, int64>
    interface IUnaryPlusOperators<int64, int64>
    interface IShiftOperators<int64, int, int64>
    interface IMinMaxValue<int64>
    interface ISignedNumber<int64>

Public Structure Int64
Implements IAdditionOperators(Of Long, Long, Long), IAdditiveIdentity(Of Long, Long), IBinaryInteger(Of Long), IBinaryNumber(Of Long), IBitwiseOperators(Of Long, Long, Long), IComparable(Of Long), IComparisonOperators(Of Long, Long, Boolean), IConvertible, IDecrementOperators(Of Long), IDivisionOperators(Of Long, Long, Long), IEqualityOperators(Of Long, Long, Boolean), IEquatable(Of Long), IIncrementOperators(Of Long), IMinMaxValue(Of Long), IModulusOperators(Of Long, Long, Long), IMultiplicativeIdentity(Of Long, Long), IMultiplyOperators(Of Long, Long, Long), INumber(Of Long), INumberBase(Of Long), IParsable(Of Long), IShiftOperators(Of Long, Integer, Long), ISignedNumber(Of Long), ISpanParsable(Of Long), ISubtractionOperators(Of Long, Long, Long), IUnaryNegationOperators(Of Long, Long), IUnaryPlusOperators(Of Long, Long), IUtf8SpanParsable(Of Long)

Dziedziczenie

Object

ValueType

Int64

Implementuje

IComparable IComparable<Int64> IConvertible IEquatable<Int64> IFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Int64> IParsable<TSelf> ISpanFormattable ISpanParsable<Int64> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Int64> IUtf8SpanParsable<TSelf> IAdditionOperators<Int64,Int64,Int64> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<Int64,Int64> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<Int64> IBinaryNumber<Int64> IBinaryNumber<TSelf> IBitwiseOperators<Int64,Int64,Int64> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<Int64,Int64,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<Int64> IDecrementOperators<TSelf> IDivisionOperators<Int64,Int64,Int64> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Int64,Int64,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<Int64> IIncrementOperators<TSelf> IMinMaxValue<Int64> IModulusOperators<Int64,Int64,Int64> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<Int64,Int64> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<Int64,Int64,Int64> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<Int64> INumber<TSelf> INumberBase<Int64> INumberBase<TSelf> IShiftOperators<Int64,Int32,Int64> IShiftOperators<TSelf,Int32,TSelf> ISignedNumber<Int64> ISubtractionOperators<Int64,Int64,Int64> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<Int64,Int64> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Int64,Int64> IUnaryPlusOperators<TSelf,TSelf>

Uwagi

Int64 jest niezmiennym typem wartości reprezentującym podpisane liczby całkowite z wartościami, które wahają się od ujemnych 9223 372 036 854 775 808 (co jest reprezentowane przez stałą Int64.MinValue ) przez dodatnie 923 372 036 854 775 807 (co jest reprezentowane przez stałą Int64.MaxValue ). Platforma .NET zawiera również niepodpisany 64-bitowy typ wartości całkowitej, UInt64który reprezentuje wartości z zakresu od 0 do 18 446 744 073 709 551 615.

Tworzyć instancję wartości Int64

Możesz zadać wartość Int64 na kilka sposobów:

• Można zadeklarować zmienną Int64 i przypisać jej literał wartości całkowitej, który mieści się w zakresie typu danych Int64. Poniższy przykład deklaruje dwie zmienne Int64 i przypisuje im wartości w ten sposób.

  long number1 = -64301728;
  long number2 = 255486129307;
  

  let number1 = -64301728L
  let number2 = 255486129307L
  

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

• Można przypisać wartość typu całkowitego, którego zakres jest podzbiorem Int64 typu. Jest to konwersja rozszerzająca, która nie wymaga operatora rzutowania w języku C# ani metody konwersji w Visual Basic. W języku F#tylko Int32 typ można rozszerzyć automatycznie.

  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
  

• Można przypisać wartość typu liczbowego, którego zakres przekracza ten typ Int64. Jest to konwersja zawężająca, dlatego wymaga operatora rzutowania w języku C# lub F# oraz metody konwersji w języku Visual Basic, jeśli Option Strict jest włączona. Jeśli wartość liczbowa jest wartością Single, Doublelub Decimal wartością zawierającą składnik ułamkowy, obsługa jej części ułamkowej zależy od kompilatora wykonującego konwersję. W poniższym przykładzie wykonywane są konwersje zawężające, aby przypisać kilka liczb do zmiennych 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.
  

• Możesz wywołać metodę klasy Convert, aby przekonwertować dowolny obsługiwany typ na wartość Int64. Jest to możliwe, ponieważ Int64 obsługuje interfejs IConvertible. Poniższy przykład ilustruje konwersję tablicy wartości Decimal na wartości 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.
  

• Możesz wywołać metodę Parse lub TryParse, aby przekonwertować reprezentację ciągu wartości Int64 na Int64. Ciąg może zawierać cyfry dziesiętne lub szesnastkowe. Poniższy przykład ilustruje operację analizowania przy użyciu zarówno ciągu dziesiętnego, jak i szesnastkowego.

  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
  

Wykonywanie operacji na wartościach Int64

Typ Int64 obsługuje standardowe operacje matematyczne, takie jak dodawanie, odejmowanie, dzielenie, mnożenie, negacja i negacja jednoargumentowa. Podobnie jak inne typy całkowite, typ Int64 obsługuje również operatory bitowych AND, OR, XOR, przesunięcia w lewo i w prawo.

Można użyć standardowych operatorów liczbowych do porównania dwóch wartości Int64 lub wywołać metodę CompareTo lub Equals.

Można również wywołać członków klasy Math, aby wykonać szeroki zakres operacji liczbowych, w tym uzyskanie wartości bezwzględnej liczby, obliczenie ilorazu i reszty z dzielenia całkowitego, określenie maksymalnej lub minimalnej wartości dwóch liczb całkowitych typu long, uzyskanie znaku liczby oraz jej zaokrąglenie.

Reprezentowanie int64 jako ciągu

Typ Int64 zapewnia pełną obsługę standardowych i niestandardowych ciągów formatu liczbowego. (Aby uzyskać więcej informacji, zobacz typy formatowania , standardowych ciągów formatu liczbowegoi niestandardowych ciągów formatu liczbowego.)

Aby sformatować wartość Int64 jako ciąg całkowity bez zer wiodących, możesz wywołać metodę ToString() bez parametrów. Używając specyfikatora formatu "D", można również uwzględnić określoną liczbę zer wiodących w reprezentacji ciągu. Używając specyfikatora formatu "N", można uwzględnić separatory grup i określić liczbę cyfr dziesiętnych, które mają być wyświetlane w ciągu reprezentującym liczbę. Używając specyfikatora formatu "X", można reprezentować wartość Int64 jako ciąg szesnastkowy. Poniższy przykład formatuje elementy w tablicy wartości Int64 na te cztery sposoby.

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

Można również sformatować wartość Int64 jako ciąg binarny, ósemkowy, dziesiętny lub szesnastkowy, wywołując metodę ToString(Int64, Int32) i podając bazę jako drugi parametr metody. Poniższy przykład wywołuje tę metodę, aby wyświetlić reprezentacje binarne, ósemkowe i szesnastkowe tablicy wartości całkowitych.

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

Praca z nie dziesiętnymi 64-bitowymi wartościami liczbowymi całkowitymi

Oprócz pracy z poszczególnymi długimi liczbami całkowitymi jako wartościami dziesiętnymi, możesz chcieć wykonać operacje bitowe lub pracować z reprezentacjami wartości długich liczb całkowitych w systemie binarnym lub szesnastkowym. Int64 wartości są reprezentowane w 63 bitach, a sześcioty czwarty bit jest używany jako bit znaku. Wartości dodatnie są reprezentowane przy użyciu reprezentacji znaku i wielkości. Wartości ujemne znajdują się w reprezentacji dwóch uzupełnień. Ważne jest, aby mieć to na uwadze podczas wykonywania operacji bitowych na wartościach Int64 lub przy pracy z pojedynczymi bitami. Aby wykonać operację liczbową, logiczną lub porównawczą na dwóch wartościach innych niż dziesiętne, obie wartości muszą używać tej samej reprezentacji.

Pola

Nazwa	Opis
MaxValue	Reprezentuje największą możliwą wartość elementu Int64. To pole jest stałe.
MinValue	Reprezentuje najmniejszą możliwą wartość elementu Int64. To pole jest stałe.

Metody

Nazwa	Opis
Abs(Int64)	Oblicza wartość bezwzględną.
BigMul(Int64, Int64)	Tworzy pełny produkt dwóch liczb 64-bitowych.
Clamp(Int64, Int64, Int64)	Zaciska wartość do wartości minimalnej i maksymalnej.
CompareTo(Int64)	Porównuje to wystąpienie z określoną 64-bitową liczbą całkowitą ze znakiem i zwraca wskazanie ich wartości względnych.
CompareTo(Object)	Porównuje to wystąpienie z określonym obiektem i zwraca wskazanie ich wartości względnych.
CopySign(Int64, Int64)	Kopiuje znak wartości do znaku innej wartości.
CreateChecked<TOther>(TOther)	Tworzy wystąpienie bieżącego typu na podstawie wartości, zgłaszając wyjątek przepełnienia dla wszystkich wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
CreateSaturating<TOther>(TOther)	Tworzy wystąpienie bieżącego typu na podstawie wartości, usytując wszystkie wartości, które wykraczają poza reprezentowany zakres bieżącego typu.
CreateTruncating<TOther>(TOther)	Tworzy wystąpienie bieżącego typu na podstawie wartości, obcinając wszystkie wartości, które wykraczają poza reprezentowany zakres bieżącego typu.
DivRem(Int64, Int64)	Oblicza iloraz i pozostałą część dwóch wartości.
Equals(Int64)	Zwraca wartość wskazującą, czy to wystąpienie jest równe określonej Int64 wartości.
Equals(Object)	Zwraca wartość wskazującą, czy to wystąpienie jest równe określonemu obiektowi.
GetHashCode()	Zwraca kod skrótu dla tego wystąpienia.
GetTypeCode()	Zwraca wartość TypeCode dla typu Int64wartości .
IsEvenInteger(Int64)	Określa, czy wartość reprezentuje liczbę całkowitą parzystą.
IsNegative(Int64)	Określa, czy wartość jest ujemna.
IsOddInteger(Int64)	Określa, czy wartość reprezentuje nieparzystną liczbę całkowitą.
IsPositive(Int64)	Określa, czy wartość jest dodatnia.
IsPow2(Int64)	Określa, czy wartość jest potęgą dwóch.
LeadingZeroCount(Int64)	Oblicza liczbę zer wiodących w wartości.
Log2(Int64)	Oblicza dziennik2 wartości.
Max(Int64, Int64)	Porównuje dwie wartości z obliczeniami, które są większe.
MaxMagnitude(Int64, Int64)	Porównuje dwie wartości z obliczeniami, które są większe.
Min(Int64, Int64)	Porównuje dwie wartości z obliczeniami, które są mniejsze.
MinMagnitude(Int64, Int64)	Porównuje dwie wartości z obliczeniami, które są mniejsze.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analizuje zakres znaków UTF-8 w wartość.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analizuje zakres znaków UTF-8 w wartość.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analizuje zakres znaków w wartości.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na 64-bitową liczbę całkowitą ze znakiem.
Parse(String, IFormatProvider)	Konwertuje reprezentację ciągu liczby w określonym formacie specyficznym dla kultury na 64-bitową liczbę całkowitą ze znakiem.
Parse(String, NumberStyles, IFormatProvider)	Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na 64-bitową liczbę całkowitą ze znakiem.
Parse(String, NumberStyles)	Konwertuje reprezentację ciągu liczby w określonym stylu na 64-bitową liczbę całkowitą ze znakiem.
Parse(String)	Konwertuje reprezentację ciągu liczby na 64-bitową liczbę całkowitą ze znakiem.
PopCount(Int64)	Oblicza liczbę bitów ustawionych w wartości.
RotateLeft(Int64, Int32)	Obraca wartość pozostawioną przez daną kwotę.
RotateRight(Int64, Int32)	Obraca wartość w prawo o daną kwotę.
Sign(Int64)	Oblicza znak wartości.
ToString()	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację ciągu.
ToString(IFormatProvider)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonych informacji o formacie specyficznym dla kultury.
ToString(String, IFormatProvider)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonego formatu i informacji o formacie specyficznym dla kultury.
ToString(String)	Konwertuje wartość liczbową tego wystąpienia na równoważną reprezentację ciągu przy użyciu określonego formatu.
TrailingZeroCount(Int64)	Oblicza liczbę końcowych zer w wartości.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia jako UTF-8 w podanym zakresie bajtów.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Próbuje sformatować wartość bieżącego wystąpienia długiej liczby w podanym zakresie znaków.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int64)	Próbuje przeanalizować zakres znaków UTF-8 w wartość.
TryParse(ReadOnlySpan<Byte>, Int64)	Próbuje przekonwertować zakres znaków UTF-8 zawierający reprezentację ciągu liczby na 64-bitową liczbę całkowitą ze znakiem.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int64)	Próbuje przeanalizować zakres znaków UTF-8 w wartość.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Int64)	Próbuje przeanalizować zakres znaków w wartości.
TryParse(ReadOnlySpan<Char>, Int64)	Konwertuje reprezentację zakresu liczby na 64-bitową liczbę całkowitą ze znakiem. Wartość zwracana wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int64)	Konwertuje reprezentację zakresu liczby w określonym stylu i formacie specyficznym dla kultury na 64-bitową liczbę całkowitą ze znakiem. Wartość zwracana wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.
TryParse(String, IFormatProvider, Int64)	Próbuje przeanalizować ciąg w wartości.
TryParse(String, Int64)	Konwertuje reprezentację ciągu liczby na 64-bitową liczbę całkowitą ze znakiem. Wartość zwracana wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.
TryParse(String, NumberStyles, IFormatProvider, Int64)	Konwertuje reprezentację ciągu liczby w określonym stylu i formacie specyficznym dla kultury na 64-bitową liczbę całkowitą ze znakiem. Wartość zwracana wskazuje, czy konwersja zakończyła się powodzeniem, czy niepowodzeniem.

Jawne implementacje interfejsu

Nazwa	Opis
IAdditionOperators<Int64,Int64,Int64>.Addition(Int64, Int64)	Dodaje dwie wartości w celu obliczenia ich sumy.
IAdditionOperators<Int64,Int64,Int64>.CheckedAddition(Int64, Int64)	Dodaje dwie wartości w celu obliczenia ich sumy.
IAdditiveIdentity<Int64,Int64>.AdditiveIdentity	Pobiera tożsamość addytywnego bieżącego typu.
IBinaryInteger<Int64>.GetByteCount()	Pobiera liczbę bajtów, które zostaną zapisane w ramach elementu TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Int64>.GetShortestBitLength()	Pobiera długość w bitach najkrótszej reprezentacji wartości bieżącej.
IBinaryInteger<Int64>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Int64)	Reprezentuje 64-bitową liczbę całkowitą ze znakiem.
IBinaryInteger<Int64>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Int64)	Reprezentuje 64-bitową liczbę całkowitą ze znakiem.
IBinaryInteger<Int64>.TryWriteBigEndian(Span<Byte>, Int32)	Próbuje zapisać bieżącą wartość w formacie big-endian do danego zakresu.
IBinaryInteger<Int64>.TryWriteLittleEndian(Span<Byte>, Int32)	Próbuje zapisać bieżącą wartość w formacie little-endian do danego zakresu.
IBinaryNumber<Int64>.AllBitsSet	Pobiera wystąpienie typu binarnego, w którym są ustawione wszystkie bity.
IBitwiseOperators<Int64,Int64,Int64>.BitwiseAnd(Int64, Int64)	Oblicza bitowe wartości i dwie wartości.
IBitwiseOperators<Int64,Int64,Int64>.BitwiseOr(Int64, Int64)	Oblicza bitowe lub dwie wartości.
IBitwiseOperators<Int64,Int64,Int64>.ExclusiveOr(Int64, Int64)	Oblicza wyłącznie lub dwie wartości.
IBitwiseOperators<Int64,Int64,Int64>.OnesComplement(Int64)	Oblicza reprezentację danej wartości jako uzupełnienie.
IComparisonOperators<Int64,Int64,Boolean>.GreaterThan(Int64, Int64)	Porównuje dwie wartości, aby określić, która wartość jest większa.
IComparisonOperators<Int64,Int64,Boolean>.GreaterThanOrEqual(Int64, Int64)	Porównuje dwie wartości, aby określić, które wartości są większe lub równe.
IComparisonOperators<Int64,Int64,Boolean>.LessThan(Int64, Int64)	Porównuje dwie wartości, aby określić, które wartości są mniejsze.
IComparisonOperators<Int64,Int64,Boolean>.LessThanOrEqual(Int64, Int64)	Porównuje dwie wartości, aby określić, które wartości są mniejsze lub równe.
IConvertible.ToBoolean(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Ta konwersja nie jest obsługiwana. Próba użycia tej metody zgłasza błąd InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Aby uzyskać opis tego elementu członkowskiego, zobacz ToUInt64(IFormatProvider).
IDecrementOperators<Int64>.CheckedDecrement(Int64)	Dekrementuje wartość.
IDecrementOperators<Int64>.Decrement(Int64)	Dekrementuje wartość.
IDivisionOperators<Int64,Int64,Int64>.Division(Int64, Int64)	Dzieli jedną wartość przez inną, aby obliczyć ich iloraz.
IEqualityOperators<Int64,Int64,Boolean>.Equality(Int64, Int64)	Porównuje dwie wartości w celu określenia równości.
IEqualityOperators<Int64,Int64,Boolean>.Inequality(Int64, Int64)	Porównuje dwie wartości w celu określenia nierówności.
IIncrementOperators<Int64>.CheckedIncrement(Int64)	Zwiększa wartość.
IIncrementOperators<Int64>.Increment(Int64)	Zwiększa wartość.
IMinMaxValue<Int64>.MaxValue	Pobiera maksymalną wartość bieżącego typu.
IMinMaxValue<Int64>.MinValue	Pobiera minimalną wartość bieżącego typu.
IModulusOperators<Int64,Int64,Int64>.Modulus(Int64, Int64)	Dzieli dwie wartości, aby obliczyć ich modulo lub resztę.
IMultiplicativeIdentity<Int64,Int64>.MultiplicativeIdentity	Pobiera mnożenie tożsamości bieżącego typu.
IMultiplyOperators<Int64,Int64,Int64>.CheckedMultiply(Int64, Int64)	Mnoży dwie wartości, aby obliczyć swój produkt.
IMultiplyOperators<Int64,Int64,Int64>.Multiply(Int64, Int64)	Mnoży dwie wartości, aby obliczyć swój produkt.
INumber<Int64>.MaxNumber(Int64, Int64)	Porównuje dwie wartości z obliczeniami, które są większe i zwracają drugą wartość, jeśli dane wejściowe to NaN.
INumber<Int64>.MinNumber(Int64, Int64)	Porównuje dwie wartości z obliczeniami, które są mniejsze i zwracają drugą wartość, jeśli dane wejściowe to NaN.
INumberBase<Int64>.IsCanonical(Int64)	Określa, czy wartość znajduje się w jej kanonicznej reprezentacji.
INumberBase<Int64>.IsComplexNumber(Int64)	Określa, czy wartość reprezentuje liczbę zespolonej.
INumberBase<Int64>.IsFinite(Int64)	Określa, czy wartość jest skończona.
INumberBase<Int64>.IsImaginaryNumber(Int64)	Określa, czy wartość reprezentuje czystą liczbę wyimaginowaną.
INumberBase<Int64>.IsInfinity(Int64)	Określa, czy wartość jest nieskończona.
INumberBase<Int64>.IsInteger(Int64)	Określa, czy wartość reprezentuje liczbę całkowitą.
INumberBase<Int64>.IsNaN(Int64)	Określa, czy wartość to NaN.
INumberBase<Int64>.IsNegativeInfinity(Int64)	Określa, czy wartość jest ujemną nieskończonością.
INumberBase<Int64>.IsNormal(Int64)	Określa, czy wartość jest normalna.
INumberBase<Int64>.IsPositiveInfinity(Int64)	Określa, czy wartość jest dodatnią nieskończonością.
INumberBase<Int64>.IsRealNumber(Int64)	Określa, czy wartość reprezentuje liczbę rzeczywistą.
INumberBase<Int64>.IsSubnormal(Int64)	Określa, czy wartość jest nienormalna.
INumberBase<Int64>.IsZero(Int64)	Określa, czy wartość ma wartość zero.
INumberBase<Int64>.MaxMagnitudeNumber(Int64, Int64)	Porównuje dwie wartości z obliczeniami o większej wielkości i zwraca drugą wartość, jeśli dane wejściowe to NaN.
INumberBase<Int64>.MinMagnitudeNumber(Int64, Int64)	Porównuje dwie wartości z obliczeniami o mniejszej wielkości i zwraca drugą wartość, jeśli dane wejściowe to NaN.
INumberBase<Int64>.MultiplyAddEstimate(Int64, Int64, Int64)	Oblicza oszacowanie (left * right) i . addend
INumberBase<Int64>.One	Pobiera wartość 1 typu.
INumberBase<Int64>.Radix	Pobiera podstawę (radix) dla typu.
INumberBase<Int64>.TryConvertFromChecked<TOther>(TOther, Int64)	Reprezentuje 64-bitową liczbę całkowitą ze znakiem.
INumberBase<Int64>.TryConvertFromSaturating<TOther>(TOther, Int64)	Reprezentuje 64-bitową liczbę całkowitą ze znakiem.
INumberBase<Int64>.TryConvertFromTruncating<TOther>(TOther, Int64)	Reprezentuje 64-bitową liczbę całkowitą ze znakiem.
INumberBase<Int64>.TryConvertToChecked<TOther>(Int64, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, zgłaszając wyjątek przepełnienia dla wszystkich wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
INumberBase<Int64>.TryConvertToSaturating<TOther>(Int64, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, saturując wszystkie wartości, które mieszczą się poza dopuszczalnym zakresem bieżącego typu.
INumberBase<Int64>.TryConvertToTruncating<TOther>(Int64, TOther)	Próbuje przekonwertować wystąpienie bieżącego typu na inny typ, obcinając wszystkie wartości, które wykraczają poza reprezentowany zakres bieżącego typu.
INumberBase<Int64>.Zero	Pobiera wartość 0 typu.
IShiftOperators<Int64,Int32,Int64>.LeftShift(Int64, Int32)	Przesuwa wartość pozostawioną przez daną kwotę.
IShiftOperators<Int64,Int32,Int64>.RightShift(Int64, Int32)	Przesuwa wartość w prawo o daną kwotę.
IShiftOperators<Int64,Int32,Int64>.UnsignedRightShift(Int64, Int32)	Przesuwa wartość w prawo o daną kwotę.
ISignedNumber<Int64>.NegativeOne	Pobiera wartość -1 typu.
ISubtractionOperators<Int64,Int64,Int64>.CheckedSubtraction(Int64, Int64)	Odejmuje dwie wartości, aby obliczyć ich różnicę.
ISubtractionOperators<Int64,Int64,Int64>.Subtraction(Int64, Int64)	Odejmuje dwie wartości, aby obliczyć ich różnicę.
IUnaryNegationOperators<Int64,Int64>.CheckedUnaryNegation(Int64)	Oblicza sprawdzoną jednoargumentową negację wartości.
IUnaryNegationOperators<Int64,Int64>.UnaryNegation(Int64)	Oblicza jednoargumentowe negację wartości.
IUnaryPlusOperators<Int64,Int64>.UnaryPlus(Int64)	Oblicza jednoargumentowy plus wartość.

Bezpieczeństwo wątkowe

Wszyscy członkowie tego typu są bezpieczni wątkami. Elementy członkowskie, które wydają się modyfikować stan wystąpienia, zwracają nowe wystąpienie zainicjowane przy użyciu nowej wartości. Podobnie jak w przypadku dowolnego innego typu odczyt i zapis w zmiennej udostępnionej, która zawiera wystąpienie tego typu, musi być chroniona przez blokadę, aby zagwarantować bezpieczeństwo wątków.

Zobacz też

• UInt64
• Przykład: .NET Core WinForms Formatting Utility (C#)
• Przykład: .NET Core WinForms Formatting Utility (Visual Basic)