Int32 结构

定义

命名空间:

System

程序集:

System.Runtime.dll

表示 32 位带符号整数。

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)

继承

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>

注解

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 值。 这是可能的，IConvertible因为Int32支持 接口。 下面的示例演示值数组 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。 字符串可以包含十进制或十六进制数字。 以下示例使用十进制和十六进制字符串演示了分析操作。

  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位 、、ORXOR、左移和右移运算符。

可以使用标准数值运算符来比较两个 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

还可以通过调用 ToString(Int32, Int32) 方法并提供 base 作为方法的第二个参数，将值格式化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 位表示，30 秒位用作符号位。 正值使用符号和数量级表示形式表示。 负值以二的补数表示形式表示。 在对 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<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<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	尝试将当前整数数字实例的值的格式设置为提供的字符范围。
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)	尝试以 little-endian 格式将当前值写入给定范围。
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)