Int32 Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Stellt eine 32-Bit-Ganzzahl mit Vorzeichen dar.

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

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

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

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

Vererbung

Object

ValueType

Int32

Implementiert

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

Hinweise

Int32 ist ein unveränderlicher Werttyp, der ganze Zahlen mit Vorzeichen mit Werten darstellt, die von negativen 2.147.483.648 (die durch die Int32.MinValue Konstante dargestellt werden) bis zu positiven 2.147.483.647 (die durch die Int32.MaxValue Konstante dargestellt wird) reichen. .NET enthält auch einen ganzzahligen 32-Bit-Werttyp ohne Vorzeichen, UInt32der Werte zwischen 0 und 4.294.967.295 darstellt.

Instanziieren eines Int32-Werts

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

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

  int number1 = 64301;
  int number2 = 25548612;
  

  let number1 = 64301
  let number2 = 25548612
  

  Dim number1 As Integer = 64301
  Dim number2 As Integer = 25548612
  

• Sie können den Wert eines Ganzzahltyps zuweisen, dessen Bereich eine Teilmenge des Int32 Typs ist. Dies ist eine Erweiterungskonvertierung, die keinen Umwandlungsoperator in C# oder eine Konvertierungsmethode in Visual Basic erfordert, aber einen in F#.

  sbyte value1 = 124;
  short value2 = 1618;
  
  int number1 = value1;
  int number2 = value2;
  

  let value1 = 124y
  let value2 = 1618s
  
  let number1 = int value1
  let number2 = int value2
  

  Dim value1 As SByte = 124
  Dim value2 As Int16 = 1618
  
  Dim number1 As Integer = value1
  Dim number2 As Integer = value2
  

• Sie können den Wert eines numerischen Typs zuweisen, dessen Bereich den des Int32 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 davon ab, dass der Compiler die Konvertierung durchführt. Im folgenden Beispiel werden einschränkende Konvertierungen ausgeführt, um Variablen mehrere numerische Werte zuzuweisen Int32 .

  long lNumber = 163245617;
  try {
     int number1 = (int) lNumber;
     Console.WriteLine(number1);
  }
  catch (OverflowException) {
     Console.WriteLine("{0} is out of range of an Int32.", lNumber);
  }
  
  double dbl2 = 35901.997;
  try {
     int number2 = (int) dbl2;
     Console.WriteLine(number2);
  }
  catch (OverflowException) {
     Console.WriteLine("{0} is out of range of an Int32.", dbl2);
  }
  
  BigInteger bigNumber = 132451;
  try {
     int number3 = (int) bigNumber;
     Console.WriteLine(number3);
  }
  catch (OverflowException) {
     Console.WriteLine("{0} is out of range of an Int32.", bigNumber);
  }
  // The example displays the following output:
  //       163245617
  //       35902
  //       132451
  

  let lNumber = 163245617L
  try
      let number1 = int lNumber
      printfn $"{number1}"
  with :? OverflowException ->
      printfn "{lNumber} is out of range of an Int32."
  
  let dbl2 = 35901.997
  try
      let number2 = int dbl2
      printfn $"{number2}"
  with :? OverflowException ->
      printfn $"{dbl2} is out of range of an Int32."
  
  let bigNumber = BigInteger 132451
  try
      let number3 = int bigNumber
      printfn $"{number3}"
  with :? OverflowException ->
      printfn $"{bigNumber} is out of range of an Int32."
  
  // The example displays the following output:
  //       163245617
  //       35902
  //       132451
  

  Dim lNumber As Long = 163245617
  Try
     Dim number1 As Integer = CInt(lNumber)
     Console.WriteLine(number1)
  Catch e As OverflowException
     Console.WriteLine("{0} is out of range of an Int32.", lNumber)
  End Try
  
  Dim dbl2 As Double = 35901.997
  Try
     Dim number2 As Integer = CInt(dbl2)
     Console.WriteLine(number2)
  Catch e As OverflowException
     Console.WriteLine("{0} is out of range of an Int32.", dbl2)
  End Try
     
  Dim bigNumber As BigInteger = 132451
  Try
     Dim number3 As Integer = CInt(bigNumber)
     Console.WriteLine(number3)
  Catch e As OverflowException
     Console.WriteLine("{0} is out of range of an Int32.", bigNumber)
  End Try    
  ' The example displays the following output:
  '       163245617
  '       35902
  '       132451
  

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

  decimal[] values= { Decimal.MinValue, -1034.23m, -12m, 0m, 147m,
                      199.55m, 9214.16m, Decimal.MaxValue };
  int result;
  
  foreach (decimal value in values)
  {
     try {
        result = Convert.ToInt32(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 Int32 type.",
                          value);
     }
  }
  // The example displays the following output:
  //    -79228162514264337593543950335 is outside the range of the Int32 type.
  //    Converted the Decimal value '-1034.23' to the Int32 value -1034.
  //    Converted the Decimal value '-12' to the Int32 value -12.
  //    Converted the Decimal value '0' to the Int32 value 0.
  //    Converted the Decimal value '147' to the Int32 value 147.
  //    Converted the Decimal value '199.55' to the Int32 value 200.
  //    Converted the Decimal value '9214.16' to the Int32 value 9214.
  //    79228162514264337593543950335 is outside the range of the Int32 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.ToInt32 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 Int32 type."
     
  // The example displays the following output:
  //    -79228162514264337593543950335 is outside the range of the Int32 type.
  //    Converted the Decimal value '-1034.23' to the Int32 value -1034.
  //    Converted the Decimal value '-12' to the Int32 value -12.
  //    Converted the Decimal value '0' to the Int32 value 0.
  //    Converted the Decimal value '147' to the Int32 value 147.
  //    Converted the Decimal value '199.55' to the Int32 value 200.
  //    Converted the Decimal value '9214.16' to the Int32 value 9214.
  //    79228162514264337593543950335 is outside the range of the Int32 type.
  

  Dim values() As Decimal = { Decimal.MinValue, -1034.23d, -12d, 0d, 147d, _
                              199.55d, 9214.16d, Decimal.MaxValue }
  Dim result As Integer
  
  For Each value As Decimal In values
     Try
        result = Convert.ToInt32(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 Int32 type.", _
                          value)
     End Try   
  Next                                  
  ' The example displays the following output:
  '    -79228162514264337593543950335 is outside the range of the Int32 type.
  '    Converted the Decimal value '-1034.23' to the Int32 value -1034.
  '    Converted the Decimal value '-12' to the Int32 value -12.
  '    Converted the Decimal value '0' to the Int32 value 0.
  '    Converted the Decimal value '147' to the Int32 value 147.
  '    Converted the Decimal value '199.55' to the Int32 value 200.
  '    Converted the Decimal value '9214.16' to the Int32 value 9214.
  '    79228162514264337593543950335 is outside the range of the Int32 type.
  

