System.Int32-Struktur

Artikel
01/11/2024

Dieser Artikel enthält ergänzende Hinweise zur Referenzdokumentation für diese API.

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

Instanziieren eines Int32-Werts

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

Sie können eine Int32 Variable deklarieren und ihm einen literalen ganzzahligen Wert zuweisen, der sich im Bereich des Int32 Datentyps 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 ganzzahligen Typs zuweisen, dessen Bereich eine Teilmenge des Int32 Typs ist. Dies ist eine Erweiterungskonvertierung, für die kein Umwandlungsoperator in C# oder eine Konvertierungsmethode in Visual Basic erforderlich ist, aber eine konvertierung in F# erforderlich ist.
```
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 Wert des Int32 Typs überschreitet. Dies ist eine schmale Konvertierung, daher ist ein Umwandlungsoperator in C# oder F# und eine Konvertierungsmethode in Visual Basic erforderlich, falls Option Strict aktiviert. Wenn es sich bei dem numerischen Wert um einen Single, Doubleoder Decimal einen Wert handelt, der eine Bruchkomponente enthält, hängt die Behandlung des Bruchteils vom Compiler ab, der die Konvertierung ausführt. Im folgenden Beispiel werden Konvertierungen eingeschränkt, 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. Im folgenden Beispiel wird die Konvertierung eines Arrays von Decimal Werten in Int32 Werte veranschaulicht.

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 TryParse Zeichenfolgendarstellung eines Werts in eine Int32 Int32Zeichenfolge konvertieren. Die Zeichenfolge kann entweder dezimale oder hexadezimale Ziffern enthalten. Im folgenden Beispiel wird der Analysevorgang mithilfe einer dezimalen und einer hexadezimalen Zeichenfolge veranschaulicht.

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 standardmäßige mathematische Operationen wie Addition, Subtraktion, Division, Multiplikation, Negation und unäre Negation. Wie bei den anderen integralen Typen unterstützt der Int32 Typ auch die bitweisen AND, OR, XORlinken Schicht- und Rechtsverschiebungsoperatoren.

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

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 des Re Standard der aus integraler Division, Bestimmen des Höchst- oder Minimalwerts von zwei ganzzahligen Zahlen, Abrufen des Vorzeichens einer Zahl und Runden einer Zahl.

Darstellen eines Int32-Elements als Zeichenfolge

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

Um einen Int32 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-Formatbezeichners können Sie Gruppentrennzeichen einschließen und die Anzahl der Dezimalziffern 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äre, oktale und hexadezimale Darstellung 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

Neben der Arbeit mit einzelnen Ganzzahlen als Dezimalwerte können Sie bitweise Vorgänge 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 31-Sekunden-Bit als Zeichenbit verwendet wird. Positive Werte werden mithilfe einer Zeichen- und Größendarstellung dargestellt. Negative Werte befinden sich in der Ergänzungsdarstellung von zwei. Dies ist wichtig, wenn Sie bitweise Vorgänge für Int32 Werte ausführen oder wenn Sie mit einzelnen Bits arbeiten. Um einen numerischen, booleschen oder Vergleichsvorgang für zwei nicht dezimale Werte auszuführen, müssen beide Werte dieselbe Darstellung verwenden.

System.Int32-Struktur

Instanziieren eines Int32-Werts

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

Darstellen eines Int32-Elements als Zeichenfolge

Arbeiten mit nicht dezimalen 32-Bit-Ganzzahlwerten

Feedback

Zusätzliche Ressourcen