IntPtr Структура

Определение

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

System

Сборка:

System.Runtime.dll

Исходный код:

IntPtr.cs

Представляет целое число со знаком, в котором битовая ширина совпадает с указателем.

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

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

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

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

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

Object

ValueType

IntPtr

Реализации

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

Примеры

В следующем примере используются управляемые указатели для обратного изменения символов в массиве. После инициализации объекта String и его длины выполняется следующее:

1. Вызывает метод Marshal.StringToHGlobalAnsi, чтобы скопировать строку Юникода в неуправляемую память в виде символа ANSI (однобайтового). Метод возвращает объект IntPtr, указывающий на начало неуправляемой строки. В примере Visual Basic этот указатель используется напрямую; в примерах C++, F# и C# он приводится к указателю на байт.

2. Вызывает метод Marshal.AllocHGlobal, чтобы выделить то же количество байтов, что и неуправляемая строка. Метод возвращает объект IntPtr, указывающий на начало неуправляемого блока памяти. В примере Visual Basic этот указатель используется напрямую; в примерах C++, F# и C# он приводится к указателю на байт.

3. В примере Visual Basic определяется переменная с именем offset, которая равна длине строки ANSI. Он используется для определения смещения в неуправляемую память, в которую копируется следующий символ в строке ANSI. Так как начальное значение является длиной строки, операция копирования копирует символ с начала строки до конца блока памяти.

   Примеры C#, F# и C++ вызывают метод ToPointer, чтобы получить неуправляемый указатель на начальный адрес строки и неуправляемый блок памяти, и они добавляют одну меньше длины строки в начальный адрес строки ANSI. Так как неуправляемый указатель строки теперь указывает на конец строки, операция копирования копирует символ из конца строки в начало блока памяти.

4. Использует цикл для копирования каждого символа из строки в неуправляемый блок памяти.

   В примере Visual Basic вызывается метод Marshal.ReadByte(IntPtr, Int32) для чтения байта (или однобайтового символа) с указанным смещением из управляемого указателя на строку ANSI. Смещение увеличивается с каждым итерацией цикла. Затем вызывает метод Marshal.WriteByte(IntPtr, Int32, Byte) для записи байта в адрес памяти, определенный начальным адресом неуправляемого блока памяти плюс offset. Затем он уменьшает offset.

   Примеры C#, F# и C++ выполняют операцию копирования, а затем уменьшает указатель на адрес следующего расположения в неуправляемой строке ANSI и увеличивает указатель на следующий адрес в неуправляемом блоке.

5. Все примеры вызывают Marshal.PtrToStringAnsi для преобразования неуправляемого блока памяти, содержащего скопированную строку ANSI в управляемый объект Юникода String.

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

using namespace System;
using namespace System::Runtime::InteropServices;

class NotTooSafeStringReverse
{
public:
    static void Main()
    {
        String^ stringA = "I seem to be turned around!";
        int copylen = stringA->Length;

        // Allocate HGlobal memory for source and destination strings
        IntPtr sptr = Marshal::StringToHGlobalAnsi(stringA);
        IntPtr dptr = Marshal::AllocHGlobal(copylen + 1);

        char *src = (char *)sptr.ToPointer();
        char *dst = (char *)dptr.ToPointer();

        if (copylen > 0)
        {
            // set the source pointer to the end of the string
            // to do a reverse copy.
            src += copylen - 1;

            while (copylen-- > 0)
            {
                *dst++ = *src--;
            }
            *dst = 0;
        }
        String^ stringB = Marshal::PtrToStringAnsi(dptr);

        Console::WriteLine("Original:\n{0}\n", stringA);
        Console::WriteLine("Reversed:\n{0}", stringB);

        // Free HGlobal memory
        Marshal::FreeHGlobal(dptr);
        Marshal::FreeHGlobal(sptr);
    }
};

int main()
{
    NotTooSafeStringReverse::Main();
}

// The progam has the following output:
//
// Original:
// I seem to be turned around!
//
// Reversed:
// !dnuora denrut eb ot mees I

