IntPtr Estrutura

Definição

Um tipo específico da plataforma que é usado para representar um ponteiro ou um identificador.A platform-specific type that is used to represent a pointer or a handle.

public value class IntPtr
public value class IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, 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 struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, System.Runtime.Serialization.ISerializable
public 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 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 IEquatable(Of IntPtr), ISerializable
Public Structure IntPtr
Implements ISerializable
Herança
IntPtr
Atributos
Implementações

Exemplos

O exemplo a seguir usa ponteiros gerenciados para reverter os caracteres em uma matriz.The following example uses managed pointers to reverse the characters in an array. Depois de inicializar um String objeto e obter seu comprimento, ele faz o seguinte:After it initializes a String object and gets its length, it does the following:

  1. Chama o Marshal.StringToHGlobalAnsi método para copiar a cadeia de caracteres Unicode para memória não gerenciada como um caractere ANSI (um byte).Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as an ANSI (one-byte) character. O método retorna um IntPtr objeto que aponta para o início da cadeia de caracteres não gerenciada.The method returns an IntPtr object that points to the beginning of the unmanaged string. O exemplo a Visual Basic usa esse ponteiro diretamente; nos exemplos de C++ e C#, ele é convertido em um ponteiro para um 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. Chama o Marshal.AllocHGlobal método para alocar o mesmo número de bytes que a cadeia de caracteres não gerenciada ocupa.Calls the Marshal.AllocHGlobal method to allocate the same number of bytes as the unmanaged string occupies. O método retorna um IntPtr objeto que aponta para o início do bloco de memória não gerenciado.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory. O exemplo a Visual Basic usa esse ponteiro diretamente; nos exemplos de C++ e C#, ele é convertido em um ponteiro para um 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. O exemplo a Visual Basic define uma variável chamada offset que é igual ao comprimento da cadeia de caracteres ANSI.The Visual Basic example defines a variable named offset that is equal to the length of the ANSI string. Ele é usado para determinar o deslocamento na memória não gerenciada para a qual o próximo caractere na cadeia de caracteres ANSI é copiado.It is used to determine the offset into unmanaged memory to which the next character in the ANSI string is copied. Como seu valor inicial é o comprimento da cadeia de caracteres, a operação de cópia copiará um caractere do início da cadeia de caracteres para o final do bloco de memória.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.

    Os exemplos de C# e C++ chamam o ToPointer método para obter um ponteiro não gerenciado para o endereço inicial da cadeia de caracteres e o bloco de memória não gerenciado e eles adicionam um menor que o comprimento da cadeia de caracteres ao endereço inicial da cadeia de caracteres 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. Como o ponteiro de cadeia de caracteres não gerenciada agora aponta para o final da cadeia de caracteres, a operação de cópia copiará um caractere do final da cadeia de caracteres para o início do bloco de memória.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 um loop para copiar cada caractere da cadeia de caracteres para o bloco de memória não gerenciado.Uses a loop to copy each character from the string to the unmanaged block of memory.

    O exemplo a Visual Basic chama o Marshal.ReadByte(IntPtr, Int32) método para ler o byte (ou caractere de um byte) em um deslocamento especificado do ponteiro gerenciado para a cadeia de caracteres 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. O deslocamento é incrementado com cada iteração do loop.The offset is incremented with each iteration of the loop. Em seguida, ele chama o Marshal.WriteByte(IntPtr, Int32, Byte) método para gravar o byte no endereço de memória definido pelo endereço inicial do bloco de memória não gerenciado mais 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. Em seguida, ele diminui offset .It then decrements offset.

    Os exemplos de C# e C++ executam a operação de cópia e decrementam o ponteiro para o endereço do próximo local na cadeia de caracteres ANSI não gerenciada e incrementam o ponteiro para o próximo endereço no bloco não gerenciado.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. Todos os exemplos chamam o Marshal.PtrToStringAnsi para converter o bloco de memória não gerenciada que contém a cadeia de caracteres ANSI copiada para um objeto Unicode gerenciado String .All examples call the Marshal.PtrToStringAnsi to convert the unmanaged memory block containing the copied ANSI string to a managed Unicode String object.

  6. Depois de exibir as cadeias de caracteres originais e inversas, todos os exemplos chamam o FreeHGlobal método para liberar a memória alocada para a cadeia de caracteres ANSI não gerenciada e o bloco de memória não gerenciado.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

