IntPtr Struktur

Definition

Stellt eine ganzzahlige Vorzeichen 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, 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 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 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,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
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, 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 IShiftOperators<nativeint, int, nativeint>
    interface IMinMaxValue<nativeint>
    interface ISignedNumber<nativeint>
    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, 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
type nativeint = struct
    interface IFormattable
    interface IParsable<nativeint>
    interface ISpanFormattable
    interface ISpanParsable<nativeint>
    interface IUtf8SpanFormattable
    interface IUtf8SpanParsable<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 IShiftOperators<nativeint, int, 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, 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)
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)
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<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 abgerufen hat, führt es folgendes aus:

  1. Ruft die Marshal.StringToHGlobalAnsi -Methode auf, um die Unicode-Zeichenfolge als ANSI-Zeichen (ein Byte) in den nicht verwalteten Arbeitsspeicher 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++-, F#- und C#-Beispielen wird es in einen Zeiger auf ein Byte umgewandelt.

  2. Ruft die Marshal.AllocHGlobal -Methode auf, um die gleiche Anzahl von Bytes zuzuweisen, die die nicht verwaltete Zeichenfolge belegt. 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 es in einen Zeiger auf ein Byte umgewandelt.

  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 den nicht verwalteten Arbeitsspeicher 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#-, F#- 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 wert unter der 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.

    Im Visual Basic-Beispiel wird die Marshal.ReadByte(IntPtr, Int32) -Methode aufgerufen, um das Byte (oder ein Bytezeichen) an einem angegebenen Offset des verwalteten Zeigers 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 von der Startadresse des nicht verwalteten Speicherblocks plus offsetdefiniert wird. Anschließend wird dekrementiert offset.

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

  5. In allen Beispielen wird aufgerufen Marshal.PtrToStringAnsi , um den nicht verwalteten Speicherblock mit der kopierten ANSI-Zeichenfolge in ein verwaltetes Unicode-Objekt String zu konvertieren.

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

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 instance dieses Typs wird erwartet, dass sie 32 Bit in einem 32-Bit-Prozess und 64 Bit in einem 64-Bit-Prozess sein wird.

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 Halten von Handles verwendet werden. Beispielsweise werden Instanzen von IntPtr in der System.IO.FileStream -Klasse häufig verwendet, um Dateihandles zu speichern.

Hinweis

Die Verwendung IntPtr als Zeiger oder Handle ist fehleranfällig und unsicher. Es ist einfach ein ganzzahliger Typ, der aufgrund der gleichen Größe als Austauschformat für Zeiger und Handles verwendet werden kann. Außerhalb bestimmter Austauschanforderungen, z. B. für das Übergeben von Daten an eine Sprache, die Zeiger nicht unterstützt, sollte ein richtig eingegebener Zeiger verwendet werden, um Zeiger darzustellen und SafeHandle zum Darstellen von Handles verwendet werden.

Dieser Typ implementiert das 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 IBinaryInteger<TSelf>Schnittstellen , IMinMaxValue<TSelf>und ISignedNumber<TSelf> .

In C# ab Version 9.0 können Sie den integrierten nint Typ verwenden, um ganze Zahlen in nativer Größe zu definieren. Dieser Typ wird intern durch den IntPtr Typ 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-Runtime nint ist ein Alias für IntPtr auf die gleiche Weise wie int ein Alias für Int32.

Konstruktoren

IntPtr(Int32)

Initialisiert eine neue instance der Verwendung der IntPtr angegebenen 32-Bit-Ganzzahl mit Vorzeichen.

IntPtr(Int64)

Initialisiert eine neue instance der IntPtr Verwendung der angegebenen 64-Bit-Ganzzahl mit Vorzeichen.

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 ganzzahlige Vorzeichen darstellt, die mit null initialisiert wurde.

Eigenschaften

MaxValue

Ruft den größtmöglichen Wert von ab IntPtr.

MinValue

Ruft den kleinstmöglichen Wert von ab IntPtr.

Size

Ruft die Größe dieser Instanz ab.

Methoden

Abs(IntPtr)

Berechnet das Absolute eines Werts.

Add(IntPtr, Int32)

Fügt einer ganzzahligen Zahl mit Vorzeichen einen Offset hinzu.

Clamp(IntPtr, IntPtr, IntPtr)

Klemmt einen Wert auf einen inklusiven Minimal- 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 Vorzeichen eines Werts in das Vorzeichen eines anderen Werts.

CreateChecked<TOther>(TOther)

Erstellt eine instance 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 instance des aktuellen Typs aus einem -Wert und sättigt alle Werte, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.

