IntPtr Estructura

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Source:

IntPtr.cs

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

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)

Herencia

Object

ValueType

IntPtr

Implementaciones

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>

Ejemplos

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

1. Llama al método Marshal.StringToHGlobalAnsi para copiar la cadena Unicode en memoria no administrada como un carácter ANSI (un byte). El método devuelve un objeto IntPtr 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.

2. Llama al método Marshal.AllocHGlobal para asignar el mismo número de bytes que ocupa la cadena no administrada. El método devuelve un objeto IntPtr 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.

3. 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 método ToPointer 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.

4. Usa un bucle para copiar cada carácter de la cadena en el bloque de memoria no administrado.

   El ejemplo de Visual Basic llama al método Marshal.ReadByte(IntPtr, Int32) para leer el byte (o carácter de un solo 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 método Marshal.WriteByte(IntPtr, Int32, Byte) 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 de la cadena ANSI no administrada e incrementan el puntero a la siguiente dirección del bloque no administrado.

5. Todos los ejemplos llaman al Marshal.PtrToStringAnsi para convertir el bloque de memoria no administrado que contiene la cadena ANSI copiada en un objeto Unicode administrado String.

6. Después de mostrar las cadenas originales e invertidas, todos los ejemplos llaman al método FreeHGlobal 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 tipo IntPtr 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 tipo de IntPtr 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 objetos también se pueden usar para contener identificadores. Por ejemplo, las instancias de IntPtr se usan ampliamente en la clase System.IO.FileStream para contener identificadores de archivo.

Nota

El uso de IntPtr 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 para representar identificadores.

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

En C# a partir de la versión 9.0, puede usar el tipo de nint integrado para definir enteros de tamaño nativo. Este tipo se representa mediante el tipo IntPtr internamente y proporciona operaciones y conversiones que son 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 al tener como destino .NET 7 o posterior runtime, nint es un alias para IntPtr de la misma manera que int es un alias para Int32.

Constructores

IntPtr(Int32)	Inicializa una nueva instancia de IntPtr con el entero de 32 bits con signo especificado.
IntPtr(Int64)	Inicializa una nueva instancia de IntPtr con 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)	Fija un valor en 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 instancia actual precede, sigue o se produce en la misma posición en el criterio de ordenación que el otro objeto.
CompareTo(Object)	Compara la instancia actual con otro objeto del mismo tipo y devuelve un entero que indica si la instancia actual precede, sigue o se produce en la misma posición en el criterio de ordenación que el otro objeto.
CopySign(IntPtr, IntPtr)	Copia el signo de un valor en el signo de otro valor.
CreateChecked<TOther>(TOther)	Crea una instancia del tipo actual a partir de un valor, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
CreateSaturating<TOther>(TOther)	Crea una instancia del tipo actual a partir de un valor, saturando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
CreateTruncating<TOther>(TOther)	Crea una instancia del tipo actual a partir de un valor, truncando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
DivRem(IntPtr, IntPtr)	Calcula el cociente y el resto de dos valores.
Equals(IntPtr)	Indica si el objeto actual es igual a otro objeto del mismo tipo.
Equals(Object)	Devuelve un valor que indica si esta instancia es igual 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 iniciales 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<Byte>, IFormatProvider)	Analiza un intervalo de caracteres UTF-8 en un valor.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analiza un intervalo de caracteres UTF-8 en un valor.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analiza un intervalo de caracteres en un valor.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Convierte el intervalo de caracteres de solo lectura de un número en un estilo especificado y un formato específico de la referencia cultural a su entero nativo con signo equivalente.
Parse(String)	Convierte la representación de cadena de un número en su entero nativo con signo equivalente.
Parse(String, IFormatProvider)	Convierte la representación de cadena de un número en un formato específico de la referencia cultural especificado en su entero nativo con signo equivalente.
Parse(String, NumberStyles)	Convierte la representación de cadena de un número en un estilo especificado en su entero nativo con signo equivalente.
Parse(String, NumberStyles, IFormatProvider)	Convierte la representación de cadena de un número en un estilo y formato específico de la referencia cultural especificados en su entero nativo con signo equivalente.
PopCount(IntPtr)	Calcula el número de bits que se establecen en un valor.
RotateLeft(IntPtr, Int32)	Gira un valor de 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 en un entero de 32 bits con signo.
ToInt64()	Convierte el valor de esta instancia en un entero de 64 bits con signo.
ToPointer()	Convierte el valor de esta instancia en 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 especificado y la información de formato específica de la referencia cultural.
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 mediante el formato especificado.
TrailingZeroCount(IntPtr)	Calcula el número de ceros finales en un valor.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual como UTF-8 en el intervalo de bytes proporcionado.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Intenta dar formato al valor de la instancia actual en el intervalo de caracteres proporcionado.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, IntPtr)	Intenta analizar un intervalo de caracteres UTF-8 en un valor.
TryParse(ReadOnlySpan<Byte>, IntPtr)	Intenta convertir un intervalo de caracteres UTF-8 que contiene la representación de cadena de un número en su entero con signo equivalente.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, IntPtr)	Intenta analizar un intervalo de caracteres UTF-8 en un valor.
TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)	Intenta analizar una cadena en un valor.
TryParse(ReadOnlySpan<Char>, IntPtr)	Convierte el intervalo de caracteres de solo lectura 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 un número en un estilo especificado y un formato específico de la referencia cultural a su entero nativo con signo equivalente. Un valor devuelto indica si la conversión se realizó correctamente.
TryParse(String, IFormatProvider, IntPtr)	Intenta analizar una cadena en un valor.
TryParse(String, IntPtr)	Convierte la representación de cadena de un número en su 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 de cadena de un número en un estilo y 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.

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 compatible con CLS.
Explicit(Void* to IntPtr)	Convierte el puntero especificado en un tipo no especificado en un IntPtr. Esta API no es compatible con 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

IAdditionOperators<IntPtr,IntPtr,IntPtr>.Addition(IntPtr, IntPtr)	Agrega dos valores juntos para calcular su suma.
IAdditionOperators<IntPtr,IntPtr,IntPtr>.CheckedAddition(IntPtr, IntPtr)	Agrega dos valores juntos para calcular su suma.
IAdditiveIdentity<IntPtr,IntPtr>.AdditiveIdentity	Obtiene la identidad de suma del tipo actual.
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>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Representa un entero con signo en el que el ancho de bits es el mismo que un puntero.
IBinaryInteger<IntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Representa un entero con signo en el que el ancho de bits es el mismo que un puntero.
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.
IBinaryNumber<IntPtr>.AllBitsSet	Obtiene una instancia del tipo binario en el que se establecen todos los bits.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseAnd(IntPtr, IntPtr)	Calcula los valores bit a bit y de dos valores.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseOr(IntPtr, IntPtr)	Calcula el bit a bit o de dos valores.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.ExclusiveOr(IntPtr, IntPtr)	Calcula el valor exclusivo o de dos valores.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.OnesComplement(IntPtr)	Calcula la representación ones-complement de un valor determinado.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThan(IntPtr, IntPtr)	Compara dos valores para determinar cuál es mayor.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThanOrEqual(IntPtr, IntPtr)	Compara dos valores para determinar cuál es mayor o igual.
IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThan(IntPtr, IntPtr)	Compara dos valores para determinar cuál es menor.
IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThanOrEqual(IntPtr, IntPtr)	Compara dos valores para determinar cuál es menor o igual.
IDecrementOperators<IntPtr>.CheckedDecrement(IntPtr)	Disminuye un valor.
IDecrementOperators<IntPtr>.Decrement(IntPtr)	Disminuye un valor.
IDivisionOperators<IntPtr,IntPtr,IntPtr>.Division(IntPtr, IntPtr)	Divide un valor por otro para calcular su cociente.
IIncrementOperators<IntPtr>.CheckedIncrement(IntPtr)	Incrementa un valor.
IIncrementOperators<IntPtr>.Increment(IntPtr)	Incrementa un valor.
IMinMaxValue<IntPtr>.MaxValue	Obtiene el valor máximo del tipo actual.
IMinMaxValue<IntPtr>.MinValue	Obtiene el valor mínimo del tipo actual.
IModulusOperators<IntPtr,IntPtr,IntPtr>.Modulus(IntPtr, IntPtr)	Divide dos valores juntos para calcular su módulo o resto.
IMultiplicativeIdentity<IntPtr,IntPtr>.MultiplicativeIdentity	Obtiene la identidad multiplicativa del tipo actual.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.CheckedMultiply(IntPtr, IntPtr)	Multiplica dos valores juntos para calcular su producto.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.Multiply(IntPtr, IntPtr)	Multiplica dos valores juntos para calcular su producto.
INumber<IntPtr>.MaxNumber(IntPtr, IntPtr)	Compara dos valores con el proceso, que es mayor y devuelve el otro valor si una entrada es NaN.
INumber<IntPtr>.MinNumber(IntPtr, IntPtr)	Compara dos valores con el proceso, que es menor y devuelve el otro valor si una entrada es NaN.
INumberBase<IntPtr>.IsCanonical(IntPtr)	Determina si un valor está en su representación canónica.
INumberBase<IntPtr>.IsComplexNumber(IntPtr)	Determina si un valor representa un número complejo.
INumberBase<IntPtr>.IsFinite(IntPtr)	Determina si un valor es finito.
INumberBase<IntPtr>.IsImaginaryNumber(IntPtr)	Determina si un valor representa un número imaginario puro.
INumberBase<IntPtr>.IsInfinity(IntPtr)	Determina si un valor es infinito.
INumberBase<IntPtr>.IsInteger(IntPtr)	Determina si un valor representa un número entero.
INumberBase<IntPtr>.IsNaN(IntPtr)	Determina si un valor es NaN.
INumberBase<IntPtr>.IsNegativeInfinity(IntPtr)	Determina si un valor es infinito negativo.
INumberBase<IntPtr>.IsNormal(IntPtr)	Determina si un valor es normal.
INumberBase<IntPtr>.IsPositiveInfinity(IntPtr)	Determina si un valor es infinito positivo.
INumberBase<IntPtr>.IsRealNumber(IntPtr)	Determina si un valor representa un número real.
INumberBase<IntPtr>.IsSubnormal(IntPtr)	Determina si un valor es subnormal.
INumberBase<IntPtr>.IsZero(IntPtr)	Determina si un valor es cero.
INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr, IntPtr)	Compara dos valores con el proceso que tiene la magnitud mayor y devuelve el otro valor si una entrada es NaN.
INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr, IntPtr)	Compara dos valores con el proceso que tiene la magnitud menor y devuelve el otro valor si una entrada es NaN.
INumberBase<IntPtr>.One	Obtiene el valor 1 para el tipo.
INumberBase<IntPtr>.Radix	Obtiene el radix, o base, para el tipo .
INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther, IntPtr)	Representa un entero con signo en el que el ancho de bits es el mismo que un puntero.
INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther, IntPtr)	Representa un entero con signo en el que el ancho de bits es el mismo que un puntero.
INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther, IntPtr)	Representa un entero con signo en el que el ancho de bits es el mismo que un puntero.
INumberBase<IntPtr>.TryConvertToChecked<TOther>(IntPtr, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, iniciando una excepción de desbordamiento para los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
INumberBase<IntPtr>.TryConvertToSaturating<TOther>(IntPtr, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, saturando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
INumberBase<IntPtr>.TryConvertToTruncating<TOther>(IntPtr, TOther)	Intenta convertir una instancia del tipo actual en otro tipo, truncando los valores que se encuentran fuera del intervalo que se puede representar del tipo actual.
INumberBase<IntPtr>.Zero	Obtiene el valor 0 para el tipo.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Rellena un objeto SerializationInfo con los datos necesarios para serializar el objeto IntPtr actual.
IShiftOperators<IntPtr,Int32,IntPtr>.LeftShift(IntPtr, Int32)	Desplaza un valor dejado por una cantidad determinada.
IShiftOperators<IntPtr,Int32,IntPtr>.RightShift(IntPtr, Int32)	Desplaza un valor hacia la derecha por una cantidad determinada.
IShiftOperators<IntPtr,Int32,IntPtr>.UnsignedRightShift(IntPtr, Int32)	Desplaza un valor hacia la derecha por una cantidad determinada.
ISignedNumber<IntPtr>.NegativeOne	Obtiene el valor -1 para el tipo.
ISubtractionOperators<IntPtr,IntPtr,IntPtr>.CheckedSubtraction(IntPtr, IntPtr)	Resta dos valores para calcular su diferencia.
ISubtractionOperators<IntPtr,IntPtr,IntPtr>.Subtraction(IntPtr, IntPtr)	Resta dos valores para calcular su diferencia.
IUnaryNegationOperators<IntPtr,IntPtr>.CheckedUnaryNegation(IntPtr)	Calcula la negación unaria activada de un valor.
IUnaryNegationOperators<IntPtr,IntPtr>.UnaryNegation(IntPtr)	Calcula la negación unaria de un valor.
IUnaryPlusOperators<IntPtr,IntPtr>.UnaryPlus(IntPtr)	Calcula la unaria más de un valor.

Seguridad para subprocesos

Este tipo es seguro para subprocesos.

Consulte también

• UIntPtr