Int64 Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Stellt eine 64-Bit-Ganzzahl mit Vorzeichen dar.

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 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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<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)

Vererbung

Object

ValueType

Int64

Implementiert

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>

Hinweise

Int64 ist ein unveränderlicher Werttyp, der ganze Vorzeichen mit Werten darstellt, die von negativen 9.223.372.036.854.775.808 (die durch die Int64.MinValue Konstante dargestellt wird) bis positiv 9.223.372.036.854.775.807 (die durch die Int64.MaxValue Konstante dargestellt wird). Die .NET Framework enthält auch einen ganzzahligen 64-Bit-Werttyp ohne Vorzeichen, UInt64der Werte zwischen 0 und 18.446.744.073.709.551.615 darstellt.

Instanziieren eines Int64-Werts

Sie können einen Int64 Wert auf verschiedene Arten instanziieren:

• Sie können eine Int64 Variable deklarieren und ihr einen ganzzahligen Literalwert zuweisen, der sich innerhalb des Bereichs des Datentyps Int64 befindet. Im folgenden Beispiel werden zwei Int64 Variablen deklariert und auf diese Weise Werte zugewiesen.

  long number1 = -64301728;
  long number2 = 255486129307;
  

  let number1 = -64301728L
  let number2 = 255486129307L
  

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

• Sie können den Wert eines integralen Typs zuweisen, dessen Bereich eine Teilmenge des Int64 Typs ist. Dies ist eine Erweiterungskonvertierung, für die kein Umwandlungsoperator in C# oder eine Konvertierungsmethode in Visual Basic erforderlich ist. In F# kann nur der Int32 Typ automatisch erweitert werden.

  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
  

• Sie können den Wert eines numerischen Typs zuweisen, dessen Bereich den des Int64 Typs überschreitet. Dies ist eine einschränkende Konvertierung, sodass ein Umwandlungsoperator in C# oder F# und eine Konvertierungsmethode in Visual Basic erforderlich ist, wenn Option Strict aktiviert ist. Wenn der numerische Wert ein Single- , Double- oder Decimal -Wert ist, der eine Bruchkomponente enthält, hängt die Behandlung des Bruchteils vom Compiler ab, der die Konvertierung ausführt. Im folgenden Beispiel werden einschränkende Konvertierungen ausgeführt, um Variablen mehrere numerische Werte zuzuweisen 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.
  

• Sie können eine Methode der Convert -Klasse aufrufen, um jeden unterstützten Typ in einen Int64 Wert zu konvertieren. Dies ist möglich, da Int64 die IConvertible Schnittstelle unterstützt wird. Das folgende Beispiel veranschaulicht die Konvertierung eines Arrays von Decimal Werten in Int64 Werte.

  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.
  

• Sie können die Parse -Methode oder TryParse aufrufen, um die Zeichenfolgendarstellung eines Int64 Werts in einen Int64zu konvertieren. Die Zeichenfolge kann dezimale oder hexadezimale Ziffern enthalten. Im folgenden Beispiel wird der Analysevorgang veranschaulicht, indem sowohl eine dezimale als auch eine hexadezimale Zeichenfolge verwendet wird.

  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
  

Ausführen von Vorgängen für Int64-Werte

Der Int64 Typ unterstützt mathematische Standardvorgänge wie Addition, Subtraktion, Division, Multiplikation, Negation und unäre Negation. Wie die anderen integralen Typen unterstützt der Int64 Typ auch die bitweisen ANDOperatoren , OR, , XORlinks und rechts.

Sie können die numerischen Standardoperatoren verwenden, um zwei Int64 Werte zu vergleichen, oder Sie können die CompareTo -Methode oder Equals aufrufen.

Sie können auch die Member der Math -Klasse aufrufen, um einen großen Bereich von numerischen Vorgängen auszuführen, einschließlich des Abrufens des absoluten Werts einer Zahl, berechnen des Quotienten und Rests aus der integralen Division, Bestimmen des Maximalen oder Minimalwerts von zwei langen ganzen Zahlen, Abrufen des Vorzeichens einer Zahl und Runden einer Zahl.

