Int64 Struct-datatyp

Definition

Namnområde:

System

Sammansättningar:

netstandard.dll, System.Runtime.dll

Källa:

Int64.cs

Representerar ett 64-bitars signerat heltal.

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

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

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

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

Arv

Object

ValueType

Int64

Implementeringar

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

Kommentarer

Int64 är en oföränderlig värdetyp som representerar signerade heltal med värden som sträcker sig från negativa 9 223 372 036 854 775 808 (som representeras av konstanten Int64.MinValue ) genom positiva 9 223 372 036 854 775 807 (som representeras av konstanten Int64.MaxValue ). .NET innehåller också en osignerad 64-bitars heltalsvärdetyp, , UInt64som representerar värden som sträcker sig från 0 till 18 446 744 073 709 551 615.

Instansiera ett Int64-värde

Du kan instansiera ett Int64 värde på flera sätt:

• Du kan deklarera en Int64 variabel och tilldela den ett literal heltalsvärde som ligger inom datatypens Int64 intervall. I följande exempel deklareras två Int64 variabler och de tilldelas värden på det här sättet.

  long number1 = -64301728;
  long number2 = 255486129307;
  

  let number1 = -64301728L
  let number2 = 255486129307L
  

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

• Du kan tilldela värdet för en integraltyp vars intervall är en delmängd av Int64 typen. Det här är en bredare konvertering som inte kräver någon cast-operator i C# eller en konverteringsmetod i Visual Basic. I F# kan endast Int32 typen utökas automatiskt.

  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
  

• Du kan tilldela värdet för en numerisk typ vars intervall överskrider den Int64 av typen. Det här är en förminskande konvertering, så det kräver en cast-operator i C# eller F#, och en konverteringsmetod i Visual Basic, om Option Strict är aktiverat. Om det numeriska värdet är ett Single, Double, eller Decimal-värde som innehåller en bråkdelskomponent, beror hanteringen av dess bråkdel på kompilatorn som utför konverteringen. I följande exempel utförs smalare konverteringar för att tilldela flera numeriska värden till Int64 variabler.

  ulong ulNumber = 163245617943825;
  try {
     long number1 = (long) ulNumber;
     Console.WriteLine(number1);
  }
  catch (OverflowException) {
     Console.WriteLine($"{ulNumber} is out of range of an Int64.");
  }
  
  double dbl2 = 35901.997;
  try {
     long number2 = (long) dbl2;
     Console.WriteLine(number2);
  }
  catch (OverflowException) {
     Console.WriteLine($"{dbl2} is out of range of an Int64.");
  }
  
  BigInteger bigNumber = (BigInteger) 1.63201978555e30;
  try {
     long number3 = (long) bigNumber;
     Console.WriteLine(number3);
  }
  catch (OverflowException) {
     Console.WriteLine($"{bigNumber} is out of range of an Int64.");
  }
  // The example displays the following output:
  //    163245617943825
  //    35902
  //    1,632,019,785,549,999,969,612,091,883,520 is out of range of an Int64.
  

  let ulNumber = 163245617943825uL
  try
      let number1 = int64 ulNumber
      printfn $"{number1}"
  with :? OverflowException ->
      printfn $"{ulNumber} is out of range of an Int64."
  
  let dbl2 = 35901.997
  try
      let number2 = int64 dbl2
      printfn $"{number2}"
  with :? OverflowException ->
      printfn $"{dbl2} is out of range of an Int64."
  
  let bigNumber = BigInteger 1.63201978555e30
  try
      let number3 = int64 bigNumber
      printfn $"{number3}"
  with :? OverflowException ->
      printfn $"{bigNumber} is out of range of an Int64."
  
  // The example displays the following output:
  //    163245617943825
  //    35902
  //    1,632,019,785,549,999,969,612,091,883,520 is out of range of an Int64.
  

  Dim ulNumber As ULong = 163245617943825
  Try
     Dim number1 As Long = CLng(ulNumber)
     Console.WriteLine(number1)
  Catch e As OverflowException
     Console.WriteLine("{0} is out of range of an Int64.", ulNumber)
  End Try
  
  Dim dbl2 As Double = 35901.997
  Try
     Dim number2 As Long = CLng(dbl2)
     Console.WriteLine(number2)
  Catch e As OverflowException
     Console.WriteLine("{0} is out of range of an Int64.", dbl2)
  End Try
     
  Dim bigNumber As BigInteger = 1.63201978555e30
  Try
     Dim number3 As Long = CLng(bigNumber)
     Console.WriteLine(number3)
  Catch e As OverflowException
     Console.WriteLine("{0:N0} is out of range of an Int64.", bigNumber)
  End Try    
  ' The example displays the following output:
  '    163245617943825
  '    35902
  '    1,632,019,785,549,999,969,612,091,883,520 is out of range of an Int64.
  

