在沒有CA警告的情況下執行Inhertited IDisposable模式

Question

我正在處理以下情況。我有一個基類有IDisposable模式，這意味着它有public virtual Dispose()方法和protected virtual Dispose(bool)方法。但是我無法在派生類中實現這個模式，所以我不會收到任何CA警告。請考慮下面的例子：

public class UtilizeClass : IDisposable 
{ 
    private MyData data; 

    public UtilizeClass() 
    { 
     data = new MyData(); 
    } 

    public void Dispose() 
    { 
     data.Dispose(); // Cannot use Dispose(bool) because it is protected. 
    } 
} 

public class MyData : Base, IDisposable 
{ 
    // Here we have some managed resources that must be disposed. 

    // How to implement the pattern? 
} 

public class Base : IDisposable 
{ 
    public virtual void Dispose() { } 
    protected virtual void Dispose(bool disposing) { } 
} 

一直以來我收到的MyData類矛盾CA警告。例如：刪除Dispose（）並將其邏輯移動到Dispose（bool）。

非常感謝您的回答和幫助。

Answer 1

你的基類不應該void Dispose()是虛擬的，應當執行並調用虛擬void Dispose(bool disposing)作爲其實現的一部分。

對於更詳細地，以及交替API這是略微更清晰，檢查出：

http://haacked.com/archive/2005/11/18/acloserlookatdisposepattern.aspx

Answer 2

基類應該有一個public void Dispose()（非虛擬）調用Dispose(true)。

派生類應該簡單地覆蓋protected virtual void Dispose(bool disposing)。

Answer 3

如果Base是你自己的類，那麼不要實現這種反模式。

當一個類同時包含必須處理的託管資源（例如應該擁有它自己的Dispose的Stream對象）和非託管資源時，使用雙重處置（如果處置爲true，則爲false）必須清理。

這是一個壞主意。相反，您的所有課程都適合一個或兩個類別：

A.只有非託管資源的課程。理想的情況是隻有一個每個類：

public sealed class HandlesUnmanaged : IDisposable 
{ 
    private IntPtr _someUnmanagedHandleOfSomeKind; 
    public string DoSomething(string someParam) 
    { 
    // your useful code goes here; 
    // make it thin, non-virtual and likely to be inlined 
    // if you need to extend functionality, but it in a 
    // containing Disposable class, not a derived class. 
    } 
    private void CleanUp() 
    { 
    //your code that cleans-up someUnmanagedHandleOfSomeKind goes here 
    } 
    public void Dispose() 
    { 
    CleanUp(); 
    GC.SuppressFinalize(this);//finaliser not needed now. 
    } 
    ~HandlesUnmanaged()//not called if already disposed 
    { 
    CleanUp(); 
    } 
} 

理想情況下，你甚至不需要任何這樣的類，但使用SafeHandle這確實是給你的。

B.類，但需要處理的一個或多個管理的資源：

public class NoUnmanaged : IDisposable 
{ 
    private HandlesUnmanaged _likeAbove; 
    private Stream _anExampleDisposableClass; 
    public virtual void Dispose() 
    { 
    _likeAbove.Dispose(); 
    _anExampleDisposableClass.Dispose(); 
    } 
    /* Note no finaliser, if Dispose isn't called, then _likeAbove's 
    finaliser will be called anyway. All a finaliser here would do is 
    slow things up and possibly introduce bugs. 
    */ 
} 
public class DerivedNoUnManaged : NoUnmanaged 
{ 
    Stream _weMayOrMayNotHaveAnotherDisposableMember; 
    public override void Dispose() 
    { 
    //note we only need this because we have 
    //another disposable member. If not, we'd just inherit 
    //all we need. 
    base.Dispose(); 
    weMayOrMayNotHaveAnotherDisposableMember.Dispose(); 
    } 
} 

總之，我們既得到了簡單的非託管產階級是做同樣的事情在他們的Dispose()及其finaliser ，但前者呼叫GC.SuppressFinalize，或者我們擁有簡單的非非託管擁有課程，只需Dispose()他們需要處置的所有內容，包括必要時致電base.Dispose()，並且沒有終結者。沒有必要將邏輯分成同一類中的兩種類型。決賽者沒有風險調用已經敲定的東西，或者在定稿隊列中強制超過需要。

理想情況下，你甚至從來沒有做過第一種類型。只是第二種類型。

如果你不得不把它從另一個黨的類繼承，然後就去做：

public MyClass : Base 
{ 
    Stream _forExample; 
    public override void Dispose(bool disposing) 
    { 
    if(disposing) 
    { 
     _forExample.Dispose(); 
    } 
    base.Dispose(disposing); 
    } 
} 

自己不要處理disposing == false情況下，由於沒有混在裏面非託管資源。