Comentários

O IntPtr tipo é projetado para ser um inteiro cujo tamanho é específico da plataforma.The IntPtr type is designed to be an integer whose size is platform-specific. Ou seja, espera-se que uma instância desse tipo seja 32 bits em sistemas operacionais e hardware de 32 bits e 64 bits em sistemas operacionais e de 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.

O IntPtr tipo pode ser usado por idiomas que dão suporte a ponteiros e como um meio comum de se referir a dados entre linguagens que fazem e não dão suporte a ponteiros.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 os objetos também podem ser usados para manter identificadores.IntPtr objects can also be used to hold handles. Por exemplo, instâncias do IntPtr são usadas extensivamente na System.IO.FileStream classe para manter identificadores de arquivo.For example, instances of IntPtr are used extensively in the System.IO.FileStream class to hold file handles.

O IntPtr tipo é compatível com CLS, enquanto o UIntPtr tipo não é.The IntPtr type is CLS-compliant, while the UIntPtr type is not. Somente o IntPtr tipo é usado na Common Language Runtime.Only the IntPtr type is used in the common language runtime. O UIntPtr tipo é fornecido principalmente para manter a simetria da arquitetura com o IntPtr tipo.The UIntPtr type is provided mostly to maintain architectural symmetry with the IntPtr type.

Esse tipo implementa o ISerializable , e, no .net 5,0 e posterior, as IFormattable interfaces.This type implements the ISerializable, and, in .NET 5.0 and later, the IFormattable interfaces.

Construtores

IntPtr(Int32)

Inicializa uma nova instância do IntPtr usando o ponteiro de 32 bits especificado ou identificador.Initializes a new instance of IntPtr using the specified 32-bit pointer or handle.

IntPtr(Int64)

Inicializa uma nova instância de IntPtr usando o ponteiro de 64 bits especificado.Initializes a new instance of IntPtr using the specified 64-bit pointer.

IntPtr(Void*)

Inicializa uma nova instância do IntPtr usando o ponteiro especificado para um tipo não especificado.Initializes a new instance of IntPtr using the specified pointer to an unspecified type.

Campos

Zero

Um campo somente leitura que representa um ponteiro ou identificador que foi inicializado para zero.A read-only field that represents a pointer or handle that has been initialized to zero.

Propriedades

MaxValue

Representa o maior valor possível de IntPtr.Represents the largest possible value of IntPtr.

MinValue

Representa o menor valor possível de IntPtr.Represents the smallest possible value of IntPtr.

Size

Obtém o tamanho dessa instância.Gets the size of this instance.

Métodos

Add(IntPtr, Int32)

Adiciona um deslocamento ao valor de um ponteiro.Adds an offset to the value of a pointer.

CompareTo(IntPtr)

Compara a instância atual com outro objeto do mesmo tipo e retorna um inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição da ordem de classificação do outro objeto.Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object.

CompareTo(Object)

Compara a instância atual com outro objeto do mesmo tipo e retorna um inteiro que indica se a instância atual precede, segue ou ocorre na mesma posição da ordem de classificação do outro objeto.Compares the current instance with another object of the same type and returns an integer that indicates whether the current instance precedes, follows, or occurs in the same position in the sort order as the other object.

Equals(IntPtr)

Indica se o objeto atual é igual a outro objeto do mesmo tipo.Indicates whether the current object is equal to another object of the same type.

Equals(Object)

Retorna um valor que indica se a instância é igual a um objeto especificado.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

Retorna o código hash para a instância.Returns the hash code for this instance.

Parse(String)

Converte a representação da cadeia de caracteres de um número no inteiro nativo com sinal equivalente.Converts the string representation of a number to its signed native integer equivalent.

