Marshal.FreeHGlobal(IntPtr) Metod

Definition

Namnområde:
System.Runtime.InteropServices
Sammansättningar:
mscorlib.dll, System.Runtime.InteropServices.dll
Sammansättning:
mscorlib.dll
Sammansättning:
System.Runtime.InteropServices.dll
Sammansättning:
netstandard.dll

Frigör minne som tidigare allokerats från ohanterat minne i processen.

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)

Parametrar

hglobal
IntPtr

nativeint

Handtaget som returnerades av det ursprungliga matchande anropet till AllocHGlobal(IntPtr).

Attribut
SecurityCriticalAttribute

Exempel

I följande exempel visas hur du anropar FreeHGlobal metoden. Det här kodexemplet är en del av ett större exempel för Marshal klassen.

// 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)

I följande exempel visas hur du konverterar innehållet i en hanterad String klass till ohanterat minne och sedan gör sig av med det ohanterade minnet när det är klart.

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

Kommentarer

Important

Den här interna minnesallokeraren är ett äldre API som ska användas exklusivt när det anropas av specifika Win32-API:er på Windows-plattformen. När du riktar in dig på .NET 6 eller senare använder du klassen NativeMemory på alla plattformar för att allokera inbyggt minne. När du riktar in dig på .NET Framework använder du AllocCoTaskMem på alla plattformar för att allokera inbyggt minne.

Du kan använda FreeHGlobal för att frigöra minne från den globala heap som allokerats av AllocHGlobal, ReAllocHGlobaleller någon motsvarande ohanterad API-metod. Om parametern hglobal är IntPtr.Zero metoden gör ingenting.

FreeHGlobal exponerar funktionen LocalFree från Kernel32.DLL, vilket frigör alla byte så att du inte längre kan använda det minne som pekas på av hglobal.

Förutom FreeHGlobalMarshal innehåller klassen två andra API-metoder för minnesfrilokalisering: DestroyStructure och FreeCoTaskMem.

Gäller för

Se även