IntPtr Struktur

Definition

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

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 : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<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>, System::Numerics::IDecrementOperators<IntPtr>, System::Numerics::IDivisionOperators<IntPtr, IntPtr, IntPtr>, System::Numerics::IEqualityOperators<IntPtr, IntPtr>, 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, 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 value class IntPtr : IEquatable<IntPtr>, System::Runtime::Serialization::ISerializable
public value class IntPtr : System::Runtime::Serialization::ISerializable
public struct IntPtr
public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, IFormattable, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IComparable, IComparable<IntPtr>, IEquatable<IntPtr>, ISpanFormattable, System.Runtime.Serialization.ISerializable
public readonly struct IntPtr : IComparable<IntPtr>, IEquatable<IntPtr>, IParsable<IntPtr>, ISpanParsable<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>, System.Numerics.IDecrementOperators<IntPtr>, System.Numerics.IDivisionOperators<IntPtr,IntPtr,IntPtr>, System.Numerics.IEqualityOperators<IntPtr,IntPtr>, 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,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 struct IntPtr : IEquatable<IntPtr>, System.Runtime.Serialization.ISerializable
public readonly 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 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>
    interface IEqualityOperators<nativeint, nativeint>
    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 IShiftOperators<nativeint, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
    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 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), IDecrementOperators(Of IntPtr), IDivisionOperators(Of IntPtr, IntPtr, IntPtr), IEqualityOperators(Of IntPtr, IntPtr), 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, IntPtr), ISignedNumber(Of IntPtr), ISpanParsable(Of IntPtr), ISubtractionOperators(Of IntPtr, IntPtr, IntPtr), IUnaryNegationOperators(Of IntPtr, IntPtr), IUnaryPlusOperators(Of IntPtr, IntPtr)
Public Structure IntPtr
Implements IEquatable(Of IntPtr), ISerializable
Public Structure IntPtr
Implements ISerializable
Vererbung
IntPtr
Attribute
Implementiert
IComparable IComparable<IntPtr> IEquatable<IntPtr> IFormattable ISerializable ISpanFormattable IComparable<TOther> IComparable<TSelf> IEquatable<TOther> 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> System.Numerics.IComparisonOperators<IntPtr,IntPtr> System.Numerics.IComparisonOperators<TSelf,TSelf> IDecrementOperators<IntPtr> IDecrementOperators<TSelf> IDivisionOperators<IntPtr,IntPtr,IntPtr> IDivisionOperators<TSelf,TSelf,TSelf> System.Numerics.IEqualityOperators<IntPtr,IntPtr> System.Numerics.IEqualityOperators<TSelf,TOther> System.Numerics.IEqualityOperators<TSelf,TSelf> 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> System.Numerics.IShiftOperators<IntPtr,IntPtr> System.Numerics.IShiftOperators<TSelf,TSelf> ISignedNumber<IntPtr> ISubtractionOperators<IntPtr,IntPtr,IntPtr> ISubtractionOperators<TSelf,TSelf,TSelf> IUnaryNegationOperators<IntPtr,IntPtr> IUnaryNegationOperators<TSelf,TSelf> IUnaryPlusOperators<IntPtr,IntPtr> IUnaryPlusOperators<TSelf,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 abruft, führt er die folgenden Aktionen aus:

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

  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. Das Visual Basic-Beispiel verwendet diesen Zeiger direkt; in den Beispielen C++, F# und C# wird sie in einen Zeiger auf ein Byte umgeworfen.

  3. Im Visual Basic-Beispiel wird eine Variable definiert offset , die der Länge der ANSI-Zeichenfolge entspricht. Es wird verwendet, um den Offset in nicht verwalteten Speicher zu bestimmen, in das 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.

    Die C#-, F#- und C++-Beispiele rufen die ToPointer Methode auf, 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 verweist, 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.

    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 durch die Startadresse des nicht verwalteten Speicherblocks plus offsetdefinierte Speicheradresse zu schreiben. Anschließend wird er erhöht offset.

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

  5. Alle Beispiele rufen den Marshal.PtrToStringAnsi nicht verwalteten Speicherblock auf, der die kopierte ANSI-Zeichenfolge in ein verwaltetes Unicode-Objekt String enthält.

  6. Nach der Anzeige der ursprünglichen und umgekehrten Zeichenfolgen rufen alle Beispiele die FreeHGlobal Methode auf, um den für die nicht verwalteten 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 voraussichtlich 32 Bit in einem 32-Bit-Prozess und 64 Bit in einem 64-Bit-Prozess sein.

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

