IntPtr Struktur

Definition

Ein plattformabhängiger Typ zur Darstellung von Zeigern und Handles.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
Vererbung
IntPtr
Attribute
Implementiert

Beispiele

Im folgenden Beispiel werden verwaltete Zeiger verwendet, um die Zeichen in einem Array umzukehren.The following example uses managed pointers to reverse the characters in an array. Nachdem Sie ein String -Objekt initialisiert und seine Länge erhalten hat, wird Folgendes ausgeführt:After it initializes a String object and gets its length, it does the following:

  1. Ruft die- Marshal.StringToHGlobalAnsi Methode auf, um die Unicode-Zeichenfolge als ANSI-Zeichen (ein Byte) in den nicht verwalteten Speicher zu kopieren.Calls the Marshal.StringToHGlobalAnsi method to copy the Unicode string to unmanaged memory as an ANSI (one-byte) character. Die-Methode gibt ein IntPtr Objekt zurück, das auf den Anfang der nicht verwalteten Zeichenfolge zeigt.The method returns an IntPtr object that points to the beginning of the unmanaged string. Das Visual Basic Beispiel verwendet diesen Zeiger direkt. in den C++-und c#-Beispielen wird Sie in einen Zeiger auf ein Byte umgewandelt.The Visual Basic example uses this pointer directly; in the C++ and C# examples, it is cast to a pointer to a byte.

  2. Ruft die- Marshal.AllocHGlobal Methode auf, um die gleiche Anzahl von Bytes zuzuordnen, wie die nicht verwaltete Zeichenfolge belegt.Calls the Marshal.AllocHGlobal method to allocate the same number of bytes as the unmanaged string occupies. Die-Methode gibt ein IntPtr Objekt zurück, das auf den Anfang des nicht verwalteten Speicherblocks zeigt.The method returns an IntPtr object that points to the beginning of the unmanaged block of memory. Das Visual Basic Beispiel verwendet diesen Zeiger direkt. in den C++-und c#-Beispielen wird Sie in einen Zeiger auf ein Byte umgewandelt.The Visual Basic example uses this pointer directly; in the C++ and C# examples, it is cast to a pointer to a byte.

  3. Das Visual Basic Beispiel definiert eine Variable offset mit dem Namen, die gleich der Länge der ANSI-Zeichenfolge ist.The Visual Basic example defines a variable named offset that is equal to the length of the ANSI string. Sie wird verwendet, um den Offset in den nicht verwalteten Speicher zu bestimmen, in den das nächste Zeichen in der ANSI-Zeichenfolge kopiert wird.It is used to determine the offset into unmanaged memory to which the next character in the ANSI string is copied. Da der Startwert die Länge der Zeichenfolge ist, kopiert der Kopiervorgang ein Zeichen vom Anfang der Zeichenfolge bis zum Ende des Speicherblocks.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.

    In den c#-und C++-Beispielen wird die-Methode aufgerufen, ToPointer um einen nicht verwalteten Zeiger auf die Startadresse der Zeichenfolge und den nicht verwalteten Speicherblock zu erhalten, und Sie fügen eine geringere Länge als die Länge der Zeichenfolge zur Startadresse der ANSI-Zeichenfolge hinzu.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. Da der nicht verwaltete Zeichen folgen Zeiger nun auf das Ende der Zeichenfolge zeigt, kopiert der Kopiervorgang ein Zeichen vom Ende der Zeichenfolge bis zum Anfang des Speicherblocks.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. Verwendet eine-Schleife, um jedes Zeichen aus der Zeichenfolge in den nicht verwalteten Speicherblock zu kopieren.Uses a loop to copy each character from the string to the unmanaged block of memory.

    Im Visual Basic Beispiel wird die- Marshal.ReadByte(IntPtr, Int32) Methode aufgerufen, um das Byte (oder ein-Byte-Zeichen) an einem angegebenen Offset aus dem verwalteten Zeiger auf die ANSI-Zeichenfolge zu lesen.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. Der Offset wird bei jeder Iterationen der Schleife inkrementiert.The offset is incremented with each iteration of the loop. Anschließend wird die- Marshal.WriteByte(IntPtr, Int32, Byte) Methode aufgerufen, um das Byte in die Speicheradresse zu schreiben, die durch die Startadresse des nicht verwalteten Speicherblocks Plus definiert wird 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. Dann Dekremente offset .It then decrements offset.

    In den c#-und C++-Beispielen wird der Kopiervorgang durchgeführt. Anschließend wird der Zeiger auf die Adresse des nächsten Speicher Orts in der nicht verwalteten ANSI-Zeichenfolge dekretet und der Zeiger auf die nächste Adresse im nicht verwalteten Block erhöht.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. In allen Beispielen wird aufgerufen Marshal.PtrToStringAnsi , um den nicht verwalteten Speicherblock mit der kopierten ANSI-Zeichenfolge in ein verwaltetes Unicode-Objekt zu konvertieren 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. Nach dem Anzeigen der ursprünglichen und umgekehrten Zeichen folgen wird in allen Beispielen die-Methode aufgerufen, FreeHGlobal um den für die nicht verwalteten ANSI-Zeichenfolge und den nicht verwalteten Speicherblock zugeordneten Arbeitsspeicher freizugeben.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

