AppDomain 和 MarshalByRefObject 生命周期：如何避免 RemotingException？

Question

当 MarshalByRef 对象从 AppDomain (1) 传递到另一个 (2) 时，如果您等待 6 分钟，然后在第二个 AppDomain (2) 中对其调用方法，您将收到 RemotingException：

System.Runtime.Remoting.RemotingException： 对象 [...] 已断开连接或 服务器上不存在。

关于这个问题的一些文档：

• http://blogs.microsoft.co.il/blogs/sasha/archive/2008/07/19/appdomains-and-remoting-life-time-service.aspx
• http://blogs.msdn.com/cbrumme/archive/2003/06/01/51466.aspx - 实例生命周期，cbrumme 说“我们应该解决这个问题。” :(

如果我错了，请纠正我：如果 InitializeLifetimeService 返回 null，那么当 AppDomain 2 Unloaded 时，即使收集了代理，也只能在 AppDomain 1 中收集对象？

有没有办法禁用生命周期并保持代理（在 AppDomain 2 中）和对象（在 AppDomain1 中）活动，直到代理完成？也许与 ISponsor...？

Answer 1

对于那些希望更深入地了解 .NET Remoting Framework 的人，我建议将标题为 "Remoting Managing the Lifetime of Remote .NET Objects with Leasing and Sponsorship" 的文章发布在MSDN Magazine December 2003 issue。

Answer 2

这里有两种可能的解决方案。

单例方法：重写 InitializeLifetimeService

作为原始海报链接的Sacha Goldshtein points out in the blog post，如果您的Marshaled 对象具有单例语义，您可以覆盖InitializeLifetimeService：

class MyMarshaledObject : MarshalByRefObject
{
    public bool DoSomethingRemote() 
    {
      // ... execute some code remotely ...
      return true; 
    }

    [SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.Infrastructure)]
    public override object InitializeLifetimeService()
    {
      return null;
    }
}

但是，正如 user266748 在another answer 中指出的那样

如果每次都创建这样的对象，该解决方案将不起作用 客户端连接自己，因为他们永远不会被 GCed 和你的 内存消耗会不断增加，直到您停止 服务器或由于没有更多内存而崩溃

基于类的方法：使用 ClientSponsor

更通用的解决方案是使用ClientSponsor 来延长类激活远程对象的寿命。链接的 MSDN 文章有一个有用的起始示例，您可以参考：

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Tcp;
using System.Runtime.Remoting.Lifetime;
namespace RemotingSamples
{

   class HelloClient
   {
       static void Main()
      {
         // Register a channel.
         TcpChannel myChannel = new TcpChannel ();
         ChannelServices.RegisterChannel(myChannel);
         RemotingConfiguration.RegisterActivatedClientType(
                                typeof(HelloService),"tcp://localhost:8085/");

         // Get the remote object.
         HelloService myService = new HelloService();

         // Get a sponsor for renewal of time.
         ClientSponsor mySponsor = new ClientSponsor();

         // Register the service with sponsor.
         mySponsor.Register(myService);

         // Set renewaltime.
         mySponsor.RenewalTime = TimeSpan.FromMinutes(2);

         // Renew the lease.
         ILease myLease = (ILease)mySponsor.InitializeLifetimeService();
         TimeSpan myTime = mySponsor.Renewal(myLease);
         Console.WriteLine("Renewed time in minutes is " + myTime.Minutes.ToString());

         // Call the remote method.
         Console.WriteLine(myService.HelloMethod("World"));

         // Unregister the channel.
         mySponsor.Unregister(myService);
         mySponsor.Close();
      }
   }
}

生命周期管理在 Remoting API（described quite well here on MSDN）中的工作方式毫无价值。我引用了我认为最有用的部分：

远程生命周期服务将租约与每个服务相关联， 并在其租用时间到期时删除服务。一生 服务可以承担传统分布式垃圾的功能 收集器，并且它也可以在每个客户端的数量时很好地调整 服务器增加。

每个应用程序域都包含一个负责的租用管理器 用于控制其域内的租约。所有租约都经过审查 定期为过期的租约时间。如果租约已到期，一个或 更多的租赁发起人被调用，并有机会 续租。如果没有赞助商决定续租， 租约管理器删除租约，对象可以被收集 垃圾收集器。租赁管理器维护一个租赁列表，其中包含 租赁按剩余租赁时间排序。最短的租约 剩余时间存储在列表顶部。远程处理 生命周期服务将一个租约与每个服务相关联，并删除一个 租期到期时提供服务。

Answer 3

如果您想在远程对象被垃圾回收后重新创建远程对象，而无需创建ISponsor 类或给它无限的生命周期，您可以在捕获RemotingException 时调用远程对象的虚拟函数.

