Question

我有一个管理流程的课程。在此类上调用Stop()或Dispose()时，它将首先向进程发送TCP命令以要求它自行关闭，然后在1秒内检查，如果它没有关闭，则调用{{1然后等待另一秒钟，如果它仍然在运行，请拨打CloseMainWindow()。

现在我有一个Kill()这个类来管理一堆进程。当我想从列表中删除它们时，我会手动拨打List<>，然后Dispose()。我想确保在松开唯一引用之前我调用了Remove()。由于调用Dispose()至少需要2秒才能返回，如果我说要删除5项，则需要一段时间。

所以我打算让另一个名为Dispose()的函数返回SafeDispose() Invoke()。现在从列表中删除这些内容并调用Dispose()而不是SafeDispose()将立即进行，而类本身会自行缓慢处理。

这样做是否明智？

Answer 1

基本上你是在建议，将Dispose“保持原样”，而是让一个辅助方法异步地拆除对象 - 它附加到对象上。

这是可取的吗？

也许，引入线程的棘手问题在于它带来的所有线程混乱。

另一种方法在异步处理时访问对象会发生什么？
同时调用另一个AsyncDispose时会发生什么？
错误如何传播？
这会引入死锁吗？
在不同的线程（和不同的对象）上运行大量处理会导致任何问题吗？（比如用完了tcp套接字）

如果你能以满意的方式回答所有问题，那么也许。

请记住，你也可以在UI中分离出一个处理所有过期的线程，并在一个线程中执行（作为另一个选项）

Answer 2

使用活动

class Program
{
    static void Main(string[] args)
    {
        using (MyClass c = new MyClass())
        {
            c.Disposed += MyClass_Disposed;
            Console.WriteLine("Press any key to dispose");
            Console.ReadKey();
        }
        Console.WriteLine("Press any key to finish");
        Console.ReadKey();
    }

    static void MyClass_Disposed(object source, EventArgs e)
    {
        Console.WriteLine("I've been disposed");
    }
}


class MyClass : IDisposable
{
    public event EventHandler Disposed;

    public void Dispose()
    {
        if (this.Disposed != null)
            this.Disposed(this, EventArgs.Empty);
    }
}

Answer 3

使用异步方法调用来处置对象，然后从列表中删除它们。

假设你有一个名为 foos 的类foo列表。

var iars = new List<IAsyncResult>();
Action<IDisposable> disposeAction = a => a.Dispose();
foreach(var foo in foos)
    iars.Add(disposeAction.BeginInvoke(null, null));
foreach(var iar in iars)
    disposeAction.EndInvoke(iar);
foreach(var foo in foos) foos.Remove(foo);

如果您使用.net 4.0，则可以使用Parallel库执行此操作以提高效率。编辑 - 对List.Remove线程安全的流行需求。至于例外安全。 Dispose（）方法不应该首先抛出异常。

自我处理课

3 个答案: