IntPtr IntPtr IntPtr IntPtr Struct

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

Ejemplos

El ejemplo siguiente utiliza punteros administrados para invertir los caracteres en una matriz.The following example uses managed pointers to reverse the characters in an array. Una vez que inicialice un String de objetos y obtiene su longitud, hace lo siguiente:After it initializes a String object and gets its length, it does the following:

  1. Las llamadas del Marshal.StringToHGlobalAnsi método para copiar la cadena de Unicode a memoria no administrada como un carácter de 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. El ejemplo de Visual Basic utiliza este puntero directamente; en los ejemplos de C++ y C#, se convierte en 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. Las llamadas del Marshal.AllocHGlobal método para asignar el mismo número de bytes que se ocupa de 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 administrado.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory. El ejemplo de Visual Basic utiliza este puntero directamente; en los ejemplos de C++ y C#, se convierte en 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. El ejemplo de Visual Basic define una variable denominada offset que es igual que 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. Sirve para determinar el desplazamiento en la memoria no administrada que se copia en la siguiente carta en 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 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.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.

    La llamada de ejemplos de C# y C++ el ToPointer método para obtener un puntero no administrado a la dirección inicial de la cadena y el bloque de memoria, no administrado agregue uno menor que la longitud de la cadena a la dirección inicial 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. Puesto que ahora apunta el puntero de cadena no administrada al final de la cadena, la operación de copia copiará un carácter desde el final de la cadena al principio 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. Utiliza un bucle para copiar cada carácter de la cadena en el bloque de memoria no administrada.Uses a loop to copy each character from the string to the unmanaged block of memory.

    El ejemplo de Visual Basic llama a la Marshal.ReadByte(IntPtr, Int32) método para leer los bytes (o caracteres de byte único) con 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 el Marshal.WriteByte(IntPtr, Int32, Byte) método para escribir los bytes en la dirección de memoria definido por la dirección inicial del bloque no administrado de memoria 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. A continuación, se reduce offset.It then decrements offset.

    Ejemplos de C++ y C# realizan la operación de copia, a continuación, disminuir el puntero a la dirección de la ubicación siguiente en la cadena ANSI no administrada e incrementar el puntero a la siguiente dirección en el 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. Llamar todos los ejemplos del Marshal.PtrToStringAnsi para convertir el bloque de memoria no administrada que contiene la cadena copiada de ANSI a Unicode administrado String objeto.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, llamar todos los ejemplos el FreeHGlobal método para liberar la memoria asignada para la cadena ANSI no administrada y el bloque de memoria no administrada.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
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, una instancia de este tipo debe ser de 32 bits en sistemas operativos y hardware de 32 bits y 64 bits en sistemas operativos y hardware 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 puede usarse por los lenguajes que admiten punteros y como un medio común para hacer referencia a los datos entre los 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.

IntPtr objetos también pueden utilizarse para controlar identificadores.IntPtr objects can also be used to hold handles. Por ejemplo, las instancias de IntPtr se usan ampliamente en el System.IO.FileStream clase para contener los identificadores de archivos.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 el UIntPtr no es de tipo.The IntPtr type is CLS-compliant, while the UIntPtr type is not. Solo el IntPtr tipo se usa en common language runtime.Only the IntPtr type is used in the common language runtime. El UIntPtr tipo sirve principalmente para mantener la simetría arquitectónica con el IntPtr tipo.The UIntPtr type is provided mostly to maintain architectural symmetry with the IntPtr type.

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

Constructores

IntPtr(Int32) IntPtr(Int32) IntPtr(Int32) 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) IntPtr(Int64) IntPtr(Int64) 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*) IntPtr(Void*) IntPtr(Void*) 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 Zero Zero 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 Size Size Size

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

Métodos

Add(IntPtr, Int32) Add(IntPtr, Int32) Add(IntPtr, Int32) Add(IntPtr, Int32)

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

Equals(Object) Equals(Object) Equals(Object) 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() GetHashCode() GetHashCode() GetHashCode()

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

Subtract(IntPtr, Int32) Subtract(IntPtr, Int32) Subtract(IntPtr, Int32) Subtract(IntPtr, Int32)

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

ToInt32() ToInt32() ToInt32() 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() ToInt64() ToInt64() 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() ToPointer() ToPointer() 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(String) ToString(String) ToString(String) 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.

ToString() ToString() ToString() 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.

Operadores

Addition(IntPtr, Int32) Addition(IntPtr, Int32) Addition(IntPtr, Int32) Addition(IntPtr, Int32)

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

Equality(IntPtr, IntPtr) Equality(IntPtr, IntPtr) Equality(IntPtr, IntPtr) Equality(IntPtr, IntPtr)

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

Explicit(Void* to IntPtr) Explicit(Void* to IntPtr) Explicit(Void* to IntPtr) 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.

Explicit(IntPtr to Int64) Explicit(IntPtr to Int64) Explicit(IntPtr to Int64) 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*) Explicit(IntPtr to Void*) Explicit(IntPtr to Void*) 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(Int64 to IntPtr) Explicit(Int64 to IntPtr) Explicit(Int64 to 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(Int32 to IntPtr) Explicit(Int32 to IntPtr) Explicit(Int32 to IntPtr) 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(IntPtr to Int32) Explicit(IntPtr to Int32) Explicit(IntPtr to Int32) 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.

Inequality(IntPtr, IntPtr) Inequality(IntPtr, IntPtr) Inequality(IntPtr, IntPtr) 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) Subtraction(IntPtr, Int32) Subtraction(IntPtr, Int32) 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) IEquatable<IntPtr>.Equals(IntPtr) IEquatable<IntPtr>.Equals(IntPtr) IEquatable<IntPtr>.Equals(IntPtr)
ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) ISerializable.GetObjectData(SerializationInfo, StreamingContext) 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: