IntPtr Struktur

Definition

Ein plattformabhängiger Typ zur Darstellung von Zeigern und Handles.

public value class IntPtr
public value class IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, System::Runtime::Serialization::ISerializable
public value class IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, ISpanFormattable, 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 : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, ISpanFormattable, 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 ISpanFormattable
    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 IComparable, IComparable(Of IntPtr), IEquatable(Of IntPtr), ISerializable, ISpanFormattable
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. Nachdem ein -Objekt initialisiert String und seine Länge erhält, führt es Folgendes aus:

  1. Ruft die Marshal.StringToHGlobalAnsi -Methode auf, um die Unicode-Zeichenfolge als EIN-Byte-Zeichen (ANSI) in den nicht verwalteten Speicher zu kopieren. Die -Methode gibt ein IntPtr -Objekt zurück, das auf den Anfang der nicht verwalteten Zeichenfolge zeigt. Im Visual Basic Beispiel wird dieser Zeiger direkt verwendet. In den C++- und C#-Beispielen wird er in einen Zeiger auf ein Byte geschrieben.

  2. Ruft die Marshal.AllocHGlobal -Methode auf, um die gleiche Anzahl von Bytes zuzuordnen, die von der nicht verwalteten Zeichenfolge belegt werden. Die -Methode gibt ein IntPtr -Objekt zurück, das auf den Anfang des nicht verwalteten Speicherblocks zeigt. Im Visual Basic Beispiel wird dieser Zeiger direkt verwendet. In den C++- und C#-Beispielen wird er in einen Zeiger auf ein Byte geschrieben.

  3. Im Visual Basic Beispiel wird eine Variable namens offset definiert, die der Länge der ANSI-Zeichenfolge entspricht. 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. Da der Startwert die Länge der Zeichenfolge ist, kopiert der Kopiervorgang ein Zeichen vom Anfang der Zeichenfolge bis zum Ende des Speicherblocks.

    In den C#- und C++-Beispielen wird die ToPointer -Methode aufgerufen, um einen nicht verwalteten Zeiger auf die Startadresse der Zeichenfolge und den nicht verwalteten Speicherblock abzurufen, und sie fügen der Startadresse der ANSI-Zeichenfolge einen kleineren Wert als die Länge der Zeichenfolge hinzu. Da der nicht verwaltete Zeichenfolgenzeiger jetzt auf das Ende der Zeichenfolge zeigt, kopiert der Kopiervorgang ein Zeichen vom Ende der Zeichenfolge bis zum Anfang des Speicherblocks.

  4. Verwendet eine -Schleife, um jedes Zeichen aus der Zeichenfolge in den nicht verwalteten Speicherblock zu kopieren.

    Das Visual Basic Beispiel ruft die Marshal.ReadByte(IntPtr, Int32) -Methode auf, um das Byte (oder ein Bytezeichen) an einem angegebenen Offset vom verwalteten Zeiger auf die ANSI-Zeichenfolge zu lesen. Der Offset wird bei jeder Iteration der Schleife erhöht. Anschließend ruft sie die Marshal.WriteByte(IntPtr, Int32, Byte) -Methode auf, um das Byte in die Speicheradresse zu schreiben, die durch die Startadresse des nicht verwalteten Speicherblocks plus definiert offset wird. Anschließend wird dekrement wird offset .

    Die C#- und C++-Beispiele führen den Kopiervorgang aus, dekrementieren dann den Zeiger auf die Adresse der nächsten Position in der nicht verwalteten ANSI-Zeichenfolge und erhöhen den Zeiger auf die nächste Adresse im nicht verwalteten Block.

  5. In allen Beispielen wird Marshal.PtrToStringAnsi aufgerufen, um den nicht verwalteten Speicherblock, der die kopierte ANSI-Zeichenfolge enthält, in ein verwaltetes Unicode-Objekt zu String konvertieren.

  6. Nach dem Anzeigen der ursprünglichen und umgekehrten Zeichenfolgen rufen alle Beispiele die FreeHGlobal -Methode auf, um den für die nicht verwaltete ANSI-Zeichenfolge und den nicht verwalteten Speicherblock belegten Arbeitsspeicher freizugeben.

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 als ganze Zahl konzipiert, deren Größe plattformspezifisch ist. Das heißt, es wird erwartet, dass eine Instanz dieses Typs 32 Bits auf 32-Bit-Hardware und -Betriebssystemen und 64-Bit-Instanzen auf 64-Bit-Hardware und -Betriebssystemen ist.

Der IntPtr Typ kann von Sprachen verwendet werden, die Zeiger unterstützen, und als gängiges Mittel zum Verweisen auf Daten zwischen Sprachen, die Zeiger unterstützen und nicht.

IntPtr -Objekte können auch zum Speichern von Handles verwendet werden. Beispielsweise werden Instanzen von IntPtr in der System.IO.FileStream -Klasse umfassend verwendet, um Dateihandles zu speichern.

Der IntPtr Typ ist CLS-kompatibel, der UIntPtr Typ hingegen nicht. Nur der IntPtr Typ wird in der Common Language Runtime verwendet. Der UIntPtr Typ wird hauptsächlich bereitgestellt, um die Architektursymmetrie mit dem Typ IntPtr beizubehalten.

Dieser Typ implementiert die ISerializable Schnittstellen und in .NET 5 und IFormattable höher.

In C# können Sie ab Version 9.0 den integrierten Typ verwenden, nint um ganze Zahlen mit nativer Größe zu definieren. Dieser Typ wird intern durch den -Typ dargestellt IntPtr und stellt Vorgänge und Konvertierungen bereit, die für ganzzahlige Typen geeignet sind. Weitere Informationen finden Sie unter nint- und nuint-Typen.