Darstellen eines Int64 als Zeichenfolge

Der Int64 Typ bietet vollständige Unterstützung für standardmäßige und benutzerdefinierte numerische Formatzeichenfolgen. (Weitere Informationen finden Sie unter Formatierungstypen, numerische Standardformatzeichenfolgen und benutzerdefinierte numerische Formatzeichenfolgen.)

Um einen Int64 Wert als integrale Zeichenfolge ohne führende Nullen zu formatieren, können Sie die parameterlose ToString() Methode aufrufen. Mit dem Formatbezeichner "D" können Sie auch eine angegebene Anzahl führender Nullen in die Zeichenfolgendarstellung einschließen. Mithilfe des Formatbezeichners "N" können Sie Gruppentrennzeichen einschließen und die Anzahl der Dezimalstellen angeben, die in der Zeichenfolgendarstellung der Zahl angezeigt werden sollen. Mithilfe des Formatbezeichners "X" können Sie einen Int64 Wert als hexadezimale Zeichenfolge darstellen. Im folgenden Beispiel werden die Elemente in einem Array von Int64 Werten auf diese vier Arten formatiert.

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

Sie können einen Int64 Wert auch als binäre, oktale, dezimale oder hexadezimale Zeichenfolge formatieren, indem Sie die ToString(Int64, Int32) -Methode aufrufen und die Basis als zweiten Parameter der Methode angeben. Im folgenden Beispiel wird diese Methode aufgerufen, um die binären, oktalen und hexadezimalen Darstellungen eines Arrays ganzzahliger Werte anzuzeigen.

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

Arbeiten mit nicht dezimalen 32-Bit-Ganzzahlwerten

Neben der Arbeit mit einzelnen langen Ganzzahlen als Dezimalwerte können Sie bitweise Vorgänge mit langen ganzzahligen Werten ausführen oder mit den binären oder hexadezimalen Darstellungen langer ganzzahliger Werte arbeiten. Int64 Werte werden in 63 Bits dargestellt, wobei das vierundsechzig bit als Zeichenbit verwendet wird. Positive Werte werden mithilfe der Darstellung von Vorzeichen und Größenangaben dargestellt. Negative Werte befinden sich in der Komplementdarstellung von zwei. Dies ist wichtig zu beachten, wenn Sie bitweise Vorgänge für Int64 Werte ausführen oder mit einzelnen Bits arbeiten. Um einen numerischen, booleschen oder vergleichsvorgang für zwei beliebige Nichtdezimalwerte auszuführen, müssen beide Werte dieselbe Darstellung verwenden.

Felder

MaxValue	Stellt den größtmöglichen Wert von Int64 dar. Dieses Feld ist konstant.
MinValue	Stellt den kleinstmöglichen Wert vom Typ Int64 dar. Dieses Feld ist konstant.

Methoden

