Int64 Struktura

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Sestavení:

mscorlib.dll

Sestavení:

netstandard.dll

Představuje 64bitové celé číslo podepsaného.

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>, System::Numerics::IDecrementOperators<long>, System::Numerics::IDivisionOperators<long, long, long>, System::Numerics::IEqualityOperators<long, long>, 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, 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>, System.Numerics.IDecrementOperators<long>, System.Numerics.IDivisionOperators<long,long,long>, System.Numerics.IEqualityOperators<long,long>, 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,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>
    interface IEqualityOperators<int64, int64>
    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, int64>
    interface IMinMaxValue<int64>
    interface ISignedNumber<int64>

[<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), IConvertible, IDecrementOperators(Of Long), IDivisionOperators(Of Long, Long, Long), IEqualityOperators(Of Long, Long), 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, Long), ISignedNumber(Of Long), ISpanParsable(Of Long), ISubtractionOperators(Of Long, Long, Long), IUnaryNegationOperators(Of Long, Long), IUnaryPlusOperators(Of Long, Long)

Public Structure Int64
Implements IComparable, IConvertible, IFormattable

Public Structure Int64
Implements IComparable, IComparable(Of Long), IEquatable(Of Long), IFormattable

Dědičnost

Object

ValueType

Int64

Atributy

SerializableAttribute ComVisibleAttribute

Implementuje

IComparable IComparable<Int64> IConvertible IEquatable<Int64> IFormattable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> 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> IComparisonOperators<TSelf,TSelf> IDecrementOperators<Int64> IDecrementOperators<TSelf> IDivisionOperators<Int64,Int64,Int64> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<Int64,Int64> IEqualityOperators<TSelf,TOther> IEqualityOperators<TSelf,TSelf> 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,Int64> IShiftOperators<TSelf,TSelf> ISignedNumber<Int64> ISubtractionOperators<Int64,Int64,Int64> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<Int64,Int64> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<Int64,Int64> IUnaryPlusOperators<TSelf,TSelf>

Poznámky

Int64 je neměnný typ hodnoty, který představuje celá čísla s hodnotami, které jsou v rozsahu od záporných 9 223 372 036 854 775 808 (což je reprezentováno konstantou) až kladně 9 223 372 036 854 775 807 (které je reprezentováno Int64.MinValue Int64.MaxValue konstantou). Rozhraní .NET Framework obsahuje také nepodepsaný 64bitový celočíselnou hodnotu, UInt64který představuje hodnoty, které jsou v rozsahu od 0 do 18 446 744 073 709 551 615.

Vytvoření instance hodnoty Int64

Hodnotu můžete vytvořit Int64 několika způsoby:

• Proměnnou Int64 můžete deklarovat a přiřadit ji celočíselnou hodnotu literálu, která je v rozsahu datového Int64 typu. Následující příklad deklaruje dvě Int64 proměnné a přiřadí je tímto způsobem.

  long number1 = -64301728;
  long number2 = 255486129307;
  

  let number1 = -64301728L
  let number2 = 255486129307L
  

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

• Můžete přiřadit hodnotu celočíselného typu, jehož rozsah je podmnožinou Int64 typu. Jedná se o rozšiřující převod, který nevyžaduje operátor přetypování v jazyce C# nebo metodu převodu v Visual Basic. V jazyce F# lze automaticky rozšířit pouze Int32 typ.

  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
  

• Můžete přiřadit hodnotu číselného typu, jehož rozsah překračuje rozsah typu Int64 . Jedná se o zúžení převodu, takže vyžaduje operátor přetypování v jazyce C# nebo F# a metodu převodu v Visual Basic, pokud Option Strict je zapnutá. Pokud je Singlečíselná hodnota , Doublenebo Decimal hodnota, která obsahuje zlomkovou součást, zpracování jeho zlomkové části závisí na kompilátoru provádějícím převod. Následující příklad provádí zúžení převodů pro přiřazení několika číselných hodnot proměnným 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.
  

• Můžete volat metodu Convert třídy pro převod libovolného podporovaného typu na Int64 hodnotu. To je možné, protože Int64 podporuje IConvertible rozhraní. Následující příklad znázorňuje převod pole Decimal hodnot na Int64 hodnoty.

  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.
  

• Můžete volat nebo TryParse metodu Parse pro převod řetězcové Int64 reprezentace hodnoty na Int64hodnotu . Řetězec může obsahovat desetinné nebo šestnáctkové číslice. Následující příklad znázorňuje operaci parsování pomocí desítkového i šestnáctkového řetězce.

  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
  

