Megosztás a következőn keresztül:

System.Int32 szerkezet

Ez a cikk kiegészítő megjegyzéseket tartalmaz az API referenciadokumentációjához.

"Int32 egy változatlan értéktípus, amely az aláírt egész számokat jelöli, amelyek értékei a -2 147 483 648-tól (amit a Int32.MinValue állandó képvisel) a +2 147 483 647-ig (amit a Int32.MaxValue állandó képvisel) terjednek." A .NET tartalmaz egy aláíratlan 32 bites egész számtípust is, UInt32amely 0 és 4 294 967 295 közötti értékeket jelöl.

Int32-érték példányosítása

Az Int32 értéket többféleképpen is létrehozhatja.

  • Deklarálhat egy változót Int32 , és az adattípus tartományán belüli literális egész számértéket rendelhet hozzá Int32 . Az alábbi példa két Int32 változót deklarál, és így rendeli hozzájuk az értékeket.

    int number1 = 64301;
int number2 = 25548612;

    let number1 = 64301
let number2 = 25548612

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

  • Olyan egész számtípus értékét rendelheti hozzá, amelynek tartománya a Int32 típus részhalmaza. Ez egy olyan szélesítő átalakítás, amely nem igényel C# kaszt operátort vagy a Visual Basic-ben konverziós metódust, de F#-ban egyet igényel.

    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

  • Olyan numerikus típus értékét rendelheti hozzá, amelynek tartománya meghaladja a Int32 típus értékét. Ez egy szűkítő konverzió, ezért C# vagy F# esetén kényszerített operátort igényel, Visual Basicben pedig egy konverziós metódust, ha a Option Strict be van kapcsolva. Ha a numerikus érték egy Single, Double vagy Decimal törtösszetevőt tartalmazó érték, a törtrész kezelése az átalakítást végző fordítótól függ. Az alábbi példa szűkítő konverziókat hajt végre, hogy több numerikus értéket rendeljen a változókhoz Int32 .

    long lNumber = 163245617;
try {
   int number1 = (int) lNumber;
   Console.WriteLine(number1);
}
catch (OverflowException) {
   Console.WriteLine($"{lNumber} is out of range of an Int32.");
}

double dbl2 = 35901.997;
try {
   int number2 = (int) dbl2;
   Console.WriteLine(number2);
}
catch (OverflowException) {
   Console.WriteLine($"{dbl2} is out of range of an Int32.");
}

BigInteger bigNumber = 132451;
try {
   int number3 = (int) bigNumber;
   Console.WriteLine(number3);
}
catch (OverflowException) {
   Console.WriteLine($"{bigNumber} is out of range of an Int32.");
}
// 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

  • Az osztály metódusát Convert meghívva bármilyen támogatott típust átalakíthat értékké Int32 . Ez azért lehetséges, mert Int32 támogatja a IConvertible felületet. Az alábbi példa egy Decimal értéktömb Int32 értékekké alakítását szemlélteti.

    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 {value.GetType().Name} value '{value}' to the {result.GetType().Name} value {result}.");
   }
   catch (OverflowException) {
      Console.WriteLine($"{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.

    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.

  • Meghívhatja a Parse vagy TryParse metódust, amely az Int32 érték sztringképét átalakítja egy Int32 típusú értékké. A sztring decimális vagy hexadecimális számjegyeket tartalmazhat. Az alábbi példa egy decimális és egy hexadecimális sztring használatával szemlélteti az elemzési műveletet.

    string string1 = "244681";
try {
   int number1 = Int32.Parse(string1);
   Console.WriteLine(number1);
}
catch (OverflowException) {
   Console.WriteLine($"'{string1}' is out of range of a 32-bit integer.");
}
catch (FormatException) {
   Console.WriteLine($"The format of '{string1}' is invalid.");
}

string string2 = "F9A3C";
try {
   int number2 = Int32.Parse(string2,
                            System.Globalization.NumberStyles.HexNumber);
   Console.WriteLine(number2);
}
catch (OverflowException) {
   Console.WriteLine($"'{string2}' is out of range of a 32-bit integer.");
}
catch (FormatException) {
   Console.WriteLine($"The format of '{string2}' is invalid.");
}
// 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

Műveletek végrehajtása Int32-értékeken

A Int32 típus támogatja a standard matematikai műveleteket, például az összeadást, kivonást, osztást, szorzást, negációt és unary negationt. A többi integráltípushoz hasonlóan a Int32 típus is támogatja a bitenkénti AND, OR, a balra tolás és a jobbra tolás operátorokat.

A standard numerikus operátorok segítségével összehasonlíthat két Int32 értéket, vagy meghívhatja a metódustCompareTo.Equals

Az osztály tagjait Math is meghívhatja numerikus műveletek széles skálájának végrehajtásához, beleértve a szám abszolút értékének lekérését, az hányados és a fennmaradó rész kiszámítását az integrál osztásból, két egész szám maximális vagy minimális értékének meghatározásával, egy szám jelének lekérésével és egy szám kerekítésével.

Int32 sztringként való ábrázolása

A Int32 típus teljes körű támogatást nyújt a szabványos és egyéni numerikus formátumú sztringekhez. (További információ: Formázástípusok, Standard numerikus formázási sztringek és egyéni numerikus formázási sztringek.)

Ha egy Int32 értéket bevezető nullák nélküli integrál sztringként szeretne formázni, meghívhatja a paraméter nélküli ToString() metódust. A "D" formátumkijelölővel megadott számú kezdő nullát is felvehet a sztringábrázolásba. Az "N" formátumkijelölő használatával csoportelválasztókat is megadhat, és megadhatja a szám sztringképében megjelenítendő tizedesjegyek számát. Az "X" formátumjelölővel egy Int32 értéket hexadecimális karakterláncként ábrázolhat. Az alábbi példa az értékek tömbjében Int32 lévő elemeket a következő négy módon formázja.

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

Az értékeket bináris, oktális, decimális vagy hexadecimális sztringként is formázhatja Int32 úgy, hogy meghívja a ToString(Int32, Int32) metódust, és megadja az alapot a metódus második paramétereként. Az alábbi példa ezt a metódust meghívja egy egész számból álló tömb bináris, oktális és hexadecimális ábrázolásának megjelenítésére.

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

Nem decimális 32 bites egész számértékek használata

Az egyes egész számok decimális értékekként való használata mellett érdemes lehet bitenkénti műveleteket végrehajtani egész számértékekkel, vagy az egész számok bináris vagy hexadecimális ábrázolásával dolgozni. Int32 az értékek 31 bitben jelennek meg, és a harminc másodperces bitet jelbitként használják. A pozitív értékeket a jelek és a nagyság ábrázolásával jelöljük. A negatív értékek két komplementer ábrázolásban vannak. Ezt fontos szem előtt tartani, amikor bitenkénti műveleteket hajt végre az értékeken Int32 , vagy amikor egyéni bitekkel dolgozik. Ha numerikus, logikai vagy összehasonlító műveletet szeretne végrehajtani két nem decimális értéken, mindkét értéknek ugyanazt a reprezentációt kell használnia.