Int32 Struktura

Definice

Obor názvů:

System

Sestavení:

System.Runtime.dll

Představuje 32bitové celé číslo se signoum sadou.

public value class int : IComparable<int>, IConvertible, IEquatable<int>, IParsable<int>, ISpanParsable<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>, 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 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)

Dědičnost

Object

ValueType

Int32

Implementuje

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>

Poznámky

Int32 je neměnný typ hodnoty, který představuje celá čísla s čísly 2 147 483 648 (který je reprezentován konstantou Int32.MinValue ) až po kladné 2 147 483 647 (který je reprezentován konstantou Int32.MaxValue ). .NET obsahuje také 32bitový typ celočíselné hodnoty bez znaménka , UInt32který představuje hodnoty v rozsahu od 0 do 4 294 967 295.

Vytvoření instance hodnoty Int32

Vytvořit instanci Int32 hodnoty můžete několika způsoby:

• Proměnnou Int32 můžete deklarovat a přiřadit jí celočíselnou hodnotu literálu, která je v rozsahu datového Int32 typu. Následující příklad deklaruje dvě Int32 proměnné a přiřadí jim hodnoty tímto způsobem.

  int number1 = 64301;
  int number2 = 25548612;
  

  let number1 = 64301
  let number2 = 25548612
  

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

• Můžete přiřadit hodnotu celočíselného typu, jehož oblast je podmnožinou Int32 typu. Jedná se o rozšiřující převod, který nevyžaduje operátor přetypování v jazyce C# ani metodu převodu v jazyce Visual Basic, ale vyžaduje ho v jazyce 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
  

• Můžete přiřadit hodnotu číselného typu, jehož rozsah překračuje Int32 rozsah typu. Jedná se o zužující převod, takže vyžaduje operátor přetypování v jazyce C# nebo F# a metodu převodu v jazyce Visual Basic, pokud Option Strict je zapnutá. Pokud je Singlečíselnou hodnotou hodnota , Doublenebo Decimal , která zahrnuje zlomkovou část, zpracování její zlomkové části závisí na kompilátoru, který provádí převod. Následující příklad provádí zúžení převodů pro přiřazení několika číselných hodnot proměnným 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
  

• Můžete volat metodu Convert třídy pro převod libovolného podporovaného Int32 typu na hodnotu. To je možné, protože Int32 podporuje IConvertible rozhraní. Následující příklad ukazuje převod pole Decimal hodnot na Int32 hodnoty.

  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.
  

• Voláním Parse metody nebo TryParse můžete převést řetězcovou Int32 reprezentaci hodnoty na Int32. Řetězec může obsahovat desetinné nebo šestnáctkové číslice. Následující příklad znázorňuje operaci parse pomocí desetinného i šestnáctkového řetězce.

  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
  

Provádění operací na hodnotách Int32

Typ Int32 podporuje standardní matematické operace, jako je sčítání, odčítání, dělení, násobení, negace a unární negace. Stejně jako ostatní integrální typy Int32 podporuje i tento typ bitové operátory AND, OR, XOR, posun vlevo a vpravo.

Můžete použít standardní číselné operátory k porovnání dvou Int32 hodnot, nebo můžete volat metodu CompareTo nebo Equals .

Můžete také volat členy Math třídy a provádět širokou škálu numerických operací, včetně získání absolutní hodnoty čísla, výpočtu podílu a zbytku z integrálního dělení, určení maximální nebo minimální hodnoty dvou celých čísel, získání znaménka čísla a zaokrouhlení čísla.

Znázornění Int32 jako řetězce

Typ Int32 poskytuje plnou podporu standardních a vlastních řetězců číselného formátu. (Další informace najdete v tématech Typy formátování, Řetězce standardního číselného formátu a Vlastní řetězce číselného formátu.)

Pokud chcete formátovat Int32 hodnotu jako integrální řetězec bez počátečních nul, můžete volat metodu bez ToString() parametrů. Pomocí specifikátoru formátu "D" můžete do řetězcové reprezentace zahrnout také zadaný počet počátečních nul. Pomocí specifikátoru formátu "N" můžete zahrnout oddělovače skupin a určit počet desetinných číslic, které se zobrazí v řetězcovém vyjádření čísla. Pomocí specifikátoru formátu "X" můžete hodnotu reprezentovat Int32 jako šestnáctkový řetězec. Následující příklad formátuje prvky v poli Int32 hodnot těmito čtyřmi způsoby.

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