• Sie können die Parse - oder TryParse -Methode aufrufen, um die Zeichenfolgendarstellung eines Int32 Werts in eine Int32zu konvertieren. Die Zeichenfolge kann dezimale oder hexadezimale Ziffern enthalten. Das folgende Beispiel veranschaulicht den Analysevorgang, indem sowohl eine dezimale als auch eine hexadezimale Zeichenfolge verwendet wird.

  string string1 = "244681";
  try {
     int number1 = Int32.Parse(string1);
     Console.WriteLine(number1);
  }
  catch (OverflowException) {
     Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string1);
  }
  catch (FormatException) {
     Console.WriteLine("The format of '{0}' is invalid.", string1);
  }
  
  string string2 = "F9A3C";
  try {
     int number2 = Int32.Parse(string2,
                              System.Globalization.NumberStyles.HexNumber);
     Console.WriteLine(number2);
  }
  catch (OverflowException) {
     Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string2);
  }
  catch (FormatException) {
     Console.WriteLine("The format of '{0}' is invalid.", string2);
  }
  // The example displays the following output:
  //       244681
  //       1022524
  

  let string1 = "244681"
  try
      let number1 = Int32.Parse string1
      printfn $"{number1}"
  with
  | :? OverflowException ->
      printfn "'{string1}' is out of range of a 32-bit integer."
  | :? FormatException ->
      printfn $"The format of '{string1}' is invalid."
  
  let string2 = "F9A3C"
  try
      let number2 = Int32.Parse(string2, System.Globalization.NumberStyles.HexNumber)
      printfn $"{number2}"
  with 
  | :? OverflowException ->
      printfn $"'{string2}' is out of range of a 32-bit integer."
  | :? FormatException ->
      printfn $"The format of '{string2}' is invalid."
  
  // The example displays the following output:
  //       244681
  //       1022524
  

  Dim string1 As String = "244681"
  Try
     Dim number1 As Integer = Int32.Parse(string1)
     Console.WriteLine(number1)
  Catch e As OverflowException
     Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string1)
  Catch e As FormatException
     Console.WriteLine("The format of '{0}' is invalid.", string1)
  End Try
  
  Dim string2 As String = "F9A3C"
  Try
     Dim number2 As Integer = Int32.Parse(string2,
                              System.Globalization.NumberStyles.HexNumber)
     Console.WriteLine(number2)
  Catch e As OverflowException
     Console.WriteLine("'{0}' is out of range of a 32-bit integer.", string2)
  Catch e As FormatException
     Console.WriteLine("The format of '{0}' is invalid.", string2)
  End Try
  ' The example displays the following output:
  '       244681
  '       1022524
  

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

