どのようにしてIDisposableがすべてのクラスに広がるのを防ぎますか？

これらの単純なクラスから始めます...

次のような単純なクラスのセットがあるとします。

class Bus
{
    Driver busDriver = new Driver();
}

class Driver
{
    Shoe[] shoes = { new Shoe(), new Shoe() };
}

class Shoe
{
    Shoelace lace = new Shoelace();
}

class Shoelace
{
    bool tied = false;
}

AにBusはがありDriver、にDriverは2つShoeのがあり、それぞれにShoeがありShoelaceます。すべて非常にばかげています。

IDisposableオブジェクトをShoelaceに追加する

後で、上のいくつかの操作をShoelaceマルチスレッド化できると判断したのでEventWaitHandle、スレッドが通信するためのを追加します。したがってShoelace、次のようになります。

class Shoelace
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;
    // ... other stuff ..
}

IDisposableをShoelaceに実装する

しかし、今度はMicrosoftのFxCopが文句を言うだろう：「IDisposableを次のIDisposable型のメンバーを作成するため、「Shoelace」にIDisposableを実装する：「EventWaitHandle」。

さて、私は実装IDisposableしShoelace、私のきちんとした小さなクラスはこの恐ろしい混乱になります：

class Shoelace : IDisposable
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;
    private bool disposed = false;

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    ~Shoelace()
    {
        Dispose(false);
    }

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                if (waitHandle != null)
                {
                    waitHandle.Close();
                    waitHandle = null;
                }
            }
            // No unmanaged resources to release otherwise they'd go here.
        }
        disposed = true;
    }
}

または（コメント投稿者が指摘したように）それShoelace自体にはアンマネージリソースがないため、Dispose(bool)およびDestructor を必要とせずに、より簡単な破棄の実装を使用できます。

class Shoelace : IDisposable
{
    private AutoResetEvent waitHandle = new AutoResetEvent(false);
    bool tied = false;

    public void Dispose()
    {
        if (waitHandle != null)
        {
            waitHandle.Close();
            waitHandle = null;
        }
        GC.SuppressFinalize(this);
    }
}

IDisposableが広がっていくのを恐怖で見る

正解です。しかし、FxCopはをShoe作成すると文句を言うShoelaceので、そうでShoeなければなりIDisposableません。

そしてDriver作成ShoeするDriver必要がありますIDisposable。そしてBus、DriverそうでBusなければなりませんIDisposable。

突然、私の小さな変更によってShoelace多くの作業が発生し、上司はなぜにBus変更するためにチェックアウトする必要があるのか​​疑問に思っていShoelaceます。

質問

どのようにしてこのの拡散を防ぎIDisposableながら、管理されていないオブジェクトが適切に破棄されるようにしますか？

IDisposableが拡散するのを実際に「防ぐ」ことはできません。など、一部のクラスは破棄する必要があります。AutoResetEvent最も効率的な方法はDispose()、ファイナライザのオーバーヘッドを回避するためにメソッドで破棄することです。ただし、このメソッドは何らかの方法で呼び出す必要があります。そのため、例のように、IDisposableをカプセル化または含むクラスはこれらを破棄する必要があるため、それらも破棄する必要があります。これを回避する唯一の方法は、次のとおりです。

• 可能な場合はIDisposableクラスの使用を避け、単一の場所でイベントをロックまたは待機する、高価なリソースを単一の場所に保持するなど
• 必要なときにのみ作成し、直後に破棄します（usingパターン）

IDisposableはオプションのケースをサポートするため、無視できる場合があります。たとえば、WaitHandleはIDisposableを実装して、名前付きミューテックスをサポートしています。名前が使用されていない場合、Disposeメソッドは何もしません。MemoryStreamは別の例で、システムリソースを使用せず、そのDispose実装も何もしません。アンマネージリソースが使用されているかどうかを慎重に検討することは、教育に役立ちます。したがって、.netライブラリの利用可能なソースを調べたり、逆コンパイラを使用したりできます。

正確さの点では、親オブジェクトが使い捨てにする必要のある子オブジェクトを作成して本質的に所有している場合、オブジェクト関係を介したIDisposableの拡散を防ぐことはできません。この状況ではFxCopは正しく、親はIDisposableである必要があります。

オブジェクト階層のリーフクラスにIDisposableを追加しないようにすることができます。これは必ずしも簡単な作業ではありませんが、興味深い演習です。論理的な観点から、ShoeLaceが使い捨てである必要がある理由はありません。ここにWaitHandleを追加する代わりに、ShoeLaceとWaitHandleの間の関連付けを、それが使用される時点で追加することもできます。最も簡単な方法は、Dictionaryインスタンスを使用することです。

WaitHandleが実際に使用される時点で、マップを介してWaitHandleを緩い関連付けに移動できる場合は、このチェーンを解除できます。