Provádění operací s hodnotami Int64

Typ Int64 podporuje standardní matematické operace, jako je sčítání, odčítání, dělení, násobení, negace a unární negace. Stejně jako ostatní celočíselné typy typ Int64 podporuje také bitové AND, , OR, XORlevý posun a operátory pravého posunu.

Standardní číselné operátory můžete použít k porovnání dvou Int64 hodnot nebo můžete volat metodu nebo Equals metoduCompareTo.

Členy třídy můžete také volat Math , aby provedli širokou škálu číselných operací, včetně získání absolutní hodnoty čísla, výpočtu podílu a zbytku z integrálního dělení, určení maximální nebo minimální hodnoty dvou dlouhých celých čísel, získání znaménka čísla a zaokrouhlování čísla.

Reprezentace int64 jako řetězce

Typ Int64 poskytuje úplnou podporu standardních a vlastních řetězců číselného formátu. (Další informace najdete v tématu Typy formátování, standardní řetězce číselného formátu a vlastní řetězce číselného formátu.)

Pokud chcete hodnotu naformátovat Int64 jako integrální řetězec bez úvodních nul, můžete volat metodu bez ToString() parametrů. Pomocí specifikátoru formátu "D" můžete do řetězcové reprezentace zahrnout také zadaný počet úvodních nul. Pomocí specifikátoru formátu "N" můžete zahrnout oddělovače skupin a zadat počet desetinných číslic, které se mají zobrazit v řetězcové reprezentaci čísla. Pomocí specifikátoru formátu X můžete reprezentovat Int64 hodnotu jako šestnáctkový řetězec. Následující příklad naformátuje prvky v poli Int64 hodnot těmito čtyřmi způsoby.

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

Hodnotu můžete také naformátovat Int64 jako binární, osmičkový, desetinný nebo šestnáctkový řetězec voláním ToString(Int64, Int32) metody a zadáním základu jako druhého parametru metody. Následující příklad volá tuto metodu k zobrazení binární, osmičkové a šestnáctkové reprezentace pole celočíselné hodnoty.

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

Práce se 32bitovými celými čísly bez desetinných hodnot

Kromě práce s jednotlivými dlouhými celými čísly jako desetinnými hodnotami můžete chtít provádět bitové operace s dlouhými celočíselnou hodnotou nebo pracovat s binárními nebo šestnáctkovými reprezentacemi dlouhých celočíselné hodnoty. Int64 hodnoty jsou reprezentovány v 63 bitech, přičemž 63-čtvrtý bit se používá jako znaménko. Kladné hodnoty jsou reprezentovány pomocí vyjádření znaku a velikosti. Záporné hodnoty jsou ve dvou reprezentacích doplňku. Je důležité mít na paměti, když provádíte bitové operace s Int64 hodnotami nebo při práci s jednotlivými bity. Aby bylo možné provést číselnou, logickou nebo porovnávací operaci u všech dvou ne desetinných hodnot, musí obě hodnoty používat stejnou reprezentaci.

Pole

MaxValue	Představuje největší možnou Int64hodnotu . Toto pole je konstantní.
MinValue	Představuje nejmenší možnou Int64hodnotu . Toto pole je konstantní.

Metody

