如何处理调用了异步方法的对象？

Question

我有这个对象PreloadClient，它实现了IDisposable，我想处理它，但是在异步方法完成它们的调用之后......这没有发生

    private void Preload(SlideHandler slide)
    {
        using(PreloadClient client = new PreloadClient())
        {                 
             client.PreloadCompleted += client_PreloadCompleted;
             client.Preload(slide);
        }
        // Here client is disposed immediately
    }
    private void client_PreloadCompleted(object sender, SlidePreloadCompletedEventArgs e)
    {
     // this is method is called after a while, 
     // but errors are thrown when trying to access object state (fields, properties)
    }

那么，有什么想法或解决方法吗？？

Answer 1

1. 您不应使用using 构造，而应在不再需要对象时将其丢弃：

   // keep a list of strong references to avoid garbage collection,
   // and dispose them all in case we're disposing the encapsulating object
   private readonly List<PreloadClient> _activeClients = new List<PreloadClient>();
   private void Preload(SlideHandler slide)
   {
       PreloadClient client = new PreloadClient();
       _activeClients.Add(client);
       client.PreloadCompleted += client_PreloadCompleted;
       client.Preload(slide);
   }
   
   private void client_PreloadCompleted(object sender,
        SlidePreloadCompletedEventArgs e)
   {
       PreloadClient client = sender as PreloadClient;
   
       // do stuff
   
       client.PreloadCompleted -= client_PreloadCompleted;
       client.Dispose();
       _activeClients.Remove(client);
   }
   

2. 在这种情况下，您必须在处置主类时处置所有客户端：

   protected override Dispose(bool disposing)
   {
       foreach (PreloadClient client in _activeClients)
       { 
           client.PreloadCompleted -= client_PreloadCompleted;
           client.Dispose();
       }
       _activeClients.Clear();
       base.Dispose(disposing);
   }
   

3. 请注意，此实现不是线程安全的

   • 对_activeClients 列表的访问权限必须为made thread-safe，因为您的PreloadCompleted 方法是从不同的线程调用的
   • 您的包含对象可能会在客户端触发事件之前被释放。在这种情况下，“做事”应该什么都不做，所以这是你应该注意的另一件事。
   • 在事件处理程序中使用 try/finally 块可能是个好主意，以确保在所有情况下都会释放对象

Answer 2

为什么不在回调中释放客户端？

Answer 3

我有几个想法：

1. 改变你的架构。
2. 在处理程序中处理
3. 使用 EventWaitHandle

Answer 4

如果注册了事件处理程序，那么当有可以在其上调用的事件时，您无法真正处置该对象。您最好的选择是使包含类成为一次性并将客户端存储在类变量中，以便在包含类存在时进行处置。

类似

class ContainingClass : IDisposable
{
    private PreloadClient m_Client;

    private void Preload(SlideHandler slide)
    {
         m_Client = new PreloadClient())

         m_Client.PreloadCompleted += client_PreloadCompleted;
         m_Client.Preload(slide);

    }
    private void client_PreloadCompleted(object sender, SlidePreloadCompletedEventArgs e)
    {
    }

    public void Dispose()
    {
        if (m_Client != null)
            m_Client.Dispose();
    }
}

Answer 5

好吧，释放对象用于杀死在 GC（最终）到来并收集您的对象之前您不希望持有的资源。你的 dispose 方法是否会在 client_PreloadCompleted 中杀死你需要的任何东西？

当所有预期的回调都发生时，您可以让对象自行处置：为您期望的每个回调保留一个“引用计数器”，并在每个发生的回调上递减 - 在回调处理程序结束时检查 null 并处置 if所以。

其他解决方法：不要担心IDisposable。 GC 会收集你的对象。您可能不希望回调处理程序（可能不会被触发）处于临界状态。它（回调）应该在被调用时打开它需要的任何资源，然后关闭它们。

Answer 6

异步等待和确定性处理不能很好地混合。如果你能找到一种拆分代码的方法，使一次性的东西放在一个类中，而事件放在另一个类中，那一切都会变得更简单。

Answer 7

为什么不在client_PreloadCompleted 方法中处理？ 与thecoop 提供的类似，只需在上述方法中调用Dispose，在您从客户端对象内部访问所有需要的数据之后。

编辑：我认为这也是 orialmog 提供的。