• Du kan anropa en klassmetod Convert för att konvertera valfri typ som stöds till ett Int64 värde. Detta är möjligt eftersom Int64 stöder IConvertible-gränssnittet. I följande exempel visas konverteringen av en matris med Decimal värden till Int64 värden.

  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.
  

• Du kan anropa Parse metoden eller TryParse för att konvertera strängrepresentationen av ett Int64 värde till en Int64. Strängen kan innehålla decimal- eller hexadecimala siffror. I följande exempel visas parsningsåtgärden med både en decimal och en hexadecimal sträng.

  string string1 = "244681903147";
  try {
     long number1 = Int64.Parse(string1);
     Console.WriteLine(number1);
  }
  catch (OverflowException) {
     Console.WriteLine($"'{string1}' is out of range of a 64-bit integer.");
  }
  catch (FormatException) {
     Console.WriteLine($"The format of '{string1}' is invalid.");
  }
  
  string string2 = "F9A3CFF0A";
  try {
     long number2 = Int64.Parse(string2,
                                System.Globalization.NumberStyles.HexNumber);
     Console.WriteLine(number2);
  }
  catch (OverflowException) {
     Console.WriteLine($"'{string2}' is out of range of a 64-bit integer.");
  }
  catch (FormatException) {
     Console.WriteLine($"The format of '{string2}' is invalid.");
  }
  // The example displays the following output:
  //    244681903147
  //    67012198154
  

  let string1 = "244681903147"
  try
      let number1 = Int64.Parse string1
      printfn $"{number1}"
  with
  | :? OverflowException ->
      printfn $"'{string1}' is out of range of a 64-bit integer."
  | :? FormatException ->
      printfn $"The format of '{string1}' is invalid."
  
  let string2 = "F9A3CFF0A"
  try
      let number2 = Int64.Parse(string2, NumberStyles.HexNumber)
      printfn $"{number2}"
  
  with
  | :? OverflowException ->
      printfn $"'{string2}' is out of range of a 64-bit integer."
  | :? FormatException ->
      printfn $"The format of '{string2}' is invalid."
  
  // The example displays the following output:
  //    244681903147
  //    67012198154
  

  Dim string1 As String = "244681903147"
  Try
     Dim number1 As Long = Int64.Parse(string1)
     Console.WriteLine(number1)
  Catch e As OverflowException
     Console.WriteLine("'{0}' is out of range of a 64-bit integer.", string1)
  Catch e As FormatException
     Console.WriteLine("The format of '{0}' is invalid.", string1)
  End Try
  
  Dim string2 As String = "F9A3CFF0A"
  Try
     Dim number2 As Long = Int64.Parse(string2,
                              System.Globalization.NumberStyles.HexNumber)
     Console.WriteLine(number2)
  Catch e As OverflowException
     Console.WriteLine("'{0}' is out of range of a 64-bit integer.", string2)
  Catch e As FormatException
     Console.WriteLine("The format of '{0}' is invalid.", string2)
  End Try
  ' The example displays the following output:
  '    244681903147
  '    67012198154
  

Utföra åtgärder på Int64-värden

Typen Int64 stöder matematiska standardåtgärder som addition, subtraktion, division, multiplikation, negation och unary negation. Precis som de andra integraltyperna stöder även den Int64-typen bitvis AND, OR, XOR, vänsterskift- och högerskiftoperatorer.

Du kan använda de numeriska standardoperatorerna för att jämföra två Int64 värden, eller anropa metoden CompareTo eller Equals.

