IntPtr Estructura

Referencia

Definición

Espacio de nombres:: System

Ensamblado:: System.Runtime.dll

Ensamblado:: mscorlib.dll

Ensamblado:: netstandard.dll

Importante

Parte de la información hace referencia a la versión preliminar del producto, que puede haberse modificado sustancialmente antes de lanzar la versión definitiva. Microsoft no otorga ninguna garantía, explícita o implícita, con respecto a la información proporcionada aquí.

Representa un entero con signo donde el ancho de bits es el mismo que un puntero.

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

Herencia: Object

ValueType
IntPtr

Atributos: SerializableAttribute ComVisibleAttribute

Implementaciones: 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>

Ejemplos

En el ejemplo siguiente se usan punteros administrados para invertir los caracteres de una matriz. Después de inicializar un String objeto y obtener su longitud, hace lo siguiente:

Llama al Marshal.StringToHGlobalAnsi método para copiar la cadena Unicode en memoria no administrada como un carácter ANSI (un byte). El método devuelve un IntPtr objeto que apunta al principio de la cadena no administrada. En el ejemplo de Visual Basic se usa este puntero directamente; en los ejemplos de C++, F# y C#, se convierte a un puntero a un byte.
Llama al Marshal.AllocHGlobal método para asignar el mismo número de bytes que ocupa la cadena no administrada. El método devuelve un IntPtr objeto que apunta al principio del bloque de memoria no administrado. En el ejemplo de Visual Basic se usa este puntero directamente; en los ejemplos de C++, F# y C#, se convierte a un puntero a un byte.
En el ejemplo de Visual Basic se define una variable denominada offset que es igual a la longitud de la cadena ANSI. Se usa para determinar el desplazamiento en memoria no administrada a la que se copia el siguiente carácter de la cadena ANSI. Dado que su valor inicial es la longitud de la cadena, la operación de copia copiará un carácter desde el principio de la cadena hasta el final del bloque de memoria.

Los ejemplos de C#, F# y C++ llaman al ToPointer método para obtener un puntero no administrado a la dirección inicial de la cadena y al bloque de memoria no administrado, y agregan una menor que la longitud de la cadena a la dirección inicial de la cadena ANSI. Dado que el puntero de cadena no administrado apunta ahora al final de la cadena, la operación de copia copiará un carácter desde el final de la cadena hasta el inicio del bloque de memoria.
Usa un bucle para copiar cada carácter de la cadena al bloque de memoria no administrado.

En el ejemplo de Visual Basic se llama al Marshal.ReadByte(IntPtr, Int32) método para leer el byte (o carácter de un byte) en un desplazamiento especificado desde el puntero administrado a la cadena ANSI. El desplazamiento se incrementa con cada iteración del bucle. A continuación, llama al Marshal.WriteByte(IntPtr, Int32, Byte) método para escribir el byte en la dirección de memoria definida por la dirección inicial del bloque de memoria no administrado más offset. A continuación, disminuye offset.

Los ejemplos de C#, F# y C++ realizan la operación de copia y, a continuación, reducen el puntero a la dirección de la siguiente ubicación en la cadena ANSI no administrada e incrementan el puntero a la siguiente dirección del bloque no administrado.
Todos los ejemplos llaman Marshal.PtrToStringAnsi a para convertir el bloque de memoria no administrado que contiene la cadena ANSI copiada en un objeto Unicode String administrado.
Después de mostrar las cadenas originales e invertidas, todos los ejemplos llaman al FreeHGlobal método para liberar la memoria asignada para la cadena ANSI no administrada y el bloque de memoria no administrado.

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

Comentarios

El IntPtr tipo está diseñado para ser un entero cuyo tamaño es el mismo que un puntero. Es decir, se espera que una instancia de este tipo sea de 32 bits en un proceso de 32 bits y 64 bits en un proceso de 64 bits.

El IntPtr tipo se puede usar en idiomas que admiten punteros y como medio común de hacer referencia a datos entre idiomas que sí y no admiten punteros.

IntPtr Los objetos también se pueden usar para contener identificadores. Por ejemplo, las instancias de IntPtr se usan ampliamente en la System.IO.FileStream clase para contener identificadores de archivo.

Nota

