IntPtr Struct

Definizione

Tipo specifico per la piattaforma usato per rappresentare un puntatore o un handle.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
Ereditarietà
IntPtr
Attributi
Implementazioni

Esempio

Nell'esempio seguente vengono usati i puntatori gestiti per invertire i caratteri in una matrice.The following example uses managed pointers to reverse the characters in an array. Dopo l'inizializzazione di un String oggetto e la relativa lunghezza, viene eseguito quanto segue:After it initializes a String object and gets its length, it does the following:

  1. Chiama il Marshal.StringToHGlobalAnsi metodo per copiare la stringa Unicode nella memoria non gestita come carattere ANSI (a un byte).Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as an ANSI (one-byte) character. Il metodo restituisce un IntPtr oggetto che punta all'inizio della stringa non gestita.The method returns an IntPtr object that points to the beginning of the unmanaged string. Nell'esempio Visual Basic viene usato direttamente questo puntatore. Negli esempi di C++ e C# viene eseguito il cast a un puntatore 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. Chiama il Marshal.AllocHGlobal metodo per allocare lo stesso numero di byte occupato dalla stringa non gestita.Calls the Marshal.AllocHGlobal method to allocate the same number of bytes as the unmanaged string occupies. Il metodo restituisce un IntPtr oggetto che punta all'inizio del blocco di memoria non gestita.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory. Nell'esempio Visual Basic viene usato direttamente questo puntatore. Negli esempi di C++ e C# viene eseguito il cast a un puntatore 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. Nell'esempio Visual Basic viene definita una variabile denominata offset uguale alla lunghezza della stringa ANSI.The Visual Basic example defines a variable named offset that is equal to the length of the ANSI string. Viene usato per determinare l'offset nella memoria non gestita in cui viene copiato il carattere successivo nella stringa ANSI.It is used to determine the offset into unmanaged memory to which the next character in the ANSI string is copied. Poiché il valore iniziale è la lunghezza della stringa, l'operazione di copia copierà un carattere dall'inizio della stringa alla fine del blocco di 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.

    Gli esempi di C# e C++ chiamano il ToPointer metodo per ottenere un puntatore non gestito all'indirizzo iniziale della stringa e il blocco di memoria non gestita e aggiungono uno minore della lunghezza della stringa all'indirizzo iniziale della stringa 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. Poiché il puntatore di stringa non gestita punta ora alla fine della stringa, l'operazione di copia copierà un carattere dalla fine della stringa all'inizio del blocco di 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 ciclo per copiare ogni carattere dalla stringa al blocco di memoria non gestito.Uses a loop to copy each character from the string to the unmanaged block of memory.

    Nell'esempio Visual Basic viene chiamato il Marshal.ReadByte(IntPtr, Int32) metodo per leggere il byte (o un carattere a un byte) in corrispondenza di un offset specificato dal puntatore gestito alla stringa 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. L'offset viene incrementato a ogni iterazione del ciclo.The offset is incremented with each iteration of the loop. Viene quindi chiamato il Marshal.WriteByte(IntPtr, Int32, Byte) metodo per scrivere il byte nell'indirizzo di memoria definito dall'indirizzo iniziale del blocco di memoria non gestito più 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. Viene quindi decrementato offset .It then decrements offset.

    Gli esempi di C# e C++ eseguono l'operazione di copia, quindi decrementano il puntatore all'indirizzo della posizione successiva nella stringa ANSI non gestita e incrementano il puntatore all'indirizzo successivo nel blocco non gestito.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. Tutti gli esempi chiamano Marshal.PtrToStringAnsi per convertire il blocco di memoria non gestita contenente la stringa ANSI copiata in un oggetto Unicode gestito 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. Dopo aver visualizzato le stringhe originali e invertite, tutti gli esempi chiamano il FreeHGlobal metodo per liberare la memoria allocata per la stringa ANSI non gestita e il blocco di memoria non gestita.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

Commenti

Il IntPtr tipo è progettato per essere un numero intero la cui dimensione è specifica della piattaforma.The IntPtr type is designed to be an integer whose size is platform-specific. Ovvero, è previsto che un'istanza di questo tipo sia 32 bit su hardware e sistemi operativi a 32 bit e 64 bit su hardware e sistemi operativi a 64 bit.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.

