IntPtr Estructura

Definición

Tipo específico de la plataforma que se usa para representar un puntero o un identificador.A platform-specific type that is used to represent a pointer or a handle.

public value class IntPtr : System::Runtime::Serialization::ISerializable
[System.Runtime.InteropServices.ComVisible(true)]
[System.Serializable]
public struct IntPtr : System.Runtime.Serialization.ISerializable
type nativeint = struct
    interface ISerializable
Public Structure IntPtr
Implements ISerializable
Herencia
IntPtr
Atributos
Implementaciones

Ejemplos

En el ejemplo siguiente se usan punteros administrados para invertir los caracteres de una matriz.The following example uses managed pointers to reverse the characters in an array. Después de inicializar un String objeto y de obtener su longitud, hace lo siguiente:After it initializes a String object and gets its length, it does the following:

  1. Llama al Marshal.StringToHGlobalAnsi método para copiar la cadena Unicode en la memoria no administrada como un carácter ANSI (un byte).Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as an ANSI (one-byte) character. El método devuelve un IntPtr objeto que apunta al principio de la cadena no administrada.The method returns an IntPtr object that points to the beginning of the unmanaged string. En el ejemplo Visual Basic se usa directamente este puntero; en los C++ ejemplos C# y, se convierte a un puntero a un byte.The Visual Basic example uses this pointer directly; in the C++ and C# examples, it is cast to a pointer to a byte.

  2. Llama al Marshal.AllocHGlobal método para asignar el mismo número de bytes que ocupa la cadena no administrada.Calls the Marshal.AllocHGlobal method to allocate the same number of bytes as the unmanaged string occupies. El método devuelve un IntPtr objeto que apunta al principio del bloque de memoria no administrada.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory. En el ejemplo Visual Basic se usa directamente este puntero; en los C++ ejemplos C# y, se convierte a un puntero a un byte.The Visual Basic example uses this pointer directly; in the C++ and C# examples, it is cast to a pointer to a byte.

  3. En el ejemplo Visual Basic se define una offset variable denominada que es igual a la longitud de la cadena ANSI.The Visual Basic example defines a variable named offset that is equal to the length of the ANSI string. Se utiliza para determinar el desplazamiento en la memoria no administrada en la que se copia la siguiente carta de la cadena ANSI.It is used to determine the offset into unmanaged memory to which the next charter in the ANSI string is copied. Dado que el valor inicial es la longitud de la cadena, la operación de copia copiará un carácter desde el inicio de la cadena hasta el final del bloque de memoria.Because its starting value is the length of the string, the copy operation will copy a character from the start of the string to the end of the memory block.

    C# C++ LosToPointer ejemplos y llaman al método para obtener un puntero no administrado a la dirección de inicio de la cadena y el bloque de memoria no administrado, y agregan una menor que la longitud de la cadena a la dirección de inicio de la cadena ANSI.The C# and C++ examples call the ToPointer method to get an unmanaged pointer to the starting address of the string and the unmanaged block of memory, and they add one less than the length of the string to the starting address of the ANSI string. Dado que el puntero de la cadena no administrada 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.Because the unmanaged string pointer now points to the end of the string, the copy operation will copy a character from the end of the string to the start of the memory block.

  4. Usa un bucle para copiar cada carácter de la cadena en el bloque de memoria no administrado.Uses a loop to copy each character from the string to the unmanaged block of memory.

    En el ejemplo Visual Basic se Marshal.ReadByte(IntPtr, Int32) llama al método para leer el byte (o un carácter de un byte) en un desplazamiento especificado desde el puntero administrado a la cadena ANSI.The Visual Basic example calls the Marshal.ReadByte(IntPtr, Int32) method to read the byte (or one-byte character) at a specified offset from the managed pointer to the ANSI string. El desplazamiento se incrementa con cada iteración del bucle.The offset is incremented with each iteration of the loop. A continuación, llama Marshal.WriteByte(IntPtr, Int32, Byte) al 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.It then calls the Marshal.WriteByte(IntPtr, Int32, Byte) method to write the byte to the memory address defined by the starting address of the unmanaged block of memory plus offset. Después disminuye offset.It then decrements offset.

    En C# los C++ ejemplos y se realiza la operación de copia, se reduce el puntero a la dirección de la siguiente ubicación en la cadena ANSI no administrada y se incrementa el puntero a la siguiente dirección del bloque no administrado.The C# and C++ examples perform the copy operation, then decrement the pointer to the address of the next location in the unmanaged ANSI string and increment the pointer to the next address in the unmanaged block.

  5. Marshal.PtrToStringAnsi En todos los ejemplos se llama a para convertir el bloque de memoria no administrada que contiene la cadena ANSI copiada en un objeto Unicode String administrado.All examples call the Marshal.PtrToStringAnsi to convert the unmanaged memory block containing the copied ANSI string to a managed Unicode String object.

  6. Después de mostrar las cadenas originales e invertidas, todos los FreeHGlobal ejemplos llaman al método para liberar la memoria asignada para la cadena ANSI no administrada y el bloque de memoria no administrado.After displaying the original and reversed strings, all examples call the FreeHGlobal method to free the memory allocated for the unmanaged ANSI string and the unmanaged block of memory.

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
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 específico de la plataforma.The IntPtr type is designed to be an integer whose size is platform-specific. Es decir, se espera que una instancia de este tipo sea 32 bits en hardware y sistemas operativos de 32 bits y 64 bits en hardware y sistemas operativos de 64 bits.That is, an instance of this type is expected to be 32-bits on 32-bit hardware and operating systems, and 64-bits on 64-bit hardware and operating systems.

