IntPtr Struktur

Definition

Namespace:

System

Assembly:

System.Runtime.dll

Quelle:

IntPtr.cs

Stellt eine signierte ganze Zahl dar, wobei die Bitbreite mit einem Zeiger identisch ist.

public value class IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<IntPtr>, IUtf8SpanParsable<IntPtr>, System::Numerics::IAdditionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IAdditiveIdentity<IntPtr, IntPtr>, System::Numerics::IBinaryInteger<IntPtr>, System::Numerics::IBinaryNumber<IntPtr>, System::Numerics::IBitwiseOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IComparisonOperators<IntPtr, IntPtr, bool>, System::Numerics::IDecrementOperators<IntPtr>, System::Numerics::IDivisionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IEqualityOperators<IntPtr, IntPtr, bool>, System::Numerics::IIncrementOperators<IntPtr>, System::Numerics::IMinMaxValue<IntPtr>, System::Numerics::IModulusOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IMultiplicativeIdentity<IntPtr, IntPtr>, System::Numerics::IMultiplyOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::INumber<IntPtr>, System::Numerics::INumberBase<IntPtr>, System::Numerics::IShiftOperators<IntPtr, int, IntPtr>, System::Numerics::ISignedNumber<IntPtr>, System::Numerics::ISubtractionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IUnaryNegationOperators<IntPtr, IntPtr>, System::Numerics::IUnaryPlusOperators<IntPtr, IntPtr>, System::Runtime::Serialization::ISerializable

public readonly struct IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<IntPtr>, IUtf8SpanParsable<IntPtr>, System.Numerics.IAdditionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IAdditiveIdentity<IntPtr,IntPtr>, System.Numerics.IBinaryInteger<IntPtr>, System.Numerics.IBinaryNumber<IntPtr>, System.Numerics.IBitwiseOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IComparisonOperators<IntPtr,IntPtr,bool>, System.Numerics.IDecrementOperators<IntPtr>, System.Numerics.IDivisionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IEqualityOperators<IntPtr,IntPtr,bool>, System.Numerics.IIncrementOperators<IntPtr>, System.Numerics.IMinMaxValue<IntPtr>, System.Numerics.IModulusOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IMultiplicativeIdentity<IntPtr,IntPtr>, System.Numerics.IMultiplyOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.INumber<IntPtr>, System.Numerics.INumberBase<IntPtr>, System.Numerics.IShiftOperators<IntPtr,int,IntPtr>, System.Numerics.ISignedNumber<IntPtr>, System.Numerics.ISubtractionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IUnaryNegationOperators<IntPtr,IntPtr>, System.Numerics.IUnaryPlusOperators<IntPtr,IntPtr>, System.Runtime.Serialization.ISerializable

type nativeint = struct
    interface IFormattable
    interface IParsable<nativeint>
    interface ISpanFormattable
    interface ISpanParsable<nativeint>
    interface IAdditionOperators<nativeint, nativeint, nativeint>
    interface IAdditiveIdentity<nativeint, nativeint>
    interface IBinaryInteger<nativeint>
    interface IBinaryNumber<nativeint>
    interface IBitwiseOperators<nativeint, nativeint, nativeint>
    interface IComparisonOperators<nativeint, nativeint, bool>
    interface IEqualityOperators<nativeint, nativeint, bool>
    interface IDecrementOperators<nativeint>
    interface IDivisionOperators<nativeint, nativeint, nativeint>
    interface IIncrementOperators<nativeint>
    interface IModulusOperators<nativeint, nativeint, nativeint>
    interface IMultiplicativeIdentity<nativeint, nativeint>
    interface IMultiplyOperators<nativeint, nativeint, nativeint>
    interface INumber<nativeint>
    interface INumberBase<nativeint>
    interface ISubtractionOperators<nativeint, nativeint, nativeint>
    interface IUnaryNegationOperators<nativeint, nativeint>
    interface IUnaryPlusOperators<nativeint, nativeint>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<nativeint>
    interface IShiftOperators<nativeint, int, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
    interface ISerializable

