So entsorgen Sie asynchron?

Async-Methoden haben in der Regel einen Rückruf sodass Sie einige Schritte nach Fertigstellung. Wenn dies Ihr Fall, es wäre so etwas wie dieses:

//The async method taks an on-completed callback delegate
myClass.AsyncDoSomething(delegate { myClass.Dispose(); });

Einen anderen Weg, um dieses ist eine asynchrone wrapper:

ThreadPool.QueueUserWorkItem(delegate
{
    using(myClass)
    {
        //The class doesn't know about async operations, a helper method does that
        myClass.DoSomething();
    }
});

Fügen Sie eine callback-Mechanismus, und eine cleanup-Funktion als callback.

var x = new MyClass();

Action cleanup = () => x.Dispose();

x.DoSomethingAsync(/*and then*/cleanup);

aber dieses problem darstellen würde, wenn Sie mehrere asynchrone Aufrufe von der gleichen Objekt-Instanz.

Eine Möglichkeit wäre, eine einfache Implementierung counting semaphore mit der Semaphore-Klasse zum zählen der Anzahl der ausgeführten async-jobs.

Fügen Sie die Zähler, MyClass und auf jeden AsyncWhatever fordert, erhöht sich der Zähler, auf den Ausgängen decerement es. Wenn die semaphore 0 ist, dann ist die Klasse bereit ist, entsorgt werden.

var x = new MyClass();

x.DoSomethingAsync();
x.DoSomethingAsync2();

while (x.RunningJobsCount > 0)
    Thread.CurrentThread.Sleep(500);

x.Dispose();

Aber ich bezweifle, dass wäre der ideale Weg. Ich rieche ein design-problem. Vielleicht ein re-Gedanken von MyClass designs könnten dies vermeiden?

Könnten Sie teilen sich einige etwas von MyClass Umsetzung? Was es tun soll?

Also, meine Idee ist, zu halten, wie viele AsyncDoSomething() anhängig ist, abgeschlossen ist, und nur dann entsorgen, wenn diese Anzahl erreicht ist, auf null. Mein Erster Ansatz ist:

public class MyClass : IDisposable {

    private delegate void AsyncDoSomethingCaller();
    private delegate void AsyncDoDisposeCaller();

    private int pendingTasks = 0;

    public DoSomething() {
        //Do whatever.
    }

    public AsyncDoSomething() {
        pendingTasks++;
        AsyncDoSomethingCaller caller = new AsyncDoSomethingCaller();
        caller.BeginInvoke( new AsyncCallback( EndDoSomethingCallback ), caller);
    }

    public Dispose() {
        AsyncDoDisposeCaller caller = new AsyncDoDisposeCaller();
        caller.BeginInvoke( new AsyncCallback( EndDoDisposeCallback ), caller);
    }

    private DoDispose() {
        WaitForPendingTasks();

        //Finally, dispose whatever managed and unmanaged resources.
    }

    private void WaitForPendingTasks() {
        while ( true ) {
            //Check if there is a pending task.
            if ( pendingTasks == 0 ) {
                return;
            }

            //Allow other threads to execute.
            Thread.Sleep( 0 );
        }
    }

    private void EndDoSomethingCallback( IAsyncResult ar ) {
        AsyncDoSomethingCaller caller = (AsyncDoSomethingCaller) ar.AsyncState;
        caller.EndInvoke( ar );
        pendingTasks--;
    }

    private void EndDoDisposeCallback( IAsyncResult ar ) {
        AsyncDoDisposeCaller caller = (AsyncDoDisposeCaller) ar.AsyncState;
        caller.EndInvoke( ar );
    }
}

Einige Probleme können auftreten, wenn zwei oder mehr threads versuchen zu Lesen /schreiben pendingTasks Variablen gleichzeitig, so die lock keyword sollte verwendet werden, um zu verhindern, dass race conditions:

public class MyClass : IDisposable {

    private delegate void AsyncDoSomethingCaller();
    private delegate void AsyncDoDisposeCaller();

    private int pendingTasks = 0;
    private readonly object lockObj = new object();

    public DoSomething() {
        //Do whatever.
    }

    public AsyncDoSomething() {
        lock ( lockObj ) {
            pendingTasks++;
            AsyncDoSomethingCaller caller = new AsyncDoSomethingCaller();
            caller.BeginInvoke( new AsyncCallback( EndDoSomethingCallback ), caller);
        }
    }

    public Dispose() {
        AsyncDoDisposeCaller caller = new AsyncDoDisposeCaller();
        caller.BeginInvoke( new AsyncCallback( EndDoDisposeCallback ), caller);
    }

    private DoDispose() {
        WaitForPendingTasks();

        //Finally, dispose whatever managed and unmanaged resources.
    }

    private void WaitForPendingTasks() {
        while ( true ) {
            //Check if there is a pending task.
            lock ( lockObj ) {
                if ( pendingTasks == 0 ) {
                    return;
                }
            }

            //Allow other threads to execute.
            Thread.Sleep( 0 );
        }
    }

    private void EndDoSomethingCallback( IAsyncResult ar ) {
        lock ( lockObj ) {
            AsyncDoSomethingCaller caller = (AsyncDoSomethingCaller) ar.AsyncState;
            caller.EndInvoke( ar );
            pendingTasks--;
        }
    }

    private void EndDoDisposeCallback( IAsyncResult ar ) {
        AsyncDoDisposeCaller caller = (AsyncDoDisposeCaller) ar.AsyncState;
        caller.EndInvoke( ar );
    }
}

Sehe ich ein problem mit diesem Ansatz. Da die Freisetzung von Ressourcen wird asynchron durchgeführt, so etwas wie dies funktionieren könnte:

MyClass myClass;

using ( myClass = new MyClass() ) {
    myClass.AsyncDoSomething();
}

myClass.DoSomething();

Wenn das erwartete Verhalten sein sollte, starten Sie eine ObjectDisposedException wenn DoSomething() heißt außerhalb der mit - Klausel. Aber ich glaube nicht, dass dies schlecht genug, um überdenken dieser Lösung.