Agfdhyk

Given following class:

public class MyDisposableContainer : IDisposable

{

    readonly List<IDisposable> _chidlren = new List<IDisposable>();



    public void Add() => _children.Add(new FileSystemWachter());

}

I'm not sure how should I implement the Disposable interface.

Either:

 public void Dispose() => _children.ForEach(item => item.Dispose());

or

public void Dispose()

{

    // Dispose of unmanaged resources.

    Dispose(true);

    // Suppress finalization.

    GC.SuppressFinalize(this);

}



protected virtual void Dispose(bool disposing)

{

    if (disposing)

    {

        _children.ForEach(item => item.Dispose());

    }

}

In my case, the children are FileSystemWatcher which uses some unmanaged resources, so I guess it implements the disposable pattern together with finalizer.

I guess, the second, longer approach is not necessary, because it Dispose(true) will be called only on explicit Dispose() call anyway. Am I right?

So the brief answer is: yes you can use the simple form

public void Dispose() => _children.ForEach(item => item.Dispose());

in your case.

The extended form

public void Dispose()

{

    Dispose(true);

    GC.SuppressFinalize(this);

}



protected virtual void Dispose(bool disposing)

{

    if (disposing)

    {

       ...

    }

}

which is basic implementation of basic dispose pattern is bit redundant here but it's suggested as a good manner and basement for future possible extensions of the class by means of inheritance (unless it's sealed).

The longer answer implies clarification of possible scenarios related to disposal and best practices for that. An object destruction process deals with two types of resources managed and managed. Managed resources can be successfully handled by GC so we mostly shouldn't bother too much with that, while unmanaged resources release is a responsibility of calling code as GC cannot track their allocations and de-allocations. IDisposable interface purpose is to address the scenarios when unmanaged resources de-allocation should be handled in some object or objects hierarchy. Now as for the possible cases:

• if your class directly retains unmanaged resources it's recommended to use extended finalizable dispose pattern with finalizer in order to cover cases of improper utilization of the class by external consumers or exceptional situations to get guaranteed resources de-allocation by means of either Dispose or a finalizer;


• if your class holds other IDisposable but doesn't hold unmanaged resources directly the recommended way is using basic dispose pattern without a finalizer;

Couple of notes about destruction responsibility separation as it popped up in the comments. Each class should be responsible for clear handling of release for only those resources which it directly retains. It shouldn't bother with trying to handle release scenarios for underlying objects in any other way other than by using thier publicly exposed contracts, that is via IDisposable or any other interface and shouldn't make any assumptions beyond of these public contracts.