Public Structure IntPtr
Implements IAdditionOperators(Of IntPtr, IntPtr, IntPtr), IAdditiveIdentity(Of IntPtr, IntPtr), IBinaryInteger(Of IntPtr), IBinaryNumber(Of IntPtr), IBitwiseOperators(Of IntPtr, IntPtr, IntPtr), IComparable(Of IntPtr), IComparisonOperators(Of IntPtr, IntPtr, Boolean), IDecrementOperators(Of IntPtr), IDivisionOperators(Of IntPtr, IntPtr, IntPtr), IEqualityOperators(Of IntPtr, IntPtr, Boolean), IEquatable(Of IntPtr), IIncrementOperators(Of IntPtr), IMinMaxValue(Of IntPtr), IModulusOperators(Of IntPtr, IntPtr, IntPtr), IMultiplicativeIdentity(Of IntPtr, IntPtr), IMultiplyOperators(Of IntPtr, IntPtr, IntPtr), INumber(Of IntPtr), INumberBase(Of IntPtr), IParsable(Of IntPtr), ISerializable, IShiftOperators(Of IntPtr, Integer, IntPtr), ISignedNumber(Of IntPtr), ISpanParsable(Of IntPtr), ISubtractionOperators(Of IntPtr, IntPtr, IntPtr), IUnaryNegationOperators(Of IntPtr, IntPtr), IUnaryPlusOperators(Of IntPtr, IntPtr), IUtf8SpanParsable(Of IntPtr)

Vererbung

Object

ValueType

IntPtr

Implementiert

IComparable IComparable<IntPtr> IEquatable<IntPtr> IFormattable ISerializable ISpanFormattable IComparable<TSelf> IEquatable<TSelf> IParsable<IntPtr> IParsable<TSelf> ISpanParsable<IntPtr> ISpanParsable<TSelf> IAdditionOperators<IntPtr,IntPtr,IntPtr> IAdditionOperators<TSelf,TSelf,TSelf> IAdditiveIdentity<IntPtr,IntPtr> IAdditiveIdentity<TSelf,TSelf> IBinaryInteger<IntPtr> IBinaryNumber<IntPtr> IBinaryNumber<TSelf> IBitwiseOperators<IntPtr,IntPtr,IntPtr> IBitwiseOperators<TSelf,TSelf,TSelf> IComparisonOperators<IntPtr,IntPtr,Boolean> IComparisonOperators<TSelf,TSelf,Boolean> IDecrementOperators<IntPtr> IDecrementOperators<TSelf> IDivisionOperators<IntPtr,IntPtr,IntPtr> IDivisionOperators<TSelf,TSelf,TSelf> IEqualityOperators<IntPtr,IntPtr,Boolean> IEqualityOperators<TSelf,TOther,TResult> IEqualityOperators<TSelf,TSelf,Boolean> IIncrementOperators<IntPtr> IIncrementOperators<TSelf> IMinMaxValue<IntPtr> IModulusOperators<IntPtr,IntPtr,IntPtr> IModulusOperators<TSelf,TSelf,TSelf> IMultiplicativeIdentity<IntPtr,IntPtr> IMultiplicativeIdentity<TSelf,TSelf> IMultiplyOperators<IntPtr,IntPtr,IntPtr> IMultiplyOperators<TSelf,TSelf,TSelf> INumber<IntPtr> INumber<TSelf> INumberBase<IntPtr> INumberBase<TSelf> IShiftOperators<IntPtr,Int32,IntPtr> IShiftOperators<TSelf,Int32,TSelf> ISignedNumber<IntPtr> ISubtractionOperators<IntPtr,IntPtr,IntPtr> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<IntPtr,IntPtr> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<IntPtr,IntPtr> IUnaryPlusOperators<TSelf,TSelf> IUtf8SpanFormattable IUtf8SpanParsable<IntPtr> IUtf8SpanParsable<TSelf>

Beispiele

Im folgenden Beispiel werden verwaltete Zeiger verwendet, um die Zeichen in einem Array umzukehren. Nachdem es ein String-Objekt initialisiert und seine Länge erhält, führt es die folgenden Aktionen aus:

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

