Marshal.FreeHGlobal(IntPtr) Método

Definición

Espacio de nombres:

System.Runtime.InteropServices

Ensamblado:

System.Runtime.InteropServices.dll

Source:

Marshal.Unix.cs

Libera memoria previamente asignada de la memoria no administrada del proceso.

public:
 static void FreeHGlobal(IntPtr hglobal);

public static void FreeHGlobal (IntPtr hglobal);

static member FreeHGlobal : nativeint -> unit

Public Shared Sub FreeHGlobal (hglobal As IntPtr)

Parámetros

hglobal

IntPtr

nativeint

Controlador devuelto por la llamada coincidente original a AllocHGlobal(IntPtr).

Ejemplos

En el ejemplo siguiente se muestra la forma de llamar al método FreeHGlobal. Este ejemplo de código es parte de un ejemplo más grande proporcionado para la clase Marshal.

// Demonstrate how to call GlobalAlloc and 
// GlobalFree using the Marshal class.
IntPtr hglobal = Marshal::AllocHGlobal(100);
Marshal::FreeHGlobal(hglobal);

// Demonstrate how to call GlobalAlloc and
// GlobalFree using the Marshal class.
IntPtr hglobal = Marshal.AllocHGlobal(100);
Marshal.FreeHGlobal(hglobal);

' Demonstrate how to call GlobalAlloc and 
' GlobalFree using the Marshal class.
Dim hglobal As IntPtr = Marshal.AllocHGlobal(100)
Marshal.FreeHGlobal(hglobal)

En el ejemplo siguiente se muestra cómo convertir el contenido de una clase administrada en memoria no administrada String y, a continuación, eliminar la memoria no administrada cuando haya terminado.

using namespace System;
using namespace System::Runtime::InteropServices;

#include <iostream>                                                 // for printf


int main()
{
    // Create a managed string.
    String^ managedString = "Hello unmanaged world (from the managed world).";

    // Marshal the managed string to unmanaged memory.
    char* stringPointer = (char*) Marshal::StringToHGlobalAnsi(managedString ).ToPointer();

    printf("stringPointer = %s\n", stringPointer);

    // Always free the unmanaged string.
    Marshal::FreeHGlobal(IntPtr(stringPointer));

    return 0;
}

using System;
using System.Runtime.InteropServices;
using System.Threading;

class MainFunction
{
    static void Main()
    {
        Console.WriteLine("\nStringToGlobalAnsi\n");

        // Create a managed string.
        String  managedString = "I am a managed String";
        Console.WriteLine("1) managedString = " + managedString);

        // Marshal the managed string to unmanaged memory.
        IntPtr stringPointer = (IntPtr)Marshal.StringToHGlobalAnsi(managedString);
        Console.WriteLine("2) stringPointer = {0}", stringPointer);

        // Get the string back from unmanaged memory.
        String RetrievedString = Marshal.PtrToStringAnsi(stringPointer);
        Console.WriteLine("3) Retrieved from unmanaged memory = " + RetrievedString);

        // Always free the unmanaged string.
        Marshal.FreeHGlobal(stringPointer);

        // IntPtr handle value is still the same:
        Console.WriteLine("4) stringPointer = " + stringPointer);

        // However, the data may be cleared after the memory is freed, depending on whether the memory allocated to stringPointer
        // has been reclaimed or not. Uncommenting the following line (Thread.Sleep(1000)) increases the likelihood of the memory being reclaimed.
        // Thread.Sleep(1000);
        String RetrievedString2 = Marshal.PtrToStringAnsi(stringPointer);
        Console.WriteLine("5) RetrievedString2 = " + RetrievedString2);
    }
}

Comentarios

Puede usar FreeHGlobal para liberar cualquier memoria del montón global asignado por AllocHGlobal, ReAllocHGlobalo cualquier método de API no administrado equivalente. Si el hglobal parámetro es IntPtr.Zero el método no hace nada.

FreeHGlobal expone la función LocalFree de Kernel32.DLL, que libera todos los bytes para que ya no pueda usar la memoria a hgloballa que apunta .

Además FreeHGlobalde , la Marshal clase proporciona otros dos métodos de API de desasignación de memoria: DestroyStructure y FreeCoTaskMem.

Consulte también

• AllocHGlobal(IntPtr)
• ReAllocHGlobal(IntPtr, IntPtr)