public static class MyClientClass
{
    private static MarshalByRefObject remoteClass;

    static MyClientClass()
    {
        CreateRemoteInstance();
    }

    // ...

    public static void DoStuff()
    {
        // Before doing stuff, check if the remote object is still reachable
        try {
            remoteClass.GetLifetimeService();
        }
        catch(RemotingException) {
            CreateRemoteInstance(); // Re-create remote instance
        }

        // Now we are sure the remote class is reachable
        // Do actual stuff ...
    }

    private static void CreateRemoteInstance()
    {
        remoteClass = (MarshalByRefObject)AppDomain.CurrentAppDomain.CreateInstanceFromAndUnwrap(remoteClassPath, typeof(MarshalByRefObject).FullName);
    }
}

Answer 4

我创建了一个在销毁时断开连接的类。

public class MarshalByRefObjectPermanent : MarshalByRefObject
{
    public override object InitializeLifetimeService()
    {
        return null;
    }

    ~MarshalByRefObjectPermanent()
    {
        RemotingServices.Disconnect(this);
    }
}

Answer 5

[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.Infrastructure)]
public override object InitializeLifetimeService()
{
  return null;
}

我已经对此进行了测试，它的工作正常，当然，必须知道代理永远存在，直到您自己进行 GC-ing。但我的情况是，使用连接到我的主应用程序的插件工厂，没有内存泄漏或类似的东西。我只是确定，我正在实现 IDisposable 并且它工作正常（我可以说，因为一旦工厂被正确处理，我加载的 dll（在工厂中）可以被覆盖）

编辑：如果您通过域冒泡事件，请将这行代码添加到创建代理的类中，否则您的冒泡也会抛出；）

Answer 6

您可以尝试实现 IObjectReference 的可序列化单例 ISponsor 对象。 GetRealObject 实现（来自 IObjectReference 应在 context.State 为 CrossAppDomain 时返回 MySponsor.Instance，否则返回自身。MySponsor.Instance 是自初始化、同步 (MethodImplOptions.Synchronized)、单例。更新实现（来自 ISponsor）应检查静态 MySponsor.IsFlaggedForUnload 并在标记为 unload/AppDomain.Current.IsFinalizingForUnload() 时返回 TimeSpan.Zero，否则返回 LifetimeServices.RenewOnCallTime。

要附加它，只需获取一个 ILease 和 Register(MySponsor.Instance)，由于 GetRealObject 实现，它将转换为 AppDomain 内的 MySponsor.Instance 集。

要停止赞助，请重新获取 ILease 和 Unregister(MySponsor.Instance)，然后通过跨 AppDomain 回调 (myPluginAppDomain.DoCallback(MySponsor.FlagForUnload)) 设置 MySponsor.IsFlaggedForUnload。

这应该让您的对象在另一个 AppDomain 中保持活动状态，直到取消注册调用、FlagForUnload 调用或 AppDomain 卸载。

Answer 7

在这里查看答案：

http://social.msdn.microsoft.com/Forums/en-US/netfxremoting/thread/3ab17b40-546f-4373-8c08-f0f072d818c9/

这基本上是说：

[SecurityPermissionAttribute(SecurityAction.Demand, Flags = SecurityPermissionFlag.Infrastructure)]
public override object InitializeLifetimeService()
{
  return null;
}

Answer 8

我最近也遇到了这个异常。现在我的解决方案只是卸载 AppDomain，然后在很长一段时间后重新加载 AppDomain。幸运的是，这个临时解决方案适用于我的情况。我希望有一种更优雅的方式来处理这个问题。

Answer 9

不幸的是，当 AppDomains 用于插件目的时，此解决方案是错误的（不得将插件程序集加载到您的主应用程序域中）。

您的构造函数和析构函数中的GetRealObject() 调用会导致获取远程对象的真实类型，这会导致尝试将远程对象的程序集加载到当前的AppDomain 中。这可能会导致异常（如果无法加载程序集）或您加载了以后无法卸载的外部程序集的不良影响。

如果您使用 ClientSponsor.Register() 方法在主 AppDomain 中注册远程对象（不是静态的，因此您必须创建客户端赞助商实例），则可能是更好的解决方案。默认情况下，它将每 2 分钟更新一次远程代理，如果您的对象具有默认的 5 分钟生命周期，这就足够了。

Answer 10

我终于找到了一种方法来执行客户端激活实例，但它涉及 Finalizer 中的托管代码 :( 我将我的课程专门用于 CrossAppDomain 通信，但您可以修改它并尝试其他远程处理。 如果您发现任何错误，请告诉我。

以下两个类必须位于所有相关应用程序域中加载的程序集中。

  /// <summary>
  /// Stores all relevant information required to generate a proxy in order to communicate with a remote object.
  /// Disconnects the remote object (server) when finalized on local host (client).
  /// </summary>
  [Serializable]
  [EditorBrowsable(EditorBrowsableState.Never)]
  public sealed class CrossAppDomainObjRef : ObjRef
  {
    /// <summary>
    /// Initializes a new instance of the CrossAppDomainObjRef class to
    /// reference a specified CrossAppDomainObject of a specified System.Type.
    /// </summary>
    /// <param name="instance">The object that the new System.Runtime.Remoting.ObjRef instance will reference.</param>
    /// <param name="requestedType"></param>
    public CrossAppDomainObjRef(CrossAppDomainObject instance, Type requestedType)
      : base(instance, requestedType)
    {
      //Proxy created locally (not remoted), the finalizer is meaningless.
      GC.SuppressFinalize(this);
    }

    /// <summary>
    /// Initializes a new instance of the System.Runtime.Remoting.ObjRef class from
    /// serialized data.
    /// </summary>
    /// <param name="info">The object that holds the serialized object data.</param>
    /// <param name="context">The contextual information about the source or destination of the exception.</param>
    private CrossAppDomainObjRef(SerializationInfo info, StreamingContext context)
      : base(info, context)
    {
      Debug.Assert(context.State == StreamingContextStates.CrossAppDomain);
      Debug.Assert(IsFromThisProcess());
      Debug.Assert(IsFromThisAppDomain() == false);
      //Increment ref counter
      CrossAppDomainObject remoteObject = (CrossAppDomainObject)GetRealObject(new StreamingContext(StreamingContextStates.CrossAppDomain));
      remoteObject.AppDomainConnect();
    }

    /// <summary>
    /// Disconnects the remote object.
    /// </summary>
    ~CrossAppDomainObjRef()
    {
      Debug.Assert(IsFromThisProcess());
      Debug.Assert(IsFromThisAppDomain() == false);
      //Decrement ref counter
      CrossAppDomainObject remoteObject = (CrossAppDomainObject)GetRealObject(new StreamingContext(StreamingContextStates.CrossAppDomain));
      remoteObject.AppDomainDisconnect();
    }

    /// <summary>
    /// Populates a specified System.Runtime.Serialization.SerializationInfo with
    /// the data needed to serialize the current System.Runtime.Remoting.ObjRef instance.
    /// </summary>
    /// <param name="info">The System.Runtime.Serialization.SerializationInfo to populate with data.</param>
    /// <param name="context">The contextual information about the source or destination of the serialization.</param>
    public override void GetObjectData(SerializationInfo info, StreamingContext context)
    {
      Debug.Assert(context.State == StreamingContextStates.CrossAppDomain);
      base.GetObjectData(info, context);
      info.SetType(typeof(CrossAppDomainObjRef));
    }
  }

现在是 CrossAppDomainObject，您的远程对象必须继承自此类而不是 MarshalByRefObject。

  /// <summary>
  /// Enables access to objects across application domain boundaries.
  /// Contrary to MarshalByRefObject, the lifetime is managed by the client.
  /// </summary>
  public abstract class CrossAppDomainObject : MarshalByRefObject
  {
    /// <summary>
    /// Count of remote references to this object.
    /// </summary>
    [NonSerialized]
    private int refCount;

    /// <summary>
    /// Creates an object that contains all the relevant information required to
    /// generate a proxy used to communicate with a remote object.
    /// </summary>
    /// <param name="requestedType">The System.Type of the object that the new System.Runtime.Remoting.ObjRef will reference.</param>
    /// <returns>Information required to generate a proxy.</returns>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed override ObjRef CreateObjRef(Type requestedType)
    {
      CrossAppDomainObjRef objRef = new CrossAppDomainObjRef(this, requestedType);
      return objRef;
    }

    /// <summary>
    /// Disables LifeTime service : object has an infinite life time until it's Disconnected.
    /// </summary>
    /// <returns>null.</returns>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public sealed override object InitializeLifetimeService()
    {
      return null;
    }

    /// <summary>
    /// Connect a proxy to the object.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public void AppDomainConnect()
    {
      int value = Interlocked.Increment(ref refCount);
      Debug.Assert(value > 0);
    }

    /// <summary>
    /// Disconnects a proxy from the object.
    /// When all proxy are disconnected, the object is disconnected from RemotingServices.
    /// </summary>
    [EditorBrowsable(EditorBrowsableState.Never)]
    public void AppDomainDisconnect()
    {
      Debug.Assert(refCount > 0);
      if (Interlocked.Decrement(ref refCount) == 0)
        RemotingServices.Disconnect(this);
    }
  }