2. Ruft die Marshal.AllocHGlobal-Methode auf, um dieselbe Anzahl von Bytes wie die nicht verwaltete Zeichenfolge zuzuweisen. Die Methode gibt ein IntPtr-Objekt zurück, das auf den Anfang des nicht verwalteten Speicherblocks verweist. Im Visual Basic-Beispiel wird dieser Zeiger direkt verwendet. in den C++-, F#- und C#-Beispielen wird sie in einen Zeiger auf ein Byte umgegossen.

3. Im Visual Basic-Beispiel wird eine Variable mit dem Namen offset definiert, die der Länge der ANSI-Zeichenfolge entspricht. Es wird verwendet, um den Offset in nicht verwalteten Speicher zu bestimmen, in den das nächste Zeichen in der ANSI-Zeichenfolge kopiert wird. Da der Anfangswert die Länge der Zeichenfolge ist, kopiert der Kopiervorgang ein Zeichen vom Anfang der Zeichenfolge bis zum Ende des Speicherblocks.

   In den Beispielen C#, F# und C++ 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 eine kleiner als die Länge der Zeichenfolge zur Startadresse der ANSI-Zeichenfolge hinzu. Da der nicht verwaltete Zeichenfolgenzeiger jetzt auf das Ende der Zeichenfolge zeigt, kopiert der Kopiervorgang ein Zeichen vom Ende der Zeichenfolge an den Anfang des Speicherblocks.

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

   Im Visual Basic-Beispiel wird die Marshal.ReadByte(IntPtr, Int32)-Methode aufgerufen, um das Byte (oder ein Bytezeichen) in einem angegebenen Offset vom verwalteten Zeiger auf die ANSI-Zeichenfolge zu lesen. Der Offset wird mit jeder Iteration der Schleife erhöht. 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 und offsetdefiniert wird. Anschließend wird offset.

   In den Beispielen C#, F# und C++ wird der Kopiervorgang ausgeführt, anschließend der Zeiger auf die Adresse des nächsten Speicherorts in der nicht verwalteten ANSI-Zeichenfolge erhöht und der Zeiger auf die nächste Adresse im nicht verwalteten Block erhöht.

5. Alle Beispiele rufen die Marshal.PtrToStringAnsi auf, um den nicht verwalteten Speicherblock mit der kopierten ANSI-Zeichenfolge in ein verwaltetes Unicode-String-Objekt zu 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 zugewiesenen Speicher 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

#nowarn "9"
open System.Runtime.InteropServices
open FSharp.NativeInterop

[<EntryPoint>]
let main _ = 
    let stringA = "I seem to be turned around!"
    let mutable copylen = stringA.Length

    // Allocate HGlobal memory for source and destination strings
    let sptr = Marshal.StringToHGlobalAnsi stringA
    let dptr = Marshal.AllocHGlobal(copylen + 1)

    let mutable src: byte nativeptr = sptr.ToPointer() |> NativePtr.ofVoidPtr
    let mutable dst: byte nativeptr = dptr.ToPointer() |> NativePtr.ofVoidPtr

    if copylen > 0 then
        // set the source pointer to the end of the string
        // to do a reverse copy.
        src <- 
            NativePtr.toNativeInt src + nativeint (copylen - 1) 
            |> NativePtr.ofNativeInt

        while copylen > 0 do
            copylen <- copylen - 1
            NativePtr.read src |> NativePtr.write dst
            dst <- NativePtr.toNativeInt dst + 1n |> NativePtr.ofNativeInt
            src <- NativePtr.toNativeInt src - 1n |> NativePtr.ofNativeInt
        NativePtr.write dst 0uy

    let stringB = Marshal.PtrToStringAnsi dptr

    printfn $"Original:\n{stringA}\n"
    printfn $"Reversed:\n{stringB}"

    // Free HGlobal memory
    Marshal.FreeHGlobal dptr
    Marshal.FreeHGlobal sptr
    0

// 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 so konzipiert, dass es sich um eine ganze Zahl handelt, deren Größe mit einem Zeiger identisch ist. Das heißt, eine Instanz dieses Typs wird in einem 32-Bit-Prozess und 64 Bit in einem 64-Bit-Prozess als 32-Bit-Prozess erwartet.