using System;
using System.Runtime.InteropServices;

class NotTooSafeStringReverse
{
    static public void Main()
    {
        string stringA = "I seem to be turned around!";
        int copylen = stringA.Length;

        // Allocate HGlobal memory for source and destination strings
        IntPtr sptr = Marshal.StringToHGlobalAnsi(stringA);
        IntPtr dptr = Marshal.AllocHGlobal(copylen + 1);

        // The unsafe section where byte pointers are used.
        unsafe
        {
            byte *src = (byte *)sptr.ToPointer();
            byte *dst = (byte *)dptr.ToPointer();

            if (copylen > 0)
            {
                // set the source pointer to the end of the string
                // to do a reverse copy.
                src += copylen - 1;

                while (copylen-- > 0)
                {
                    *dst++ = *src--;
                }
                *dst = 0;
            }
        }
        string stringB = Marshal.PtrToStringAnsi(dptr);

        Console.WriteLine("Original:\n{0}\n", stringA);
        Console.WriteLine("Reversed:\n{0}", stringB);

        // Free HGlobal memory
        Marshal.FreeHGlobal(dptr);
        Marshal.FreeHGlobal(sptr);
    }
}

// The progam has the following output:
//
// Original:
// I seem to be turned around!
//
// Reversed:
// !dnuora denrut eb ot mees I

#nowarn "9"
open System.Runtime.InteropServices
open FSharp.NativeInterop

[<EntryPoint>]
let main _ = 
    let stringA = "I seem to be turned around!"
    let mutable copylen = stringA.Length

    // Allocate HGlobal memory for source and destination strings
    let sptr = Marshal.StringToHGlobalAnsi stringA
    let dptr = Marshal.AllocHGlobal(copylen + 1)

    let mutable src: byte nativeptr = sptr.ToPointer() |> NativePtr.ofVoidPtr
    let mutable dst: byte nativeptr = dptr.ToPointer() |> NativePtr.ofVoidPtr

    if copylen > 0 then
        // set the source pointer to the end of the string
        // to do a reverse copy.
        src <- 
            NativePtr.toNativeInt src + nativeint (copylen - 1) 
            |> NativePtr.ofNativeInt

        while copylen > 0 do
            copylen <- copylen - 1
            NativePtr.read src |> NativePtr.write dst
            dst <- NativePtr.toNativeInt dst + 1n |> NativePtr.ofNativeInt
            src <- NativePtr.toNativeInt src - 1n |> NativePtr.ofNativeInt
        NativePtr.write dst 0uy

    let stringB = Marshal.PtrToStringAnsi dptr

    printfn $"Original:\n{stringA}\n"
    printfn $"Reversed:\n{stringB}"

    // Free HGlobal memory
    Marshal.FreeHGlobal dptr
    Marshal.FreeHGlobal sptr
    0

// The progam has the following output:
//
// Original:
// I seem to be turned around!
//
// Reversed:
// !dnuora denrut eb ot mees I

Imports System.Runtime.InteropServices

Public Module Example
    Public Sub Main()
        Dim stringA As String = "I seem to be turned around!"
        Dim copylen As Integer = stringA.Length

        ' Allocate HGlobal memory for source and destination strings
        Dim sptr As IntPtr = Marshal.StringToHGlobalAnsi(stringA)
        Dim dptr As IntPtr = Marshal.AllocHGlobal(copylen)
        Dim offset As Integer = copylen - 1

         For ctr As Integer = 0 To copylen - 1
            Dim b As Byte = Marshal.ReadByte(sptr, ctr)
            Marshal.WriteByte(dptr, offset, b)
            offset -= 1
         Next

        Dim stringB As String = Marshal.PtrToStringAnsi(dptr)

        Console.WriteLine("Original:{1}{0}{1}", stringA, vbCrLf)
        Console.WriteLine("Reversed:{1}{0}{1}", stringB, vbCrLf)

        ' Free HGlobal memory
        Marshal.FreeHGlobal(dptr)
        Marshal.FreeHGlobal(sptr)
    End Sub
