Int64 Структура
Определение
Важно!
Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.
Представляет 64-разрядное целое число со знаком.
public value class long : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
public value class long : IComparable, IComparable<long>, IConvertible, IEquatable<long>, ISpanFormattable
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 value class long : IComparable<long>, IConvertible, IEquatable<long>, IParsable<long>, ISpanParsable<long>, IUtf8SpanFormattable, 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 value class long : IComparable, IConvertible, IFormattable
public value class long : IComparable, IComparable<long>, IEquatable<long>, IFormattable
public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
public readonly struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
public readonly struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, ISpanFormattable
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>
public readonly struct Int64 : IComparable<long>, IConvertible, IEquatable<long>, IParsable<long>, ISpanParsable<long>, IUtf8SpanFormattable, 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>
[System.Serializable]
public struct Int64 : IComparable, IConvertible, IFormattable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Int64 : IComparable, IComparable<long>, IConvertible, IEquatable<long>, IFormattable
public struct Int64 : IComparable, IComparable<long>, IEquatable<long>, IFormattable
type int64 = struct
interface IConvertible
interface IFormattable
type int64 = struct
interface IConvertible
interface ISpanFormattable
interface IFormattable
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>
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 IUtf8SpanParsable<int64>
interface IShiftOperators<int64, int, int64>
interface IMinMaxValue<int64>
interface ISignedNumber<int64>
interface IUtf8SpanFormattable
[<System.Serializable>]
type int64 = struct
interface IFormattable
interface IConvertible
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type int64 = struct
interface IFormattable
interface IConvertible
type int64 = struct
interface IFormattable
Public Structure Int64
Implements IComparable, IComparable(Of Long), IConvertible, IEquatable(Of Long), IFormattable
Public Structure Int64
Implements IComparable, IComparable(Of Long), IConvertible, IEquatable(Of Long), ISpanFormattable
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)
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), IUtf8SpanFormattable, IUtf8SpanParsable(Of Long)
Public Structure Int64
Implements IComparable, IConvertible, IFormattable
Public Structure Int64
Implements IComparable, IComparable(Of Long), IEquatable(Of Long), IFormattable
- Наследование
- Атрибуты
- Реализации
-
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> IUtf8SpanFormattable IUtf8SpanParsable<Int64> IUtf8SpanParsable<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() | |
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<Byte>, IFormatProvider) |
Анализирует диапазон символов UTF-8 в значение. |
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider) |
Анализирует диапазон символов UTF-8 в значение. |
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<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Пытается отформатировать значение текущего экземпляра как UTF-8 в предоставленный диапазон байтов. |
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider) |
Пытается форматировать значение текущего экземпляра длинного числа в указанный диапазон символов. |
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int64) |
Пытается проанализировать диапазон символов UTF-8 в значение. |
TryParse(ReadOnlySpan<Byte>, Int64) |
Пытается преобразовать диапазон символов UTF-8, содержащий строковое представление числа, в эквивалентное 64-разрядное целое число со знаком. |
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int64) |
Пытается проанализировать диапазон символов UTF-8 в значение. |
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) |
Вычисляет представление определенного значения с дополнением к единицам. |
IComparable.CompareTo(Object) |
Сравнивает этот экземпляр с заданным объектом и возвращает значение, указывающее, как соотносятся значения этих объектов. |
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.GetTypeCode() | |
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) |
Сравнивает два значения с вычислением, которое больше, и возвращает другое значение, если входными данными является |
INumber<Int64>.MinNumber(Int64, Int64) |
Сравнивает два значения с вычислением, которое меньше, и возвращает другое значение, если входными данными является |
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) |
Сравнивает два значения с вычислением, которое имеет большую величину, и возвращает другое значение, если входными данными является |
INumberBase<Int64>.MinMagnitudeNumber(Int64, Int64) |
Сравнивает два значения с вычислением, которое имеет меньшую величину, и возвращает другое значение, если входными данными является |
INumberBase<Int64>.One |
Возвращает значение |
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 |
Возвращает значение |
IShiftOperators<Int64,Int32,Int64>.LeftShift(Int64, Int32) |
Сдвиг значения влево на заданную сумму. |
IShiftOperators<Int64,Int32,Int64>.RightShift(Int64, Int32) |
Сдвигает значение вправо на заданную величину. |
IShiftOperators<Int64,Int32,Int64>.UnsignedRightShift(Int64, Int32) |
Сдвигает значение вправо на заданную величину. |
ISignedNumber<Int64>.NegativeOne |
Возвращает значение |
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) |
Вычисляет унарный плюс значения. |
Применяется к
Потокобезопасность
Все члены этого типа являются потокобезопасны. Члены, которые могут изменить состояние экземпляра, в действительности возвращают новый экземпляр, инициализированный новым значением. Как с любым другим типом, чтение и запись общей переменной, которая содержит экземпляр этого типа, должны быть защищены блокировкой для обеспечения потокобезопасности.