El uso IntPtr de como puntero o un identificador es propenso a errores y no es seguro. Es simplemente un tipo entero que se puede usar como formato de intercambio para punteros y identificadores debido a que tiene el mismo tamaño. Fuera de requisitos de intercambio específicos, como para pasar datos a un lenguaje que no admite punteros, se debe usar un puntero con tipo correcto para representar punteros y SafeHandle se debe usar para representar identificadores.

Este tipo implementa .ISerializable En .NET 5 y versiones posteriores, este tipo también implementa las IFormattable interfaces. En .NET 7 y versiones posteriores, este tipo también implementa las IBinaryInteger<TSelf>interfaces , IMinMaxValue<TSelf>y ISignedNumber<TSelf> .

En C# a partir de la versión 9.0, puede usar el tipo integrado nint para definir enteros de tamaño nativo. Este tipo se representa mediante el IntPtr tipo internamente y proporciona operaciones y conversiones adecuadas para los tipos enteros. Para obtener más información, vea tipos nint y nuint.

En C# a partir de la versión 11 y cuando el destino es el entorno de ejecución de .NET 7 o posterior, nint es un alias de IntPtr la misma manera que int un alias para Int32.

Constructores

IntPtr(Int32)	Inicializa una nueva instancia de IntPtr utilizando el entero de 32 bits con signo especificado.
IntPtr(Int64)	Inicializa una nueva instancia de IntPtr utilizando el entero de 64 bits con signo especificado.
IntPtr(Void*)	Inicializa una nueva instancia de IntPtr usando el puntero especificado a un tipo no especificado.

Campos

Zero	Campo de solo lectura que representa un entero con signo inicializado en cero.

Propiedades

MaxValue	Obtiene el valor más grande posible de IntPtr.
MinValue	Obtiene el valor más pequeño posible de IntPtr.
Size	Obtiene el tamaño de esta instancia.

Métodos

Abs(IntPtr)	Calcula el valor absoluto de un valor.
Add(IntPtr, Int32)	Agrega un desplazamiento a un entero con signo.
Clamp(IntPtr, IntPtr, IntPtr)	Sujeta un valor a un valor mínimo inclusivo y máximo.
CompareTo(IntPtr)	Compara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la posición de la instancia actual es anterior, posterior o igual que la del otro objeto en el criterio de ordenación.
CompareTo(Object)	Compara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la posición de la instancia actual es anterior, posterior o igual que la del otro objeto en el criterio de ordenación.
CopySign(IntPtr, IntPtr)	Copia el signo de un valor en el signo de otro valor.
DivRem(IntPtr, IntPtr)	Calcula el cociente y el resto de dos valores.
Equals(IntPtr)	Indica si el objeto actual es igual que otro objeto del mismo tipo.
Equals(Object)	Devuelve un valor que indica si esta instancia equivale a un objeto especificado.
GetHashCode()	Devuelve el código hash de esta instancia.
IsEvenInteger(IntPtr)	Determina si un valor representa un número entero par.
IsNegative(IntPtr)	Determina si un valor es negativo.
IsOddInteger(IntPtr)	Determina si un valor representa un número entero impar.
IsPositive(IntPtr)	Determina si un valor es positivo.
IsPow2(IntPtr)	Determina si un valor es una potencia de dos.
LeadingZeroCount(IntPtr)	Calcula el número de ceros a la izquierda en un valor.
Log2(IntPtr)	Calcula el registro2 de un valor.
Max(IntPtr, IntPtr)	Compara dos valores con el proceso, que es mayor.
MaxMagnitude(IntPtr, IntPtr)	Compara dos valores con el proceso, que es mayor.
Min(IntPtr, IntPtr)	Compara dos valores con el proceso, que es menor.
MinMagnitude(IntPtr, IntPtr)	Compara dos valores con el proceso, que es menor.
Parse(ReadOnlySpan<Char>, IFormatProvider)
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convierte el intervalo de caracteres de solo lectura de una representación de caracteres en un estilo y un formato específico de la referencia cultural especificados en su entero nativo con signo equivalente.
Parse(String)	Convierte la representación en forma de cadena de un número en el entero nativo con signo equivalente.
Parse(String, IFormatProvider)	Convierte la representación en forma de cadena de un número con el formato específico de la referencia cultural que se haya especificado en el entero nativo con signo equivalente.
Parse(String, NumberStyles)	Convierte la representación en forma de cadena de un número del estilo especificado en el entero nativo con signo equivalente.
Parse(String, NumberStyles, IFormatProvider)	Convierte la representación en forma de cadena de un número con el estilo y el formato específicos de la referencia cultural que se hayan especificado en el entero nativo con signo equivalente.
PopCount(IntPtr)	Calcula el número de bits establecidos en un valor.
RotateLeft(IntPtr, Int32)	Gira un valor a la izquierda por una cantidad determinada.
RotateRight(IntPtr, Int32)	Gira un valor a la derecha por una cantidad determinada.
Sign(IntPtr)	Calcula el signo de un valor.
Subtract(IntPtr, Int32)	Resta un desplazamiento de un entero con signo.
ToInt32()	Convierte el valor de esta instancia a un entero de 32 bits con signo.
ToInt64()	Convierte el valor de esta instancia a un entero de 64 bits con signo.
ToPointer()	Convierte el valor de esta instancia a un puntero a un tipo no especificado.
ToString()	Convierte el valor numérico del objeto IntPtr actual en su representación de cadena equivalente.
ToString(IFormatProvider)	Convierte el valor numérico de esta instancia en su representación de cadena equivalente mediante el formato y la información de formato específica de la referencia cultural que se especificaran.
ToString(String)	Convierte el valor numérico del objeto IntPtr actual en su representación de cadena equivalente.
ToString(String, IFormatProvider)	Da formato al valor de la instancia actual usando el formato especificado.
TrailingZeroCount(IntPtr)	Calcula el número de ceros finales en un valor.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual en el intervalo de caracteres proporcionado.
TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)
TryParse(ReadOnlySpan<Char>, IntPtr)	Convierte el intervalo de caracteres de solo lectura de una representación de un número en su entero nativo con signo equivalente. Un valor devuelto indica si la conversión se realizó correctamente.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, IntPtr)	Convierte el intervalo de caracteres de solo lectura de una representación de caracteres en un estilo y un formato específico de la referencia cultural especificados en su entero nativo con signo equivalente. Un valor devuelto indica si la conversión se realizó correctamente.
TryParse(String, IFormatProvider, IntPtr)
TryParse(String, IntPtr)	Convierte la representación en forma de cadena de un número en el entero nativo con signo equivalente. Un valor devuelto indica si la conversión se realizó correctamente.
TryParse(String, NumberStyles, IFormatProvider, IntPtr)	Convierte la representación en forma de cadena de un número con el estilo y el formato específicos de la referencia cultural que se hayan especificado en el entero nativo con signo equivalente. Un valor devuelto indica si la conversión se realizó correctamente.