Du kan också anropa medlemmarna i Math klassen för att utföra ett brett spektrum av numeriska åtgärder, inklusive att hämta det absoluta värdet för ett tal, beräkna kvoten och resten från integraldivisionen, bestämma det maximala eller lägsta värdet för två långa heltal, hämta tecknet för ett tal och avrunda ett tal.

Representera en Int64 som en sträng

Int64-typen ger fullt stöd för standard- och anpassade numeriska formatsträngar. (Mer information finns i Formateringstyper, Standard numeriska formatsträngar och Anpassade numeriska formatsträngar.)

Om du vill formatera ett Int64 värde som en integrerad sträng utan inledande nollor kan du anropa metoden parameterlös ToString() . Genom att använda formatspecificeraren "D" kan du även inkludera ett angivet antal inledande nollor i strängrepresentationen. Genom att använda formatspecificeraren "N" kan du inkludera gruppavgränsare och ange antalet decimalsiffror som ska visas i strängrepresentationen av talet. Genom att använda formatspecificeraren "X" kan du representera ett Int64 värde som en hexadecimal sträng. I följande exempel formateras elementen i en matris med Int64 värden på dessa fyra sätt.

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

Du kan också formatera ett Int64 värde som en binär, oktal, decimal eller hexadecimal sträng genom att anropa ToString(Int64, Int32) metoden och ange basen som metodens andra parameter. I följande exempel anropas den här metoden för att visa binära, oktala och hexadecimala representationer av en matris med heltalsvärden.

long[] numbers = { -146, 11043, 2781913 };
foreach (var number in numbers)
{
    Console.WriteLine($"{number} (Base 10):");
    Console.WriteLine($"   Binary:  {Convert.ToString(number, 2)}");
    Console.WriteLine($"   Octal:   {Convert.ToString(number, 8)}");
    Console.WriteLine($"   Hex:     {Convert.ToString(number, 16)}{Environment.NewLine}");
}
// The example displays the following output:
//    -146 (Base 10):
//       Binary:  1111111111111111111111111111111111111111111111111111111101101110
//       Octal:   1777777777777777777556
//       Hex:     ffffffffffffff6e
//
//    11043 (Base 10):
//       Binary:  10101100100011
//       Octal:   25443
//       Hex:     2b23
//
//    2781913 (Base 10):
//       Binary:  1010100111001011011001
//       Octal:   12471331
//       Hex:     2a72d9

let numbers = [| -146L; 11043L; 2781913L |]
for number in numbers do
    printfn $"{number} (Base 10):"
    printfn $"   Binary:  {Convert.ToString(number, 2)}"
    printfn $"   Octal:   {Convert.ToString(number, 8)}"
    printfn $"   Hex:     {Convert.ToString(number, 16)}\n"

// The example displays the following output:
//    -146 (Base 10):
//       Binary:  1111111111111111111111111111111111111111111111111111111101101110
//       Octal:   1777777777777777777556
//       Hex:     ffffffffffffff6e
//
//    11043 (Base 10):
//       Binary:  10101100100011
//       Octal:   25443
//       Hex:     2b23
//
//    2781913 (Base 10):
//       Binary:  1010100111001011011001
//       Octal:   12471331
//       Hex:     2a72d9

Dim numbers() As Long = { -146, 11043, 2781913 }
For Each number In numbers
   Console.WriteLine("{0} (Base 10):", number)
   Console.WriteLine("   Binary:  {0}", Convert.ToString(number, 2))
   Console.WriteLine("   Octal:   {0}", Convert.ToString(number, 8))
   Console.WriteLine("   Hex:     {0}", Convert.ToString(number, 16))
   Console.WriteLine()
Next      
' The example displays the following output:
'    -146 (Base 10):
'       Binary:  1111111111111111111111111111111111111111111111111111111101101110
'       Octal:   1777777777777777777556
'       Hex:     ffffffffffffff6e
'
'    11043 (Base 10):
'       Binary:  10101100100011
'       Octal:   25443
'       Hex:     2b23
'
'    2781913 (Base 10):
'       Binary:  1010100111001011011001
'       Octal:   12471331
'       Hex:     2a72d9

Arbeta med 64-bitars heltalsvärden som inte är decimaler

