Int32 Структура

Определение

Пространство имен:

System

Сборка:

System.Runtime.dll

Представляет 32-разрядное целое число со знаком.

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

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

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

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

Наследование

Object

ValueType

Int32

Реализации

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

Комментарии

Int32 является неизменяемым типом значения, представляющим целые числа со знаком в диапазоне от отрицательного 2 147 483 648 (представленного константой Int32.MinValue) до положительного 2 147 483 647 (представленного константой Int32.MaxValue). .NET также включает 32-разрядный целочисленный тип без знака, UInt32который представляет значения в диапазоне от 0 до 4 294 967 295.

Создание экземпляра значения Int32

Создать экземпляр значения Int32 можно несколькими способами:

• Можно объявить переменную типа Int32 и присвоить ей значение целочисленного литерала, находящееся в диапазоне типа данных Int32. В следующем примере объявляются две переменные Int32 и им присваиваются значения описанным способом.

  int number1 = 64301;
  int number2 = 25548612;
  

  let number1 = 64301
  let number2 = 25548612
  

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

• Можно присвоить значение целого типа, диапазон которого является подмножеством типа Int32. Это расширяющее преобразование, которое не требует оператора приведения в C# или метода преобразования в Visual Basic, но требует один в 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
  

• Можно присвоить значение числового типа с более широким диапазоном, чем у типа Int32. Это сужающее преобразование, поэтому требуется оператор приведения в C# или F#, а также метод преобразования в Visual Basic, если Option Strict включен. Если числовое значение имеет тип Single, Double или Decimal, содержащий дробную часть, обработка его дробной части зависит от компилятора, выполняющего преобразование. В следующем примере при присвоении нескольким переменным типа 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
  

• Можно вызвать метод класса Convert для преобразования любого поддерживаемого типа в значение Int32. Это возможно, так как Int32 реализует интерфейс IConvertible. В следующем примере показано преобразование массива значений Decimal в значения типа Int32.

  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.
  

• Можно вызвать метод Parse или TryParse для преобразования строкового представления значения Int32 в тип Int32. Строка может содержать либо десятичные, либо шестнадцатеричные цифры. В следующем примере показан вызов метода Parse с использованием десятичной и шестнадцатеричной строк.

  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
  

Выполнение операций со значениями Int32

Тип Int32 поддерживает стандартные операции, такие как сложение, вычитание, деление, умножение, отрицание и унарное отрицание. Как и другие целочисленные типы, тип Int32 также поддерживает битовые операторы AND, OR, XOR и операторы правого и левого сдвига.

Можно использовать стандартные числовые операторы для сравнения двух значений Int32 либо вызвать метод CompareTo или Equals.

Можно также вызывать члены класса Math для выполнения разнообразных числовых операций, включая получение абсолютного значения числа, вычисление частного и остатка от целочисленного деления, определение максимального или минимального из двух целых чисел, получение знака числа, а также округление чисел.

Представление int32 в виде строки

Тип Int32 полностью поддерживает строки стандартных и настраиваемых числовых форматов (дополнительные сведения см. в разделах Типы форматирования, Строки стандартных числовых форматов и Строки настраиваемых числовых форматов).

Для форматирования значения Int32 как целочисленной строки без начальных нулей можно вызвать метод ToString() без параметров. С помощью описателя формата "D" можно также включить указанное число начальных нулей в строковом представлении. С помощью описателя формата "N" можно включить разделители групп и указать количество цифр дробной части для отображения в строковом представлении числа. С помощью описателя формата "X" можно представить значение Int32 в виде шестнадцатеричной строки. Следующий пример форматирует элементы массива значений Int32 описанными четырьмя способами.

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

Также можно форматировать значение Int32 в виде двоичной, восьмеричной, десятичной или шестнадцатеричной строки, вызвав метод ToString(Int32, Int32) и передав вторым параметром основание системы счисления. В следующем примере этот метод используется для отображения двоичного, восьмеричного и шестнадцатеричного представлений массива целочисленных значений.

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

Работа с 32-разряднымм целыми числами как с недесятичными значениями

