Marshal.FreeHGlobal(IntPtr) Méthode

Définition

Espace de noms:

System.Runtime.InteropServices

Assembly:

System.Runtime.InteropServices.dll

Source:

Marshal.Unix.cs

Libère la mémoire précédemment allouée à partir de la mémoire non managée du processus.

public:
 static void FreeHGlobal(IntPtr hglobal);

public static void FreeHGlobal (IntPtr hglobal);

static member FreeHGlobal : nativeint -> unit

Public Shared Sub FreeHGlobal (hglobal As IntPtr)

Paramètres

hglobal

IntPtr

nativeint

Handle retourné par l’appel correspondant d’origine à AllocHGlobal(IntPtr).

Exemples

L’exemple suivant illustre l’appel de la méthode FreeHGlobal. Cet exemple de code fait partie d’un exemple plus large fourni pour la 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)

L’exemple suivant montre comment convertir le contenu d’une classe de String managée en mémoire non managée, puis supprimer la mémoire non managée lorsque vous avez terminé.

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

Remarques

Important

Cet allocateur de mémoire native est une API héritée qui doit être utilisée exclusivement lorsqu’elle est appelée par des API Win32 spécifiques sur la plateforme Windows. Lorsque vous ciblez .NET 6 ou version ultérieure, utilisez la classe NativeMemory sur toutes les plateformes pour allouer de la mémoire native. Lorsque vous ciblez .NET 6 ou une version antérieure, utilisez AllocCoTaskMem sur toutes les plateformes pour allouer de la mémoire native.

Vous pouvez utiliser FreeHGlobal pour libérer n’importe quelle mémoire du tas global alloué par AllocHGlobal, ReAllocHGlobalou toute méthode d’API non managée équivalente. Si le paramètre hglobal est IntPtr.Zero la méthode ne fait rien.

FreeHGlobal expose la fonction LocalFree de Kernel32.DLL, qui libère tous les octets afin que vous ne puissiez plus utiliser la mémoire pointée par hglobal.

Outre FreeHGlobal, la classe Marshal fournit deux autres méthodes d’API de désallocation de mémoire : DestroyStructure et FreeCoTaskMem.

Voir aussi

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