Marshal.FreeHGlobal(IntPtr) Método

  • Referencia

Definición

Espacio de nombres:
System.Runtime.InteropServices
Ensamblado:
System.Runtime.InteropServices.dll
Ensamblado:
mscorlib.dll
Ensamblado:
netstandard.dll
Source:
Marshal.Unix.cs
Source:
Marshal.Unix.cs
Source:
Marshal.Unix.cs

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

public:
 static void FreeHGlobal(IntPtr hglobal);
[System.Security.SecurityCritical]
public static void FreeHGlobal (IntPtr hglobal);
public static void FreeHGlobal (IntPtr hglobal);
[<System.Security.SecurityCritical>]
static member FreeHGlobal : nativeint -> unit
static member FreeHGlobal : nativeint -> unit
Public Shared Sub FreeHGlobal (hglobal As IntPtr)

Parámetros

hglobal
IntPtr

nativeint

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

Atributos
SecurityCriticalAttribute

Ejemplos

En el ejemplo siguiente se muestra cómo llamar al método FreeHGlobal. Este ejemplo de código forma 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 de String administrada en memoria no administrada 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

Importante

Este asignador de memoria nativo es una API heredada que se debe usar exclusivamente cuando se llama a las API de Win32 específicas en la plataforma Windows. Cuando tenga como destino .NET 6 o posterior, use la clase NativeMemory en todas las plataformas para asignar memoria nativa. Cuando tenga como destino .NET 6 o versiones anteriores, use AllocCoTaskMem en todas las plataformas para asignar memoria nativa.

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 parámetro hglobal 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 la que apunta hglobal.

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

Se aplica a

Consulte también