Abs(Int64)	Vypočítá absolutní hodnotu.
Clamp(Int64, Int64, Int64)	Upne hodnotu na inkluzivní minimum a maximální hodnotu.
CompareTo(Int64)	Porovná tuto instanci se zadaným 64bitovým znaménkem a vrátí indikaci jejich relativních hodnot.
CompareTo(Object)	Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.
CopySign(Int64, Int64)	Zkopíruje znaménko hodnoty na znaménko jiné hodnoty..
CreateChecked<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty a vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
CreateSaturating<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty, která sytí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
CreateTruncating<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
DivRem(Int64, Int64)	Vypočítá podíl a zbytek dvou hodnot.
Equals(Int64)	Vrátí hodnotu označující, jestli se tato instance rovná zadané Int64 hodnotě.
Equals(Object)	Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.
GetHashCode()	Vrátí hodnotu hash pro tuto instanci.
GetTypeCode()	TypeCode Vrátí hodnotu pro typ Int64hodnoty .
IsNegative(Int64)	Určuje, jestli je hodnota záporná.
IsPow2(Int64)	Určuje, jestli je hodnota mocninou dvou.
LeadingZeroCount(Int64)	Vypočítá počet počátečních nul v hodnotě.
Log2(Int64)	Vypočítá protokol 2 hodnoty.
Max(Int64, Int64)	Porovná dvě hodnoty s výpočetními prostředky, které jsou větší.
MaxMagnitude(Int64, Int64)	Porovná dvě hodnoty s výpočetními prostředky, které jsou větší.
Min(Int64, Int64)	Porovná dvě hodnoty k výpočtu, což je menší.
MinMagnitude(Int64, Int64)	Porovná dvě hodnoty k výpočtu, což je menší.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků do hodnoty.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový celočíselnou ekvivalent.
Parse(String)	Převádí řetězcové vyjádření čísla na 64bitové celé číslo se znaménkem stejné hodnoty.
Parse(String, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 64bitový ekvivalent integeru.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na jeho 64bitové celé číslo s 64bitovým ekvivalentem.
Parse(String, NumberStyles, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový ekvivalent celého čísla.
PopCount(Int64)	Vypočítá počet bitů, které jsou nastavené v hodnotě.
RotateLeft(Int64, Int32)	Otočí hodnotu doleva o danou částku.
RotateRight(Int64, Int32)	Otočí hodnotu doprava o danou částku.
Sign(Int64)	Vypočítá znaménko hodnoty.
ToString()	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření.
ToString(IFormatProvider)	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určených informací o formátování specifických pro jazykovou verzi.
ToString(String)	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu.
ToString(String, IFormatProvider)	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu a informací o formátování specifických pro jazykovou verzi.
TrailingZeroCount(Int64)	Vypočítá počet koncových nul v hodnotě.
TryCreate<TOther>(TOther, Int64)	Pokusí se vytvořit instanci aktuálního typu z hodnoty.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální dlouhé instance čísla do zadaného rozsahu znaků.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Int64)	Pokusí se parsovat rozsah znaků do hodnoty.
TryParse(ReadOnlySpan<Char>, Int64)	Převede reprezentaci čísla na 64bitové celé číslo s 64bitovým celočíselnou ekvivalentem. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int64)	Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový celočíselnou ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.
TryParse(String, IFormatProvider, Int64)
TryParse(String, Int64)	Převádí řetězcové vyjádření čísla na 64bitové celé číslo se znaménkem stejné hodnoty. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.
TryParse(String, NumberStyles, IFormatProvider, Int64)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 64bitový ekvivalent celého čísla. Vrácená hodnota označuje, zda byl převod úspěšný, či nikoli.

Explicitní implementace rozhraní

IBinaryInteger<Int64>.GetByteCount()	Získá počet bajtů, které budou zapsány jako součást TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Int64>.GetShortestBitLength()	Získá délku v bitech nejkratšího dvou doplňku reprezentace aktuální hodnoty.
IBinaryInteger<Int64>.TryWriteLittleEndian(Span<Byte>, Int32)	Pokusí se napsat aktuální hodnotu v malém endian formátu do daného rozsahu.
IComparable.CompareTo(Object)	Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.
IConvertible.GetTypeCode()	TypeCode Vrátí hodnotu pro typ Int64hodnoty .
IConvertible.ToBoolean(IFormatProvider)	Popis tohoto člena naleznete v tématu ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Popis tohoto člena naleznete v tématu ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Popis tohoto člena naleznete v tématu ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Tento převod není podporován. Pokus o použití této metody vyvolá InvalidCastExceptionchybu .
IConvertible.ToDecimal(IFormatProvider)	Popis tohoto člena naleznete v tématu ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Popis tohoto člena naleznete v tématu ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Popis tohoto člena naleznete v tématu ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Popis tohoto člena naleznete v tématu ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Popis tohoto člena naleznete v tématu ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Popis tohoto člena naleznete v tématu ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Popis tohoto člena naleznete v tématu ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Popis tohoto člena naleznete v tématu ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Popis tohoto člena naleznete v tématu ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Popis tohoto člena naleznete v tématu ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Popis tohoto člena naleznete v tématu ToUInt64(IFormatProvider).

Bezpečný přístup z více vláken

Všechny členy tohoto typu jsou zabezpečeny pro přístup z více vláken. Členy, které patrně upravují stav instance, ve skutečnosti vrací novou instanci inicializovanou s použitím nové hodnoty. Jako u jakéhokoli typu, čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, musí být chráněn zámkem, který zaručí bezpečný přístup z více vláken.

Viz také

• UInt64
• Ukázka: Nástroj pro formátování .NET Core WinForms (C#)
• Ukázka: Nástroj pro formátování WinForms pro .NET Core (Visual Basic)