IntPtr Struct

Definitie

public value class IntPtr

public value class IntPtr : System::Runtime::Serialization::ISerializable

public value class IntPtr : IEquatable<IntPtr>, System::Runtime::Serialization::ISerializable

public struct IntPtr

[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

public readonly struct IntPtr : IEquatable<IntPtr>, System.Runtime.Serialization.ISerializable

type nativeint = struct

[<System.Serializable>]
type nativeint = struct
    interface ISerializable

[<System.Serializable>]
[<System.Runtime.InteropServices.ComVisible(true)>]
type nativeint = struct
    interface ISerializable

type nativeint = struct
    interface ISerializable

Public Structure IntPtr

Public Structure IntPtr
Implements ISerializable

Public Structure IntPtr
Implements IEquatable(Of IntPtr), ISerializable

Overname

Object

ValueType

IntPtr

Kenmerken

SerializableAttribute ComVisibleAttribute

Implementeringen

ISerializable IEquatable<IntPtr>

Voorbeelden

In het volgende voorbeeld worden beheerde aanwijzers gebruikt om de tekens in een matrix om te draaien. Nadat een String object is geïnitialiseerd en de lengte ervan heeft opgehaald, doet het het volgende:

1. Roept de Marshal.StringToHGlobalAnsi methode aan om de Unicode-tekenreeks te kopiëren naar onbeheerd geheugen als een ANSI-teken (een-byte). De methode retourneert een IntPtr object dat verwijst naar het begin van de onbeheerde tekenreeks. In het Visual Basic voorbeeld wordt deze aanwijzer rechtstreeks gebruikt. In de voorbeelden C++, F# en C# wordt deze naar een byte gecast.

2. Roept de Marshal.AllocHGlobal methode aan om hetzelfde aantal bytes toe te wijzen als de niet-beheerde tekenreeks in beslag neemt. De methode retourneert een IntPtr object dat verwijst naar het begin van het onbeheerde geheugenblok. In het Visual Basic voorbeeld wordt deze aanwijzer rechtstreeks gebruikt. In de voorbeelden C++, F# en C# wordt deze naar een byte gecast.

3. Het Visual Basic voorbeeld definieert een variabele met de naam offset die gelijk is aan de lengte van de ANSI-tekenreeks. Deze wordt gebruikt om de verschuiving te bepalen in onbeheerd geheugen waarnaar het volgende teken in de ANSI-tekenreeks wordt gekopieerd. Omdat de beginwaarde de lengte van de tekenreeks is, kopieert de kopieerbewerking een teken van het begin van de tekenreeks naar het einde van het geheugenblok.

   De C#-, F#- en C++-voorbeelden roepen de ToPointer methode aan om een niet-beheerde aanwijzer op te halen naar het beginadres van de tekenreeks en het niet-beheerde geheugenblok, en ze voegen er één toe die kleiner is dan de lengte van de tekenreeks aan het beginadres van de ANSI-tekenreeks. Omdat de niet-beheerde tekenreeks aanwijzer nu verwijst naar het einde van de tekenreeks, kopieert de kopieerbewerking een teken van het einde van de tekenreeks naar het begin van het geheugenblok.

4. Hiermee wordt een lus gebruikt om elk teken van de tekenreeks naar het niet-beheerde geheugenblok te kopiëren.

   In het Visual Basic voorbeeld wordt de methode Marshal.ReadByte(IntPtr, Int32) aangeroepen om het byteteken (of een-byteteken) te lezen op een opgegeven offset van de beheerde aanwijzer naar de ANSI-tekenreeks. De offset wordt verhoogd met elke iteratie van de lus. Vervolgens wordt de Marshal.WriteByte(IntPtr, Int32, Byte) methode aangeroepen om de byte naar het geheugenadres te schrijven dat is gedefinieerd door het beginadres van het niet-beheerde blok geheugen plus offset. Vervolgens wordt het afschroeven offset.

   De voorbeelden C#, F# en C++ voeren de kopieerbewerking uit en verlagen de aanwijzer vervolgens naar het adres van de volgende locatie in de niet-beheerde ANSI-tekenreeks en verhogen de aanwijzer naar het volgende adres in het niet-beheerde blok.

5. Alle voorbeelden roepen het Marshal.PtrToStringAnsi aan om het niet-beheerde geheugenblok met de gekopieerde ANSI-tekenreeks te converteren naar een beheerd Unicode-object String .

6. Nadat de oorspronkelijke en omgekeerde tekenreeksen zijn weergegeven, roepen alle voorbeelden de FreeHGlobal methode aan om het geheugen vrij te maken dat is toegewezen voor de niet-beheerde ANSI-tekenreeks en het onbeheerde geheugenblok.

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

Opmerkingen

Het IntPtr type is ontworpen als een geheel getal waarvan de grootte gelijk is aan een aanwijzer. Een exemplaar van dit type is naar verwachting 32 bits in een 32-bits proces en 64 bits in een 64-bits proces.

Het IntPtr type kan worden gebruikt door talen die pointers ondersteunen en als algemene manier om te verwijzen naar gegevens tussen talen die wel en geen ondersteuning bieden voor verwijzingen.

IntPtr objecten kunnen ook worden gebruikt voor het opslaan van ingangen. Exemplaren van worden bijvoorbeeld uitgebreid gebruikt in de System.IO.FileStream klasse voor het opslaan van IntPtr bestandsingangen.

Met dit type wordt de ISerializable. In .NET 5- en latere versies implementeert dit type ook de interfaces IFormattable. In .NET 7 en latere versies implementeert dit type ook de interfaces IBinaryInteger<TSelf>, IMinMaxValue<TSelf> en ISignedNumber<TSelf>.

In C# vanaf versie 9.0 kunt u het ingebouwde nint type gebruiken om gehele getallen van systeemeigen grootte te definiëren. Dit type wordt intern vertegenwoordigd door het IntPtr type en biedt bewerkingen en conversies die geschikt zijn voor gehele getallen. Zie nint- en nuint-typen voor meer informatie.

In C# vanaf versie 11 en bij het doel van de runtime .NET 7 of hoger is nint een alias voor IntPtr op dezelfde manier dat int een alias is voor Int32.

Veiligheid thread

Dit type is thread veilig.

Zie ook

• UIntPtr