Der IntPtr Typ kann von Sprachen verwendet werden, die Zeiger unterstützen, und als gängige Möglichkeit, auf Daten zwischen Sprachen zu verweisen, die Zeiger unterstützen und keine Zeiger unterstützen.

IntPtr Objekte können auch zum Halten von Ziehpunkten verwendet werden. Instanzen von IntPtr werden beispielsweise in der System.IO.FileStream Klasse umfassend zum Speichern von Dateihandles verwendet.

Anmerkung

Die Verwendung von IntPtr als Zeiger oder Handle ist fehleranfällig und unsicher. Es handelt sich einfach um einen ganzzahligen Typ, der als Austauschformat für Zeiger und Handles verwendet werden kann, da sie dieselbe Größe aufweisen. Außerhalb bestimmter Austauschanforderungen, z. B. zum Übergeben von Daten an eine Sprache, die Zeiger nicht unterstützt, sollte ein richtig typierter Zeiger verwendet werden, um Zeiger darzustellen, und SafeHandle zum Darstellen von Handles verwendet werden sollen.

Dieser Typ implementiert die ISerializable. In .NET 5 und höheren Versionen implementiert dieser Typ auch die IFormattable Schnittstellen. In .NET 7 und höheren Versionen implementiert dieser Typ auch die schnittstellen IBinaryInteger<TSelf>, IMinMaxValue<TSelf>und ISignedNumber<TSelf>.

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

In C# ab Version 11 und beim Ziel der .NET 7- oder höher-Laufzeit ist nint ein Alias für IntPtr auf die gleiche Weise wie int ein Alias für Int32.

Konstruktoren

IntPtr(Int32)	Initialisiert eine neue Instanz von IntPtr mithilfe der angegebenen 32-Bit-ganzzahligen Vorzeichen.
IntPtr(Int64)	Initialisiert eine neue Instanz von IntPtr mithilfe der angegebenen 64-Bit-ganzzahligen Vorzeichen.
IntPtr(Void*)	Initialisiert eine neue Instanz von IntPtr mithilfe des angegebenen Zeigers auf einen nicht angegebenen Typ.

Felder

Zero	Ein schreibgeschütztes Feld, das eine signierte ganze Zahl darstellt, die auf Null initialisiert wurde.

Eigenschaften

MaxValue	Ruft den größten möglichen Wert von IntPtrab.
MinValue	Ruft den kleinsten möglichen Wert von IntPtrab.
Size	Ruft die Größe dieser Instanz ab.

Methoden

