Int32 Структура

Ссылка

Определение

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

Сборка:: System.Runtime.dll

Сборка:: mscorlib.dll

Сборка:: netstandard.dll

Важно!

Некоторые сведения относятся к предварительной версии продукта, в которую до выпуска могут быть внесены существенные изменения. Майкрософт не предоставляет никаких гарантий, явных или подразумеваемых, относительно приведенных здесь сведений.

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

public value class int : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable

public value class int : IComparable, IComparable<int>, IConvertible, IEquatable<int>, ISpanFormattable

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>, System::Numerics::IDecrementOperators<int>, System::Numerics::IDivisionOperators<int, int, int>, System::Numerics::IEqualityOperators<int, int>, 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>, System::Numerics::ISignedNumber<int>, System::Numerics::ISubtractionOperators<int, int, int>, System::Numerics::IUnaryNegationOperators<int, int>, System::Numerics::IUnaryPlusOperators<int, int>

public value class int : IComparable, IConvertible, IFormattable

public value class int : IComparable, IComparable<int>, IEquatable<int>, IFormattable

public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable

public readonly struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable

public readonly struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, ISpanFormattable

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>, System.Numerics.IDecrementOperators<int>, System.Numerics.IDivisionOperators<int,int,int>, System.Numerics.IEqualityOperators<int,int>, 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>, System.Numerics.ISignedNumber<int>, System.Numerics.ISubtractionOperators<int,int,int>, System.Numerics.IUnaryNegationOperators<int,int>, System.Numerics.IUnaryPlusOperators<int,int>

[System.Serializable]
public struct Int32 : IComparable, IConvertible, IFormattable

[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct Int32 : IComparable, IComparable<int>, IConvertible, IEquatable<int>, IFormattable

public struct Int32 : IComparable, IComparable<int>, IEquatable<int>, IFormattable

type int = struct
    interface IConvertible
    interface IFormattable

type int = struct
    interface IConvertible
    interface ISpanFormattable
    interface IFormattable

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>
    interface IEqualityOperators<int, int>
    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>
    interface IMinMaxValue<int>
    interface ISignedNumber<int>

[<System.Serializable>]
type int = struct
    interface IFormattable
    interface IConvertible

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type int = struct
    interface IFormattable
    interface IConvertible

type int = struct
    interface IFormattable

Public Structure Int32
Implements IComparable, IComparable(Of Integer), IConvertible, IEquatable(Of Integer), IFormattable

Public Structure Int32
Implements IComparable, IComparable(Of Integer), IConvertible, IEquatable(Of Integer), ISpanFormattable

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), IConvertible, IDecrementOperators(Of Integer), IDivisionOperators(Of Integer, Integer, Integer), IEqualityOperators(Of Integer, Integer), 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), ISignedNumber(Of Integer), ISpanParsable(Of Integer), ISubtractionOperators(Of Integer, Integer, Integer), IUnaryNegationOperators(Of Integer, Integer), IUnaryPlusOperators(Of Integer, Integer)

Public Structure Int32
Implements IComparable, IConvertible, IFormattable

Public Structure Int32
Implements IComparable, IComparable(Of Integer), IEquatable(Of Integer), IFormattable

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

ValueType
Int32

Атрибуты: SerializableAttribute ComVisibleAttribute

Реализации: IComparable IComparable<Int32> IConvertible IEquatable<Int32> IFormattable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> 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> System.Numerics.IComparisonOperators<Int32,Int32> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<Int32> IDecrementOperators<TSelf> IDivisionOperators<Int32,Int32,Int32> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<Int32,Int32> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> 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> System.Numerics.IShiftOperators<Int32,Int32> System.Numerics.IShiftOperators<TSelf,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-разрядный 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)	Определяет, является ли значение степенью двух.
LeadingZeroCount(Int32)	Вычисляет число начальных нулей в значении.
Log2(Int32)	Вычисляет журнал 2 значения.
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-битовое целое число со знаком. Возвращает значение, указывающее, успешно ли выполнено преобразование.

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

IBinaryInteger<Int32>.GetByteCount()	Возвращает число байтов, которые будут записаны в составе TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<Int32>.GetShortestBitLength()	Возвращает длину (в битах) в представлении дополнения кратчайшего двоих текущего значения.
IBinaryInteger<Int32>.TryWriteBigEndian(Span<Byte>, Int32)	Пытается записать текущее значение в формате big-endian в заданный диапазон.
IBinaryInteger<Int32>.TryWriteLittleEndian(Span<Byte>, Int32)	Пытается записать текущее значение в минимальном формате в заданный диапазон.
IComparable.CompareTo(Object)	Сравнивает этот экземпляр с заданным объектом и возвращает значение, указывающее, как соотносятся значения этих объектов.
IConvertible.GetTypeCode()	Возвращает TypeCode для типа значения 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).

Применяется к

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

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