Der Int32 Typ unterstützt mathematische Standardoperationen wie Addition, Subtraktion, Division, Multiplikation, Negation und unäre Negation. Wie die anderen integralen Typen unterstützt der Int32 Typ auch die bitweisen ANDOperatoren , OR, XOR, Linksverschiebung und Rechtsverschiebung.

Sie können die numerischen Standardoperatoren verwenden, um zwei Int32 Werte zu vergleichen, oder Sie können die - oder Equals -CompareToMethode aufrufen.

Sie können auch die Member der Math -Klasse aufrufen, um einen breiten Bereich numerischer Vorgänge 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 ganzen Zahlen, Abrufen des Vorzeichens einer Zahl und Runden einer Zahl.

Darstellen eines Int32 als Zeichenfolge

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

Um einen Int32 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 von führenden 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. Mit dem Formatbezeichner "X" können Sie einen Int32 Wert als hexadezimale Zeichenfolge darstellen. Im folgenden Beispiel werden die Elemente in einem Array von Int32 Werten auf diese vier Arten formatiert.

int[] numbers = { -1403, 0, 169, 1483104 };
foreach (int 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,11:D3}", number);
   // Display value with 1 decimal digit.
   Console.Write("{0,13:N1}", number);
   // Display value as hexadecimal.
   Console.Write("{0,12:X2}", number);
   // Display value with eight hexadecimal digits.
   Console.WriteLine("{0,14:X8}", number);
}
// The example displays the following output:
//    -1403     -->         -1403     -1,403.0    FFFFFA85      FFFFFA85
//    0         -->           000          0.0          00      00000000
//    169       -->           169        169.0          A9      000000A9
//    1483104   -->       1483104  1,483,104.0      16A160      0016A160

let numbers = [| -1403; 0; 169; 1483104 |]
for number in numbers do
    // Display value using default formatting.
    printf $"{number,-8}  -->   "
    // Display value with 3 digits and leading zeros.
    printf $"{number,11:D3}"
    // Display value with 1 decimal digit.
    printf $"{number,13:N1}"
    // Display value as hexadecimal.
    printf $"{number,12:X2}"
    // Display value with eight hexadecimal digits.
    printfn $"{number,14:X8}"


  // The example displays the following output:
  //    -1403     -->         -1403     -1,403.0    FFFFFA85      FFFFFA85
  //    0         -->           000          0.0          00      00000000
  //    169       -->           169        169.0          A9      000000A9
  //    1483104   -->       1483104  1,483,104.0      16A160      0016A160

Dim numbers() As Integer = { -1403, 0, 169, 1483104 }
For Each number As Integer In numbers
   ' Display value using default formatting.
   Console.Write("{0,-8}  -->   ", number.ToString())
   ' Display value with 3 digits and leading zeros.
   Console.Write("{0,11:D3}", number) 
   ' Display value with 1 decimal digit.
   Console.Write("{0,13:N1}", number) 
   ' Display value as hexadecimal.
   Console.Write("{0,12:X2}", number) 
   ' Display value with eight hexadecimal digits.
   Console.WriteLine("{0,14:X8}", number)
Next   
' The example displays the following output:
'    -1403     -->         -1403     -1,403.0    FFFFFA85      FFFFFA85
'    0         -->           000          0.0          00      00000000
'    169       -->           169        169.0          A9      000000A9
'    1483104   -->       1483104  1,483,104.0      16A160      0016A160

Sie können einen Int32 Wert auch als binäre, oktale, dezimale oder hexadezimale Zeichenfolge formatieren, indem Sie die ToString(Int32, 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.

int[] numbers = { -146, 11043, 2781913 };
Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}",
                  "Value", "Binary", "Octal", "Hex");
foreach (int number in numbers) {
   Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}",
                     number, Convert.ToString(number, 2),
                     Convert.ToString(number, 8),
                     Convert.ToString(number, 16));
}
// The example displays the following output:
//       Value                             Binary         Octal          Hex
//        -146   11111111111111111111111101101110   37777777556     ffffff6e
//       11043                     10101100100011         25443         2b23
//     2781913             1010100111001011011001      12471331       2a72d9

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

