Int32 Struktura

Definice

Obor názvů:

System

Sestavení:

netstandard.dll, System.Runtime.dll

Zdroj:

Int32.cs

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

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 IUtf8SpanFormattable
    interface IUtf8SpanParsable<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), IUtf8SpanParsable(Of Integer)

Dědičnost

Object

ValueType

Int32

Implementuje

IComparable IComparable<Int32> IConvertible IEquatable<Int32> IFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<Int32> IParsable<TSelf> ISpanFormattable ISpanParsable<Int32> ISpanParsable<TSelf> IUtf8SpanFormattable IUtf8SpanParsable<Int32> IUtf8SpanParsable<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 podepsaná celá čísla s hodnotami v rozsahu od záporných 2 147 483 648 (což je reprezentováno konstantou Int32.MinValue) až po kladných 2 147 483 647 (což je reprezentováno konstantou Int32.MaxValue). Rozhraní .NET obsahuje také celočíselnou hodnotu bez znaménka, UInt32, která představuje hodnoty v rozsahu od 0 do 4 294 967 295.

Inicializujte hodnotu Int32

Můžete vytvořit instanci hodnoty Int32 několika způsoby:

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

  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ž rozsah je podmnožinou typu Int32. Jedná se o rozšiřující převod, který nevyžaduje operátor přetypování v jazyce C# nebo 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, jejíž rozsah přesahuje typ Int32. 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 je zapnutá Option Strict. Pokud je číselná hodnota Single, Doublenebo Decimal hodnota, která zahrnuje zlomkovou součást, zpracování jeho zlomkové části závisí na kompilátoru provádějícím převod. Následující příklad provádí zúžující konverze, aby přiřadil několik číselných hodnot proměnným 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
  

• Můžete volat metodu Convert třídy pro převod libovolného podporovaného typu na hodnotu Int32. Je to možné, protože Int32 podporuje rozhraní IConvertible. 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.
  

• Můžete použít metodu Parse nebo TryParse pro převedení řetězcové reprezentace hodnoty Int32 na Int32. Řetězec může obsahovat desetinné nebo šestnáctkové číslice. Následující příklad znázorňuje operaci analýzy pomocí desítkového i šestnáctkového řetězce.

  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
  

Provádění operací s hodnotami Int32

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

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

Členy třídy Math můžete také volat pro provedení široké škály číselných operací, včetně získání absolutní hodnoty čísla, výpočtu kvocientu a zbytku z celočíselné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 pro standardní a vlastní řetězce číselného formátu. (Další informace naleznete v tématu Typy formátování, standardní řetězce číselného formátua vlastní řetězce číselného formátu.)

Chcete-li formátovat hodnotu Int32 jako celočíselný řetězec bez počátečních nul, můžete volat bez parametrů ToString() metodu. 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 zadat počet desetinných číslic, které se mají zobrazit v řetězcové reprezentaci čísla. Pomocí specifikátoru formátu "X" můžete reprezentovat hodnotu Int32 jako šestnáctkový řetězec. Následující příklad formátuje prvky v poli Int32 hodnoty 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 Int32 můžete také naformátovat jako binární, osmičkový, desetinný nebo šestnáctkový řetězec zavoláním metody ToString(Int32, Int32) a zadáním základu jako druhého parametru metody. Následující příklad volá tuto metodu k zobrazení binární, osmičkové a šestnáctkové reprezentace pole celočíselné hodnoty.

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 s 32bitovými celočíselnými hodnotami bez desetinné čárky

Kromě práce s jednotlivými celými čísly jako desetinnými hodnotami můžete chtít provádět bitové operace s celočíselnou hodnotou nebo pracovat s binární nebo šestnáctkovou reprezentací celočíselné hodnoty. Int32 hodnoty jsou reprezentovány 31 bity, přičemž třicetisekundový bit se používá jako znaménko. Kladné hodnoty jsou představovány pomocí znamenkového a velikostního vyjádření. Záporné hodnoty jsou v reprezentaci dvojkového doplňku. Je důležité mít na paměti, když provádíte bitové operace s Int32 hodnotami nebo při práci s jednotlivými bity. Aby bylo možné provést číselnou, logickou nebo porovnávací operaci se dvěma ne desetinnými hodnotami, musí obě hodnoty používat stejnou reprezentaci.