Abs(IntPtr)	Berechnet den absoluten Wert.
Add(IntPtr, Int32)	Fügt einen Offset zu einer signierten ganzzahligen Zahl hinzu.
Clamp(IntPtr, IntPtr, IntPtr)	Klammert einen Wert auf einen inklusiven Minimal- und Maximalwert.
CompareTo(IntPtr)	Vergleicht die aktuelle Instanz mit einem anderen Objekt desselben Typs und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz vorgeht, folgt oder in derselben Position in der Sortierreihenfolge wie das andere Objekt auftritt.
CompareTo(Object)	Vergleicht die aktuelle Instanz mit einem anderen Objekt desselben Typs und gibt eine ganze Zahl zurück, die angibt, ob die aktuelle Instanz vorgeht, folgt oder in derselben Position in der Sortierreihenfolge wie das andere Objekt auftritt.
CopySign(IntPtr, IntPtr)	Kopiert das Vorzeichen eines Werts in das Vorzeichen eines anderen Werts.
CreateChecked<TOther>(TOther)	Erstellt eine Instanz des aktuellen Typs aus einem Wert und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateSaturating<TOther>(TOther)	Erstellt eine Instanz des aktuellen Typs aus einem Wert, wobei alle Werte gesättigt werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
CreateTruncating<TOther>(TOther)	Erstellt eine Instanz des aktuellen Typs aus einem Wert, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
DivRem(IntPtr, IntPtr)	Berechnet den Quotienten und rest von zwei Werten.
Equals(IntPtr)	Gibt an, ob das aktuelle Objekt einem anderen Objekt desselben Typs entspricht.
Equals(Object)	Gibt einen Wert zurück, der angibt, ob diese Instanz einem angegebenen Objekt entspricht.
GetHashCode()	Gibt den Hashcode für diese Instanz zurück.
IsEvenInteger(IntPtr)	Bestimmt, ob ein Wert eine gerade integrale Zahl darstellt.
IsNegative(IntPtr)	Bestimmt, ob ein Wert negativ ist.
IsOddInteger(IntPtr)	Bestimmt, ob ein Wert eine ungerade integrale Zahl darstellt.
IsPositive(IntPtr)	Bestimmt, ob ein Wert positiv ist.
IsPow2(IntPtr)	Bestimmt, ob ein Wert eine Potenz von zwei ist.
LeadingZeroCount(IntPtr)	Berechnet die Anzahl der führenden Nullen in einem Wert.
Log2(IntPtr)	Berechnet das Protokoll2 eines Werts.
Max(IntPtr, IntPtr)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
MaxMagnitude(IntPtr, IntPtr)	Vergleicht zwei Werte mit der Berechnung, die größer ist.
Min(IntPtr, IntPtr)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
MinMagnitude(IntPtr, IntPtr)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist.
Parse(ReadOnlySpan<Byte>, IFormatProvider)	Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.
Parse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider)	Analysiert eine Spanne von UTF-8 Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, IFormatProvider)	Analysiert eine Spanne von Zeichen in einen Wert.
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)	Wandelt den schreibgeschützten Bereich der Zeichendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das signierte systemeigene ganzzahlige Äquivalent um.
Parse(String)	Konvertiert die Zeichenfolgendarstellung einer Zahl in das signierte, systemeigene ganzzahlige Äquivalent.
Parse(String, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einem angegebenen kulturspezifischen Format in das signierte systemeigene ganzzahlige Äquivalent.
Parse(String, NumberStyles)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage in das signierte systemeigene ganzzahlige Äquivalent.
Parse(String, NumberStyles, IFormatProvider)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das signierte systemeigene ganzzahlige Äquivalent.
PopCount(IntPtr)	Berechnet die Anzahl der Bits, die in einem Wert festgelegt sind.
RotateLeft(IntPtr, Int32)	Dreht einen Wert um einen bestimmten Betrag nach links.
RotateRight(IntPtr, Int32)	Dreht einen Wert um einen bestimmten Betrag nach rechts.
Sign(IntPtr)	Berechnet das Vorzeichen eines Werts.
Subtract(IntPtr, Int32)	Subtrahiert einen Offset von einer signierten ganzzahligen Zahl.
ToInt32()	Konvertiert den Wert dieser Instanz in eine 32-Bit-ganzzahlige Vorzeichen.
ToInt64()	Konvertiert den Wert dieser Instanz in eine 64-Bit-ganzzahlige Vorzeichen.
ToPointer()	Konvertiert den Wert dieser Instanz in einen Zeiger in einen nicht angegebenen Typ.
ToString()	Wandelt den numerischen Wert des aktuellen IntPtr -Objekts in die entsprechende Zeichenfolgendarstellung um.
ToString(IFormatProvider)	Wandelt den numerischen Wert dieser Instanz mithilfe der angegebenen Format- und kulturspezifischen Formatinformationen in die entsprechende Zeichenfolgendarstellung um.
ToString(String)	Wandelt den numerischen Wert des aktuellen IntPtr -Objekts in die entsprechende Zeichenfolgendarstellung um.
ToString(String, IFormatProvider)	Formatiert den Wert der aktuellen Instanz mithilfe des angegebenen Formats.
TrailingZeroCount(IntPtr)	Berechnet die Anzahl der nachfolgenden Nullen in einem Wert.
TryFormat(Span<Byte>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Instanz als UTF-8 in die bereitgestellte Bytespanne zu formatieren.
TryFormat(Span<Char>, Int32, ReadOnlySpan<Char>, IFormatProvider)	Versucht, den Wert der aktuellen Instanz in die bereitgestellte Zeichenspanne zu formatieren.
TryParse(ReadOnlySpan<Byte>, IFormatProvider, IntPtr)	Versucht, eine Spanne von UTF-8 Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Byte>, IntPtr)	Versucht, einen UTF-8-Zeichenbereich zu konvertieren, der die Zeichenfolgendarstellung einer Zahl in seine vorzeichenierte ganzzahlige Entsprechung enthält.
TryParse(ReadOnlySpan<Byte>, NumberStyles, IFormatProvider, IntPtr)	Versucht, eine Spanne von UTF-8 Zeichen in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, IFormatProvider, IntPtr)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(ReadOnlySpan<Char>, IntPtr)	Wandelt den schreibgeschützten Bereich der Zeichendarstellung einer Zahl in die signierte native ganzzahlige Entsprechung um. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.
TryParse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider, IntPtr)	Wandelt den schreibgeschützten Bereich der Zeichendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das signierte systemeigene ganzzahlige Äquivalent um. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.
TryParse(String, IFormatProvider, IntPtr)	Versucht, eine Zeichenfolge in einen Wert zu analysieren.
TryParse(String, IntPtr)	Konvertiert die Zeichenfolgendarstellung einer Zahl in das signierte, systemeigene ganzzahlige Äquivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.
TryParse(String, NumberStyles, IFormatProvider, IntPtr)	Konvertiert die Zeichenfolgendarstellung einer Zahl in einer angegebenen Formatvorlage und einem kulturspezifischen Format in das signierte systemeigene ganzzahlige Äquivalent. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich war.