Il IntPtr tipo può essere usato da linguaggi che supportano i puntatori e come mezzo comune per fare riferimento ai dati tra lingue che non supportano i puntatori.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 gli oggetti possono essere usati anche per contenere gli handle.IntPtr objects can also be used to hold handles. Ad esempio, le istanze di IntPtr vengono utilizzate ampiamente nella System.IO.FileStream classe per mantenere gli handle di file.For example, instances of IntPtr are used extensively in the System.IO.FileStream class to hold file handles.

Il IntPtr tipo è conforme a CLS, mentre il UIntPtr tipo non lo è.The IntPtr type is CLS-compliant, while the UIntPtr type is not. IntPtrNel Common Language Runtime viene utilizzato solo il tipo.Only the IntPtr type is used in the common language runtime. Il UIntPtr tipo viene fornito principalmente per mantenere la simmetria dell'architettura con il IntPtr tipo.The UIntPtr type is provided mostly to maintain architectural symmetry with the IntPtr type.

Questo tipo implementa ISerializable e, in .net 5,0 e versioni successive, le IFormattable interfacce.This type implements the ISerializable, and, in .NET 5.0 and later, the IFormattable interfaces.

Costruttori

IntPtr(Int32)

Inizializza una nuova istanza di IntPtr usando il puntatore o handle a 32 bit specificato.Initializes a new instance of IntPtr using the specified 32-bit pointer or handle.

IntPtr(Int64)

Inizializza una nuova istanza di IntPtr usando il puntatore a 64 bit specificato.Initializes a new instance of IntPtr using the specified 64-bit pointer.

IntPtr(Void*)

Inizializza una nuova istanza di IntPtr usando il puntatore specificato a un tipo non specificato.Initializes a new instance of IntPtr using the specified pointer to an unspecified type.

Campi

Zero

Campo di sola lettura che rappresenta un puntatore o un handle inizializzato su zero.A read-only field that represents a pointer or handle that has been initialized to zero.

Proprietà

MaxValue

Rappresenta il valore massimo possibile di IntPtr.Represents the largest possible value of IntPtr.

MinValue

Rappresenta il valore più piccolo possibile di IntPtr.Represents the smallest possible value of IntPtr.

Size

Ottiene le dimensioni dell'istanza.Gets the size of this instance.

Metodi

Add(IntPtr, Int32)

Aggiunge un offset al valore di un puntatore.Adds an offset to the value of a pointer.

CompareTo(IntPtr)

Confronta l'istanza corrente con un altro oggetto dello stesso tipo e restituisce un intero che indica se l'istanza corrente precede, segue o si trova nella stessa posizione dell'altro oggetto all'interno dell'ordinamento.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)

Confronta l'istanza corrente con un altro oggetto dello stesso tipo e restituisce un intero che indica se l'istanza corrente precede, segue o si trova nella stessa posizione dell'altro oggetto all'interno dell'ordinamento.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 l'oggetto corrente è uguale a un altro oggetto dello stesso tipo.Indicates whether the current object is equal to another object of the same type.

Equals(Object)

Restituisce un valore che indica se questa istanza è uguale a un oggetto specificato.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

Restituisce il codice hash per l'istanza.Returns the hash code for this instance.

Parse(String)

Converte la rappresentazione di stringa di un numero nell'intero nativo con segno equivalente.Converts the string representation of a number to its signed native integer equivalent.

Parse(String, IFormatProvider)

Converte la rappresentazione di stringa di un numero in un formato specifico delle impostazioni cultura nell'equivalente intero nativo con segno.Converts the string representation of a number in a specified culture-specific format to its signed native integer equivalent.

Parse(String, NumberStyles)

Converte la rappresentazione di stringa di un numero in uno stile specificato nell'equivalente intero con segno a 64 bit.Converts the string representation of a number in a specified style to its signed native integer equivalent.

Parse(String, NumberStyles, IFormatProvider)

Converte la rappresentazione di stringa di un numero in uno stile e un formato delle impostazioni cultura specifici nell'equivalente intero nativo con segno.Converts the string representation of a number in a specified style and culture-specific format to its signed native integer equivalent.

Subtract(IntPtr, Int32)