// The example displays the following output:
//       Value                             Binary         Octal          Hex
//        -146   11111111111111111111111101101110   37777777556     ffffff6e
//       11043                     10101100100011         25443         2b23
//     2781913             1010100111001011011001      12471331       2a72d9

Dim numbers() As Integer = { -146, 11043, 2781913 }
Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}", _
                  "Value", "Binary", "Octal", "Hex")
For Each number As Integer In numbers
   Console.WriteLine("{0,8}   {1,32}   {2,11}   {3,10}", _
                     number, Convert.ToString(number, 2), _
                     Convert.ToString(number, 8), _
                     Convert.ToString(number, 16))
Next      
' The example displays the following output:
'       Value                             Binary         Octal          Hex
'        -146   11111111111111111111111101101110   37777777556     ffffff6e
'       11043                     10101100100011         25443         2b23
'     2781913             1010100111001011011001      12471331       2a72d9

Arbeiten mit nicht dezimalen 32-Bit-Ganzzahlwerten

Zusätzlich zur Arbeit mit einzelnen ganzen Zahlen als Dezimalwerte können Sie bitweise Operationen mit ganzzahligen Werten ausführen oder mit den binären oder hexadezimalen Darstellungen ganzzahliger Werte arbeiten. Int32 -Werte werden in 31 Bits dargestellt, wobei das Dreißigsekundebit als Vorzeichenbit verwendet wird. Positive Werte werden mithilfe der Darstellung von Vorzeichen und Größen dargestellt. Negative Werte befinden sich in der Komplementdarstellung von zwei. Dies ist wichtig zu beachten, wenn Sie bitweise Operationen für Int32 Werte ausführen oder mit einzelnen Bits arbeiten. Um einen numerischen, booleschen oder Vergleichsvorgang für zwei beliebige nicht dezimale Werte auszuführen, müssen beide Werte dieselbe Darstellung verwenden.

Felder

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

Methoden

Abs(Int32)	Berechnet das Absolute eines Werts.
Clamp(Int32, Int32, Int32)	Klemmt einen Wert auf einen inklusiven Minimal- und Maximalwert.
CompareTo(Int32)	Vergleicht diese Instanz mit einer angegebenen 32-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(Int32, Int32)	Kopiert das Zeichen eines Werts in das Zeichen 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 einen instance des aktuellen Typs aus einem Wert, der alle Werte überlastt, 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(Int32, Int32)	Berechnet den Quotienten und den Rest von zwei Werten.
Equals(Int32)	Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Int32-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 Int32 zurück.
IsEvenInteger(Int32)	Bestimmt, ob ein Wert eine gerade Integralzahl darstellt.
IsNegative(Int32)	Bestimmt, ob ein Wert negativ ist.
IsOddInteger(Int32)	Bestimmt, ob ein Wert eine ungerade Integralzahl darstellt.
IsPositive(Int32)	Bestimmt, ob ein Wert positiv ist.
IsPow2(Int32)	Bestimmt, ob ein Wert eine Macht von zwei ist.
LeadingZeroCount(Int32)	Berechnet die Anzahl der führenden Nullen in einem Wert.
Log2(Int32)	Berechnet das protokoll2 eines Werts.
Max(Int32, Int32)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
MaxMagnitude(Int32, Int32)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
Min(Int32, Int32)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
MinMagnitude(Int32, Int32)	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 32-Bit-Ganzzahl mit Vorzeichen.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen.
PopCount(Int32)	Berechnet die Anzahl der Bits, die in einem Wert festgelegt sind.
RotateLeft(Int32, Int32)	Rotiert einen Wert, der um einen bestimmten Betrag verlassen wird.
RotateRight(Int32, Int32)	Rotiert einen Wert nach rechts um einen bestimmten Betrag.
Sign(Int32)	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(Int32)	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 bereitgestellte Bytespanne zu formatieren.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der Instanz einer ganzen Zahl in die angegebene Zeichenspanne zu formatieren.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int32)	Versucht, eine Spanne von UTF-8-Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Byte>, Int32)	Versucht, eine UTF-8-Zeichenspanne, die die Zeichenfolgendarstellung einer Zahl enthält, in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen zu konvertieren.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int32)	Versucht, eine Spanne von UTF-8-Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)	Versucht, eine Spanne von Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, Int32)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)	Konvertiert die Spannendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.
TryParse(String, IFormatProvider, Int32)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(String, Int32)	Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.
TryParse(String, NumberStyles, IFormatProvider, Int32)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und einem kulturspezifischen Format in die entsprechende 32-Bit-Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.