Помимо работы с отдельными целыми числами как с десятичными значениями, может возникнуть необходимость выполнения с ними битовых операций или работы с их двоичными или шестнадцатеричными представлениями. Значения Int32 представлены 31 битом, тридцать второй бит используется как знаковый бит. Положительные значения представлены в виде знака и абсолютной величины. Отрицательные значения представлены в дополнительном коде. Это важно помнить при выполнении побитовых операции со значениями Int32 или при работе с отдельными их битами. Для выполнения числовых, логических операций или операции сравнения с двумя недесятичными значениями, оба значения должны использовать одно и то же представление.

Поля

MaxValue	Представляет наибольшее возможное значение типа Int32. Это поле является константой.
MinValue	Представляет минимально допустимое значение типа Int32. Это поле является константой.

Методы

Abs(Int32)	Вычисляет абсолютное значение.
Clamp(Int32, Int32, Int32)	Зажимает значение до минимального и максимального значений включительно.
CompareTo(Int32)	Сравнивает данный экземпляр с заданным 32-битовым целым числом со знаком и возвращает значение, указывающее, как соотносятся их значения.
CompareTo(Object)	Сравнивает этот экземпляр с заданным объектом и возвращает значение, указывающее, как соотносятся значения этих объектов.
CopySign(Int32, Int32)	Копирует знак значения в знак другого значения.
CreateChecked<TOther>(TOther)	Создает экземпляр текущего типа из значения, вызывая исключение переполнения для всех значений, которые выходят за пределы диапазона, представляющего текущий тип.
CreateSaturating<TOther>(TOther)	Создает экземпляр текущего типа из значения, насыщая все значения, которые выходят за пределы представляемого диапазона текущего типа.
CreateTruncating<TOther>(TOther)	Создает экземпляр текущего типа из значения, усекая все значения, которые выходят за пределы представляемого диапазона текущего типа.
DivRem(Int32, Int32)	Вычисляет частное и оставшееся число двух значений.
Equals(Int32)	Возвращает значение, указывающее, равен ли этот экземпляр заданному значению типа Int32.
Equals(Object)	Возвращает значение, показывающее, равен ли данный экземпляр заданному объекту.
GetHashCode()	Возвращает хэш-код данного экземпляра.
GetTypeCode()	Возвращает TypeCode для типа значения Int32.
IsEvenInteger(Int32)	Определяет, представляет ли значение четное целое число.
IsNegative(Int32)	Определяет, является ли значение отрицательным.
IsOddInteger(Int32)	Определяет, представляет ли значение нечетное целое число.
IsPositive(Int32)	Определяет, является ли значение положительным.
IsPow2(Int32)	Определяет, является ли значение степенью 2.
LeadingZeroCount(Int32)	Вычисляет число начальных нулей в значении.
Log2(Int32)	Вычисляет значение log2.
Max(Int32, Int32)	Сравнивает два значения, чтобы вычислить большее значение.
MaxMagnitude(Int32, Int32)	Сравнивает два значения, чтобы вычислить большее значение.
Min(Int32, Int32)	Сравнивает два значения для вычисления меньшего значения.
MinMagnitude(Int32, Int32)	Сравнивает два значения для вычисления меньшего значения.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Анализирует диапазон символов UTF-8 в значение.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Анализирует диапазон символов UTF-8 в значение.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Анализирует диапазон символов в значение.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Преобразует представление числа в виде диапазона в формате, соответствующем стилю, языку и региональным параметрам, в эквивалентное ему 32-битовое целое число со знаком.
Parse(String)	Преобразует строковое представление числа в эквивалентное ему 32-битовое целое число со знаком.
Parse(String, IFormatProvider)	Преобразует строковое представление числа в указанном формате, соответствующем языку и региональным параметрам, в эквивалентное ему 32-битовое целое число со знаком.
Parse(String, NumberStyles)	Преобразует строковое представление числа в указанном формате в эквивалентное ему 32-битовое целое число со знаком.
Parse(String, NumberStyles, IFormatProvider)	Преобразует строковое представление числа в формате, соответствующем языку и региональным параметрам, в эквивалентное ему 32-битовое целое число со знаком.
PopCount(Int32)	Вычисляет количество битов, заданных в значении .
RotateLeft(Int32, Int32)	Поворачивает значение влево на заданную величину.
RotateRight(Int32, Int32)	Поворачивает значение вправо на заданную величину.
Sign(Int32)	Вычисляет знак значения.
ToString()	Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление.
ToString(IFormatProvider)	Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление с использованием указанных сведений об особенностях форматирования для данного языка и региональных параметров.
ToString(String)	Преобразует числовое значение данного экземпляра в эквивалентное строковое представление с использованием указанного формата.
ToString(String, IFormatProvider)	Преобразует числовое значение данного экземпляра в эквивалентное ему строковое представление с использованием указанного формата и сведений об особенностях форматирования для данного языка и региональных параметров.
TrailingZeroCount(Int32)	Вычисляет число конечных нулей в значении.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается отформатировать значение текущего экземпляра как UTF-8 в предоставленный диапазон байтов.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Пытается форматировать значение текущего экземпляра целого числа в указанный диапазон символов.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, Int32)	Пытается проанализировать диапазон символов UTF-8 в значение.
TryParse(ReadOnlySpan<Byte>, Int32)	Пытается преобразовать диапазон символов UTF-8, содержащий строковое представление числа, в эквивалентное 32-разрядное целое число со знаком.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, Int32)	Пытается проанализировать диапазон символов UTF-8 в значение.
TryParse(ReadOnlySpan<Char>, IFormatProvider, Int32)	Пытается проанализировать диапазон символов в значение.
TryParse(ReadOnlySpan<Char>, Int32)	Преобразует представление числа в виде диапазона в формате, соответствующем стилю, языку и региональным параметрам, в эквивалентное ему 32-битовое целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, Int32)	Преобразует представление числа в виде диапазона в формате, соответствующем стилю, языку и региональным параметрам, в эквивалентное ему 32-битовое целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.
TryParse(String, IFormatProvider, Int32)	Пытается проанализировать строку в значение.
TryParse(String, Int32)	Преобразует строковое представление числа в эквивалентное ему 32-битовое целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.
TryParse(String, NumberStyles, IFormatProvider, Int32)	Преобразует строковое представление числа в формате, соответствующем языку и региональным параметрам, в эквивалентное ему 32-битовое целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.

