Marshal.FreeHGlobal(IntPtr) Método

Referência

Definição

Namespace:: System.Runtime.InteropServices

Assembly:: System.Runtime.InteropServices.dll

Assembly:: mscorlib.dll

Assembly:: netstandard.dll

Origem:: Marshal.Unix.cs

Origem:: Marshal.Unix.cs

Origem:: Marshal.Unix.cs

Importante

Algumas informações se referem a produtos de pré-lançamento que podem ser substancialmente modificados antes do lançamento. A Microsoft não oferece garantias, expressas ou implícitas, das informações aqui fornecidas.

Libera memória alocada anteriormente da memória não gerenciada do processo.

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

O identificador retornado pela chamada correspondente original para AllocHGlobal(IntPtr).

Atributos: SecurityCriticalAttribute

Exemplos

O exemplo a seguir demonstra a chamada do método FreeHGlobal. Este exemplo de código faz parte de um exemplo maior fornecido para a classe 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)

O exemplo a seguir demonstra como converter o conteúdo de uma classe String gerenciada em memória não gerenciada e, em seguida, descartar a memória não gerenciada quando terminar.

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);
    }
}

Comentários

Importante

Esse alocador de memória nativa é uma API herdada que deve ser usada exclusivamente quando solicitada por APIs específicas do Win32 na plataforma Windows. Ao direcionar o .NET 6 ou posterior, use a classe NativeMemory em todas as plataformas para alocar memória nativa. Ao direcionar o .NET 6 ou anterior, use AllocCoTaskMem em todas as plataformas para alocar memória nativa.

Você pode usar FreeHGlobal para liberar qualquer memória do heap global alocado por AllocHGlobal, ReAllocHGlobalou qualquer método de API não gerenciado equivalente. Se o parâmetro hglobal for IntPtr.Zero o método não fará nada.

FreeHGlobal expõe a função LocalFree de Kernel32.DLL, que libera todos os bytes para que você não possa mais usar a memória apontada por hglobal.

Além de FreeHGlobal, a classe Marshal fornece dois outros métodos de API de desalocação de memória: DestroyStructure e FreeCoTaskMem.

Aplica-se a

Partilhar via