Operatoren

Addition(IntPtr, Int32)	Fügt einen Offset zu einer signierten ganzzahligen Zahl hinzu.
Equality(IntPtr, IntPtr)	Bestimmt, ob zwei angegebene Instanzen von IntPtr gleich sind.
Explicit(Int32 to IntPtr)	Wandelt den Wert einer 32-Bit-ganzzahligen 32-Bit-Ganzzahl in eine IntPtrum.
Explicit(Int64 to IntPtr)	Wandelt den Wert einer 64-Bit-ganzzahligen Vorzeichen in eine IntPtrum.
Explicit(IntPtr to Int32)	Wandelt den Wert der angegebenen IntPtr in eine 32-Bit-Ganzzahl um.
Explicit(IntPtr to Int64)	Wandelt den Wert der angegebenen IntPtr in eine ganze 64-Bit-Ganzzahl um.
Explicit(IntPtr to Void*)	Konvertiert den Wert der angegebenen IntPtr in einen Zeiger in einen nicht angegebenen Typ. Diese API ist nicht CLS-kompatibel.
Explicit(Void* to IntPtr)	Wandelt den angegebenen Zeiger in einen nicht angegebenen Typ in einen IntPtrum. 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 von einer signierten ganzzahligen Zahl.

Explizite Schnittstellenimplementierungen