Явные реализации интерфейса

IAdditionOperators<Int32,Int32,Int32>.Addition(Int32, Int32)	Добавляет два значения вместе для вычисления их суммы.
IAdditionOperators<Int32,Int32,Int32>.CheckedAddition(Int32, Int32)	Добавляет два значения вместе для вычисления их суммы.
IAdditiveIdentity<Int32,Int32>.AdditiveIdentity	Возвращает аддитивное удостоверение текущего типа.
IBinaryInteger<Int32>.GetByteCount()	Возвращает количество байтов, которые будут записаны в составе TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Int32>.GetShortestBitLength()	Возвращает длину (в битах) представления текущего значения в дополнение к кратчайшему двум.
IBinaryInteger<Int32>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, Int32)	Представляет 32-разрядное целое число со знаком.
IBinaryInteger<Int32>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, Int32)	Представляет 32-разрядное целое число со знаком.
IBinaryInteger<Int32>.TryWriteBigEndian(Span<Byte>, Int32)	Пытается записать текущее значение в формате big-endian в заданный диапазон.
IBinaryInteger<Int32>.TryWriteLittleEndian(Span<Byte>, Int32)	Пытается записать текущее значение в малобайтовом формате в заданный диапазон.
IBinaryNumber<Int32>.AllBitsSet	Возвращает экземпляр двоичного типа, в котором заданы все биты.
IBitwiseOperators<Int32,Int32,Int32>.BitwiseAnd(Int32, Int32)	Вычисляет побитовое и двух значений.
IBitwiseOperators<Int32,Int32,Int32>.BitwiseOr(Int32, Int32)	Вычисляет побитовое значение или из двух значений.
IBitwiseOperators<Int32,Int32,Int32>.ExclusiveOr(Int32, Int32)	Вычисляет исключающее значение или из двух значений.
IBitwiseOperators<Int32,Int32,Int32>.OnesComplement(Int32)	Вычисляет представление с дополнением к единицам заданного значения.
IComparisonOperators<Int32,Int32,Boolean>.GreaterThan(Int32, Int32)	Сравнивает два значения, чтобы определить, какое значение больше.
IComparisonOperators<Int32,Int32,Boolean>.GreaterThanOrEqual(Int32, Int32)	Сравнивает два значения, чтобы определить, какое значение больше или равно.
IComparisonOperators<Int32,Int32,Boolean>.LessThan(Int32, Int32)	Сравнивает два значения, чтобы определить, какое значение меньше.
IComparisonOperators<Int32,Int32,Boolean>.LessThanOrEqual(Int32, Int32)	Сравнивает два значения, чтобы определить, какое значение меньше или равно.
IConvertible.ToBoolean(IFormatProvider)	Описание этого члена см. в разделе ToBoolean(IFormatProvider).
IConvertible.ToByte(IFormatProvider)	Описание этого члена см. в разделе ToByte(IFormatProvider).
IConvertible.ToChar(IFormatProvider)	Описание этого члена см. в разделе ToChar(IFormatProvider).
IConvertible.ToDateTime(IFormatProvider)	Это преобразование не поддерживается. При попытке использовать этот метод выбрасывается исключение InvalidCastException.
IConvertible.ToDecimal(IFormatProvider)	Описание этого члена см. в разделе ToDecimal(IFormatProvider).
IConvertible.ToDouble(IFormatProvider)	Описание этого члена см. в разделе ToDouble(IFormatProvider).
IConvertible.ToInt16(IFormatProvider)	Описание этого члена см. в разделе ToInt16(IFormatProvider).
IConvertible.ToInt32(IFormatProvider)	Описание этого члена см. в разделе ToInt32(IFormatProvider).
IConvertible.ToInt64(IFormatProvider)	Описание этого члена см. в разделе ToInt64(IFormatProvider).
IConvertible.ToSByte(IFormatProvider)	Описание этого члена см. в разделе ToSByte(IFormatProvider).
IConvertible.ToSingle(IFormatProvider)	Описание этого члена см. в разделе ToSingle(IFormatProvider).
IConvertible.ToType(Type, IFormatProvider)	Описание этого члена см. в разделе ToType(Type, IFormatProvider).
IConvertible.ToUInt16(IFormatProvider)	Описание этого члена см. в разделе ToUInt16(IFormatProvider).
IConvertible.ToUInt32(IFormatProvider)	Описание этого члена см. в разделе ToUInt32(IFormatProvider).
IConvertible.ToUInt64(IFormatProvider)	Описание этого члена см. в разделе ToUInt64(IFormatProvider).
IDecrementOperators<Int32>.CheckedDecrement(Int32)	Уменьшает значение.
IDecrementOperators<Int32>.Decrement(Int32)	Уменьшает значение.
IDivisionOperators<Int32,Int32,Int32>.Division(Int32, Int32)	Делит одно значение на другое для вычисления их частного значения.
IEqualityOperators<Int32,Int32,Boolean>.Equality(Int32, Int32)	Сравнивает два значения для определения равенства.
IEqualityOperators<Int32,Int32,Boolean>.Inequality(Int32, Int32)	Сравнивает два значения для определения неравенства.
IIncrementOperators<Int32>.CheckedIncrement(Int32)	Увеличивает значение.
IIncrementOperators<Int32>.Increment(Int32)	Увеличивает значение.
IMinMaxValue<Int32>.MaxValue	Возвращает максимальное значение текущего типа.
IMinMaxValue<Int32>.MinValue	Возвращает минимальное значение текущего типа.
IModulusOperators<Int32,Int32,Int32>.Modulus(Int32, Int32)	Делит два значения для вычисления их модуля или остатка.
IMultiplicativeIdentity<Int32,Int32>.MultiplicativeIdentity	Возвращает мультипликативное удостоверение текущего типа.
IMultiplyOperators<Int32,Int32,Int32>.CheckedMultiply(Int32, Int32)	Умножает два значения вместе для вычисления их продукта.
IMultiplyOperators<Int32,Int32,Int32>.Multiply(Int32, Int32)	Умножает два значения вместе для вычисления их продукта.
INumber<Int32>.MaxNumber(Int32, Int32)	Сравнивает два значения для вычисления, которое больше, и возвращает другое значение, если входные данные имеют значение NaN.
INumber<Int32>.MinNumber(Int32, Int32)	Сравнивает два значения для вычисления меньшего значения и возвращает другое значение, если входные данные имеют значение NaN.
INumberBase<Int32>.IsCanonical(Int32)	Определяет, находится ли значение в своем каноническом представлении.
INumberBase<Int32>.IsComplexNumber(Int32)	Определяет, представляет ли значение комплексное число.
INumberBase<Int32>.IsFinite(Int32)	Определяет, является ли значение конечным.
INumberBase<Int32>.IsImaginaryNumber(Int32)	Определяет, представляет ли значение чистое мнимое число.
INumberBase<Int32>.IsInfinity(Int32)	Определяет, является ли значение бесконечным.
INumberBase<Int32>.IsInteger(Int32)	Определяет, представляет ли значение целое число.
INumberBase<Int32>.IsNaN(Int32)	Определяет, является ли значение NaN.
INumberBase<Int32>.IsNegativeInfinity(Int32)	Определяет, является ли значение отрицательным бесконечностью.
INumberBase<Int32>.IsNormal(Int32)	Определяет, является ли значение нормальным.
INumberBase<Int32>.IsPositiveInfinity(Int32)	Определяет, является ли значение положительным бесконечностью.
INumberBase<Int32>.IsRealNumber(Int32)	Определяет, представляет ли значение реальное число.
INumberBase<Int32>.IsSubnormal(Int32)	Определяет, является ли значение ненормальным.
INumberBase<Int32>.IsZero(Int32)	Определяет, равно ли значение нулю.
INumberBase<Int32>.MaxMagnitudeNumber(Int32, Int32)	Сравнивает два значения с вычислением, которое имеет большую величину, и возвращает другое значение, если входными данными является NaN.
INumberBase<Int32>.MinMagnitudeNumber(Int32, Int32)	Сравнивает два значения с вычислением, которое имеет меньшую величину, и возвращает другое значение, если входными данными является NaN.
INumberBase<Int32>.One	Возвращает значение 1 типа .
INumberBase<Int32>.Radix	Возвращает радикс или основание для типа.
INumberBase<Int32>.TryConvertFromChecked<TOther>(TOther, Int32)	Представляет 32-разрядное целое число со знаком.
INumberBase<Int32>.TryConvertFromSaturating<TOther>(TOther, Int32)	Представляет 32-разрядное целое число со знаком.
INumberBase<Int32>.TryConvertFromTruncating<TOther>(TOther, Int32)	Представляет 32-разрядное целое число со знаком.
INumberBase<Int32>.TryConvertToChecked<TOther>(Int32, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, вызывая исключение переполнения для всех значений, которые находятся за пределами представляемого диапазона текущего типа.
INumberBase<Int32>.TryConvertToSaturating<TOther>(Int32, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, насыщая все значения, которые выходят за пределы представляемого диапазона текущего типа.
INumberBase<Int32>.TryConvertToTruncating<TOther>(Int32, TOther)	Пытается преобразовать экземпляр текущего типа в другой тип, усекая все значения, которые находятся за пределами представляемого диапазона текущего типа.
INumberBase<Int32>.Zero	Возвращает значение 0 типа .
IShiftOperators<Int32,Int32,Int32>.LeftShift(Int32, Int32)	Сдвиг значения влево на заданную сумму.
IShiftOperators<Int32,Int32,Int32>.RightShift(Int32, Int32)	Сдвигает значение вправо на заданную величину.
IShiftOperators<Int32,Int32,Int32>.UnsignedRightShift(Int32, Int32)	Сдвигает значение вправо на заданную величину.
ISignedNumber<Int32>.NegativeOne	Возвращает значение -1 типа .
ISubtractionOperators<Int32,Int32,Int32>.CheckedSubtraction(Int32, Int32)	Вычитает два значения, чтобы вычислить их разницу.
ISubtractionOperators<Int32,Int32,Int32>.Subtraction(Int32, Int32)	Вычитает два значения, чтобы вычислить их разницу.
IUnaryNegationOperators<Int32,Int32>.CheckedUnaryNegation(Int32)	Вычисляет проверенное унарное отрицание значения.
IUnaryNegationOperators<Int32,Int32>.UnaryNegation(Int32)	Вычисляет унарное отрицание значения.
IUnaryPlusOperators<Int32,Int32>.UnaryPlus(Int32)	Вычисляет унарный плюс значения.

Потокобезопасность

Все члены этого типа являются потокобезопасны. Члены, которые могут изменить состояние экземпляра, в действительности возвращают новый экземпляр, инициализированный новым значением. Как с любым другим типом, чтение и запись общей переменной, которая содержит экземпляр этого типа, должны быть защищены блокировкой для обеспечения потокобезопасности.

См. также раздел

• UInt32
• Пример: служебная программа форматирования .NET Core WinForms (C#)
• Пример: служебная программа форматирования .NET Core WinForms (Visual Basic)