Wie verhindern Sie, dass sich IDisposable auf alle Ihre Klassen ausbreitet?

Beginnen Sie mit diesen einfachen Klassen ...

Angenommen, ich habe eine einfache Reihe solcher Klassen:

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 Bushat a Driver, das Driverhat zwei Shoes, jeder Shoehat a Shoelace. Alles sehr dumm.

Fügen Sie Shoelace ein IDisposable-Objekt hinzu

Später entscheide ich, dass eine Operation auf dem ShoelaceMultithreading ausgeführt werden kann, also füge ich eine hinzu, EventWaitHandlemit der die Threads kommunizieren können. So Shoelacesieht es jetzt aus:

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

Implementieren Sie IDisposable auf Shoelace

Jetzt beschwert sich Microsoft FxCop jedoch: "Implementieren Sie IDisposable auf 'Shoelace', da Mitglieder der folgenden IDisposable-Typen erstellt werden: 'EventWaitHandle'."

Okay, ich implementiere IDisposableweiter Shoelaceund meine nette kleine Klasse wird zu diesem schrecklichen Durcheinander:

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;
    }
}

Oder (wie von Kommentatoren hervorgehoben), da es Shoelaceselbst keine nicht verwalteten Ressourcen gibt, könnte ich die einfachere Entsorgungsimplementierung verwenden, ohne den Dispose(bool)und Destructor zu benötigen :

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);
    }
}

Beobachten Sie entsetzt, wie sich IDisposable ausbreitet

Richtig, das ist behoben. Aber jetzt wird sich FxCop beschweren, dass ein Shoeschafft Shoelace, so Shoemuss es IDisposableauch sein.

Und Driverschafft muss Shoeso Driversein IDisposable. Und Busschafft Driverso Busmuss sein IDisposableund so weiter.

Plötzlich verursacht meine kleine Änderung an Shoelaceviel Arbeit und mein Chef fragt sich, warum ich zur Kasse gehen muss Bus, um eine Änderung vorzunehmen Shoelace.

Die Frage

Wie verhindern Sie diese Ausbreitung IDisposableund stellen dennoch sicher, dass Ihre nicht verwalteten Objekte ordnungsgemäß entsorgt werden?

Sie können die Ausbreitung von IDisposable nicht wirklich "verhindern". Einige Klassen müssen entsorgt werden AutoResetEvent, und der effizienteste Weg besteht darin, dies in der Dispose()Methode zu tun , um den Overhead von Finalisierern zu vermeiden. Aber diese Methode muss irgendwie aufgerufen werden, so genau wie in Ihrem Beispiel die Klassen, die IDisposable kapseln oder enthalten, diese entsorgen müssen, also müssen sie auch verfügbar sein usw. Der einzige Weg, dies zu vermeiden, ist:

• Vermeiden Sie nach Möglichkeit die Verwendung von IDisposable-Klassen, sperren oder warten Sie auf Ereignisse an einzelnen Orten, halten Sie teure Ressourcen an einem Ort usw.
• Erstellen Sie sie nur, wenn Sie sie benötigen, und entsorgen Sie sie unmittelbar danach (das usingMuster).

In einigen Fällen kann IDisposable ignoriert werden, da es einen optionalen Fall unterstützt. Beispielsweise implementiert WaitHandle IDisposable, um einen benannten Mutex zu unterstützen. Wenn kein Name verwendet wird, führt die Dispose-Methode nichts aus. MemoryStream ist ein weiteres Beispiel, es verwendet keine Systemressourcen und seine Dispose-Implementierung führt auch nichts aus. Sorgfältiges Überlegen, ob eine nicht verwaltete Ressource verwendet wird oder nicht, kann lehrreich sein. So können Sie die verfügbaren Quellen für die .net-Bibliotheken untersuchen oder einen Dekompiler verwenden.

In Bezug auf die Korrektheit können Sie die Verbreitung von IDisposable durch eine Objektbeziehung nicht verhindern, wenn ein übergeordnetes Objekt ein untergeordnetes Objekt erstellt und im Wesentlichen besitzt, das jetzt verfügbar sein muss. FxCop ist in dieser Situation korrekt und das übergeordnete Element muss IDisposable sein.