Parse(String, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um formato indicado específico à cultura no seu inteiro nativo com sinal equivalente.Converts the string representation of a number in a specified culture-specific format to its signed native integer equivalent.

Parse(String, NumberStyles)

Converte a representação de cadeia de caracteres de um número em um estilo especificado no inteiro nativo com sinal equivalente.Converts the string representation of a number in a specified style to its signed native integer equivalent.

Parse(String, NumberStyles, IFormatProvider)

Converte a representação de cadeia de caracteres de um número em um formato indicado específico de estilo e cultura no seu inteiro nativo com sinal equivalente.Converts the string representation of a number in a specified style and culture-specific format to its signed native integer equivalent.

Subtract(IntPtr, Int32)

Subtrai um deslocamento do valor de um ponteiro.Subtracts an offset from the value of a pointer.

ToInt32()

Converte o valor desta instância em um inteiro com sinal de 32 bits.Converts the value of this instance to a 32-bit signed integer.

ToInt64()

Converte o valor desta instância em um inteiro com sinal de 64 bits.Converts the value of this instance to a 64-bit signed integer.

ToPointer()

Converte o valor dessa instância em um ponteiro para um tipo não especificado.Converts the value of this instance to a pointer to an unspecified type.

ToString()

Converte o valor numérico do objeto IntPtr atual na representação da cadeia de caracteres equivalente.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString(IFormatProvider)

Converte o valor numérico dessa instância na representação da cadeia de caracteres equivalente usando o formato especificado e as informações de formato específicas da cultura especificada.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

ToString(String)

Converte o valor numérico do objeto IntPtr atual na representação da cadeia de caracteres equivalente.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString(String, IFormatProvider)

Formata o valor da instância atual usando o formato especificado.Formats the value of the current instance using the specified format.

TryParse(String, IntPtr)

Converte a representação da cadeia de caracteres de um número no inteiro nativo com sinal equivalente.Converts the string representation of a number to its signed native integer equivalent. Um valor retornado indica se a conversão foi bem-sucedida.A return value indicates whether the conversion succeeded.

TryParse(String, NumberStyles, IFormatProvider, IntPtr)

Converte a representação de cadeia de caracteres de um número em um formato indicado específico de estilo e cultura no seu inteiro nativo com sinal equivalente.Converts the string representation of a number in a specified style and culture-specific format to its signed native integer equivalent. Um valor retornado indica se a conversão foi bem-sucedida.A return value indicates whether the conversion succeeded.

Operadores

Addition(IntPtr, Int32)

Adiciona um deslocamento ao valor de um ponteiro.Adds an offset to the value of a pointer.

Equality(IntPtr, IntPtr)

Determina se duas instâncias especificadas do IntPtr são iguais.Determines whether two specified instances of IntPtr are equal.

Explicit(Int32 to IntPtr)

Converte o valor de um inteiro com sinal de 32 bits em um IntPtr.Converts the value of a 32-bit signed integer to an IntPtr.

Explicit(Int64 to IntPtr)

Converte o valor de um inteiro com sinal de 64 bits em um IntPtr.Converts the value of a 64-bit signed integer to an IntPtr.

Explicit(IntPtr to Int32)

Converte o valor do IntPtr especificado em um inteiro com sinal de 32 bits.Converts the value of the specified IntPtr to a 32-bit signed integer.

Explicit(IntPtr to Int64)

Converte o valor do IntPtr especificado em um inteiro com sinal de 64 bits.Converts the value of the specified IntPtr to a 64-bit signed integer.

Explicit(IntPtr to Void*)

Converte o valor do IntPtr especificado em um ponteiro para um tipo não especificado.Converts the value of the specified IntPtr to a pointer to an unspecified type.

Esta API não compatível com CLS.This API is not CLS-compliant.

Explicit(Void* to IntPtr)

Converte o ponteiro especificado em um tipo não especificado para um IntPtr.Converts the specified pointer to an unspecified type to an IntPtr.

Esta API não compatível com CLS.This API is not CLS-compliant.

Inequality(IntPtr, IntPtr)

Determina se duas instâncias especificadas de IntPtr não são iguais.Determines whether two specified instances of IntPtr are not equal.

Subtraction(IntPtr, Int32)

Subtrai um deslocamento do valor de um ponteiro.Subtracts an offset from the value of a pointer.

Implantações explícitas de interface

IEquatable<IntPtr>.Equals(IntPtr)

Retorna um valor que indica se esta instância é igual a outro ponteiro de inteiro com sinal.Returns a value that indicates whether this instance is equal to another signed integer pointer.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Popula um objeto SerializationInfo com os dados necessários para serializar o objeto IntPtr atual.Populates a SerializationInfo object with the data needed to serialize the current IntPtr object.

Aplica-se a

Acesso thread-safe

Este tipo é thread-safe.This type is thread safe.

Confira também