Förutom att arbeta med enskilda långa heltal som decimalvärden kanske du vill utföra bitvis åtgärder eller arbeta med binära eller hexadecimala representationer av långa heltalsvärden. Int64 värden representeras i 63 bitar, där den sextiofyrde biten används som en teckenbit. Positiva värden representeras med hjälp av tecken-och-magnitudrepresentation. Negativa värden finns i tvås komplementrepresentation. Detta är viktigt att tänka på när du utför bitvis åtgärder på Int64 värden eller när du arbetar med enskilda bitar. Om du vill utföra en numerisk, boolesk eller jämförelseåtgärd på två icke-decimalvärden måste båda värdena använda samma representation.

Fält

Name	Description
MaxValue	Representerar det största möjliga värdet för en Int64. Det här fältet är konstant.
MinValue	Representerar det minsta möjliga värdet för en Int64. Det här fältet är konstant.

Metoder

Name	Description
Abs(Int64)	Beräknar det absoluta värdet.
BigMul(Int64, Int64)	Producerar den fullständiga produkten av två 64-bitarsnummer.
Clamp(Int64, Int64, Int64)	Klämmer fast ett värde till ett inkluderande lägsta och högsta värde.
CompareTo(Int64)	Jämför den här instansen med ett angivet 64-bitars signerat heltal och returnerar en indikation på deras relativa värden.
CompareTo(Object)	Jämför den här instansen med ett angivet objekt och returnerar en indikation på deras relativa värden.
CopySign(Int64, Int64)	Kopierar tecknet för ett värde till tecknet för ett annat värde.
CreateChecked<TOther>(TOther)	Skapar en instans av den aktuella typen från ett värde, vilket utlöser ett spill-undantag för värden som ligger utanför det representerarbara intervallet för den aktuella typen.
CreateSaturating<TOther>(TOther)	Skapar en instans av den aktuella typen från ett värde som mättar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
CreateTruncating<TOther>(TOther)	Skapar en instans av den aktuella typen från ett värde och trunkerar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
DivRem(Int64, Int64)	Beräknar kvoten och resten av två värden.
Equals(Int64)	Returnerar ett värde som anger om den här instansen är lika med ett angivet Int64 värde.
Equals(Object)	Returnerar ett värde som anger om den här instansen är lika med ett angivet objekt.
GetHashCode()	Returnerar hash-koden för den här instansen.
GetTypeCode()	TypeCode Returnerar för värdetypen Int64.
IsEvenInteger(Int64)	Avgör om ett värde representerar ett jämnt heltal.
IsNegative(Int64)	Avgör om ett värde är negativt.
IsOddInteger(Int64)	Avgör om ett värde representerar ett udda integraltal.
IsPositive(Int64)	Avgör om ett värde är positivt.
IsPow2(Int64)	Avgör om ett värde är en kraft på två.
LeadingZeroCount(Int64)	Beräknar antalet inledande nollor i ett värde.
Log2(Int64)	Beräknar log2 för ett värde.
Max(Int64, Int64)	Jämför två värden med beräkning som är större.
MaxMagnitude(Int64, Int64)	Jämför två värden med beräkning som är större.
Min(Int64, Int64)	Jämför två värden med beräkning som är mindre.
MinMagnitude(Int64, Int64)	Jämför två värden med beräkning som är mindre.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsar ett intervall med UTF-8 tecken till ett värde.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsar ett intervall med UTF-8 tecken till ett värde.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsar ett teckenintervall till ett värde.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konverterar spännviddsrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess 64-bitars signerade heltalsekvivalent.
Parse(String, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet kulturspecifikt format till dess 64-bitars signerade heltalsekvivalent.
Parse(String, NumberStyles, IFormatProvider)	Konverterar strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess 64-bitars signerade heltalsekvivalent.
Parse(String, NumberStyles)	Konverterar strängrepresentationen av ett tal i ett angivet format till dess 64-bitars signerade heltalsekvivalent.
Parse(String)	Konverterar strängrepresentationen av ett tal till dess 64-bitars signerade heltalsekvivalent.
PopCount(Int64)	Beräknar antalet bitar som anges i ett värde.
RotateLeft(Int64, Int32)	Roterar ett värde som lämnas av ett angivet belopp.
RotateRight(Int64, Int32)	Roterar ett värde höger med ett angivet belopp.
Sign(Int64)	Beräknar tecknet för ett värde.
ToString()	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation.
ToString(IFormatProvider)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med den angivna kulturspecifika formatinformationen.
ToString(String, IFormatProvider)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet och den kulturspecifika formatinformationen.
ToString(String)	Konverterar det numeriska värdet för den här instansen till motsvarande strängrepresentation med det angivna formatet.
TrailingZeroCount(Int64)	Beräknar antalet avslutande nollor i ett värde.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Försöker formatera värdet för den aktuella instansen som UTF-8 i det angivna byteintervallet.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Försöker formatera värdet för den aktuella långa talinstansen till det angivna intervallet med tecken.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int64)	Försöker parsa ett intervall med UTF-8 tecken till ett värde.
TryParse(ReadOnlySpan<Byte>, Int64)	Försöker konvertera ett UTF-8-teckensintervall som innehåller strängrepresentationen av ett tal till dess 64-bitars signerade heltalsmotsvarighet.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int64)	Försöker parsa ett intervall med UTF-8 tecken till ett värde.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Int64)	Försöker parsa ett teckenintervall till ett värde.
TryParse(ReadOnlySpan<Char>, Int64)	Konverterar spanrepresentationen av ett tal till dess 64-bitars signerade heltalsekvivalent. Ett returvärde anger om konverteringen lyckades eller misslyckades.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int64)	Konverterar spännviddsrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess 64-bitars signerade heltalsekvivalent. Ett returvärde anger om konverteringen lyckades eller misslyckades.
TryParse(String, IFormatProvider, Int64)	Försöker parsa en sträng till ett värde.
TryParse(String, Int64)	Konverterar strängrepresentationen av ett tal till dess 64-bitars signerade heltalsekvivalent. Ett returvärde anger om konverteringen lyckades eller misslyckades.
TryParse(String, NumberStyles, IFormatProvider, Int64)	Konverterar strängrepresentationen av ett tal i ett angivet format och kulturspecifikt format till dess 64-bitars signerade heltalsekvivalent. Ett returvärde anger om konverteringen lyckades eller misslyckades.