Konstruktoren

IntPtr(Int32)

Initialisiert eine neue Instanz von IntPtr mit dem angegebenen 32-Bit-Zeiger bzw. -Handle.

IntPtr(Int64)

Initialisiert eine neue Instanz von IntPtr mit einem 64-Bit-Zeiger oder -Handle.

IntPtr(Void*)

Initialisiert eine neue Instanz von IntPtr mit dem angegebenen Zeiger auf einen nicht angegebenen Typ.

Felder

Zero

Ein schreibgeschütztes Feld, das einen mit 0 (null) initialisierten Zeiger oder ein Handle darstellt.

Eigenschaften

MaxValue

Stellt den größtmöglichen Wert von IntPtr dar.

MinValue

Stellt den kleinstmöglichen Wert von IntPtr dar.

Size

Ruft die Größe dieser Instanz ab.

Methoden

Add(IntPtr, Int32)

Addiert einen Offset zum Wert eines Zeigers.

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.

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.

Equals(IntPtr)

Gibt an, ob das aktuelle Objekt gleich einem anderen Objekt des gleichen Typs ist.

Equals(Object)

Gibt einen Wert zurück, der angibt, ob diese Instanz gleich einem angegebenen Objekt ist.

GetHashCode()

Gibt den Hashcode für diese Instanz zurück.

Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Konvertiert die schreibgeschützte Zeichenspannendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in die entsprechende native Ganzzahl mit Vorzeichen.

Parse(String)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende native Ganzzahl mit Vorzeichen.

Parse(String, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in die entsprechende native Ganzzahl mit Vorzeichen.

Parse(String, NumberStyles)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil in die entsprechende native Ganzzahl mit Vorzeichen.

Parse(String, NumberStyles, IFormatProvider)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in die entsprechende native Ganzzahl mit Vorzeichen.

Subtract(IntPtr, Int32)

Subtrahiert einen Offset vom Wert eines Zeigers.

ToInt32()

Konvertiert den Wert dieser Instanz in eine 32-Bit-Ganzzahl mit Vorzeichen.

ToInt64()

Konvertiert den Wert dieser Instanz in eine 64-Bit-Ganzzahl mit Vorzeichen.

ToPointer()

Konvertiert den Wert dieser Instanz in einen Zeiger auf einen nicht angegebenen Typ.

ToString()

Konvertiert den numerischen Wert des aktuellen IntPtr-Objekts in die entsprechende Zeichenfolgendarstellung.

ToString(IFormatProvider)

Konvertiert den numerischen Wert dieser Instanz unter Verwendung des angegebenen Formats und der angegebenen kulturabhängigen Formatierungsinformationen in die entsprechende Zeichenfolgendarstellung.

ToString(String)

Konvertiert den numerischen Wert des aktuellen IntPtr-Objekts in die entsprechende Zeichenfolgendarstellung.

ToString(String, IFormatProvider)

Formatiert den Wert der aktuellen Instanz mit dem angegebenen Format.

TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)

Versucht, den Wert der aktuellen Instanz in die angegebene Zeichenspanne zu formatieren.

TryParse(ReadOnlySpan<Char>, IntPtr)

Konvertiert die schreibgeschützte Zeichenspannendarstellung einer Zahl in die entsprechende native Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.

TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, IntPtr)

Konvertiert die schreibgeschützte Zeichenspannendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in die entsprechende native Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.

TryParse(String, IntPtr)

Konvertiert die Zeichenfolgendarstellung einer Zahl in die entsprechende native Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.

TryParse(String, NumberStyles, IFormatProvider, IntPtr)

Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in die entsprechende native Ganzzahl mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.

Operatoren

Addition(IntPtr, Int32)

Addiert einen Offset zum Wert eines Zeigers.

Equality(IntPtr, IntPtr)

Bestimmt, ob zwei angegebene Instanzen von IntPtr gleich sind.

Explicit(Int32 to IntPtr)

Konvertiert den Wert einer 32-Bit-Ganzzahl mit Vorzeichen in einen IntPtr-Konstruktor.

Explicit(Int64 to IntPtr)

Konvertiert den Wert einer 64-Bit-Ganzzahl mit Vorzeichen in einen IntPtr-Konstruktor.

Explicit(IntPtr to Int32)

Konvertiert den Wert des angegebenen IntPtr-Konstruktors in eine 32-Bit-Ganzzahl mit Vorzeichen.

Explicit(IntPtr to Int64)

Konvertiert den Wert des angegebenen IntPtr-Konstruktors in eine 64-Bit-Ganzzahl mit Vorzeichen.

Explicit(IntPtr to Void*)

Konvertiert den Wert des angegebenen IntPtr in einen Zeiger auf einen nicht angegebenen Typ.

Diese API ist nicht CLS-kompatibel.

Explicit(Void* to IntPtr)

Konvertiert den angegebenen Zeiger auf einen nicht angegebenen Typ in einen IntPtr.

Diese API ist nicht CLS-kompatibel.

Inequality(IntPtr, IntPtr)

Bestimmt, ob zwei angegebene Instanzen von IntPtr nicht gleich sind.

Subtraction(IntPtr, Int32)

Subtrahiert einen Offset vom Wert eines Zeigers.

Explizite Schnittstellenimplementierungen

IEquatable<IntPtr>.Equals(IntPtr)

Gibt einen Wert zurück, der angibt, ob diese Instanz einem signierten ganzzahligen Zeiger gleicht.

ISerializable.GetObjectData(SerializationInfo, StreamingContext)

Füllt ein SerializationInfo-Objekt mit den für das Serialisieren des aktuellen IntPtr-Objekts erforderlichen Daten.

Gilt für

Threadsicherheit

Dieser Typ ist threadsicher.

Siehe auch