IntPtr.ToPointer Método

Definición

Espacio de nombres:

System

Ensamblado:

System.Runtime.dll

Ensamblado:

mscorlib.dll

Ensamblado:

netstandard.dll

Importante

Esta API no es conforme a CLS.

Convierte el valor de esta instancia a un puntero a un tipo no especificado.

public:
 void* ToPointer();

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

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

Devoluciones

Void*

Puntero a Void; es decir, puntero a memoria que contiene datos de un tipo no especificado.

Atributos

CLSCompliantAttribute

Ejemplos

En el ejemplo siguiente se usan punteros administrados para invertir los caracteres de una matriz. Después de inicializar un String objeto y obtener su longitud, hace lo siguiente:

• Llama al Marshal.StringToHGlobalAnsi método para copiar la cadena Unicode en memoria no administrada como caracteres ANSI (un byte). El método devuelve un IntPtr objeto que apunta al principio de la cadena no administrada.

• Llama al Marshal.AllocHGlobal método para asignar el mismo número de bytes que ocupa la cadena no administrada. El método devuelve un IntPtr objeto que apunta al principio del bloque de memoria no administrado.

• Llama al ToPointer método para obtener un puntero no administrado a la dirección inicial de la cadena y al bloque de memoria no administrado, y agrega una menor que la longitud de la cadena a la dirección inicial de la cadena ANSI. Dado que el puntero de cadena no administrado apunta ahora al final de la cadena, la operación de copia copiará un carácter desde el final de la cadena hasta el inicio del bloque de memoria.

• Usa un bucle para copiar cada carácter de la cadena al bloque de memoria no administrado. Después de cada operación de copia, disminuye el puntero a la dirección de la siguiente ubicación de la cadena ANSI no administrada e incrementa el puntero a la siguiente dirección del bloque no administrado.

• Marshal.PtrToStringAnsi Llama a para convertir el bloque de memoria no administrado que contiene la cadena ANSI copiada en un objeto Unicode String administrado.

• Después de mostrar las cadenas originales e invertidas, llama al Marshal.FreeHGlobal método para liberar la memoria asignada para la cadena ANSI no administrada y el bloque de memoria no administrado.

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