IntPtr Структура

Определение

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

public value class IntPtr
public value class IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, System::Runtime::Serialization::ISerializable
public value class IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, ISpanFormattable, System::Runtime::Serialization::ISerializable
public value class IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<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>, System::Numerics::IDecrementOperators<IntPtr>, System::Numerics::IDivisionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IEqualityOperators<IntPtr, IntPtr>, 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, 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 value class IntPtr : IEquatable<IntPtr>, System::Runtime::Serialization::ISerializable
public value class IntPtr : System::Runtime::Serialization::ISerializable
public struct IntPtr
public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, ISpanFormattable, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<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>, System.Numerics.IDecrementOperators<IntPtr>, System.Numerics.IDivisionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IEqualityOperators<IntPtr,IntPtr>, 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,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 struct IntPtr : IEquatable<IntPtr>, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IEquatable<IntPtr>, System.Runtime.Serialization.ISerializable
[System.Serializable]
public struct IntPtr : System.Runtime.Serialization.ISerializable
[System.Serializable]
[System.Runtime.InteropServices.ComVisible(true)]
public struct IntPtr : System.Runtime.Serialization.ISerializable
public struct IntPtr : System.Runtime.Serialization.ISerializable
type nativeint = struct
type nativeint = struct
    interface IFormattable
    interface ISerializable
type nativeint = struct
    interface ISpanFormattable
    interface IFormattable
    interface 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>
    interface IEqualityOperators<nativeint, nativeint>
    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 IShiftOperators<nativeint, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
    interface ISerializable
type nativeint = struct
    interface ISerializable
[<System.Serializable>]
type nativeint = struct
    interface ISerializable
[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type nativeint = struct
    interface ISerializable
Public Structure IntPtr
Public Structure IntPtr
Implements IComparable, IComparable(Of IntPtr), IEquatable(Of IntPtr), IFormattable, ISerializable
Public Structure IntPtr
Implements IComparable, IComparable(Of IntPtr), IEquatable(Of IntPtr), ISerializable, ISpanFormattable
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), IDecrementOperators(Of IntPtr), IDivisionOperators(Of IntPtr, IntPtr, IntPtr), IEqualityOperators(Of IntPtr, IntPtr), 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, IntPtr), ISignedNumber(Of IntPtr), ISpanParsable(Of IntPtr), ISubtractionOperators(Of IntPtr, IntPtr, IntPtr), IUnaryNegationOperators(Of IntPtr, IntPtr), IUnaryPlusOperators(Of IntPtr, IntPtr)
Public Structure IntPtr
Implements IEquatable(Of IntPtr), ISerializable
Public Structure IntPtr
Implements ISerializable
Наследование
IntPtr
Атрибуты
Реализации
IComparable IComparable<IntPtr> IEquatable<IntPtr> IFormattable ISerializable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> 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> System.Numerics.IComparisonOperators<IntPtr,IntPtr> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<IntPtr> IDecrementOperators<TSelf> IDivisionOperators<IntPtr,IntPtr,IntPtr> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<IntPtr,IntPtr> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> 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> System.Numerics.IShiftOperators<IntPtr,IntPtr> System.Numerics.IShiftOperators<TSelf,TSelf> ISignedNumber<IntPtr> ISubtractionOperators<IntPtr,IntPtr,IntPtr> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<IntPtr,IntPtr> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<IntPtr,IntPtr> IUnaryPlusOperators<TSelf,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)

Инициализирует новый экземпляр с использованием указанного 32-разрядного целого IntPtr числа со знаком.

IntPtr(Int64)

Инициализирует новый экземпляр с использованием указанного 64-разрядного целого IntPtr числа со знаком.

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)

Копирует знак значения в знак другого значения.

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<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<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Пытается отформатировать значение текущего экземпляра в предоставленный диапазон символов.

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)

Вычитает смещение из целого числа со знаком.

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

IBinaryInteger<IntPtr>.GetByteCount()

Возвращает число байтов, которые будут записаны в составе TryWriteLittleEndian(Span<Byte>, Int32).

IBinaryInteger<IntPtr>.GetShortestBitLength()

Возвращает длину (в битах) от кратчайшего дополнительного представления текущего значения.

IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)

Пытается записать текущее значение в формате big-endian в заданный диапазон.

IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)

Пытается записать текущее значение в минимальном формате в заданный диапазон.

IEquatable<IntPtr>.Equals(IntPtr)

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

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Заполняет объект SerializationInfo данными, необходимыми для сериализации текущего объекта IntPtr.

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

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

Данный тип потокобезопасен.

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