Pole

Name	Description
MaxValue	Představuje největší možnou Int32hodnotu . Toto pole je konstantní.
MinValue	Představuje nejmenší možnou Int32hodnotu . Toto pole je konstantní.

Metody

Name	Description
Abs(Int32)	Vypočítá absolutní hodnotu.
BigMul(Int32, Int32)	Vytvoří plný součin dvou 32bitových čísel.
Clamp(Int32, Int32, Int32)	Uchytá hodnotu na inkluzivní minimální a maximální hodnotu.
CompareTo(Int32)	Porovná tuto instanci se zadaným 32bitovým celým číslem se znaménkem a vrátí indikaci jejich relativních hodnot.
CompareTo(Object)	Porovná tuto instanci se zadaným objektem a vrátí indikaci jejich relativních hodnot.
CopySign(Int32, Int32)	Zkopíruje znaménko hodnoty na znaménko jiné hodnoty.
CreateChecked<TOther>(TOther)	Vytvoří instanci aktuálního typu z hodnoty, která 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, která saturuje 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 určující, zda je tato instance rovna zadané Int32 hodnotě.
Equals(Object)	Vrátí hodnotu určující, zda je tato instance rovna zadanému objektu.
GetHashCode()	Vrátí kód hash pro tuto instanci.
GetTypeCode()	TypeCode Vrátí hodnotu pro typ Int32hodnoty .
IsEvenInteger(Int32)	Určuje, zda hodnota představuje sudé celočíselné číslo.
IsNegative(Int32)	Určuje, zda 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 dvou.
LeadingZeroCount(Int32)	Vypočítá počet úvodních nul v hodnotě.
Log2(Int32)	Vypočítá protokol 2 hodnoty.
Max(Int32, Int32)	Porovná dvě hodnoty s výpočty, které jsou větší.
MaxMagnitude(Int32, Int32)	Porovná dvě hodnoty s výpočty, které jsou větší.
Min(Int32, Int32)	Porovná dvě hodnoty s výpočetními prostředky, které jsou menší.
MinMagnitude(Int32, Int32)	Porovná dvě hodnoty s výpočetními prostředky, které jsou menší.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Parsuje rozsah znaků UTF-8 do hodnoty.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Parsuje rozsah znaků do hodnoty.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent.
Parse(String, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném formátu specifickém pro jazykovou verzi na jeho 32bitový ekvivalent celého čísla se znaky.
Parse(String, NumberStyles, IFormatProvider)	Převede řetězcovou reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na 32bitové celé číslo se znaky.
Parse(String, NumberStyles)	Převede řetězcovou reprezentaci čísla v zadaném stylu na 32bitový ekvivalent celého čísla se znaky.
Parse(String)	Převede řetězcové vyjádření čísla na jeho 32bitové celé číslo se znaky.
PopCount(Int32)	Vypočítá počet bitů, které jsou nastavené v hodnotě.
RotateLeft(Int32, Int32)	Otočí hodnotu doleva o danou částku.
RotateRight(Int32, Int32)	Otočí hodnotu doprava o danou částku.
Sign(Int32)	Vypočítá znaménko hodnoty.
ToString()	Převede číselnou hodnotu této instance na ekvivalentní řetězcové vyjádření.
ToString(IFormatProvider)	Převede číselnou hodnotu této instance na ekvivalentní řetězcové vyjádření pomocí zadaných informací o formátu specifickém pro jazykovou verzi.
ToString(String, IFormatProvider)	Převede číselnou hodnotu této instance na ekvivalentní řetězcové vyjádření pomocí zadaného formátu a informací o formátu specifickém pro jazykovou verzi.
ToString(String)	Převede číselnou hodnotu této instance na ekvivalentní řetězcové vyjádření pomocí zadaného formátu.
TrailingZeroCount(Int32)	Vypočítá počet koncových nul v hodnotě.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální instance jako UTF-8 do poskytnutého rozsahu bajtů.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Pokusí se naformátovat hodnotu aktuální celočíselné instance do zadaného rozsahu znaků.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int32)	Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.
TryParse(ReadOnlySpan<Byte>, Int32)	Pokusí se převést rozsah znaků UTF-8 obsahující řetězcovou reprezentaci čísla na jeho 32bitové celé číslo se znaménkem.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int32)	Pokusí se analyzovat rozsah znaků UTF-8 do hodnoty.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)	Pokusí se analyzovat rozsah znaků do hodnoty.
TryParse(ReadOnlySpan<Char>, Int32)	Převede reprezentaci čísla ve formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)	Převede reprezentaci čísla v zadaném stylu a formátu specifickém pro jazykovou verzi na jeho 32bitový celočíselnou ekvivalent. Vrácená hodnota označuje, zda byl převod úspěšný.
TryParse(String, IFormatProvider, Int32)	Pokusí se analyzovat řetězec do hodnoty.
TryParse(String, Int32)	Převede řetězcové vyjádření čísla na jeho 32bitové celé číslo se znaky. Vrácená hodnota označuje, zda byl převod ú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 32bitové celé číslo se znaky. Vrácená hodnota označuje, zda byl převod úspěšný.

