Int64 Структура

Определение

Пространство имен:

System

Сборка:

System.Runtime.dll

Представляет 64-разрядное целое число со знаком.

public value class long : IComparable<long>, IConvertible, IEquatable<long>, IParsable<long>, ISpanParsable<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>, 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 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)

Наследование

Object

ValueType

Int64

Реализации

IComparable IComparable<Int64> IConvertible IEquatable<Int64> IFormattable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Int64> IParsable<TSelf> ISpanParsable<Int64> ISpanParsable<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>

Комментарии

Int64 — это тип неизменяемого значения, представляющий целые числа со знаком со значениями в диапазоне от отрицательных 9 223 372 036 854 775 808 (которые представлены константой Int64.MinValue ) до положительных 9 223 372 036 854 775 807 (представленных константой Int64.MaxValue ). Платформа .NET Framework также включает 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. Строка может содержать либо десятичные, либо шестнадцатеричные цифры. В следующем примере показан вызов метода Parse с использованием десятичной и шестнадцатеричной строк.

  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

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

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 бита, а шестьдесят четвертый бит используется в качестве бита знака. Положительные значения представлены в виде знака и абсолютной величины. Отрицательные значения представлены в дополнительном коде. Это важно помнить при выполнении побитовых операции со значениями Int64 или при работе с отдельными их битами. Для выполнения числовых, логических операций или операции сравнения с двумя недесятичными значениями, оба значения должны использовать одно и то же представление.

Поля

MaxValue	Представляет наибольшее возможное значение типа Int64. Это поле является константой.
MinValue	Представляет наименьшее возможное значение типа Int64. Это поле является константой.

Методы

Abs(Int64)	Вычисляет абсолютное значение.
Clamp(Int64, Int64, Int64)	Зажимает значение до минимального и максимального значений.
CompareTo(Int64)	Сравнивает данный экземпляр с заданным 64-битовым целым числом со знаком и возвращает значение, указывающее, как соотносятся их значения.
CompareTo(Object)	Сравнивает этот экземпляр с заданным объектом и возвращает значение, указывающее, как соотносятся значения этих объектов.
CopySign(Int64, Int64)	Копирует знак значения в знак другого значения.
CreateChecked<TOther>(TOther)	Создает экземпляр текущего типа из значения, вызывая исключение переполнения для всех значений, которые находятся за пределами представляемого диапазона текущего типа.
CreateSaturating<TOther>(TOther)	Создает экземпляр текущего типа из значения, насыщая все значения, которые находятся за пределами представляемого диапазона текущего типа.
CreateTruncating<TOther>(TOther)	Создает экземпляр текущего типа из значения, усекая все значения, которые находятся за пределами представляемого диапазона текущего типа.
DivRem(Int64, Int64)	Вычисляет коэффициент и остаток двух значений.
Equals(Int64)	Возвращает значение, указывающее, равен ли этот экземпляр заданному значению типа Int64.
Equals(Object)	Возвращает значение, показывающее, равен ли данный экземпляр заданному объекту.
GetHashCode()	Возвращает хэш-код данного экземпляра.
GetTypeCode()	Возвращает TypeCode для типа значения Int64.
IsEvenInteger(Int64)	Определяет, представляет ли значение четное целочисленное число.
IsNegative(Int64)	Определяет, является ли значение отрицательным.
IsOddInteger(Int64)	Определяет, представляет ли значение нечетное целочисленное число.
IsPositive(Int64)	Определяет, является ли значение положительным.
IsPow2(Int64)	Определяет, является ли значение степенью 2.
LeadingZeroCount(Int64)	Вычисляет число начальных нулей в значении.
Log2(Int64)	Вычисляет значение log2.
Max(Int64, Int64)	Сравнивает два значения с вычислением, которое больше.
MaxMagnitude(Int64, Int64)	Сравнивает два значения с вычислением, которое больше.
Min(Int64, Int64)	Сравнивает два значения с вычислением, которое меньше.
MinMagnitude(Int64, Int64)	Сравнивает два значения с вычислением, которое меньше.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Анализирует диапазон символов в значение.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Преобразует представление числа в виде диапазона в указанном стиле и формате, соответствующем языку и региональным параметрам, в эквивалентное ему 64-битовое целое число со знаком.
Parse(String)	Преобразует строковое представление числа в эквивалентное ему 64-битовое целое число со знаком.
Parse(String, IFormatProvider)	Преобразует строковое представление числа в указанном формате, соответствующем языку и региональным параметрам, в эквивалентное ему 64-битовое целое число со знаком.
Parse(String, NumberStyles)	Преобразует строковое представление числа в указанном формате в эквивалентное ему 64-битовое целое число со знаком.
Parse(String, NumberStyles, IFormatProvider)	Преобразует строковое представление числа в формате, соответствующем языку и региональным параметрам, в эквивалентное ему 64-битовое целое число со знаком.
PopCount(Int64)	Вычисляет количество битов, заданных в значении .
RotateLeft(Int64, Int32)	Поворачивает значение влево на заданную сумму.
RotateRight(Int64, Int32)	Поворачивает значение вправо на заданную величину.
Sign(Int64)	Вычисляет знак значения.
ToString()	Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление.
ToString(IFormatProvider)	Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление с использованием указанных сведений об особенностях форматирования для данного языка и региональных параметров.
ToString(String)	Преобразует числовое значение данного экземпляра в эквивалентное строковое представление с использованием указанного формата.
ToString(String, IFormatProvider)	Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление с использованием указанного формата и сведений об особенностях форматирования для данного языка и региональных параметров.
TrailingZeroCount(Int64)	Вычисляет число конечных нулей в значении.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается форматировать значение текущего экземпляра длинного числа в указанный диапазон символов.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Int64)	Пытается проанализировать диапазон символов в значение.
TryParse(ReadOnlySpan<Char>, Int64)	Преобразует представление числа в виде диапазона в эквивалентное ему 64-битовое целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int64)	Преобразует представление числа в виде диапазона в указанном стиле и формате, соответствующем языку и региональным параметрам, в эквивалентное ему 64-битовое целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.
TryParse(String, IFormatProvider, Int64)	Пытается проанализировать строку в значение.
TryParse(String, Int64)	Преобразует строковое представление числа в эквивалентное ему 64-битовое целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.
TryParse(String, NumberStyles, IFormatProvider, Int64)	Преобразует строковое представление числа в формате, соответствующем языку и региональным параметрам, в эквивалентное ему 64-битовое целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.