Abs(Int64)	Berechnet das Absolute eines Werts.
Clamp(Int64, Int64, Int64)	Klemmt einen Wert auf einen inklusiven Minimal- und Höchstwert.
CompareTo(Int64)	Vergleicht diese Instanz mit einer angegebenen 64-Bit-Ganzzahl mit Vorzeichen und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.
CompareTo(Object)	Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.
CopySign(Int64, Int64)	Kopiert das Vorzeichen eines Werts in das Vorzeichen eines anderen Werts.
CreateChecked<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateSaturating<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem -Wert und sättigt alle Werte, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateTruncating<TOther>(TOther)	Erstellt eine instance des aktuellen Typs aus einem Wert und schneidet alle Werte ab, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
DivRem(Int64, Int64)	Berechnet den Quotienten und den Rest von zwei Werten.
Equals(Int64)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Int64-Wert ist.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
GetTypeCode()	Gibt den TypeCode für den Werttyp Int64 zurück.
IsEvenInteger(Int64)	Bestimmt, ob ein Wert eine gerade ganzzahlige Zahl darstellt.
IsNegative(Int64)	Bestimmt, ob ein Wert negativ ist.
IsOddInteger(Int64)	Bestimmt, ob ein Wert eine ungerade ganzzahlige Zahl darstellt.
IsPositive(Int64)	Bestimmt, ob ein Wert positiv ist.
IsPow2(Int64)	Bestimmt, ob ein Wert eine Potenz von zwei ist.
LeadingZeroCount(Int64)	Berechnet die Anzahl der führenden Nullen in einem Wert.
Log2(Int64)	Berechnet das Protokoll2 eines Werts.
Max(Int64, Int64)	Vergleicht zwei Werte mit einem höheren Computewert.
MaxMagnitude(Int64, Int64)	Vergleicht zwei Werte mit einem höheren Computewert.
Min(Int64, Int64)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
MinMagnitude(Int64, Int64)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analysiert eine Spanne von UTF-8-Zeichen in einen Wert.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analysiert eine Spanne von UTF-8-Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen.
PopCount(Int64)	Berechnet die Anzahl der Bits, die in einem -Wert festgelegt sind.
RotateLeft(Int64, Int32)	Rotiert einen Wert nach links um einen bestimmten Betrag.
RotateRight(Int64, Int32)	Rotiert einen Wert um einen bestimmten Betrag nach rechts.
Sign(Int64)	Berechnet das Vorzeichen eines Werts.
ToString()	Konvertiert den Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung.
ToString(IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Berücksichtigung der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
ToString(String)	Konvertiert den numerischen Wert dieser Instanz in die entsprechende Zeichenfolgendarstellung unter Berücksichtigung des angegebenen Formats.
ToString(String, IFormatProvider)	Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.
TrailingZeroCount(Int64)	Berechnet die Anzahl der nachfolgenden Nullen in einem Wert.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert des aktuellen instance als UTF-8 in die angegebene Bytesspanne zu formatieren.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Instanz der langen Zahl in die angegebene Zeichenspanne zu formatieren.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int64)	Versucht, eine Spanne von UTF-8-Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Byte>, Int64)	Versucht, eine UTF-8-Zeichenspanne, die die Zeichenfolgendarstellung einer Zahl enthält, in ihre 64-Bit-Entsprechung ganzzahliger Zeichen zu konvertieren.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int64)	Versucht, eine Spanne von UTF-8-Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Int64)	Versucht, eine Spanne von Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, Int64)	Konvertiert die Spannendarstellung einer Zahl in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int64)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, IFormatProvider, Int64)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(String, Int64)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.
TryParse(String, NumberStyles, IFormatProvider, Int64)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 64-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war oder nicht.

Explizite Schnittstellenimplementierungen