CreateTruncating<TOther>(TOther)

Erstellt eine instance des aktuellen Typs aus einem Wert und schneidet alle Werte ab, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.

DivRem(IntPtr, IntPtr)

Berechnet den Quotienten und den 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 ganzzahlige Zahl darstellt.

IsNegative(IntPtr)

Bestimmt, ob ein Wert negativ ist.

IsOddInteger(IntPtr)

Bestimmt, ob ein Wert eine ungerade ganzzahlige 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 einem höheren Computewert.

MaxMagnitude(IntPtr, IntPtr)

Vergleicht zwei Werte mit einem höheren Computewert.

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)

Konvertiert die schreibgeschützte Spanne der Zeichendarstellung einer Zahl in einem angegebenen Stil und kulturspezifischen Format in die entsprechende native ganze Zahl 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.

PopCount(IntPtr)

Berechnet die Anzahl der Bits, die in einem -Wert festgelegt sind.

RotateLeft(IntPtr, Int32)

Rotiert einen Wert nach links um einen bestimmten Betrag.

RotateRight(IntPtr, Int32)

Rotiert einen Wert um einen bestimmten Betrag nach rechts.

Sign(IntPtr)

Berechnet das Vorzeichen eines Werts.

Subtract(IntPtr, Int32)

Subtrahiert einen Offset von einer ganzen Zahl mit Vorzeichen.

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 nachfolgenden Nullen in einem Wert.

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

Versucht, den Wert des aktuellen instance als UTF-8 in die angegebene Bytesspanne zu formatieren.

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

Versucht, den Wert des aktuellen instance in die angegebene 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, eine UTF-8-Zeichenspanne, die die Zeichenfolgendarstellung einer Zahl enthält, in deren Entsprechung mit ganzer Vorzeichen zu konvertieren.

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)

Konvertiert die schreibgeschützte Spanne der Zeichendarstellung einer Zahl in ihre native ganzzahlige Entsprechung mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.

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

Konvertiert die schreibgeschützte Spanne der Zeichendarstellung einer Zahl in einem angegebenen Format und kulturspezifischen Format in ihr natives Ganzzahläquivalent mit Vorzeichen. Ein Rückgabewert gibt an, ob die Konvertierung erfolgreich abgeschlossen wurde.

TryParse(String, IFormatProvider, IntPtr)

Versucht, eine Zeichenfolge in einen Wert zu analysieren.

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 einer ganzzahligen Zahl mit Vorzeichen einen Offset 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 ganzen Zahl mit Vorzeichen.

Explizite Schnittstellenimplementierungen

IAdditionOperators<IntPtr,IntPtr,IntPtr>.Addition(IntPtr, IntPtr)

Fügt zwei Werte zusammen, um deren Summe zu berechnen.

IAdditionOperators<IntPtr,IntPtr,IntPtr>.CheckedAddition(IntPtr, IntPtr)

Fügt zwei Werte zusammen, um deren 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 der komplementen Darstellung des aktuellen Werts in Bits ab.

IBinaryInteger<IntPtr>.TryReadBigEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)

Stellt eine ganzzahlige Vorzeichen dar, bei der die Bitbreite mit einem Zeiger identisch ist.

IBinaryInteger<IntPtr>.TryReadLittleEndian(ReadOnlySpan<Byte>, Boolean, IntPtr)

Stellt eine ganzzahlige Vorzeichen dar, bei der die Bitbreite mit einem Zeiger identisch ist.

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

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

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

Versucht, den aktuellen Wert im Little-Endian-Format in eine bestimmte Spanne zu schreiben.

IBinaryNumber<IntPtr>.AllBitsSet

Ruft eine instance des binären Typs ab, in dem alle Bits festgelegt sind.

IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseAnd(IntPtr, IntPtr)

Berechnet das bitweise und von zwei Werten.

IBitwiseOperators<IntPtr,IntPtr,IntPtr>.BitwiseOr(IntPtr, IntPtr)

Berechnet das bitweise oder von zwei Werten.

IBitwiseOperators<IntPtr,IntPtr,IntPtr>.ExclusiveOr(IntPtr, IntPtr)

Berechnet den exklusiven oder von zwei Werten.

IBitwiseOperators<IntPtr,IntPtr,IntPtr>.OnesComplement(IntPtr)

Berechnet die Eins-Komplement-Darstellung eines angegebenen Werts.

IComparisonOperators<IntPtr,IntPtr,Boolean>.GreaterThan(IntPtr, IntPtr)

Vergleicht zwei Werte, um zu bestimmen, welcher 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, welcher kleiner ist.