Explicitní implementace rozhraní

Name	Description
IAdditionOperators<Int32,Int32,Int32>.Addition(Int32, Int32)	Sečte dvě hodnoty ke výpočtu jejich součtu.
IAdditionOperators<Int32,Int32,Int32>.CheckedAddition(Int32, Int32)	Sečte dvě hodnoty ke 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šího dvou doplňku reprezentace aktuální hodnoty.
IBinaryInteger<Int32>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Int32)	Představuje 32bitové celé číslo se signedm.
IBinaryInteger<Int32>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Int32)	Představuje 32bitové celé číslo se signedm.
IBinaryInteger<Int32>.TryWriteBigEndian(Span<Byte>, Int32)	Pokusí se na daný rozsah napsat aktuální hodnotu ve formátu big-endian.
IBinaryInteger<Int32>.TryWriteLittleEndian(Span<Byte>, Int32)	Pokusí se na daný rozsah napsat aktuální hodnotu v malém endian formátu.
IBinaryNumber<Int32>.AllBitsSet	Získá instanci binárního typu, ve které jsou nastaveny všechny bity.
IBitwiseOperators<Int32,Int32,Int32>.BitwiseAnd(Int32, Int32)	Vypočítá bitové a dvě hodnoty.
IBitwiseOperators<Int32,Int32,Int32>.BitwiseOr(Int32, Int32)	Vypočítá bitové nebo dvě hodnoty.
IBitwiseOperators<Int32,Int32,Int32>.ExclusiveOr(Int32, Int32)	Vypočítá výhradní nebo dvě hodnoty.
IBitwiseOperators<Int32,Int32,Int32>.OnesComplement(Int32)	Vypočítá reprezentaci daného doplňku.
IComparisonOperators<Int32,Int32,Boolean>.GreaterThan(Int32, Int32)	Porovná dvě hodnoty a určí, která hodnota 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 naleznete v tématu ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Popis tohoto člena naleznete v tématu ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Popis tohoto člena naleznete v tématu ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Tento převod není podporován. Pokus o použití této metody vyvolá výjimku InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Popis tohoto člena naleznete v tématu ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Popis tohoto člena naleznete v tématu ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Popis tohoto člena naleznete v tématu ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Popis tohoto člena naleznete v tématu ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Popis tohoto člena naleznete v tématu ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Popis tohoto člena naleznete v tématu ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Popis tohoto člena naleznete v tématu ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Popis tohoto člena naleznete v tématu ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Popis tohoto člena naleznete v tématu ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Popis tohoto člena naleznete v tématu ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Popis tohoto člena naleznete v tématu ToUInt64(IFormatProvider).
IDecrementOperators<Int32>.CheckedDecrement(Int32)	Dekrementuje hodnotu.
IDecrementOperators<Int32>.Decrement(Int32)	Dekrementuje hodnotu.
IDivisionOperators<Int32,Int32,Int32>.Division(Int32, Int32)	Vydělí jednu hodnotu jinou, aby se vypočítá jejich podíl.
IEqualityOperators<Int32,Int32,Boolean>.Equality(Int32, Int32)	Porovná dvě hodnoty k určení rovnosti.
IEqualityOperators<Int32,Int32,Boolean>.Inequality(Int32, Int32)	Porovná dvě hodnoty k určení nerovnosti.
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)	Rozdělí dvě hodnoty dohromady a vypočítá jejich moduly nebo zbytek.
IMultiplicativeIdentity<Int32,Int32>.MultiplicativeIdentity	Získá multiplikativní identitu aktuálního typu.
IMultiplyOperators<Int32,Int32,Int32>.CheckedMultiply(Int32, Int32)	Vynásobí dvě hodnoty dohromady pro výpočet jejich produktu.
IMultiplyOperators<Int32,Int32,Int32>.Multiply(Int32, Int32)	Vynásobí dvě hodnoty dohromady pro výpočet jejich produktu.
INumber<Int32>.MaxNumber(Int32, Int32)	Porovná dvě hodnoty k výpočtu, což je větší a vrátí druhou hodnotu, pokud je NaNvstup .
INumber<Int32>.MinNumber(Int32, Int32)	Porovná dvě hodnoty k výpočtu, což je menší a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<Int32>.IsCanonical(Int32)	Určuje, zda je hodnota v kanonickém vyjádření.
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, jestli 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, zda je hodnota normální.
INumberBase<Int32>.IsPositiveInfinity(Int32)	Určuje, jestli je hodnota kladná nekonečno.
INumberBase<Int32>.IsRealNumber(Int32)	Určuje, zda 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 k výpočtu, které mají větší velikost a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<Int32>.MinMagnitudeNumber(Int32, Int32)	Porovná dvě hodnoty k výpočtu, které mají menší velikost a vrátí druhou hodnotu, pokud je NaNvstup .
INumberBase<Int32>.MultiplyAddEstimate(Int32, Int32, Int32)	Vypočítá odhad (left * right) + . addend
INumberBase<Int32>.One	Získá hodnotu 1 pro typ.
INumberBase<Int32>.Radix	Získá radix (základ číselné soustavy) pro typ.
INumberBase<Int32>.TryConvertFromChecked<TOther>(TOther, Int32)	Představuje 32bitové celé číslo se signedm.
INumberBase<Int32>.TryConvertFromSaturating<TOther>(TOther, Int32)	Představuje 32bitové celé číslo se signedm.
INumberBase<Int32>.TryConvertFromTruncating<TOther>(TOther, Int32)	Představuje 32bitové celé číslo se signedm.
INumberBase<Int32>.TryConvertToChecked<TOther>(Int32, TOther)	Pokusí se převést instanci aktuálního typu na jiný typ a 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 nasytí 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čte dvě hodnoty pro výpočet jejich rozdílu.
ISubtractionOperators<Int32,Int32,Int32>.Subtraction(Int32, Int32)	Odečte dvě hodnoty pro výpočet jejich rozdílu.
IUnaryNegationOperators<Int32,Int32>.CheckedUnaryNegation(Int32)	Vypočítá zaškrtnutou unární negaci 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šichni členové tohoto typu jsou bezpečné pro přístup z více vláken. Členové, kteří se zdá, že upravují stav instance, ve skutečnosti vrátí novou instanci inicializovanou s novou hodnotou. Stejně jako u jakéhokoli jiného typu musí být čtení a zápis do sdílené proměnné, která obsahuje instanci tohoto typu, chráněn zámkem, aby se zajistilo zabezpečení vlákna.

Viz také

• UInt32
• Ukázka : rozhraní .NET Core WinForms (C#)
• ukázka : .NET Core WinForms Formatting Utility (Visual Basic)