Explicita gränssnittsimplementeringar

Name	Description
IAdditionOperators<Int64,Int64,Int64>.Addition(Int64, Int64)	Lägger till två värden tillsammans för att beräkna summan.
IAdditionOperators<Int64,Int64,Int64>.CheckedAddition(Int64, Int64)	Lägger till två värden tillsammans för att beräkna summan.
IAdditiveIdentity<Int64,Int64>.AdditiveIdentity	Hämtar den aktuella typens additiva identitet.
IBinaryInteger<Int64>.GetByteCount()	Hämtar antalet byte som ska skrivas som en del av TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Int64>.GetShortestBitLength()	Hämtar längden, i bitar, på de kortaste tvås komplementrepresentation av det aktuella värdet.
IBinaryInteger<Int64>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Int64)	Representerar ett 64-bitars signerat heltal.
IBinaryInteger<Int64>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Int64)	Representerar ett 64-bitars signerat heltal.
IBinaryInteger<Int64>.TryWriteBigEndian(Span<Byte>, Int32)	Försöker skriva det aktuella värdet, i stor endianskt format, till ett givet intervall.
IBinaryInteger<Int64>.TryWriteLittleEndian(Span<Byte>, Int32)	Försöker skriva det aktuella värdet, i lite endianskt format, till ett givet intervall.
IBinaryNumber<Int64>.AllBitsSet	Hämtar en instans av den binära typen där alla bitar anges.
IBitwiseOperators<Int64,Int64,Int64>.BitwiseAnd(Int64, Int64)	Beräknar bitvis och av två värden.
IBitwiseOperators<Int64,Int64,Int64>.BitwiseOr(Int64, Int64)	Beräknar bitvis eller två värden.
IBitwiseOperators<Int64,Int64,Int64>.ExclusiveOr(Int64, Int64)	Beräknar uteslutande eller av två värden.
IBitwiseOperators<Int64,Int64,Int64>.OnesComplement(Int64)	Beräknar enkomplementrepresentationen av ett visst värde.
IComparisonOperators<Int64,Int64,Boolean>.GreaterThan(Int64, Int64)	Jämför två värden för att avgöra vilket som är större.
IComparisonOperators<Int64,Int64,Boolean>.GreaterThanOrEqual(Int64, Int64)	Jämför två värden för att avgöra vilket som är större eller lika med.
IComparisonOperators<Int64,Int64,Boolean>.LessThan(Int64, Int64)	Jämför två värden för att avgöra vilket som är mindre.
IComparisonOperators<Int64,Int64,Boolean>.LessThanOrEqual(Int64, Int64)	Jämför två värden för att avgöra vilket som är mindre eller lika med.
IConvertible.ToBoolean(IFormatProvider)	En beskrivning av den här medlemmen finns i ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	En beskrivning av den här medlemmen finns i ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	En beskrivning av den här medlemmen finns i ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Den här konverteringen stöds inte. Om du försöker använda den här metoden utlöser en InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	En beskrivning av den här medlemmen finns i ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	En beskrivning av den här medlemmen finns i ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	En beskrivning av den här medlemmen finns i ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	En beskrivning av den här medlemmen finns i ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	En beskrivning av den här medlemmen finns i ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	En beskrivning av den här medlemmen finns i ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	En beskrivning av den här medlemmen finns i ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	En beskrivning av den här medlemmen finns i ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	En beskrivning av den här medlemmen finns i ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	En beskrivning av den här medlemmen finns i ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	En beskrivning av den här medlemmen finns i ToUInt64(IFormatProvider).
IDecrementOperators<Int64>.CheckedDecrement(Int64)	Minskar ett värde.
IDecrementOperators<Int64>.Decrement(Int64)	Minskar ett värde.
IDivisionOperators<Int64,Int64,Int64>.Division(Int64, Int64)	Delar upp ett värde med ett annat för att beräkna deras kvot.
IEqualityOperators<Int64,Int64,Boolean>.Equality(Int64, Int64)	Jämför två värden för att fastställa likhet.
IEqualityOperators<Int64,Int64,Boolean>.Inequality(Int64, Int64)	Jämför två värden för att fastställa ojämlikhet.
IIncrementOperators<Int64>.CheckedIncrement(Int64)	Ökar ett värde.
IIncrementOperators<Int64>.Increment(Int64)	Ökar ett värde.
IMinMaxValue<Int64>.MaxValue	Hämtar det maximala värdet för den aktuella typen.
IMinMaxValue<Int64>.MinValue	Hämtar det lägsta värdet för den aktuella typen.
IModulusOperators<Int64,Int64,Int64>.Modulus(Int64, Int64)	Delar upp två värden för att beräkna deras modulus eller rest.
IMultiplicativeIdentity<Int64,Int64>.MultiplicativeIdentity	Hämtar den multiplicativa identiteten för den aktuella typen.
IMultiplyOperators<Int64,Int64,Int64>.CheckedMultiply(Int64, Int64)	Multiplicerar två värden tillsammans för att beräkna produkten.
IMultiplyOperators<Int64,Int64,Int64>.Multiply(Int64, Int64)	Multiplicerar två värden tillsammans för att beräkna produkten.
INumber<Int64>.MaxNumber(Int64, Int64)	Jämför två värden med beräkning som är större och returnerar det andra värdet om en indata är NaN.
INumber<Int64>.MinNumber(Int64, Int64)	Jämför två värden med beräkning som är mindre och returnerar det andra värdet om en indata är NaN.
INumberBase<Int64>.IsCanonical(Int64)	Avgör om ett värde finns i dess kanoniska representation.
INumberBase<Int64>.IsComplexNumber(Int64)	Avgör om ett värde representerar ett komplext tal.
INumberBase<Int64>.IsFinite(Int64)	Avgör om ett värde är begränsat.
INumberBase<Int64>.IsImaginaryNumber(Int64)	Avgör om ett värde representerar ett rent imaginärt tal.
INumberBase<Int64>.IsInfinity(Int64)	Avgör om ett värde är oändligt.
INumberBase<Int64>.IsInteger(Int64)	Avgör om ett värde representerar ett heltal.
INumberBase<Int64>.IsNaN(Int64)	Avgör om ett värde är NaN.
INumberBase<Int64>.IsNegativeInfinity(Int64)	Avgör om ett värde är negativ oändlighet.
INumberBase<Int64>.IsNormal(Int64)	Avgör om ett värde är normalt.
INumberBase<Int64>.IsPositiveInfinity(Int64)	Avgör om ett värde är positiv oändlighet.
INumberBase<Int64>.IsRealNumber(Int64)	Avgör om ett värde representerar ett verkligt tal.
INumberBase<Int64>.IsSubnormal(Int64)	Avgör om ett värde är subnormalt.
INumberBase<Int64>.IsZero(Int64)	Avgör om ett värde är noll.
INumberBase<Int64>.MaxMagnitudeNumber(Int64, Int64)	Jämför två värden med beräkning som har större storlek och returnerar det andra värdet om en indata är NaN.
INumberBase<Int64>.MinMagnitudeNumber(Int64, Int64)	Jämför två värden med beräkning som har mindre storlek och returnerar det andra värdet om en indata är NaN.
INumberBase<Int64>.MultiplyAddEstimate(Int64, Int64, Int64)	Beräknar en uppskattning av (left * right) + addend.
INumberBase<Int64>.One	Hämtar värdet 1 för typen.
INumberBase<Int64>.Radix	Hämtar radixet, eller basen, för typen.
INumberBase<Int64>.TryConvertFromChecked<TOther>(TOther, Int64)	Representerar ett 64-bitars signerat heltal.
INumberBase<Int64>.TryConvertFromSaturating<TOther>(TOther, Int64)	Representerar ett 64-bitars signerat heltal.
INumberBase<Int64>.TryConvertFromTruncating<TOther>(TOther, Int64)	Representerar ett 64-bitars signerat heltal.
INumberBase<Int64>.TryConvertToChecked<TOther>(Int64, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ, vilket utlöser ett spill-undantag för värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Int64>.TryConvertToSaturating<TOther>(Int64, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ, vilket mättar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Int64>.TryConvertToTruncating<TOther>(Int64, TOther)	Försöker konvertera en instans av den aktuella typen till en annan typ och trunkerar alla värden som ligger utanför det representerarbara intervallet för den aktuella typen.
INumberBase<Int64>.Zero	Hämtar värdet 0 för typen.
IShiftOperators<Int64,Int32,Int64>.LeftShift(Int64, Int32)	Flyttar ett värde som lämnas av ett visst belopp.
IShiftOperators<Int64,Int32,Int64>.RightShift(Int64, Int32)	Flyttar ett värde efter ett visst belopp.
IShiftOperators<Int64,Int32,Int64>.UnsignedRightShift(Int64, Int32)	Flyttar ett värde efter ett visst belopp.
ISignedNumber<Int64>.NegativeOne	Hämtar värdet -1 för typen.
ISubtractionOperators<Int64,Int64,Int64>.CheckedSubtraction(Int64, Int64)	Subtraherar två värden för att beräkna skillnaden.
ISubtractionOperators<Int64,Int64,Int64>.Subtraction(Int64, Int64)	Subtraherar två värden för att beräkna skillnaden.
IUnaryNegationOperators<Int64,Int64>.CheckedUnaryNegation(Int64)	Beräknar den kontrollerade obevakade negationen av ett värde.
IUnaryNegationOperators<Int64,Int64>.UnaryNegation(Int64)	Beräknar en oharisk negation av ett värde.
IUnaryPlusOperators<Int64,Int64>.UnaryPlus(Int64)	Beräknar det unary plus av ett värde.

Trådsäkerhet

Alla medlemmar av den här typen är trådsäkra. Medlemmar som verkar ändra instanstillstånd returnerar faktiskt en ny instans som initierats med det nya värdet. Precis som med andra typer måste läsning och skrivning till en delad variabel som innehåller en instans av den här typen skyddas av ett lås för att garantera trådsäkerheten.

Se även

• UInt64
• Exempel: Formateringsverktyget för .NET Core WinForms (C#)
• Exempel: Formateringsverktyget för .NET Core WinForms (Visual Basic)