IntPtr Objekte können auch zum Halten von Ziehpunkten verwendet werden. Beispielsweise werden Instanzen von IntPtr Dateien in der System.IO.FileStream Klasse umfassend verwendet, um Dateiziehpunkte zu speichern.

Hinweis

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

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

In C# ab Version 9.0 können Sie den integrierten nint Typ verwenden, um systemeigene Ganzzahlen zu definieren. Dieser Typ wird durch den IntPtr Typ intern 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 bei der Ausrichtung auf die .NET 7 oder höher-Laufzeit nint ist ein Alias auf IntPtr die gleiche Weise wie int ein Alias für Int32.

Konstruktoren

IntPtr(Int32)

Initialisiert eine neue Instanz der IntPtr Verwendung der angegebenen 32-Bit-Ganzzahl.

IntPtr(Int64)

Initialisiert eine neue Instanz der IntPtr Verwendung der angegebenen 64-Bit-Ganzzahl.

IntPtr(Void*)

Initialisiert eine neue Instanz von IntPtr mit dem angegebenen Zeiger 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 IntPtr.

MinValue

Ruft den kleinsten möglichen Wert von IntPtr.

Size

Ruft die Größe dieser Instanz ab.

Methoden

Abs(IntPtr)

Berechnet das Absolute eines Werts.

Add(IntPtr, Int32)

Fügt einen Offset zu einer signierten ganzzahligen Zahl hinzu.

Clamp(IntPtr, IntPtr, IntPtr)

Klammert einen Wert auf einen inklusiven Mindest- und Höchstwert.

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.

CopySign(IntPtr, IntPtr)

Kopiert das Zeichen eines Werts in das Zeichen eines anderen Werts.

DivRem(IntPtr, IntPtr)

Berechnet den Quotienten und rest von zwei Werten.

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.

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 Leistung 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, um zu berechnen, was größer ist.

MaxMagnitude(IntPtr, IntPtr)

Vergleicht zwei Werte, um zu berechnen, was 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<Char>, IFormatProvider)
Parse(ReadOnlySpan<Char>, NumberStyles, IFormatProvider)

Wandelt den schreibgeschützten Bereich der Zeichendarstellung einer Zahl in einem angegebenen Format und kulturspezifischen Format in sein signiertes systemeigenes ganzzahliges Äquivalent um.

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.

PopCount(IntPtr)

Berechnet die Anzahl der Bits, die in einem Wert festgelegt werden.

RotateLeft(IntPtr, Int32)

Dreht einen Wert nach links um einen bestimmten Betrag.

RotateRight(IntPtr, Int32)

Dreht einen Wert nach rechts um einen bestimmten Betrag.

Sign(IntPtr)

Berechnet das Zeichen eines Werts.

Subtract(IntPtr, Int32)

Subtrahiert einen Offset von einer signierten ganzzahligen Zahl.

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.

TrailingZeroCount(IntPtr)

Berechnet die Anzahl der nachgestellten Nullen in einem Wert.

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

Versucht, den Wert der aktuellen Instanz in den angegebenen Bereich von Zeichen zu formatieren.

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

Wandelt den schreibgeschützten Bereich der Zeichendarstellung einer Zahl in das signierte systemeigene ganze Äquivalent um. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.

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

Wandelt den schreibgeschützten Bereich der Zeichendarstellung einer Zahl in einem angegebenen Format und kulturspezifischen Format in sein signiertes systemeigenes ganzzahliges Äquivalent um. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.

TryParse(String, IFormatProvider, IntPtr)
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)

Fügt einen Offset zu einer signierten Ganzzahl hinzu.

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 von einer signierten Ganzzahl.

Explizite Schnittstellenimplementierungen

IBinaryInteger<IntPtr>.GetByteCount()

Ruft die Anzahl der Bytes ab, die als Teil von TryWriteLittleEndian(Span<Byte>, Int32).

IBinaryInteger<IntPtr>.GetShortestBitLength()

Ruft die Länge in Bits der kürzesten Ergänzungsdarstellung des aktuellen Werts ab.

IBinaryInteger<IntPtr>.TryWriteBigEndian(Span<Byte>, Int32)

Versucht, den aktuellen Wert im Big-End-Format in eine bestimmte Spanne zu schreiben.

IBinaryInteger<IntPtr>.TryWriteLittleEndian(Span<Byte>, Int32)

Versucht, den aktuellen Wert in einem kleinen endischen Format in einen bestimmten Bereich zu schreiben.

IEquatable<IntPtr>.Equals(IntPtr)

Gibt einen Wert zurück, der angibt, ob diese Instanz einer anderen signierten Ganzzahl entspricht.

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