End Module
' The example displays the following output:
'       Original:
'       I seem to be turned around!
'
'       Reversed:
'       !dnuora denrut eb ot mees I

Комментарии

Тип IntPtr предназначен для целого числа, размер которого совпадает с указателем. То есть экземпляр этого типа, как ожидается, будет 32 бита в 32-разрядном процессе и 64-разрядном процессе в 64-разрядном процессе.

Тип IntPtr можно использовать языками, поддерживающими указатели, и в качестве распространенных средств ссылки на данные между языками, которые делают и не поддерживают указатели.

IntPtr объекты также можно использовать для хранения дескрипторов. Например, экземпляры IntPtr широко используются в классе System.IO.FileStream для хранения дескрипторов файлов.

Заметка

Использование IntPtr в качестве указателя или дескриптора подвержено ошибкам и небезопасным. Это просто целый тип, который можно использовать в качестве формата обмена для указателей и дескрипторов из-за того, что он совпадает с размером. Вне определенных требований обмена, таких как передача данных на язык, который не поддерживает указатели, следует использовать правильно типизированный указатель для представления указателей и SafeHandle использовать для представления дескрипторов.

Этот тип реализует ISerializable. В .NET 5 и более поздних версиях этот тип также реализует интерфейсы IFormattable. В .NET 7 и более поздних версиях этот тип также реализует интерфейсы IBinaryInteger<TSelf>, IMinMaxValue<TSelf>и ISignedNumber<TSelf>.

В C# начиная с версии 9.0 можно использовать встроенный тип nint для определения целых чисел собственного размера. Этот тип представлен внутренним типом IntPtr и предоставляет операции и преобразования, подходящие для целых типов. Дополнительные сведения см. в типах nint и nuint.

В C# начиная с версии 11 и при назначении среды выполнения .NET 7 или более поздней, nint является псевдонимом для IntPtr таким же образом, что int является псевдонимом для Int32.

Конструкторы

IntPtr(Int32)	Инициализирует новый экземпляр IntPtr с помощью указанного 32-разрядного целого числа со знаком.
IntPtr(Int64)	Инициализирует новый экземпляр IntPtr с помощью указанного 64-разрядного целого числа со знаком.
IntPtr(Void*)	Инициализирует новый экземпляр IntPtr с помощью указанного указателя на неопределенный тип.

Поля

Zero	Поле только для чтения, представляющее целое число со знаком, которое инициализировано до нуля.

Свойства

MaxValue	Получает наибольшее возможное значение IntPtr.
MinValue	Получает наименьшее возможное значение IntPtr.
Size	Возвращает размер этого экземпляра.

Методы

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

Операторы

Addition(IntPtr, Int32)	Добавляет смещение в целое число со знаком.
Equality(IntPtr, IntPtr)	Определяет, равны ли два указанных экземпляра IntPtr.
Explicit(Int32 to IntPtr)	Преобразует значение 32-разрядного целого числа со знаком в IntPtr.
Explicit(Int64 to IntPtr)	Преобразует значение 64-разрядного целого числа со знаком в IntPtr.
Explicit(IntPtr to Int32)	Преобразует значение указанного IntPtr в 32-разрядное целое число со знаком.
Explicit(IntPtr to Int64)	Преобразует значение указанного IntPtr в 64-разрядное целое число со знаком.
Explicit(IntPtr to Void*)	Преобразует значение указанного IntPtr в указатель на неопределенный тип. Этот API не соответствует CLS.
Explicit(Void* to IntPtr)	Преобразует указанный указатель в неопределенный тип в IntPtr. Этот API не соответствует CLS.
Inequality(IntPtr, IntPtr)	Определяет, равны ли два указанных экземпляра IntPtr.
Subtraction(IntPtr, Int32)	Вычитает смещение из целого числа со знаком.

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

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

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

Этот тип является потокобезопасной.

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

• UIntPtr