Implementacja IDisposable w zamkniętej klasie

Question

Nie sądzę, aby to pytanie było wcześniej zadawane. Jestem nieco zdezorientowany, jeśli chodzi o najlepszy sposób implementacji IDisposable na zamkniętej klasie, zamkniętej klasie, która nie dziedziczy po klasie bazowej. (Oznacza to "czystą zamkniętą klasę", która jest moim wymyślonym terminem.)

Być może niektórzy zgadzają się ze mną, że wytyczne dotyczące wdrażania IDisposable są bardzo mylące. Powiedział, że chcę wiedzieć, że sposób, w jaki zamierzam wdrożyć IDisposable jest wystarczający i bezpieczny.

Zrobiłem kod P/Invoke, który przydziela IntPtr do Marshal.AllocHGlobal i oczywiście, chcę czysto pozbyć się niezarządzanej pamięci, którą stworzyłem. Więc mam na myśli coś takiego

using System.Runtime.InteropServices; 

[StructLayout(LayoutKind.Sequential)] 
public sealed class MemBlock : IDisposable 
{ 
    IntPtr ptr; 
    int length; 

    MemBlock(int size) 
    { 
      ptr = Marshal.AllocHGlobal(size); 
      length = size; 
    } 

    public void Dispose() 
    { 
      if (ptr != IntPtr.Zero) 
      { 
       Marshal.FreeHGlobal(ptr); 
       ptr = IntPtr.Zero; 
       GC.SuppressFinalize(this); 
      } 
    } 

    ~MemBlock() 
    { 
      Dispose(); 
    }  
} 

jestem przy założeniu, że z powodu MemBlock jest całkowicie szczelny i nie wywodzi się z innej klasy, która realizuje virtual protected Dispose(bool disposing) nie jest konieczne.

Czy finalizator jest absolutnie niezbędny? Wszystkie myśli mile widziane.

Answer 1

Finalizator jest niezbędny jako mechanizm rezerwowy, aby ostatecznie uwolnić niezarządzane zasoby, jeśli zapomniałeś zadzwonić pod numer Dispose.

Nie, nie powinieneś zadeklarować metody virtual w klasie sealed. W ogóle się nie skompiluje. Ponadto nie zaleca się deklarowania nowych członków w klasach protected w klasach .

Answer 2

Dodatek dodatkowy; w przypadku ogólne, wspólny wzorzec ma mieć metodę Dispose(bool disposing), dzięki czemu wiesz, czy jesteś w Dispose (gdzie jest więcej dostępnych rzeczy) w stosunku do finalizatora (gdzie nie powinieneś naprawdę dotykać żadnych innych połączonych zarządzanych obiektów) .

Na przykład:

public void Dispose() { Dispose(true); } 
~MemBlock() { Dispose(false); } 
void Dispose(bool disposing) { // would be protected virtual if not sealed 
    if(disposing) { // only run this logic when Dispose is called 
     GC.SuppressFinalize(this); 
     // and anything else that touches managed objects 
    } 
    if (ptr != IntPtr.Zero) { 
      Marshal.FreeHGlobal(ptr); 
      ptr = IntPtr.Zero; 
    } 
} 

Answer 3

Od Joe Duffy's Weblog:

Dla zamkniętych klas, to wzór musi nie być przestrzegane, co oznacza, powinieneś prostu zaimplementować Finalizer i Usuwać z prostych metod (tj. ~ T() (Finalizacja) i Dispose() w języku C#). Wybierając drugą trasę, Twój kod powinien nadal być zgodny z poniższymi wytycznymi dotyczącymi implementacji finalizacji i logiki unieszkodliwienia.

Tak, powinieneś być dobry.

Potrzebujesz finalizatora, o którym wspomniał Mehrdad. Jeśli chcesz tego uniknąć, możesz rzucić okiem na SafeHandle. Nie mam wystarczającego doświadczenia z P/Invoke, aby zasugerować prawidłowe użycie.

Answer 4

Nie można zadeklarować metod wirtualnych w zamkniętej klasie. Zgłoszenie chronionych członków w zamkniętej klasie daje ostrzeżenie kompilatora. Więc zaimplementowałeś to poprawnie. Wywołanie GC.SuppressFinalize (this) z finalizatora nie jest konieczne z oczywistych powodów, ale nie może zaszkodzić.

Posiadanie finalizatora jest niezbędne przy zarządzaniu zasobami niezarządzanymi, ponieważ nie są one automatycznie zwalniane, musisz to zrobić w finalizatorze z wywołaniem automatycznie po zebraniu śmieci.