Hinweise

Der IntPtr -Typ ist eine ganze Zahl, deren Größe plattformspezifisch ist.The IntPtr type is designed to be an integer whose size is platform-specific. Das heißt, es wird erwartet, dass eine Instanz dieses Typs 32 Bit auf 32-Bit-Hardware und-Betriebssystemen und 64 Bits auf 64-Bit-Hardware und-Betriebssystemen ist.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.

Der IntPtr -Typ kann von Sprachen verwendet werden, die Zeiger unterstützen, und als gängiges Mittel, um auf Daten zwischen Sprachen zu verweisen, die keine Zeiger unterstützen.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 -Objekte können auch zum Speichern von Handles verwendet werden.IntPtr objects can also be used to hold handles. Beispielsweise werden Instanzen von IntPtr in der-Klasse häufig System.IO.FileStream zum Speichern von Datei Handles verwendet.For example, instances of IntPtr are used extensively in the System.IO.FileStream class to hold file handles.

Der IntPtr Typ ist CLS-kompatibel, der- UIntPtr Typ ist jedoch nicht.The IntPtr type is CLS-compliant, while the UIntPtr type is not. Nur der- IntPtr Typ wird in der Common Language Runtime verwendet.Only the IntPtr type is used in the common language runtime. Der- UIntPtr Typ wird größtenteils zur Aufrechterhaltung der Architektur Symmetrie mit dem-Typ bereitgestellt IntPtr .The UIntPtr type is provided mostly to maintain architectural symmetry with the IntPtr type.

Dieser Typ implementiert die ISerializable -Schnittstellen, und in .net 5,0 und höher IFormattable .This type implements the ISerializable, and, in .NET 5.0 and later, the IFormattable interfaces.

Konstruktoren

IntPtr(Int32)

Initialisiert eine neue Instanz von IntPtr mit dem angegebenen 32-Bit-Zeiger bzw. -Handle.Initializes a new instance of IntPtr using the specified 32-bit pointer or handle.

IntPtr(Int64)

Initialisiert eine neue Instanz von IntPtr mit einem 64-Bit-Zeiger oder -Handle.Initializes a new instance of IntPtr using the specified 64-bit pointer.

IntPtr(Void*)

Initialisiert eine neue Instanz von IntPtr mit dem angegebenen Zeiger auf einen nicht angegebenen Typ.Initializes a new instance of IntPtr using the specified pointer to an unspecified type.

Felder

Zero

Ein schreibgeschütztes Feld, das einen mit 0 (null) initialisierten Zeiger oder ein Handle darstellt.A read-only field that represents a pointer or handle that has been initialized to zero.

Eigenschaften

MaxValue

Stellt den größtmöglichen Wert von IntPtr dar.Represents the largest possible value of IntPtr.

MinValue

Stellt den kleinstmöglichen Wert von IntPtr dar.Represents the smallest possible value of IntPtr.

Size

Ruft die Größe dieser Instanz ab.Gets the size of this instance.

Methoden

Add(IntPtr, Int32)

Addiert einen Offset zum Wert eines Zeigers.Adds an offset to the value of a pointer.

CompareTo(IntPtr)

Vergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.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)

Vergleicht die aktuelle Instanz mit einem anderen Objekt vom selben Typ und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz in der Sortierreihenfolge vor oder nach dem anderen Objekt oder an derselben Position auftritt.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)

Gibt an, ob das aktuelle Objekt gleich einem anderen Objekt des gleichen Typs ist.Indicates whether the current object is equal to another object of the same type.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.Returns a value indicating whether this instance is equal to a specified object.

GetHashCode()

Gibt den Hashcode für diese Instanz zurück.Returns the hash code for this instance.

Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende native Ganzzahl mit Vorzeichen.Converts the string representation of a number to its signed native integer equivalent.

Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die entsprechende native Ganzzahl mit Vorzeichen.Converts the string representation of a number in a specified culture-specific format to its signed native integer equivalent.