Sottrae un offset dal valore di un puntatore.Subtracts an offset from the value of a pointer.

ToInt32()

Converte il valore dell'istanza in un intero con segno a 32 bit.Converts the value of this instance to a 32-bit signed integer.

ToInt64()

Converte il valore dell'istanza in un intero con segno a 64 bit.Converts the value of this instance to a 64-bit signed integer.

ToPointer()

Converte il valore dell'istanza in un puntatore a un tipo non specificato.Converts the value of this instance to a pointer to an unspecified type.

ToString()

Converte il valore numerico dell'oggetto IntPtr corrente nella rappresentazione di stringa equivalente.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString(IFormatProvider)

Converte il valore numerico dell'istanza nella rappresentazione di stringa equivalente usando il formato specificato e le informazioni di formattazione specifiche delle impostazioni cultura.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

ToString(String)

Converte il valore numerico dell'oggetto IntPtr corrente nella rappresentazione di stringa equivalente.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString(String, IFormatProvider)

Formatta il valore dell'istanza corrente usando il formato specificato.Formats the value of the current instance using the specified format.

TryParse(String, IntPtr)

Converte la rappresentazione di stringa di un numero nell'intero nativo con segno equivalente.Converts the string representation of a number to its signed native integer equivalent. Un valore restituito indica se la conversione è riuscita.A return value indicates whether the conversion succeeded.

TryParse(String, NumberStyles, IFormatProvider, IntPtr)

Converte la rappresentazione di stringa di un numero in uno stile e un formato delle impostazioni cultura specifici nell'equivalente intero nativo con segno.Converts the string representation of a number in a specified style and culture-specific format to its signed native integer equivalent. Un valore restituito indica se la conversione è riuscita.A return value indicates whether the conversion succeeded.

Operatori

Addition(IntPtr, Int32)

Aggiunge un offset al valore di un puntatore.Adds an offset to the value of a pointer.

Equality(IntPtr, IntPtr)

Determina se due istanze specificate dell'oggetto IntPtr sono uguali.Determines whether two specified instances of IntPtr are equal.

Explicit(Int32 to IntPtr)

Converte il valore di un intero con segno a 32 bit in un tipo IntPtr.Converts the value of a 32-bit signed integer to an IntPtr.

Explicit(Int64 to IntPtr)

Converte il valore di un intero con segno a 64 bit in un tipo IntPtr.Converts the value of a 64-bit signed integer to an IntPtr.

Explicit(IntPtr to Int32)

Converte il valore dell'oggetto IntPtr specificato in un intero con segno a 32 bit.Converts the value of the specified IntPtr to a 32-bit signed integer.

Explicit(IntPtr to Int64)

Converte il valore dell'oggetto IntPtr specificato in un intero con segno a 64 bit.Converts the value of the specified IntPtr to a 64-bit signed integer.

Explicit(IntPtr to Void*)

Converte il valore dell'oggetto IntPtr specificato in un puntatore a un tipo non specificato.Converts the value of the specified IntPtr to a pointer to an unspecified type.

Questa API non è conforme a CLS.This API is not CLS-compliant.

Explicit(Void* to IntPtr)

Converte il puntatore specificato per un tipo non specificato in un oggetto IntPtr.Converts the specified pointer to an unspecified type to an IntPtr.

Questa API non è conforme a CLS.This API is not CLS-compliant.

Inequality(IntPtr, IntPtr)

Determina se due istanze specificate dell'oggetto IntPtr non sono uguali.Determines whether two specified instances of IntPtr are not equal.

Subtraction(IntPtr, Int32)

Sottrae un offset dal valore di un puntatore.Subtracts an offset from the value of a pointer.

Implementazioni dell'interfaccia esplicita

IEquatable<IntPtr>.Equals(IntPtr)

Restituisce un valore che indica se questa istanza è uguale a un altro puntatore a un intero con segno.Returns a value that indicates whether this instance is equal to another signed integer pointer.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Compila un oggetto SerializationInfo con i dati necessari per serializzare l'oggetto IntPtr corrente.Populates a SerializationInfo object with the data needed to serialize the current IntPtr object.

Si applica a

Thread safety

Questo tipo è thread-safe.This type is thread safe.

Vedi anche