IDisposable拡散を防ぐには、使い捨てオブジェクトの使用を1つのメソッド内にカプセル化するようにしてください。Shoelace別の方法で設計してみてください。

class Shoelace { 
  bool tied = false; 

  public void Tie() {

    using (var waitHandle = new AutoResetEvent(false)) {

      // you can even pass the disposable to other methods
      OtherMethod(waitHandle);

      // or hold it in a field (but FxCop will complain that your class is not disposable),
      // as long as you take control of its lifecycle
      _waitHandle = waitHandle;
      OtherMethodThatUsesTheWaitHandleFromTheField();

    } 

  }
} 

待機ハンドルのスコープはTieメソッドに制限されており、クラスには使い捨てフィールドが必要ないため、それ自体が使い捨てである必要はありません。

待機ハンドルは内の実装の詳細であるためShoelace、宣言に新しいインターフェースを追加するなど、パブリックインターフェースを変更する必要はありません。使い捨てフィールドが不要になった場合はどうなりますIDisposableか？宣言を削除しますか？Shoelace 抽象化について考えると、のようなインフラストラクチャの依存関係によって汚染されるべきではないことがすぐにわかりますIDisposable。IDisposable決定論的なクリーンアップを必要とするリソースを抽象化してカプセル化するクラスのために予約する必要があります。つまり、使い捨てが抽象化の一部であるクラスの場合です。

これは、基本的に、CompositionまたはAggregationとDisposableクラスを混在させるとどうなるかです。前述のように、最初の方法は、waitHandleを靴紐からリファクタリングすることです。

そうは言っても、アンマネージリソースがない場合は、Disposableパターンを大幅に削減できます。（私はまだこれの公式リファレンスを探しています。）

ただし、デストラクタとGC.SuppressFinalize（this）;は省略できます。仮想ボイドのDispose（bool disposing）を少しクリーンアップします。

興味深いことに、Driver上記のように定義されている場合：

class Driver
{
    Shoe[] shoes = { new Shoe(), new Shoe() };
}

次に、Shoeが作成されるとIDisposable、FxCop（v1.36）はDriver、IDisposable。

ただし、次のように定義されている場合：

class Driver
{
    Shoe leftShoe = new Shoe();
    Shoe rightShoe = new Shoe();
}

それから文句を言うでしょう。

これはソリューションではなくFxCopの制限にすぎないのではないかと思います。最初のバージョンではShoeインスタンスはまだによって作成されてDriverおり、何らかの方法で破棄する必要があるためです。

デザインを非常に緊密に結合している場合、IDisposableが拡散するのを防ぐ技術的な方法はないと思います。次に、設計が正しいかどうか疑問に思う必要があります。

あなたの例では、靴に靴ひもを所有させることは理にかなっていると思います。おそらく、ドライバーが自分の靴を所有する必要があります。ただし、バスはドライバーを所有するべきではありません。通常、バスの運転手はスクラップヤードまでバスを追いません:)運転手と靴の場合、運転手が自分の靴を作ることはめったにありません。

代替設計は次のとおりです。

class Bus
{
   IDriver busDriver = null;
   public void SetDriver(IDriver d) { busDriver = d; }
}

class Driver : IDriver
{
   IShoePair shoes = null;
   public void PutShoesOn(IShoePair p) { shoes = p; }
}

class ShoePairWithDisposableLaces : IShoePair, IDisposable
{
   Shoelace lace = new Shoelace();
}

class Shoelace : IDisposable
{
   ...
}

新しいデザインは、残念ながら、インスタンスを作成して靴とドライバーの具体的なインスタンスを破棄するために追加のクラスを必要とするため、より複雑になりますが、この複雑さは、解決される問題に固有のものです。良い点は、靴ひもを処分するためだけにバスを使い捨てにする必要がなくなったことです。

制御の反転を使用するのはどうですか？

class Bus
{
    private Driver busDriver;

    public Bus(Driver busDriver)
    {
        this.busDriver = busDriver;
    }
}

class Driver
{
    private Shoe[] shoes;

    public Driver(Shoe[] shoes)
    {
        this.shoes = shoes;
    }
}

class Shoe
{
    private Shoelace lace;

    public Shoe(Shoelace lace)
    {
        this.lace = lace;
    }
}

class Shoelace
{
    bool tied;
    private AutoResetEvent waitHandle;

    public Shoelace(bool tied, AutoResetEvent waitHandle)
    {
        this.tied = tied;
        this.waitHandle = waitHandle;
    }
}

class Program
{
    static void Main(string[] args)
    {
        using (var leftShoeWaitHandle = new AutoResetEvent(false))
        using (var rightShoeWaitHandle = new AutoResetEvent(false))
        {
            var bus = new Bus(new Driver(new[] {new Shoe(new Shoelace(false, leftShoeWaitHandle)),new Shoe(new Shoelace(false, rightShoeWaitHandle))}));
        }
    }
}