Parse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende native Ganzzahl mit Vorzeichen.Converts the string representation of a number in a specified style to its signed native integer equivalent.

Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in die entsprechende native Ganzzahl mit Vorzeichen.Converts the string representation of a number in a specified style and culture-specific format to its signed native integer equivalent.

Subtract(IntPtr, Int32)

Subtrahiert einen Offset vom Wert eines Zeigers.Subtracts an offset from the value of a pointer.

ToInt32()

Konvertiert den Wert dieser Instanz in eine 32-Bit-Ganzzahl mit Vorzeichen.Converts the value of this instance to a 32-bit signed integer.

ToInt64()

Konvertiert den Wert dieser Instanz in eine 64-Bit-Ganzzahl mit Vorzeichen.Converts the value of this instance to a 64-bit signed integer.

ToPointer()

Konvertiert den Wert dieser Instanz in einen Zeiger auf einen nicht angegebenen Typ.Converts the value of this instance to a pointer to an unspecified type.

ToString()

Konvertiert den numerischen Wert des aktuellen IntPtr-Objekts in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString(IFormatProvider)

Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of this instance to its equivalent string representation using the specified format and culture-specific format information.

ToString(String)

Konvertiert den numerischen Wert des aktuellen IntPtr-Objekts in die entsprechende Zeichenfolgendarstellung.Converts the numeric value of the current IntPtr object to its equivalent string representation.

ToString(String, IFormatProvider)

Formatiert den Wert der aktuellen Instanz mit dem angegebenen Format.Formats the value of the current instance using the specified format.

TryParse(String, IntPtr)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende native Ganzzahl mit Vorzeichen.Converts the string representation of a number to its signed native integer equivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.A return value indicates whether the conversion succeeded.

TryParse(String, NumberStyles, IFormatProvider, IntPtr)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in die entsprechende native Ganzzahl mit Vorzeichen.Converts the string representation of a number in a specified style and culture-specific format to its signed native integer equivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.A return value indicates whether the conversion succeeded.

Operatoren

Addition(IntPtr, Int32)

Addiert einen Offset zum Wert eines Zeigers.Adds an offset to the value of a pointer.

Equality(IntPtr, IntPtr)

Bestimmt, ob zwei angegebene Instanzen von IntPtr gleich sind.Determines whether two specified instances of IntPtr are equal.

Explicit(Int32 to IntPtr)

Konvertiert den Wert einer 32-Bit-Ganzzahl mit Vorzeichen in einen IntPtr-Konstruktor.Converts the value of a 32-bit signed integer to an IntPtr.

Explicit(Int64 to IntPtr)

Konvertiert den Wert einer 64-Bit-Ganzzahl mit Vorzeichen in einen IntPtr-Konstruktor.Converts the value of a 64-bit signed integer to an IntPtr.

Explicit(IntPtr to Int32)

Konvertiert den Wert des angegebenen IntPtr-Konstruktors in eine 32-Bit-Ganzzahl mit Vorzeichen.Converts the value of the specified IntPtr to a 32-bit signed integer.

Explicit(IntPtr to Int64)

Konvertiert den Wert des angegebenen IntPtr-Konstruktors in eine 64-Bit-Ganzzahl mit Vorzeichen.Converts the value of the specified IntPtr to a 64-bit signed integer.

Explicit(IntPtr to Void*)

Konvertiert den Wert des angegebenen IntPtr in einen Zeiger auf einen nicht angegebenen Typ.Converts the value of the specified IntPtr to a pointer to an unspecified type.

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant.

Explicit(Void* to IntPtr)

Konvertiert den angegebenen Zeiger auf einen nicht angegebenen Typ in einen IntPtr.Converts the specified pointer to an unspecified type to an IntPtr.

Diese API ist nicht CLS-kompatibel.This API is not CLS-compliant.

Inequality(IntPtr, IntPtr)

Bestimmt, ob zwei angegebene Instanzen von IntPtr nicht gleich sind.Determines whether two specified instances of IntPtr are not equal.

Subtraction(IntPtr, Int32)

Subtrahiert einen Offset vom Wert eines Zeigers.Subtracts an offset from the value of a pointer.

Explizite Schnittstellenimplementierungen

IEquatable<IntPtr>.Equals(IntPtr)

Gibt einen Wert zurück, der angibt, ob diese Instanz einem signierten ganzzahligen Zeiger gleicht.Returns a value that indicates whether this instance is equal to another signed integer pointer.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Füllt ein SerializationInfo-Objekt mit den für das Serialisieren des aktuellen IntPtr-Objekts erforderlichen Daten.Populates a SerializationInfo object with the data needed to serialize the current IntPtr object.

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.This type is thread safe.

Weitere Informationen