Explizite Schnittstellenimplementierungen

IAdditionOperators<Int32,Int32,Int32>.Addition(Int32, Int32)	Fügt zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditionOperators<Int32,Int32,Int32>.CheckedAddition(Int32, Int32)	Fügt zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditiveIdentity<Int32,Int32>.AdditiveIdentity	Ruft die additive Identität des aktuellen Typs ab.
IBinaryInteger<Int32>.GetByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteLittleEndian(Span<Byte>, Int32)geschrieben werden.
IBinaryInteger<Int32>.GetShortestBitLength()	Ruft die Länge der Komplementdarstellung des aktuellen Werts in Bits ab.
IBinaryInteger<Int32>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Int32)	Stellt eine 32-Bit-Ganzzahl mit Vorzeichen dar.
IBinaryInteger<Int32>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Int32)	Stellt eine 32-Bit-Ganzzahl mit Vorzeichen dar.
IBinaryInteger<Int32>.TryWriteBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Big-End-Format in eine bestimmte Spanne zu schreiben.
IBinaryInteger<Int32>.TryWriteLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Little-Endian-Format in eine bestimmte Spanne zu schreiben.
IBinaryNumber<Int32>.AllBitsSet	Ruft eine instance des Binärtyps ab, in dem alle Bits festgelegt sind.
IBitwiseOperators<Int32,Int32,Int32>.BitwiseAnd(Int32, Int32)	Berechnet den bitweisen und von zwei Werten.
IBitwiseOperators<Int32,Int32,Int32>.BitwiseOr(Int32, Int32)	Berechnet den bitweisen oder von zwei Werten.
IBitwiseOperators<Int32,Int32,Int32>.ExclusiveOr(Int32, Int32)	Berechnet den exklusiven oder von zwei Werten.
IBitwiseOperators<Int32,Int32,Int32>.OnesComplement(Int32)	Berechnet die Eins-Komplement-Darstellung eines bestimmten Werts.
IComparisonOperators<Int32,Int32,Boolean>.GreaterThan(Int32, Int32)	Vergleicht zwei Werte, um zu ermitteln, welcher größer ist.
IComparisonOperators<Int32,Int32,Boolean>.GreaterThanOrEqual(Int32, Int32)	Vergleicht zwei Werte, um zu bestimmen, welche größer oder gleich sind.
IComparisonOperators<Int32,Int32,Boolean>.LessThan(Int32, Int32)	Vergleicht zwei Werte, um zu ermitteln, welcher kleiner ist.
IComparisonOperators<Int32,Int32,Boolean>.LessThanOrEqual(Int32, Int32)	Vergleicht zwei Werte, um zu bestimmen, welche kleiner oder gleich sind.
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<Int32>.CheckedDecrement(Int32)	Dekrementiert einen Wert.
IDecrementOperators<Int32>.Decrement(Int32)	Dekrementiert einen Wert.
IDivisionOperators<Int32,Int32,Int32>.Division(Int32, Int32)	Dividiert einen Wert durch einen anderen, um den Quotienten zu berechnen.
IEqualityOperators<Int32,Int32,Boolean>.Equality(Int32, Int32)	Vergleicht zwei Werte, um die Gleichheit zu ermitteln.
IEqualityOperators<Int32,Int32,Boolean>.Inequality(Int32, Int32)	Vergleicht zwei Werte, um Ungleichheit zu ermitteln.
IIncrementOperators<Int32>.CheckedIncrement(Int32)	Erhöht einen Wert.
IIncrementOperators<Int32>.Increment(Int32)	Erhöht einen Wert.
IMinMaxValue<Int32>.MaxValue	Ruft den Maximalwert des aktuellen Typs ab.
IMinMaxValue<Int32>.MinValue	Ruft den Mindestwert des aktuellen Typs ab.
IModulusOperators<Int32,Int32,Int32>.Modulus(Int32, Int32)	Teilt zwei Werte zusammen, um deren Modul oder Rest zu berechnen.
IMultiplicativeIdentity<Int32,Int32>.MultiplicativeIdentity	Ruft die multiplikative Identität des aktuellen Typs ab.
IMultiplyOperators<Int32,Int32,Int32>.CheckedMultiply(Int32, Int32)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
IMultiplyOperators<Int32,Int32,Int32>.Multiply(Int32, Int32)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
INumber<Int32>.MaxNumber(Int32, Int32)	Vergleicht zwei Werte mit der Berechnung, die größer ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumber<Int32>.MinNumber(Int32, Int32)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<Int32>.IsCanonical(Int32)	Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet.
INumberBase<Int32>.IsComplexNumber(Int32)	Bestimmt, ob ein Wert eine komplexe Zahl darstellt.
INumberBase<Int32>.IsFinite(Int32)	Bestimmt, ob ein Wert endlich ist.
INumberBase<Int32>.IsImaginaryNumber(Int32)	Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt.
INumberBase<Int32>.IsInfinity(Int32)	Bestimmt, ob ein Wert unendlich ist.
INumberBase<Int32>.IsInteger(Int32)	Bestimmt, ob ein Wert eine integrale Zahl darstellt.
INumberBase<Int32>.IsNaN(Int32)	Bestimmt, ob ein Wert NaN ist.
INumberBase<Int32>.IsNegativeInfinity(Int32)	Bestimmt, ob ein Wert negativ unendlich ist.
INumberBase<Int32>.IsNormal(Int32)	Bestimmt, ob ein Wert normal ist.
INumberBase<Int32>.IsPositiveInfinity(Int32)	Bestimmt, ob ein Wert positiv unendlich ist.
INumberBase<Int32>.IsRealNumber(Int32)	Bestimmt, ob ein Wert eine reelle Zahl darstellt.
INumberBase<Int32>.IsSubnormal(Int32)	Bestimmt, ob ein Wert subnormal ist.
INumberBase<Int32>.IsZero(Int32)	Bestimmt, ob ein Wert 0 ist.
INumberBase<Int32>.MaxMagnitudeNumber(Int32, Int32)	Vergleicht zwei Werte mit der Berechnung, die die größere Größe hat, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<Int32>.MinMagnitudeNumber(Int32, Int32)	Vergleicht zwei Werte mit einer Berechnung, die die geringere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.
INumberBase<Int32>.One	Ruft den Wert 1 für den Typ ab.
INumberBase<Int32>.Radix	Ruft die Basis für den Typ ab.
INumberBase<Int32>.TryConvertFromChecked<TOther>(TOther, Int32)	Stellt eine 32-Bit-Ganzzahl mit Vorzeichen dar.
INumberBase<Int32>.TryConvertFromSaturating<TOther>(TOther, Int32)	Stellt eine 32-Bit-Ganzzahl mit Vorzeichen dar.
INumberBase<Int32>.TryConvertFromTruncating<TOther>(TOther, Int32)	Stellt eine 32-Bit-Ganzzahl mit Vorzeichen dar.
INumberBase<Int32>.TryConvertToChecked<TOther>(Int32, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wodurch eine Überlaufausnahme für alle Werte ausgelöst wird, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Int32>.TryConvertToSaturating<TOther>(Int32, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen, gesättigt werden.
INumberBase<Int32>.TryConvertToTruncating<TOther>(Int32, TOther)	Versucht, eine instance des aktuellen Typs in einen anderen Typ zu konvertieren, wodurch alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<Int32>.Zero	Ruft den Wert 0 für den Typ ab.
IShiftOperators<Int32,Int32,Int32>.LeftShift(Int32, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach links.
IShiftOperators<Int32,Int32,Int32>.RightShift(Int32, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
IShiftOperators<Int32,Int32,Int32>.UnsignedRightShift(Int32, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
ISignedNumber<Int32>.NegativeOne	Ruft den Wert -1 für den Typ ab.
ISubtractionOperators<Int32,Int32,Int32>.CheckedSubtraction(Int32, Int32)	Subtrahiert zwei Werte, um deren Differenz zu berechnen.
ISubtractionOperators<Int32,Int32,Int32>.Subtraction(Int32, Int32)	Subtrahiert zwei Werte, um deren Differenz zu berechnen.
IUnaryNegationOperators<Int32,Int32>.CheckedUnaryNegation(Int32)	Berechnet die überprüfte unäre Negation eines Werts.
IUnaryNegationOperators<Int32,Int32>.UnaryNegation(Int32)	Berechnet die unäre Negation eines Werts.
IUnaryPlusOperators<Int32,Int32>.UnaryPlus(Int32)	Berechnet das unäre Plus eines Werts.

Threadsicherheit

Alle Member dieses Typs sind threadsicher. Member, die instance Zustand zu ändern scheinen, 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

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