.NET Framework
Minneshantering

Anmärkningar

O hanterade resurser

När vi pratar om GC och "högen", pratar vi verkligen om vad som kallas den hanterade högen . Objekt på den hanterade högen får tillgång till resurser som inte finns på den hanterade högen, till exempel när du skriver till eller läser från en fil. Oväntat beteende kan uppstå när en fil öppnas för läsning och sedan inträffar ett undantag, vilket hindrar filhandtaget från att stängas som normalt. Av den anledningen kräver .NET att IDisposable resurser implementerar det IDisposable gränssnittet. Detta gränssnitt har en enda metod som heter Dispose utan parametrar:

public interface IDisposable
{
    Dispose();
} 

När du hanterar icke-hanterade resurser bör du se till att de är bortskaffade på rätt sätt. Du kan göra detta genom att uttryckligen ringa Dispose() i ett finally block eller med ett using uttalande.

StreamReader sr; 
string textFromFile;
string filename = "SomeFile.txt";
try 
{
    sr = new StreamReader(filename);
    textFromFile = sr.ReadToEnd();
}
finally
{
    if (sr != null) sr.Dispose();
}

eller

string textFromFile;
string filename = "SomeFile.txt";

using (StreamReader sr = new Streamreader(filename))
{
    textFromFile = sr.ReadToEnd();
}

Den senare är den föredragna metoden och utvidgas automatiskt till den förstnämnda under sammanställningen.

Använd SafeHandle när du lägger in okontrollerade resurser

När du skriver omslag för outhanterade resurser, bör du underklassa SafeHandle snarare än att försöka implementera IDisposable och en finaliserare själv. Din SafeHandle underklass bör vara så liten och enkel som möjligt för att minimera risken för ett handtagsläckage. Detta innebär sannolikt att din SafeHandle-implementering skulle vara en intern implementationsdetalj av en klass som lindar den för att ge ett användbart API. Denna klass säkerställer att även om ett program läcker din SafeHandle instans, kommer ditt obehandlade handtag att släppas.

using System.Runtime.InteropServices;

class MyHandle : SafeHandle
{
    public override bool IsInvalid => handle == IntPtr.Zero;
    public MyHandle() : base(IntPtr.Zero, true)
    { }

    public MyHandle(int length) : this()
    {
        SetHandle(Marshal.AllocHGlobal(length));
    }

    protected override bool ReleaseHandle()
    {
        Marshal.FreeHGlobal(handle);
        return true;
    }
}

Friskrivningsklausul: Detta exempel är ett försök att visa hur man skyddar en hanterad resurs med SafeHandle som implementerar IDisposable för dig och konfigurerar slutbehandlare på lämpligt sätt. Det är mycket motstridigt och troligt meningslöst att tilldela en bit av minnet på detta sätt.