Int64 Struktur

Definition

Stellt eine 64-Bit-Ganzzahl mit Vorzeichen dar.

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 : IAdditionOperators<long, long, long>, IAdditiveIdentity<long, long>, IBinaryInteger<long>, IBinaryNumber<long>, IBitwiseOperators<long, long, long>, IComparable<long>, IComparisonOperators<long, long>, IConvertible, IDecrementOperators<long>, IDivisionOperators<long, long, long>, IEqualityOperators<long, long>, IEquatable<long>, IIncrementOperators<long>, IMinMaxValue<long>, IModulusOperators<long, long, long>, IMultiplicativeIdentity<long, long>, IMultiplyOperators<long, long, long>, INumber<long>, IParseable<long>, IShiftOperators<long, long>, ISignedNumber<long>, ISpanParseable<long>, ISubtractionOperators<long, long, long>, IUnaryNegationOperators<long, long>, 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 : IAdditionOperators<long,long,long>, IAdditiveIdentity<long,long>, IBinaryInteger<long>, IBinaryNumber<long>, IBitwiseOperators<long,long,long>, IComparable<long>, IComparisonOperators<long,long>, IConvertible, IDecrementOperators<long>, IDivisionOperators<long,long,long>, IEqualityOperators<long,long>, IEquatable<long>, IIncrementOperators<long>, IMinMaxValue<long>, IModulusOperators<long,long,long>, IMultiplicativeIdentity<long,long>, IMultiplyOperators<long,long,long>, INumber<long>, IParseable<long>, IShiftOperators<long,long>, ISignedNumber<long>, ISpanParseable<long>, ISubtractionOperators<long,long,long>, IUnaryNegationOperators<long,long>, 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 ISpanFormattable
    interface IFormattable
    interface IBinaryInteger<int64>
    interface IBinaryNumber<int64>
    interface IBitwiseOperators<int64, int64, int64>
    interface INumber<int64>
    interface IAdditionOperators<int64, int64, int64>
    interface IAdditiveIdentity<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 IParseable<int64>
    interface ISpanParseable<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), IParseable(Of Long), IShiftOperators(Of Long, Long), ISignedNumber(Of Long), ISpanParseable(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
Vererbung
Attribute
Implementiert

Hinweise

Int64 ist ein unveränderlicher Werttyp, der signierte ganze Zahlen mit Werten darstellt, die sich aus negativen 9.223.372.036.854.775.808 (dargestellt durch die Konstante) durch positive 9.223.372.036.854.775.807 (dargestellt durch die Int64.MinValue Int64.MaxValue Konstante) darstellen. Die .NET Framework enthält auch einen nicht signierten 64-Bit-Ganzzahlwerttyp, UInt64der Werte darstellt, die zwischen 0 und 18.446.744.073.709.551.615 liegen.

Instanziieren eines Int64-Werts

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

  • Sie können eine Int64 Variable deklarieren und ihm einen Literalzahlwert zuweisen, der sich im Bereich des Int64 Datentyps befindet. Im folgenden Beispiel werden zwei Int64 Variablen deklariert und diese Werte auf diese Weise 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, die keinen Castoperator in C# oder eine Konvertierungsmethode in Visual Basic erfordert. 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 Wert des Int64 Typs überschreitet. Dies ist eine schmale Konvertierung, sodass ein Castoperator in C# oder F# und eine Konvertierungsmethode in Visual Basic erforderlich ist, wenn Option Strict es sich um eine Option handelt. Wenn der numerische Wert ein , Doubleoder Decimal ein Wert ist, der eine SingleBruchkomponente enthält, hängt die Behandlung des Bruchteils vom Compiler ab, der die Konvertierung ausführt. Im folgenden Beispiel wird eine Verschränkung von Konvertierungen ausgeführt, um variablen mehrere numerische Werte Int64 zuzuweisen.

    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. Im folgenden Beispiel wird die Konvertierung eines Arrays von Decimal Werten in Int64 Werte veranschaulicht.

    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 TryParse Zeichenfolgendarstellung eines Werts in einen Int64 Int64Wert konvertieren oder eine Methode aufrufen. Die Zeichenfolge kann entweder dezimale oder hexadezimale Ziffern enthalten. Im folgenden Beispiel wird der Analysevorgang veranschaulicht, indem sie sowohl eine Dezimal- als auch eine Hexadezimalzeichenfolge verwenden.

    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 auf Int64-Werten

Der Int64 Typ unterstützt standardmäßige mathematische Vorgänge wie Ergänzung, Subtraktion, Abteilung, Multiplikation, Negation und nichtary Negation. Wie die anderen integralen Typen unterstützt der Int64 Typ auch die BitweiseAND, OR``XOR, die linke Umschalt- und die rechte Schichtoperatoren.

Sie können die standardmäßigen numerischen Operatoren verwenden, um zwei Int64 Werte zu vergleichen, oder Sie können die CompareTo Equals Methode aufrufen.

Sie können auch die Mitglieder der Math Klasse aufrufen, um einen breiten Bereich numerischer Vorgänge auszuführen, einschließlich des absoluten Werts einer Zahl, der Berechnung des Quotienten und des Rests aus der integralen Abteilung, bestimmen den maximalen oder minimalen Wert von zwei langen ganzzahligen Zahlen, das Abrufen des Zeichens einer Zahl und das Runden einer Zahl.

Darstellen einer Int64 als Zeichenfolge

Der Int64 Typ bietet vollständige Unterstützung für Standard- und benutzerdefinierte numerische Formatzeichenfolgen. (Weitere Informationen finden Sie unter Formatierungstypen, Standard numerische Formatzeichenfolgen 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. Mithilfe des Formatbezeichners "D" können Sie auch eine angegebene Anzahl von führenden Nullen in die Zeichenfolgendarstellung einschließen. Mithilfe des N-Formatauszeichners können Sie Gruppentrennzeichen einschließen und die Anzahl der dezimalen Ziffern angeben, die in der Zeichenfolgendarstellung der Zahl angezeigt werden sollen. Mithilfe des Formatbezeichners "X" können Sie einen Int64 Wert als Hexadezimalzeichenfolge 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 auch einen Int64 Wert 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äre, oktale und hexadezimale Darstellung eines Arrays von ganzzahligen Werten 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

Zusätzlich zum Arbeiten mit einzelnen langen ganzzahligen Zahlen als Dezimalwerte können Sie Bitzeigervorgänge mit langen ganzzahligen Werten ausführen oder mit den binären oder hexadezimalen Darstellungen von langen ganzzahligen Werten arbeiten. Int64 Werte werden in 63 Bit dargestellt, wobei der sechszig-vierte Bit als Signierbit verwendet wird. Positive Werte werden mithilfe von Sign-and-Magnitude-Darstellung dargestellt. Negative Werte befinden sich in der Ergänzungsdarstellung von zwei. Dies ist wichtig, wenn Sie bitweise Vorgänge auf Int64 Werten oder beim Arbeiten mit einzelnen Bits ausführen. Um einen numerischen, booleschen oder Vergleichsvorgang für alle zwei nicht dezimalen Werte 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

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.

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.

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.

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.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Versucht, den Wert der aktuellen Instanz der langen Zahl in die angegebene Zeichenspanne zu formatieren.

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, 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

IComparable.CompareTo(Object)

Vergleicht diese Instanz mit einem angegebenen Objekt und gibt eine Angabe über das Verhältnis der entsprechenden Werte zurück.

IConvertible.GetTypeCode()

Gibt den TypeCode für den Werttyp Int64 zurück.

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).

Gilt für:

Threadsicherheit

Alle Elemente dieses Typs sind threadsicher. Elemente, die den Instanzstatus ändern möchten, geben tatsächlich eine neue Instanz zurück, die mit dem neuen Wert initialisiert wurde. Wie bei jedem anderen Typ muss das Lesen und Schreiben an eine freigegebene Variable, die eine Instanz dieses Typs enthält, durch eine Sperrung geschützt werden, um die Threadsicherheit zu gewährleisten.

Siehe auch