IAdditionOperators<Int64,Int64,Int64>.Addition(Int64, Int64)	Fügt zwei Werte zusammen, um deren Summe zu berechnen.
IAdditionOperators<Int64,Int64,Int64>.CheckedAddition(Int64, Int64)	Fügt zwei Werte zusammen, um deren Summe zu berechnen.
IAdditiveIdentity<Int64,Int64>.AdditiveIdentity	Ruft die additive Identität des aktuellen Typs ab.
IBinaryInteger<Int64>.GetByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteLittleEndian(Span<Byte>, Int32)geschrieben werden.
IBinaryInteger<Int64>.GetShortestBitLength()	Ruft die Länge der komplementen Darstellung des aktuellen Werts in Bits ab.
IBinaryInteger<Int64>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Int64)	Stellt eine 64-Bit-Ganzzahl mit Vorzeichen dar.
IBinaryInteger<Int64>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Int64)	Stellt eine 64-Bit-Ganzzahl mit Vorzeichen dar.
IBinaryInteger<Int64>.TryWriteBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Big-Endian-Format in eine bestimmte Spanne zu schreiben.
IBinaryInteger<Int64>.TryWriteLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Little-Endian-Format in eine bestimmte Spanne zu schreiben.
IBinaryNumber<Int64>.AllBitsSet	Ruft eine instance des binären Typs ab, in dem alle Bits festgelegt sind.
IBitwiseOperators<Int64,Int64,Int64>.BitwiseAnd(Int64, Int64)	Berechnet das bitweise und von zwei Werten.
IBitwiseOperators<Int64,Int64,Int64>.BitwiseOr(Int64, Int64)	Berechnet das bitweise oder von zwei Werten.
IBitwiseOperators<Int64,Int64,Int64>.ExclusiveOr(Int64, Int64)	Berechnet den exklusiven oder von zwei Werten.
IBitwiseOperators<Int64,Int64,Int64>.OnesComplement(Int64)	Berechnet die Eins-Komplement-Darstellung eines angegebenen Werts.
IComparisonOperators<Int64,Int64,Boolean>.GreaterThan(Int64, Int64)	Vergleicht zwei Werte, um zu bestimmen, welcher größer ist.
IComparisonOperators<Int64,Int64,Boolean>.GreaterThanOrEqual(Int64, Int64)	Vergleicht zwei Werte, um zu bestimmen, welche größer oder gleich sind.
IComparisonOperators<Int64,Int64,Boolean>.LessThan(Int64, Int64)	Vergleicht zwei Werte, um zu bestimmen, welcher kleiner ist.
IComparisonOperators<Int64,Int64,Boolean>.LessThanOrEqual(Int64, Int64)	Vergleicht zwei Werte, um zu bestimmen, welcher kleiner oder gleich ist.
IConvertible.ToBoolean(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Diese Konvertierung wird nicht unterstützt. Bei dem Versuch der Verwendung dieser Methode wird eine InvalidCastException ausgelöst.
IConvertible.ToDecimal(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Eine Beschreibung dieses Elements finden Sie unter ToUInt64(IFormatProvider).
IDecrementOperators<Int64>.CheckedDecrement(Int64)	Verringert einen Wert.
IDecrementOperators<Int64>.Decrement(Int64)	Verringert einen Wert.
IDivisionOperators<Int64,Int64,Int64>.Division(Int64, Int64)	Dividiert einen Wert durch einen anderen, um den Quotienten zu berechnen.
IEqualityOperators<Int64,Int64,Boolean>.Equality(Int64, Int64)	Vergleicht zwei Werte, um die Gleichheit zu bestimmen.
IEqualityOperators<Int64,Int64,Boolean>.Inequality(Int64, Int64)	Vergleicht zwei Werte, um ungleichheit zu bestimmen.
IIncrementOperators<Int64>.CheckedIncrement(Int64)	Erhöht einen Wert.
IIncrementOperators<Int64>.Increment(Int64)	Erhöht einen Wert.
IMinMaxValue<Int64>.MaxValue	Ruft den Maximalwert des aktuellen Typs ab.
IMinMaxValue<Int64>.MinValue	Ruft den Minimalwert des aktuellen Typs ab.
IModulusOperators<Int64,Int64,Int64>.Modulus(Int64, Int64)	Dividiert zwei Werte, um ihren Modulus oder Rest zu berechnen.
IMultiplicativeIdentity<Int64,Int64>.MultiplicativeIdentity	Ruft die multiplikative Identität des aktuellen Typs ab.
IMultiplyOperators<Int64,Int64,Int64>.CheckedMultiply(Int64, Int64)	Multipliziert zwei Werte, um ihr Produkt zu berechnen.
IMultiplyOperators<Int64,Int64,Int64>.Multiply(Int64, Int64)	Multipliziert zwei Werte, um ihr Produkt zu berechnen.
INumber<Int64>.MaxNumber(Int64, Int64)	Vergleicht zwei Werte mit der Berechnung, die größer ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumber<Int64>.MinNumber(Int64, Int64)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<Int64>.IsCanonical(Int64)	Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet.
INumberBase<Int64>.IsComplexNumber(Int64)	Bestimmt, ob ein Wert eine komplexe Zahl darstellt.
INumberBase<Int64>.IsFinite(Int64)	Bestimmt, ob ein Wert endlich ist.
INumberBase<Int64>.IsImaginaryNumber(Int64)	Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt.
INumberBase<Int64>.IsInfinity(Int64)	Bestimmt, ob ein Wert unendlich ist.
INumberBase<Int64>.IsInteger(Int64)	Bestimmt, ob ein Wert eine ganzzahlige Zahl darstellt.
INumberBase<Int64>.IsNaN(Int64)	Bestimmt, ob ein Wert NaN ist.
INumberBase<Int64>.IsNegativeInfinity(Int64)	Bestimmt, ob ein Wert negativ unendlich ist.
INumberBase<Int64>.IsNormal(Int64)	Bestimmt, ob ein Wert normal ist.
INumberBase<Int64>.IsPositiveInfinity(Int64)	Bestimmt, ob ein Wert positiv unendlich ist.
INumberBase<Int64>.IsRealNumber(Int64)	Bestimmt, ob ein Wert eine reelle Zahl darstellt.
INumberBase<Int64>.IsSubnormal(Int64)	Bestimmt, ob ein Wert subnormal ist.
INumberBase<Int64>.IsZero(Int64)	Bestimmt, ob ein Wert 0 ist.
INumberBase<Int64>.MaxMagnitudeNumber(Int64, Int64)	Vergleicht zwei Werte mit der Berechnung, die die größere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<Int64>.MinMagnitudeNumber(Int64, Int64)	Vergleicht zwei Werte mit der Berechnung, die die geringere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<Int64>.One	Ruft den Wert 1 für den Typ ab.
INumberBase<Int64>.Radix	Ruft die Basis für den Typ ab.
INumberBase<Int64>.TryConvertFromChecked<TOther>(TOther, Int64)	Stellt eine 64-Bit-Ganzzahl mit Vorzeichen dar.
INumberBase<Int64>.TryConvertFromSaturating<TOther>(TOther, Int64)	Stellt eine 64-Bit-Ganzzahl mit Vorzeichen dar.
INumberBase<Int64>.TryConvertFromTruncating<TOther>(TOther, Int64)	Stellt eine 64-Bit-Ganzzahl mit Vorzeichen dar.
INumberBase<Int64>.TryConvertToChecked<TOther>(Int64, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Int64>.TryConvertToSaturating<TOther>(Int64, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren und dabei alle Werte zu überlasten, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Int64>.TryConvertToTruncating<TOther>(Int64, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Int64>.Zero	Ruft den Wert 0 für den Typ ab.
IShiftOperators<Int64,Int32,Int64>.LeftShift(Int64, Int32)	Verschiebt einen Wert, der von einem bestimmten Betrag übrig bleibt.
IShiftOperators<Int64,Int32,Int64>.RightShift(Int64, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
IShiftOperators<Int64,Int32,Int64>.UnsignedRightShift(Int64, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
ISignedNumber<Int64>.NegativeOne	Ruft den Wert -1 für den Typ ab.
ISubtractionOperators<Int64,Int64,Int64>.CheckedSubtraction(Int64, Int64)	Subtrahiert zwei Werte, um deren Differenz zu berechnen.
ISubtractionOperators<Int64,Int64,Int64>.Subtraction(Int64, Int64)	Subtrahiert zwei Werte, um deren Differenz zu berechnen.
IUnaryNegationOperators<Int64,Int64>.CheckedUnaryNegation(Int64)	Berechnet die überprüfte unäre Negation eines Werts.
IUnaryNegationOperators<Int64,Int64>.UnaryNegation(Int64)	Berechnet die unäre Negation eines Werts.
IUnaryPlusOperators<Int64,Int64>.UnaryPlus(Int64)	Berechnet das unäre Plus eines Werts.

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Elemente, die instance Zustand ändern, geben tatsächlich eine neue instance zurück, die mit dem neuen Wert initialisiert wurde. Wie bei jedem anderen Typ muss das Lesen und Schreiben in eine freigegebene Variable, die eine instance dieses Typs enthält, durch eine Sperre geschützt werden, um die Threadsicherheit zu gewährleisten.

Weitere Informationen

• UInt64
• Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (C#)
• Beispiel: .NET Core-Hilfsprogramm zur Formatierung von WinForms (Visual Basic)