Operadores

Addition(IntPtr, Int32)	Agrega un desplazamiento a un entero con signo.
Equality(IntPtr, IntPtr)	Determina si dos instancias especificadas de IntPtr son iguales.
Explicit(Int32 to IntPtr)	Convierte el valor de un entero de 32 bits con signo en un IntPtr.
Explicit(Int64 to IntPtr)	Convierte el valor de un entero de 64 bits con signo en un IntPtr.
Explicit(IntPtr to Int32)	Convierte el valor del IntPtr especificado en un entero de 32 bits con signo.
Explicit(IntPtr to Int64)	Convierte el valor del IntPtr especificado en un entero de 64 bits con signo.
Explicit(IntPtr to Void*)	Convierte el valor del IntPtr especificado en un puntero a un tipo no especificado. Esta API no es conforme a CLS.
Explicit(Void* to IntPtr)	Convierte el puntero especificado a un tipo no especificado en un IntPtr. Esta API no es conforme a CLS.
Inequality(IntPtr, IntPtr)	Determina si dos instancias especificadas de IntPtr no son iguales.
Subtraction(IntPtr, Int32)	Resta un desplazamiento de un entero con signo.

Implementaciones de interfaz explícitas

IBinaryInteger<IntPtr>.GetByteCount()	Obtiene el número de bytes que se escribirán como parte de TryWriteLittleEndian(Span<Byte>, Int32).
IBinaryInteger<IntPtr>.GetShortestBitLength()	Obtiene la longitud, en bits, de la representación complementaria de dos más corta del valor actual.
IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Intenta escribir el valor actual, en formato big-endian, en un intervalo determinado.
IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Intenta escribir el valor actual, en formato little-endian, en un intervalo determinado.
IEquatable<IntPtr>.Equals(IntPtr)	Devuelve un valor que indica si esta instancia es igual a otro entero con signo.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Rellena un objeto SerializationInfo con los datos necesarios para serializar el objeto IntPtr actual.

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.

Consulte también

UIntPtr