IComparisonOperators<IntPtr,IntPtr,Boolean>.LessThanOrEqual(IntPtr, IntPtr)

Vergleicht zwei Werte, um zu bestimmen, welcher kleiner oder gleich ist.

IDecrementOperators<IntPtr>.CheckedDecrement(IntPtr)

Verringert einen Wert.

IDecrementOperators<IntPtr>.Decrement(IntPtr)

Verringert einen Wert.

IDivisionOperators<IntPtr,IntPtr,IntPtr>.Division(IntPtr, IntPtr)

Dividiert einen Wert durch einen anderen, um den Quotienten zu berechnen.

IEquatable<IntPtr>.Equals(IntPtr)

Gibt einen Wert zurück, der angibt, ob dieser instance gleich einer anderen ganzen Zahl mit Vorzeichen ist.

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, um ihren Modulus oder Rest zu berechnen.

IMultiplicativeIdentity<IntPtr,IntPtr>.MultiplicativeIdentity

Ruft die multiplikative Identität des aktuellen Typs ab.

IMultiplyOperators<IntPtr,IntPtr,IntPtr>.CheckedMultiply(IntPtr, IntPtr)

Multipliziert zwei Werte, um ihr Produkt zu berechnen.

IMultiplyOperators<IntPtr,IntPtr,IntPtr>.Multiply(IntPtr, IntPtr)

Multipliziert zwei Werte, um ihr Produkt zu berechnen.

INumber<IntPtr>.MaxNumber(IntPtr, IntPtr)

Vergleicht zwei Werte mit der Berechnung, die größer ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.

INumber<IntPtr>.MinNumber(IntPtr, IntPtr)

Vergleicht zwei Werte mit der Berechnung, die kleiner ist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.

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 ganzzahlige Zahl darstellt.

INumberBase<IntPtr>.IsNaN(IntPtr)

Bestimmt, ob ein Wert NaN ist.

INumberBase<IntPtr>.IsNegativeInfinity(IntPtr)

Bestimmt, ob ein Wert negativ unendlich ist.

INumberBase<IntPtr>.IsNormal(IntPtr)

Bestimmt, ob ein Wert normal ist.

INumberBase<IntPtr>.IsPositiveInfinity(IntPtr)

Bestimmt, ob ein Wert positiv unendlich 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 0 ist.

INumberBase<IntPtr>.MaxMagnitudeNumber(IntPtr, IntPtr)

Vergleicht zwei Werte mit der Berechnung, die die größere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.

INumberBase<IntPtr>.MinMagnitudeNumber(IntPtr, IntPtr)

Vergleicht zwei Werte mit der Berechnung, die die geringere Größe aufweist, und gibt den anderen Wert zurück, wenn eine Eingabe ist NaN.

INumberBase<IntPtr>.One

Ruft den Wert 1 für den Typ ab.

INumberBase<IntPtr>.Radix

Ruft die Basis für den Typ ab.

INumberBase<IntPtr>.TryConvertFromChecked<TOther>(TOther, IntPtr)

Stellt eine ganzzahlige Vorzeichen dar, bei der die Bitbreite mit einem Zeiger identisch ist.

INumberBase<IntPtr>.TryConvertFromSaturating<TOther>(TOther, IntPtr)

Stellt eine ganzzahlige Vorzeichen dar, bei der die Bitbreite mit einem Zeiger identisch ist.

INumberBase<IntPtr>.TryConvertFromTruncating<TOther>(TOther, IntPtr)

Stellt eine ganzzahlige Vorzeichen dar, bei der die Bitbreite mit einem Zeiger identisch ist.

INumberBase<IntPtr>.TryConvertToChecked<TOther>(IntPtr, TOther)

Versucht, eine instance 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 instance des aktuellen Typs in einen anderen Typ zu konvertieren und dabei alle Werte zu überlasten, die außerhalb des darstellbaren Bereichs des aktuellen Typs liegen.

INumberBase<IntPtr>.TryConvertToTruncating<TOther>(IntPtr, TOther)

Versucht, eine instance 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 für das Serialisieren des aktuellen IntPtr-Objekts erforderlichen Daten.

IShiftOperators<IntPtr,Int32,IntPtr>.LeftShift(IntPtr, Int32)

Verschiebt einen Wert, der von einem bestimmten Betrag übrig bleibt.

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 deren Differenz zu berechnen.

ISubtractionOperators<IntPtr,IntPtr,IntPtr>.Subtraction(IntPtr, IntPtr)

Subtrahiert zwei Werte, um deren 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 Plus eines Werts.

Gilt für:

Threadsicherheit

Dieser Typ ist threadsicher.

Weitere Informationen