Явные реализации интерфейса

IAdditionOperators<Int64,Int64,Int64>.Addition(Int64, Int64)	Добавляет два значения вместе для вычисления их суммы.
IAdditionOperators<Int64,Int64,Int64>.CheckedAddition(Int64, Int64)	Добавляет два значения вместе для вычисления их суммы.
IAdditiveIdentity<Int64,Int64>.AdditiveIdentity	Возвращает аддитивное удостоверение текущего типа.
IBinaryInteger<Int64>.GetByteCount()	Возвращает количество байтов, которые будут записаны как часть TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Int64>.GetShortestBitLength()	Возвращает длину (в битах) представления с дополнением наименьшего двух значений текущего значения.
IBinaryInteger<Int64>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Int64)	Представляет 64-разрядное целое число со знаком.
IBinaryInteger<Int64>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Int64)	Представляет 64-разрядное целое число со знаком.
IBinaryInteger<Int64>.TryWriteBigEndian(Span<Byte>, Int32)	Пытается записать текущее значение в формате big-endian в заданный диапазон.
IBinaryInteger<Int64>.TryWriteLittleEndian(Span<Byte>, Int32)	Пытается записать текущее значение в минимальном формате в заданный диапазон.
IBinaryNumber<Int64>.AllBitsSet	Возвращает экземпляр двоичного типа, в котором заданы все биты.
IBitwiseOperators<Int64,Int64,Int64>.BitwiseAnd(Int64, Int64)	Вычисляет побитовое и двух значений.
IBitwiseOperators<Int64,Int64,Int64>.BitwiseOr(Int64, Int64)	Вычисляет побитовое значение или из двух значений.
IBitwiseOperators<Int64,Int64,Int64>.ExclusiveOr(Int64, Int64)	Вычисляет монопольное значение или из двух значений.
IBitwiseOperators<Int64,Int64,Int64>.OnesComplement(Int64)	Вычисляет представление определенного значения с дополнением к единицам.
IComparisonOperators<Int64,Int64,Boolean>.GreaterThan(Int64, Int64)	Сравнивает два значения, чтобы определить, какое значение больше.
IComparisonOperators<Int64,Int64,Boolean>.GreaterThanOrEqual(Int64, Int64)	Сравнивает два значения, чтобы определить, какое значение больше или равно.
IComparisonOperators<Int64,Int64,Boolean>.LessThan(Int64, Int64)	Сравнивает два значения, чтобы определить, какое меньше.
IComparisonOperators<Int64,Int64,Boolean>.LessThanOrEqual(Int64, Int64)	Сравнивает два значения, чтобы определить, какое значение меньше или равно.
IConvertible.ToBoolean(IFormatProvider)	Описание этого члена см. в разделе ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Описание этого члена см. в разделе ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Описание этого члена см. в разделе ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Описание этого члена см. в разделе ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Описание этого члена см. в разделе ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Описание этого члена см. в разделе ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Описание этого члена см. в разделе ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Описание этого члена см. в разделе ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Описание этого члена см. в разделе ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Описание этого члена см. в разделе ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Описание этого члена см. в разделе ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Описание этого члена см. в разделе ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Описание этого члена см. в разделе ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Описание этого члена см. в разделе ToUInt64(IFormatProvider).
IDecrementOperators<Int64>.CheckedDecrement(Int64)	Уменьшает значение.
IDecrementOperators<Int64>.Decrement(Int64)	Уменьшает значение.
IDivisionOperators<Int64,Int64,Int64>.Division(Int64, Int64)	Делит одно значение на другое для вычисления их коэффициента.
IEqualityOperators<Int64,Int64,Boolean>.Equality(Int64, Int64)	Сравнивает два значения для определения равенства.
IEqualityOperators<Int64,Int64,Boolean>.Inequality(Int64, Int64)	Сравнивает два значения для определения неравенства.
IIncrementOperators<Int64>.CheckedIncrement(Int64)	Увеличивает значение.
IIncrementOperators<Int64>.Increment(Int64)	Увеличивает значение.
IMinMaxValue<Int64>.MaxValue	Возвращает максимальное значение текущего типа.
IMinMaxValue<Int64>.MinValue	Возвращает минимальное значение текущего типа.
IModulusOperators<Int64,Int64,Int64>.Modulus(Int64, Int64)	Делит два значения вместе для вычисления их модуля или остатка.
IMultiplicativeIdentity<Int64,Int64>.MultiplicativeIdentity	Возвращает мультипликативное удостоверение текущего типа.
IMultiplyOperators<Int64,Int64,Int64>.CheckedMultiply(Int64, Int64)	Умножает два значения вместе для вычисления их продукта.
IMultiplyOperators<Int64,Int64,Int64>.Multiply(Int64, Int64)	Умножает два значения вместе для вычисления их продукта.
INumber<Int64>.MaxNumber(Int64, Int64)	Сравнивает два значения с вычислением, которое больше, и возвращает другое значение, если входными данными является NaN.
INumber<Int64>.MinNumber(Int64, Int64)	Сравнивает два значения с вычислением, которое меньше, и возвращает другое значение, если входными данными является NaN.
INumberBase<Int64>.IsCanonical(Int64)	Определяет, находится ли значение в каноническом представлении.
INumberBase<Int64>.IsComplexNumber(Int64)	Определяет, представляет ли значение комплексное число.
INumberBase<Int64>.IsFinite(Int64)	Определяет, является ли значение конечным.
INumberBase<Int64>.IsImaginaryNumber(Int64)	Определяет, представляет ли значение чистое мнимое число.
INumberBase<Int64>.IsInfinity(Int64)	Определяет, является ли значение бесконечным.
INumberBase<Int64>.IsInteger(Int64)	Определяет, представляет ли значение целочисленное число.
INumberBase<Int64>.IsNaN(Int64)	Определяет, является ли значение NaN.
INumberBase<Int64>.IsNegativeInfinity(Int64)	Определяет, является ли значение отрицательным бесконечностью.
INumberBase<Int64>.IsNormal(Int64)	Определяет, является ли значение нормальным.
INumberBase<Int64>.IsPositiveInfinity(Int64)	Определяет, является ли значение положительным бесконечностью.
INumberBase<Int64>.IsRealNumber(Int64)	Определяет, представляет ли значение реальное число.
INumberBase<Int64>.IsSubnormal(Int64)	Определяет, является ли значение ненормальным.
INumberBase<Int64>.IsZero(Int64)	Определяет, равно ли значение нулю.
INumberBase<Int64>.MaxMagnitudeNumber(Int64, Int64)	Сравнивает два значения с вычислением, которое имеет большую величину, и возвращает другое значение, если входными данными является NaN.
INumberBase<Int64>.MinMagnitudeNumber(Int64, Int64)	Сравнивает два значения с вычислением, которое имеет меньшую величину, и возвращает другое значение, если входными данными является NaN.
INumberBase<Int64>.One	Возвращает значение 1 типа .
INumberBase<Int64>.Radix	Возвращает радикс или основание для типа.
INumberBase<Int64>.TryConvertFromChecked<TOther>(TOther, Int64)	Представляет 64-разрядное целое число со знаком.
INumberBase<Int64>.TryConvertFromSaturating<TOther>(TOther, Int64)	Представляет 64-разрядное целое число со знаком.
INumberBase<Int64>.TryConvertFromTruncating<TOther>(TOther, Int64)	Представляет 64-разрядное целое число со знаком.
INumberBase<Int64>.TryConvertToChecked<TOther>(Int64, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, вызывая исключение переполнения для всех значений, которые находятся за пределами представляемого диапазона текущего типа.
INumberBase<Int64>.TryConvertToSaturating<TOther>(Int64, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, насыщая все значения, которые выходят за пределы представляемого диапазона текущего типа.
INumberBase<Int64>.TryConvertToTruncating<TOther>(Int64, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, усекая все значения, которые находятся за пределами представляемого диапазона текущего типа.
INumberBase<Int64>.Zero	Возвращает значение 0 типа .
IShiftOperators<Int64,Int32,Int64>.LeftShift(Int64, Int32)	Сдвиг значения влево на заданную сумму.
IShiftOperators<Int64,Int32,Int64>.RightShift(Int64, Int32)	Сдвигает значение вправо на заданную величину.
IShiftOperators<Int64,Int32,Int64>.UnsignedRightShift(Int64, Int32)	Сдвигает значение вправо на заданную величину.
ISignedNumber<Int64>.NegativeOne	Возвращает значение -1 типа .
ISubtractionOperators<Int64,Int64,Int64>.CheckedSubtraction(Int64, Int64)	Вычитает два значения, чтобы вычислить их разницу.
ISubtractionOperators<Int64,Int64,Int64>.Subtraction(Int64, Int64)	Вычитает два значения, чтобы вычислить их разницу.
IUnaryNegationOperators<Int64,Int64>.CheckedUnaryNegation(Int64)	Вычисляет проверенное унарное отрицание значения.
IUnaryNegationOperators<Int64,Int64>.UnaryNegation(Int64)	Вычисляет унарное отрицание значения.
IUnaryPlusOperators<Int64,Int64>.UnaryPlus(Int64)	Вычисляет унарный плюс значения.

Потокобезопасность

Все члены этого типа являются потокобезопасны. Члены, которые могут изменить состояние экземпляра, в действительности возвращают новый экземпляр, инициализированный новым значением. Как с любым другим типом, чтение и запись общей переменной, которая содержит экземпляр этого типа, должны быть защищены блокировкой для обеспечения потокобезопасности.

См. также раздел

• UInt64
• Пример: служебная программа форматирования .NET Core WinForms (C#)
• Пример: служебная программа форматирования .NET Core WinForms (Visual Basic)