Hodnotu můžete také formátovat Int32 jako binární, osmičkový, desetinný nebo šestnáctkový řetězec voláním ToString(Int32, Int32) metody a zadáním základu jako druhého parametru metody. Následující příklad volá tuto metodu k zobrazení binárních, osmičkových a šestnáctkových reprezentací pole celočíselných hodnot.

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

Práce se 32bitovými celými čísly bez desetinných hodnot

Kromě práce s jednotlivými celými čísly jako desetinnými hodnotami můžete chtít provádět bitové operace s celočíselnými hodnotami nebo pracovat s binárními nebo hexadecimálními reprezentacemi celočíselných hodnot. Int32 hodnoty jsou reprezentovány v 31 bitech, přičemž třicetisekundový bit se používá jako znaménko. Kladné hodnoty jsou reprezentovány pomocí reprezentace znaménka a velikosti. Záporné hodnoty jsou v reprezentaci komplementu dvou. To je důležité mít na paměti při provádění bitových operací s Int32 hodnotami nebo při práci s jednotlivými bity. Aby bylo možné provést numerickou, logickou nebo porovnávací operaci se dvěma ne desetinnými hodnotami, musí obě hodnoty používat stejnou reprezentaci.

Pole

MaxValue	Představuje největší možnou hodnotu objektu Int32. Toto pole je konstantní.
MinValue	Představuje nejmenší možnou hodnotu .Int32 Toto pole je konstantní.

Metody

Abs(Int32)	Vypočítá absolutní hodnotu.
Clamp(Int32, Int32, Int32)	Upne hodnotu na inkluzivní minimální a maximální hodnotu.
CompareTo(Int32)	Porovná tuto instanci se zadaným 32bitovým znaménkem integer a vrátí indikaci jejich relativních hodnot.
CompareTo(Object)	Porovná tuto instanci se zadaným objektem a vrací údaj o jejich relativních hodnotách.
CopySign(Int32, Int32)	Zkopíruje znaménko hodnoty na znaménko jiné hodnoty.
CreateChecked<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty a vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
CreateSaturating<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty a nasytí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
CreateTruncating<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
DivRem(Int32, Int32)	Vypočítá podíl a zbytek dvou hodnot.
Equals(Int32)	Vrátí hodnotu označující, zda se tato instance rovná zadané Int32 hodnotě.
Equals(Object)	Vrací hodnotu, která určuje, zda je tato instance rovna zadanému objektu.
GetHashCode()	Vrátí hodnotu hash pro tuto instanci.
GetTypeCode()	Vrátí hodnotu TypeCode pro typ Int32hodnoty .
IsEvenInteger(Int32)	Určuje, zda hodnota představuje sudé číslo.
IsNegative(Int32)	Určuje, jestli je hodnota záporná.
IsOddInteger(Int32)	Určuje, zda hodnota představuje liché celočíselné číslo.
IsPositive(Int32)	Určuje, jestli je hodnota kladná.
IsPow2(Int32)	Určuje, zda je hodnota mocnina dva.
LeadingZeroCount(Int32)	Vypočítá počet počátečních nul v hodnotě.
Log2(Int32)	Vypočítá log2 hodnoty.
Max(Int32, Int32)	Porovná dvě hodnoty pro výpočet, který je větší.
MaxMagnitude(Int32, Int32)	Porovná dvě hodnoty pro výpočet, který je větší.
Min(Int32, Int32)	Porovná dvě hodnoty s výpočtem, který je menší.
MinMagnitude(Int32, Int32)	Porovná dvě hodnoty s výpočtem, který je menší.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků na hodnotu.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Převede reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný ekvivalent.
Parse(String)	Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 32bitového celého čísla se znaménkem.
Parse(String, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný ekvivalent.
Parse(String, NumberStyles)	Převede řetězcové vyjádření čísla v zadaném stylu na jeho 32bitové celočíselné číslo.
Parse(String, NumberStyles, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný ekvivalent.
PopCount(Int32)	Vypočítá počet bitů, které jsou nastaveny v hodnotě.
RotateLeft(Int32, Int32)	Otočí hodnotu, která zbyla o danou částku.
RotateRight(Int32, Int32)	Otočí hodnotu doprava o danou částku.
Sign(Int32)	Vypočítá znaménko hodnoty.
ToString()	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření.
ToString(IFormatProvider)	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určených informací o formátování specifických pro jazykovou verzi.
ToString(String)	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu.
ToString(String, IFormatProvider)	Převádí číselnou hodnotu této instance na její ekvivalentní řetězcové vyjádření pomocí určeného formátu a informací o formátování specifických pro jazykovou verzi.
TrailingZeroCount(Int32)	Vypočítá počet koncových nul v hodnotě.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance celočíselného čísla do zadaného rozsahu znaků.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)	Pokusí se parsovat rozsah znaků na hodnotu.
TryParse(ReadOnlySpan<Char>, Int32)	Převede reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný ekvivalent se signýmým kódem. Návratová hodnota označuje, jestli převod proběhl úspěšně.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)	Převede reprezentaci rozsahu čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný ekvivalent se signýmým kódem. Návratová hodnota označuje, jestli převod proběhl úspěšně.
TryParse(String, IFormatProvider, Int32)	Pokusí se parsovat řetězec na hodnotu.
TryParse(String, Int32)	Převádí řetězcové vyjádření čísla na jeho ekvivalent v podobě 32bitového celého čísla se znaménkem. Návratová hodnota označuje, jestli převod proběhl úspěšně.
TryParse(String, NumberStyles, IFormatProvider, Int32)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselný ekvivalent se znaky. Návratová hodnota označuje, jestli převod proběhl úspěšně.