IAdditionOperators<IntPtr,IntPtr,IntPtr>.Addition(IntPtr, IntPtr)	Addiert zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditionOperators<IntPtr,IntPtr,IntPtr>.CheckedAddition(IntPtr, IntPtr)	Addiert zwei Werte zusammen, um ihre Summe zu berechnen.
IAdditiveIdentity<IntPtr,IntPtr>.AdditiveIdentity	Ruft die additive Identität des aktuellen Typs ab.
IBinaryInteger<IntPtr>.GetByteCount()	Ruft die Anzahl der Bytes ab, die als Teil von TryWriteLittleEndian(Span<Byte>, Int32)geschrieben werden.
IBinaryInteger<IntPtr>.GetShortestBitLength()	Ruft die Länge in Bits der kürzesten beiden Ergänzungsdarstellung des aktuellen Werts ab.
IBinaryInteger<IntPtr>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Stellt eine signierte ganze Zahl dar, wobei die Bitbreite mit einem Zeiger identisch ist.
IBinaryInteger<IntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)	Stellt eine signierte ganze Zahl dar, wobei die Bitbreite mit einem Zeiger identisch ist.
IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert im Big-End-Format in einen bestimmten Bereich zu schreiben.
IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)	Versucht, den aktuellen Wert in einem kleinen endischen Format in einen bestimmten Bereich zu schreiben.
IBinaryNumber<IntPtr>.AllBitsSet	Ruft eine Instanz des binären Typs ab, in der alle Bits festgelegt sind.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseAnd(IntPtr, IntPtr)	Berechnet die bitweise und von zwei Werten.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseOr(IntPtr, IntPtr)	Berechnet die bitweise oder zwei Werte.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.ExclusiveOr(IntPtr, IntPtr)	Berechnet die exklusiven oder zwei Werte.
IBitwiseOperators<IntPtr,IntPtr,IntPtr>.OnesComplement(IntPtr)	Berechnet die Darstellung eines bestimmten Werts.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThan(IntPtr, IntPtr)	Vergleicht zwei Werte, um zu bestimmen, welche größer ist.
IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThanOrEqual(IntPtr, IntPtr)	Vergleicht zwei Werte, um zu bestimmen, welche größer oder gleich sind.
IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThan(IntPtr, IntPtr)	Vergleicht zwei Werte, um zu bestimmen, welche werte kleiner sind.
IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThanOrEqual(IntPtr, IntPtr)	Vergleicht zwei Werte, um zu bestimmen, welche kleiner oder gleich ist.
IDecrementOperators<IntPtr>.CheckedDecrement(IntPtr)	Erhöht einen Wert.
IDecrementOperators<IntPtr>.Decrement(IntPtr)	Erhöht einen Wert.
IDivisionOperators<IntPtr,IntPtr,IntPtr>.Division(IntPtr, IntPtr)	Dividiert einen Wert durch einen anderen, um seinen Quotienten zu berechnen.
IIncrementOperators<IntPtr>.CheckedIncrement(IntPtr)	Erhöht einen Wert.
IIncrementOperators<IntPtr>.Increment(IntPtr)	Erhöht einen Wert.
IMinMaxValue<IntPtr>.MaxValue	Ruft den Maximalwert des aktuellen Typs ab.
IMinMaxValue<IntPtr>.MinValue	Ruft den Minimalwert des aktuellen Typs ab.
IModulusOperators<IntPtr,IntPtr,IntPtr>.Modulus(IntPtr, IntPtr)	Dividiert zwei Werte zusammen, um deren Modul oder Rest zu berechnen.
IMultiplicativeIdentity<IntPtr,IntPtr>.MultiplicativeIdentity	Ruft die multiplizierte Identität des aktuellen Typs ab.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.CheckedMultiply(IntPtr, IntPtr)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
IMultiplyOperators<IntPtr,IntPtr,IntPtr>.Multiply(IntPtr, IntPtr)	Multipliziert zwei Werte zusammen, um ihr Produkt zu berechnen.
INumber<IntPtr>.MaxNumber(IntPtr, IntPtr)	Vergleicht zwei Werte mit der Berechnung, die größer ist und den anderen Wert zurückgibt, wenn eine Eingabe NaNist.
INumber<IntPtr>.MinNumber(IntPtr, IntPtr)	Vergleicht zwei Werte mit der Berechnung, die kleiner ist und den anderen Wert zurückgibt, wenn eine Eingabe NaNist.
INumberBase<IntPtr>.IsCanonical(IntPtr)	Bestimmt, ob sich ein Wert in seiner kanonischen Darstellung befindet.
INumberBase<IntPtr>.IsComplexNumber(IntPtr)	Bestimmt, ob ein Wert eine komplexe Zahl darstellt.
INumberBase<IntPtr>.IsFinite(IntPtr)	Bestimmt, ob ein Wert endlich ist.
INumberBase<IntPtr>.IsImaginaryNumber(IntPtr)	Bestimmt, ob ein Wert eine reine imaginäre Zahl darstellt.
INumberBase<IntPtr>.IsInfinity(IntPtr)	Bestimmt, ob ein Wert unendlich ist.
INumberBase<IntPtr>.IsInteger(IntPtr)	Bestimmt, ob ein Wert eine integrale Zahl darstellt.
INumberBase<IntPtr>.IsNaN(IntPtr)	Bestimmt, ob ein Wert NaN ist.
INumberBase<IntPtr>.IsNegativeInfinity(IntPtr)	Bestimmt, ob ein Wert negative Unendlichkeit ist.
INumberBase<IntPtr>.IsNormal(IntPtr)	Bestimmt, ob ein Wert normal ist.
INumberBase<IntPtr>.IsPositiveInfinity(IntPtr)	Bestimmt, ob ein Wert positive Unendlichkeit ist.
INumberBase<IntPtr>.IsRealNumber(IntPtr)	Bestimmt, ob ein Wert eine reelle Zahl darstellt.
INumberBase<IntPtr>.IsSubnormal(IntPtr)	Bestimmt, ob ein Wert subnormal ist.
INumberBase<IntPtr>.IsZero(IntPtr)	Bestimmt, ob ein Wert null ist.
INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr, IntPtr)	Vergleicht zwei Werte mit der Berechnung, die größer ist und den anderen Wert zurückgibt, wenn eine Eingabe NaNist.
INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr, IntPtr)	Vergleicht zwei Werte mit der Berechnung, die die geringere Größe aufweist und den anderen Wert zurückgibt, wenn eine Eingabe NaNist.
INumberBase<IntPtr>.One	Ruft den Wert 1 für den Typ ab.
INumberBase<IntPtr>.Radix	Ruft das Radix oder die Basis für den Typ ab.
INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther, IntPtr)	Stellt eine signierte ganze Zahl dar, wobei die Bitbreite mit einem Zeiger identisch ist.
INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther, IntPtr)	Stellt eine signierte ganze Zahl dar, wobei die Bitbreite mit einem Zeiger identisch ist.
INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther, IntPtr)	Stellt eine signierte ganze Zahl dar, wobei die Bitbreite mit einem Zeiger identisch ist.
INumberBase<IntPtr>.TryConvertToChecked<TOther>(IntPtr, TOther)	Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren und löst eine Überlaufausnahme für alle Werte aus, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<IntPtr>.TryConvertToSaturating<TOther>(IntPtr, TOther)	Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren und alle Werte zu sättigungen, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<IntPtr>.TryConvertToTruncating<TOther>(IntPtr, TOther)	Versucht, eine Instanz des aktuellen Typs in einen anderen Typ zu konvertieren, wobei alle Werte abgeschnitten werden, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.
INumberBase<IntPtr>.Zero	Ruft den Wert 0 für den Typ ab.
ISerializable.GetObjectData(SerializationInfo, StreamingContext)	Füllt ein SerializationInfo -Objekt mit den Daten auf, die zum Serialisieren des aktuellen IntPtr -Objekts erforderlich sind.
IShiftOperators<IntPtr,Int32,IntPtr>.LeftShift(IntPtr, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach links.
IShiftOperators<IntPtr,Int32,IntPtr>.RightShift(IntPtr, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
IShiftOperators<IntPtr,Int32,IntPtr>.UnsignedRightShift(IntPtr, Int32)	Verschiebt einen Wert um einen bestimmten Betrag nach rechts.
ISignedNumber<IntPtr>.NegativeOne	Ruft den Wert -1 für den Typ ab.
ISubtractionOperators<IntPtr,IntPtr,IntPtr>.CheckedSubtraction(IntPtr, IntPtr)	Subtrahiert zwei Werte, um ihre Differenz zu berechnen.
ISubtractionOperators<IntPtr,IntPtr,IntPtr>.Subtraction(IntPtr, IntPtr)	Subtrahiert zwei Werte, um ihre Differenz zu berechnen.
IUnaryNegationOperators<IntPtr,IntPtr>.CheckedUnaryNegation(IntPtr)	Berechnet die überprüfte unäre Negation eines Werts.
IUnaryNegationOperators<IntPtr,IntPtr>.UnaryNegation(IntPtr)	Berechnet die unäre Negation eines Werts.
IUnaryPlusOperators<IntPtr,IntPtr>.UnaryPlus(IntPtr)	Berechnet das unäre Pluszeichen eines Werts.

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen

• UIntPtr