El IntPtr tipo se puede usar en los lenguajes que admiten punteros, y como un medio común para hacer referencia a datos entre lenguajes que no admiten punteros.The IntPtr type can be used by languages that support pointers, and as a common means of referring to data between languages that do and do not support pointers.

IntPtrlos objetos también se pueden usar para contener identificadores.IntPtr objects can also be used to hold handles. Por ejemplo, las instancias IntPtr de se usan exhaustivamente en System.IO.FileStream la clase para contener los identificadores de archivo.For example, instances of IntPtr are used extensively in the System.IO.FileStream class to hold file handles.

El IntPtr tipo es conforme a CLS, mientras que UIntPtr el tipo no es.The IntPtr type is CLS-compliant, while the UIntPtr type is not. Solo se IntPtr utiliza el tipo en el Common Language Runtime.Only the IntPtr type is used in the common language runtime. El UIntPtr tipo se proporciona principalmente para mantener la simetría arquitectónica con IntPtr el tipo.The UIntPtr type is provided mostly to maintain architectural symmetry with the IntPtr type.

Este tipo implementa la interfaz ISerializable.This type implements the ISerializable interface.

Constructores

IntPtr(Int32)

Inicializa una nueva instancia de IntPtr usando el puntero o identificador de 32 bits especificado.Initializes a new instance of IntPtr using the specified 32-bit pointer or handle.

IntPtr(Int64)

Inicializa una nueva instancia de IntPtr usando el puntero de 64 bits especificado.Initializes a new instance of IntPtr using the specified 64-bit pointer.

IntPtr(Void*)

Inicializa una nueva instancia de IntPtr usando el puntero especificado a un tipo no especificado.Initializes a new instance of IntPtr using the specified pointer to an unspecified type.

Campos

Zero

Campo de solo lectura que representa un puntero o identificador que se inicializó en cero.A read-only field that represents a pointer or handle that has been initialized to zero.

Propiedades

Size

Obtiene el tamaño de esta instancia.Gets the size of this instance.

Métodos

Add(IntPtr, Int32)

Suma un desplazamiento al valor de un puntero.Adds an offset to the value of a pointer.

Equals(Object)

Devuelve un valor que indica si esta instancia equivale a un objeto especificado.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

Devuelve el código hash de esta instancia.Returns the hash code for this instance.

Subtract(IntPtr, Int32)

Resta un desplazamiento del valor de un puntero.Subtracts an offset from the value of a pointer.

ToInt32()

Convierte el valor de esta instancia a un entero de 32 bits con signo.Converts the value of this instance to a 32-bit signed integer.

ToInt64()

Convierte el valor de esta instancia a un entero de 64 bits con signo.Converts the value of this instance to a 64-bit signed integer.

ToPointer()

Convierte el valor de esta instancia a un puntero a un tipo no especificado.Converts the value of this instance to a pointer to an unspecified type.

ToString()

Convierte el valor numérico del objeto IntPtr actual en su representación de cadena equivalente.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString(String)

Convierte el valor numérico del objeto IntPtr actual en su representación de cadena equivalente.Converts the numeric value of the current IntPtr object to its equivalent string representation.

Operadores

Addition(IntPtr, Int32)

Suma un desplazamiento al valor de un puntero.Adds an offset to the value of a pointer.

Equality(IntPtr, IntPtr)

Determina si dos instancias especificadas de IntPtr son iguales.Determines whether two specified instances of IntPtr are equal.

Explicit(Int32 to IntPtr)

Convierte el valor de un entero de 32 bits con signo en un IntPtr.Converts the value of a 32-bit signed integer to an IntPtr.

Explicit(Int64 to IntPtr)

Convierte el valor de un entero de 64 bits con signo en un IntPtr.Converts the value of a 64-bit signed integer to an IntPtr.

Explicit(IntPtr to Int32)

Convierte el valor del IntPtr especificado en un entero de 32 bits con signo.Converts the value of the specified IntPtr to a 32-bit signed integer.

Explicit(IntPtr to Int64)

Convierte el valor del IntPtr especificado en un entero de 64 bits con signo.Converts the value of the specified IntPtr to a 64-bit signed integer.

Explicit(IntPtr to Void*)

Convierte el valor del IntPtr especificado en un puntero a un tipo no especificado.Converts the value of the specified IntPtr to a pointer to an unspecified type.

Esta API no es conforme a CLS.This API is not CLS-compliant.

Explicit(Void* to IntPtr)

Convierte el puntero especificado a un tipo no especificado en un IntPtr.Converts the specified pointer to an unspecified type to an IntPtr.

Esta API no es conforme a CLS.This API is not CLS-compliant.

Inequality(IntPtr, IntPtr)

Determina si dos instancias especificadas de IntPtr no son iguales.Determines whether two specified instances of IntPtr are not equal.

Subtraction(IntPtr, Int32)

Resta un desplazamiento del valor de un puntero.Subtracts an offset from the value of a pointer.

Implementaciones de interfaz explícitas

IEquatable<IntPtr>.Equals(IntPtr)
ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Rellena un objeto SerializationInfo con los datos necesarios para serializar el objeto IntPtr actual.Populates a SerializationInfo object with the data needed to serialize the current IntPtr object.

Se aplica a

Seguridad para subprocesos

Este tipo es seguro para la ejecución de subprocesos.This type is thread safe.

Consulte también: