C＃异步TCP和它的闭包引用实例的垃圾回收？

Question

想知道在异步TCP或其他EAP模式的情况下，如果成功处理程序具有参考this，例如， this.state，理论上有一个对当前实例的引用，因为this被闭包性质保存在某个生成的对象作用域中。因此，即使创建实例的范围完成执行，实例本身也不应被垃圾收集？

我的代码是类似以下内容：该执行它可以像

public class ATcpClient 
    { 
     private ATcpState state = null; 

     private void Receive() 
     { 
      // create the callback here, in order to use in dynamic 
      AsyncCallback ReceiveCallback = delegate(IAsyncResult ar) 
       { 
        try 
        { 
         // Read data from the remote device. 
         this.state.BytesReceived = this.state.Socket.EndReceive(ar); 

        } 
        catch (Exception e) 
        { 
         // ... 

        } 
       }; 

      try 
      { 
        this.state.Socket.BeginReceive(this.state.Buffer, 0, this.state.BufferSize, 0, 
         ReceiveCallback, null); 
      } 
      catch (Exception e) 
      { 
       // ... 
       // ... 
      } 
     } 
} 

代码：

public void DoExecuteCode() 
{ 
    new ATcpClient().Receive(); 
} 

会被GC的实例，它会导致接收（）失败作为一个整体？

Answer 1

这取决于编译器的聪明程度。

就你而言，是的，this一定会一直活着的代表，只要代表活着。

让我们来看看这肯定不会保持this活着的情况：其中，编译器优化可能会影响集合行为的情况下

private void Receive() 
    { 
     ATcpState state = this.state; 
     // create the callback here, in order to use in dynamic 
     AsyncCallback ReceiveCallback = delegate(IAsyncResult ar) 
      { 
       try 
       { 
        // Read data from the remote device. 
        state.BytesReceived = state.Socket.EndReceive(ar); 

       } 
       catch (Exception e) 
       { 
        // ... 

       } 
      }; 

     try 
     { 
       state.Socket.BeginReceive(state.Buffer, 0, state.BufferSize, 0, 
        ReceiveCallback, null); 
     } 
     catch (Exception e) 
     { 
      // ... 
      // ... 
     } 
    } 

然后：

private readonly ATcpState state = new ATcpState(); 
    private void Receive() 
    { 
     // create the callback here, in order to use in dynamic 
     AsyncCallback ReceiveCallback = delegate(IAsyncResult ar) 
      { 
       try 
       { 
        // Read data from the remote device. 
        state.BytesReceived = state.Socket.EndReceive(ar); 

       } 
       catch (Exception e) 
       { 
        // ... 

       } 
      }; 

     try 
     { 
       state.Socket.BeginReceive(state.Buffer, 0, state.BufferSize, 0, 
        ReceiveCallback, null); 
     } 
     catch (Exception e) 
     { 
      // ... 
      // ... 
     } 
    } 

唯一剩下的问题是，该代表的一生是什么？挂起的操作是否为根，或者我们是否在委托人（可能为this，state，state.Socket）和操作之间有循环引用？如果这些都不能从根到达，那么可以完成整个堆栈（这将关闭套接字，取消操作）。

At least for some objects using the BeginReceive/EndReceive pattern, the operation is NOT a root

它看起来像你的情况（Socket.BeginReceive），在里面System.Net.Sockets.BaseOverlappedAsyncResult.PinUnmanagedObjects创建了根。