IntPtr.ToPointer Yöntem

Tanım

Ad Alanı:

System

Bütünleştirilmiş Kod:

System.Runtime.dll

Bütünleştirilmiş Kod:

mscorlib.dll

Bütünleştirilmiş Kod:

netstandard.dll

Önemli

Bu API, CLS uyumlu değildir.

Bu örneğin değerini belirtilmemiş bir türe işaretçiye dönüştürür.

public:
 void* ToPointer();

[System.CLSCompliant(false)]
public void* ToPointer ();

[<System.CLSCompliant(false)>]
member this.ToPointer : unit -> nativeptr<unit>

Döndürülenler

Void*

öğesinin Voidişaretçisi; yani belirtilmemiş bir türe ait verileri içeren belleğe yönelik bir işaretçi.

Öznitelikler

CLSCompliantAttribute

Örnekler

Aşağıdaki örnek, bir dizideki karakterleri ters çevirmek için yönetilen işaretçileri kullanır. Bir String nesneyi başlatıp uzunluğunu aldıktan sonra aşağıdakileri yapar:

• Unicode dizesini Marshal.StringToHGlobalAnsi yönetilmeyen belleğe ANSI (bir bayt) karakterleri olarak kopyalamak için yöntemini çağırır. yöntemi, yönetilmeyen dizenin başlangıcına işaret eden bir IntPtr nesne döndürür.

• Marshal.AllocHGlobal Yönetilmeyen dizenin kapladıkça aynı sayıda bayt ayırmak için yöntemini çağırır. yöntemi, yönetilmeyen bellek bloğunun başına işaret eden bir IntPtr nesne döndürür.

• Dizenin ToPointer başlangıç adresine ve yönetilmeyen bellek bloğuna yönetilmeyen bir işaretçi almak için yöntemini çağırır ve ansi dizesinin başlangıç adresine dizenin uzunluğundan daha az bir işaretçi ekler. Yönetilmeyen dize işaretçisi artık dizenin sonuna işaret ettiğinden, kopyalama işlemi dizenin sonundan bellek bloğunun başlangıcına bir karakter kopyalar.

• Dizedeki her karakteri yönetilmeyen bellek bloğuna kopyalamak için bir döngü kullanır. Her kopyalama işleminden sonra, yönetilmeyen ANSI dizesindeki bir sonraki konumun adresinin işaretçisini azaltıp işaretçiyi yönetilmeyen bloktaki bir sonraki adrese artırır.

• Marshal.PtrToStringAnsi Kopyalanan ANSI dizesini içeren yönetilmeyen bellek bloğunu yönetilen bir Unicode String nesnesine dönüştürmek için öğesini çağırır.

• Özgün ve ters çevrilmiş dizeleri görüntüledikten sonra, yönetilmeyen ANSI dizesi ve yönetilmeyen bellek bloğu için ayrılan belleği boşaltmak için yöntemini çağırır Marshal.FreeHGlobal .

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