Explicitní implementace rozhraní

IAdditionOperators<Int32,Int32,Int32>.Addition(Int32, Int32)	Sečte dvě hodnoty k výpočtu jejich součtu.
IAdditionOperators<Int32,Int32,Int32>.CheckedAddition(Int32, Int32)	Sečte dvě hodnoty k výpočtu jejich součtu.
IAdditiveIdentity<Int32,Int32>.AdditiveIdentity	Získá přídatnou identitu aktuálního typu.
IBinaryInteger<Int32>.GetByteCount()	Získá počet bajtů, které budou zapsány jako součást .TryWriteLittleEndian(Span<Byte>, Int32)
IBinaryInteger<Int32>.GetShortestBitLength()	Získá délku, v bitech, nejkratší dva je doplněk reprezentace aktuální hodnoty.
IBinaryInteger<Int32>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Int32)	Představuje 32bitové celé číslo se signoum sadou.
IBinaryInteger<Int32>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Int32)	Představuje 32bitové celé číslo se signoum sadou.
IBinaryInteger<Int32>.TryWriteBigEndian(Span<Byte>, Int32)	Pokusí se zapsat aktuální hodnotu v daném rozsahu ve formátu big-endian.
IBinaryInteger<Int32>.TryWriteLittleEndian(Span<Byte>, Int32)	Pokusí se zapsat aktuální hodnotu v daném rozsahu ve formátu little-endian.
IBinaryNumber<Int32>.AllBitsSet	Získá instanci binárního typu, ve kterém jsou nastaveny všechny bity.
IBitwiseOperators<Int32,Int32,Int32>.BitwiseAnd(Int32, Int32)	Vypočítá bitové hodnoty a dvou hodnot.
IBitwiseOperators<Int32,Int32,Int32>.BitwiseOr(Int32, Int32)	Vypočítá bitové nebo dvě hodnoty.
IBitwiseOperators<Int32,Int32,Int32>.ExclusiveOr(Int32, Int32)	Vypočítá výhradní hodnotu nebo dvou hodnot.
IBitwiseOperators<Int32,Int32,Int32>.OnesComplement(Int32)	Vypočítá reprezentaci dané hodnoty jako doplněk.
IComparisonOperators<Int32,Int32,Boolean>.GreaterThan(Int32, Int32)	Porovná dvě hodnoty a určí, která je větší.
IComparisonOperators<Int32,Int32,Boolean>.GreaterThanOrEqual(Int32, Int32)	Porovná dvě hodnoty a určí, která hodnota je větší nebo rovna.
IComparisonOperators<Int32,Int32,Boolean>.LessThan(Int32, Int32)	Porovná dvě hodnoty a určí, která hodnota je menší.
IComparisonOperators<Int32,Int32,Boolean>.LessThanOrEqual(Int32, Int32)	Porovná dvě hodnoty a určí, která hodnota je menší nebo rovna.
IConvertible.ToBoolean(IFormatProvider)	Popis tohoto člena najdete v tématu ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Popis tohoto člena najdete v tématu ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Popis tohoto člena najdete v tématu ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Tento převod není podporován. Pokus o použití této metody vyvolá .InvalidCastException
IConvertible.ToDecimal(IFormatProvider)	Popis tohoto člena najdete v tématu ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Popis tohoto člena najdete v tématu ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Popis tohoto člena najdete v tématu ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Popis tohoto člena najdete v tématu ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Popis tohoto člena najdete v tématu ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Popis tohoto člena najdete v tématu ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Popis tohoto člena najdete v tématu ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Popis tohoto člena najdete v tématu ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Popis tohoto člena najdete v tématu ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Popis tohoto člena najdete v tématu ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Popis tohoto člena najdete v tématu ToUInt64(IFormatProvider).
IDecrementOperators<Int32>.CheckedDecrement(Int32)	Sníží hodnotu.
IDecrementOperators<Int32>.Decrement(Int32)	Sníží hodnotu.
IDivisionOperators<Int32,Int32,Int32>.Division(Int32, Int32)	Vydělí jednu hodnotu jinou za účelem výpočtu jejich podílu.
IEqualityOperators<Int32,Int32,Boolean>.Equality(Int32, Int32)	Porovná dvě hodnoty a určí rovnost.
IEqualityOperators<Int32,Int32,Boolean>.Inequality(Int32, Int32)	Porovná dvě hodnoty a určí nerovnost.
IIncrementOperators<Int32>.CheckedIncrement(Int32)	Zvýší hodnotu.
IIncrementOperators<Int32>.Increment(Int32)	Zvýší hodnotu.
IMinMaxValue<Int32>.MaxValue	Získá maximální hodnotu aktuálního typu.
IMinMaxValue<Int32>.MinValue	Získá minimální hodnotu aktuálního typu.
IModulusOperators<Int32,Int32,Int32>.Modulus(Int32, Int32)	Vydělí dvě hodnoty dohromady za účelem výpočtu jejich modulu nebo zbytku.
IMultiplicativeIdentity<Int32,Int32>.MultiplicativeIdentity	Získá multiplikativní identitu aktuálního typu.
IMultiplyOperators<Int32,Int32,Int32>.CheckedMultiply(Int32, Int32)	Vynásobí dvě hodnoty dohromady a vypočítá jejich součin.
IMultiplyOperators<Int32,Int32,Int32>.Multiply(Int32, Int32)	Vynásobí dvě hodnoty dohromady a vypočítá jejich součin.
INumber<Int32>.MaxNumber(Int32, Int32)	Porovná dvě hodnoty pro výpočet, který je větší a vrátí druhou hodnotu, pokud je NaNvstup .
INumber<Int32>.MinNumber(Int32, Int32)	Porovná dvě hodnoty pro výpočet, který je menší a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<Int32>.IsCanonical(Int32)	Určuje, zda je hodnota v kanonické reprezentaci.
INumberBase<Int32>.IsComplexNumber(Int32)	Určuje, zda hodnota představuje komplexní číslo.
INumberBase<Int32>.IsFinite(Int32)	Určuje, zda je hodnota konečná.
INumberBase<Int32>.IsImaginaryNumber(Int32)	Určuje, zda hodnota představuje čisté imaginární číslo.
INumberBase<Int32>.IsInfinity(Int32)	Určuje, zda je hodnota nekonečná.
INumberBase<Int32>.IsInteger(Int32)	Určuje, zda hodnota představuje celočíselné číslo.
INumberBase<Int32>.IsNaN(Int32)	Určuje, jestli je hodnota NaN.
INumberBase<Int32>.IsNegativeInfinity(Int32)	Určuje, zda je hodnota záporné nekonečno.
INumberBase<Int32>.IsNormal(Int32)	Určuje, jestli je hodnota normální.
INumberBase<Int32>.IsPositiveInfinity(Int32)	Určuje, jestli je hodnota kladné nekonečno.
INumberBase<Int32>.IsRealNumber(Int32)	Určuje, jestli hodnota představuje reálné číslo.
INumberBase<Int32>.IsSubnormal(Int32)	Určuje, jestli je hodnota podnormální.
INumberBase<Int32>.IsZero(Int32)	Určuje, jestli je hodnota nula.
INumberBase<Int32>.MaxMagnitudeNumber(Int32, Int32)	Porovná dvě hodnoty s výpočtem, který má větší velikost, a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<Int32>.MinMagnitudeNumber(Int32, Int32)	Porovná dvě hodnoty s výpočtem, který má menší velikost, a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<Int32>.One	Získá hodnotu 1 pro typ.
INumberBase<Int32>.Radix	Získá radix nebo základ pro typ.
INumberBase<Int32>.TryConvertFromChecked<TOther>(TOther, Int32)	Představuje 32bitové celé číslo se signoum sadou.
INumberBase<Int32>.TryConvertFromSaturating<TOther>(TOther, Int32)	Představuje 32bitové celé číslo se signoum sadou.
INumberBase<Int32>.TryConvertFromTruncating<TOther>(TOther, Int32)	Představuje 32bitové celé číslo se signoum sadou.
INumberBase<Int32>.TryConvertToChecked<TOther>(Int32, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ, vyvolá výjimku přetečení pro všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<Int32>.TryConvertToSaturating<TOther>(Int32, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ a saturovat všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<Int32>.TryConvertToTruncating<TOther>(Int32, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ a zkrátí všechny hodnoty, které spadají mimo reprezentovatelný rozsah aktuálního typu.
INumberBase<Int32>.Zero	Získá hodnotu 0 pro typ.
IShiftOperators<Int32,Int32,Int32>.LeftShift(Int32, Int32)	Posune hodnotu doleva o danou částku.
IShiftOperators<Int32,Int32,Int32>.RightShift(Int32, Int32)	Posune hodnotu doprava o danou částku.
IShiftOperators<Int32,Int32,Int32>.UnsignedRightShift(Int32, Int32)	Posune hodnotu doprava o danou částku.
ISignedNumber<Int32>.NegativeOne	Získá hodnotu -1 pro typ.
ISubtractionOperators<Int32,Int32,Int32>.CheckedSubtraction(Int32, Int32)	Odečítá dvě hodnoty pro výpočet jejich rozdílu.
ISubtractionOperators<Int32,Int32,Int32>.Subtraction(Int32, Int32)	Odečítá dvě hodnoty pro výpočet jejich rozdílu.
IUnaryNegationOperators<Int32,Int32>.CheckedUnaryNegation(Int32)	Vypočítá zkontrolované unární negace hodnoty.
IUnaryNegationOperators<Int32,Int32>.UnaryNegation(Int32)	Vypočítá unární negaci hodnoty.
IUnaryPlusOperators<Int32,Int32>.UnaryPlus(Int32)	Vypočítá unární plus hodnoty.

Bezpečný přístup z více vláken

Všechny členy tohoto typu jsou zabezpečeny pro přístup z více vláken. Členy, které patrně upravují stav instance, ve skutečnosti vrací novou instanci inicializovanou s použitím nové hodnoty. Jako u jakéhokoli typu, čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, musí být chráněn zámkem, který zaručí bezpečný přístup z více vláken.

Viz také

• UInt32
• Ukázka: .NET Core WinForms Formating Utility (C#)
• Ukázka: .NET Core WinForms Formating Utility (Visual Basic)