Sie können vermeiden, einer Blattklasse in Ihrer Objekthierarchie ein IDisposable hinzuzufügen. Dies ist nicht immer eine leichte Aufgabe, aber eine interessante Übung. Aus logischer Sicht gibt es keinen Grund, warum eine Schuhspitze wegwerfbar sein muss. Anstatt hier ein WaitHandle hinzuzufügen, ist es auch möglich, an der Stelle, an der es verwendet wird, eine Zuordnung zwischen einem ShoeLace und einem WaitHandle hinzuzufügen. Der einfachste Weg führt über eine Dictionary-Instanz.

Wenn Sie den WaitHandle an dem Punkt, an dem der WaitHandle tatsächlich verwendet wird, über eine Karte in eine lose Zuordnung verschieben können, können Sie diese Kette unterbrechen.

Um eine IDisposableAusbreitung zu verhindern , sollten Sie versuchen, die Verwendung eines Einwegobjekts in einer einzigen Methode zusammenzufassen. Versuchen Sie Shoelaceanders zu gestalten :

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();

    } 

  }
} 

Der Umfang des Wartehandles ist auf die TieMethode beschränkt, und die Klasse muss kein verfügbares Feld haben und muss daher nicht selbst verfügbar sein.

Da das Wait-Handle ein Implementierungsdetail innerhalb von ist Shoelace, sollte es seine öffentliche Schnittstelle in keiner Weise ändern, wie das Hinzufügen einer neuen Schnittstelle in seiner Deklaration. Was passiert dann, wenn Sie kein Einwegfeld mehr benötigen IDisposable? Entfernen Sie die Deklaration? Wenn Sie über die Shoelace Abstraktion nachdenken , erkennen Sie schnell, dass sie nicht durch Infrastrukturabhängigkeiten wie verschmutzt werden sollte IDisposable. IDisposablesollte für Klassen reserviert werden, deren Abstraktion eine Ressource enthält, die eine deterministische Bereinigung erfordert; dh für Klassen, in denen die Verfügbarkeit Teil der Abstraktion ist .

Dies ist im Grunde das, was passiert, wenn Sie Komposition oder Aggregation mit Einwegklassen mischen. Wie bereits erwähnt, besteht der erste Ausweg darin, den waitHandle aus dem Schnürsenkel herauszuarbeiten.

Allerdings können Sie das Einwegmuster erheblich reduzieren, wenn Sie nicht über nicht verwaltete Ressourcen verfügen. (Ich suche noch nach einer offiziellen Referenz dafür.)

Sie können jedoch den Destruktor und GC.SuppressFinalize (this) weglassen. und vielleicht die virtuelle Leere aufräumen (bool disposing) ein bisschen.

Interessanterweise, wenn Driverwie oben definiert ist:

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

Wenn Shoedann gemacht wird IDisposable, beschwert sich FxCop (v1.36) nicht, dass dies Driverauch sein sollte IDisposable.

Wenn es jedoch so definiert ist:

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

dann wird es sich beschweren.

Ich vermute, dass dies nur eine Einschränkung von FxCop ist und keine Lösung, da in der ersten Version die ShoeInstanzen noch von der erstellt werden Driverund noch irgendwie entsorgt werden müssen.

Ich glaube nicht, dass es eine technische Möglichkeit gibt, die Verbreitung von IDisposable zu verhindern, wenn Sie Ihr Design so eng miteinander verbinden. Man sollte sich dann fragen, ob das Design stimmt.

In Ihrem Beispiel halte ich es für sinnvoll, dass der Schuh den Schnürsenkel besitzt, und vielleicht sollte der Fahrer seine Schuhe besitzen. Der Bus sollte jedoch nicht den Fahrer besitzen. Normalerweise folgen Busfahrer Bussen nicht zum Schrottplatz :) Bei Fahrern und Schuhen stellen Fahrer selten ihre eigenen Schuhe her, was bedeutet, dass sie diese nicht wirklich "besitzen".

Ein alternatives Design könnte sein:

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
{
   ...
}

Das neue Design ist leider komplizierter, da zusätzliche Klassen erforderlich sind, um konkrete Instanzen von Schuhen und Fahrern zu instanziieren und zu entsorgen. Diese Komplikation ist jedoch mit dem zu lösenden Problem verbunden. Das Gute ist, dass Busse nicht mehr nur zum Entsorgen von Schnürsenkeln wegwerfbar sein müssen.

Wie wäre es mit Inversion of Control?

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))}));
        }
    }
}