将__TransparentProxy of RemotingProxy包装在另一个代理中将引发RemotingException

Question

目标

我有几个接口和一些dll为这些接口提供实现。我希望将实现加载到一个新的AppDomain中(以便以后可以卸载dll )，并在新的AppDomain中安装实现，然后使用客户端(这里是默认的AppDomain)代理来包装实际的实现对象。目标是创建这些ClientProxy实例一次，并在没有将实现程序集加载到默认AppDomain的情况下，随时更改它们的实际实现。

问题

当调用ClientProxy __TransparentProxy对象上获取另一个ClientProxy作为参数的方法时，我会得到以下异常：

System.Runtime.Remoting.RemotingException：'The argument type 'System.MarshalByRefObject' cannot be converted into parameter type 'IData'.'

除内部例外：

InvalidCastException：Object must implement IConvertible.

当传递直接从服务器AppDomain获得的AppDomain时，ClientProxy工作。

设置

可克隆来自：https://github.com/mailgerigk/remoting

接口：

public interface IData
{
    int Foo { get; set; }
}

public interface ILogic
{
    void Update(IData data);
}

_impl.dll中的接口Impl：

public class DataImpl : MarshalByRefObject, IData
{
    public int Foo { get; set; }
}

public class LogicImpl : MarshalByRefObject, ILogic
{
    public void Update(IData data)
    {
        data.Foo++;
    }
}

服务器端AssemblyLoader：

class AssemblyLoader : MarshalByRefObject
{
    public Assembly Assembly { get; private set; }

    public AssemblyLoader(string assemblyFile)
    {
        Assembly = Assembly.LoadFrom(assemblyFile);
    }

    public object CreateInstance(string typeName)
    {
        return Activator.CreateInstance(Assembly.GetType(typeName));
    }
}

ClientProxy：

class ClientProxy : RealProxy
{
    private RealProxy innerProxy;

    public ClientProxy(Type interfaceType, object proxyObject)
        : base(interfaceType)
    {
        SetInnerProxy(proxyObject);
    }

    public void SetInnerProxy(object proxyObject)
    {
        innerProxy = RemotingServices.GetRealProxy(proxyObject);
    }

    public override IMessage Invoke(IMessage msg)
    {
        return innerProxy.Invoke(msg);
    }
}

Main：

class Program
{
    static void Main(string[] args)
    {
        var app = AppDomain.CreateDomain("ImplDomain", null,
            AppDomain.CurrentDomain.BaseDirectory, AppDomain.CurrentDomain.RelativeSearchPath,
            true);

        var assmblyLoader = app.CreateInstanceFromAndUnwrap(
            typeof(AssemblyLoader).Assembly.Location, typeof(AssemblyLoader).FullName,
            false, BindingFlags.CreateInstance, null,
            new object[]
            {
                "_impl.dll"
            },
            null, null) as AssemblyLoader;

        var dataImpl = assmblyLoader.CreateInstance("DataImpl") as IData;
        var logicImpl = assmblyLoader.CreateInstance("LogicImpl") as ILogic;

        logicImpl.Update(dataImpl); // Works
        Console.WriteLine(dataImpl.Foo); // prints 1

        var clientDataProxy = new ClientProxy(typeof(IData), dataImpl);
        var clientDataImpl = clientDataProxy.GetTransparentProxy() as IData;

        var clientLogicProxy = new ClientProxy(typeof(ILogic), logicImpl);
        var clientLogicImpl = clientLogicProxy.GetTransparentProxy() as ILogic;

        clientLogicImpl.Update(dataImpl); // Works
        Console.WriteLine(clientDataImpl.Foo); // prints 2

        clientLogicImpl.Update(clientDataImpl); // throws System.Runtime.Remoting.RemotingException
        Console.WriteLine(clientDataImpl.Foo);
    }
}

Answer 1

在不知道您的推理的情况下，从提供的示例代码来看，ClientProxy类似乎没有必要，因为您可以直接使用RealProxy获得相同的行为：

var clientDataProxy = RemotingServices.GetRealProxy(dataImpl);

话虽如此，您当然可以创建自己的具体RealProxy，并让它按预期工作--您只是缺少了一个从innerProxy获取TransparentProxy的覆盖。

class ClientProxy : RealProxy
{
    ... everything else ...

    public override object GetTransparentProxy() => innerProxy.GetTransparentProxy();

    public object GetOuterTransparentProxy() => base.GetTransparentProxy();
}

...
var clientDataProxy = new ClientProxy(typeof(IData), dataImpl);
var clientDataImpl = clientDataProxy.GetOuterTransparentProxy() as IData;

var clientLogicProxy = new ClientProxy(typeof(ILogic), logicImpl);
var clientLogicImpl = clientLogicProxy.GetOuterTransparentProxy() as ILogic;
...

目前，您的ClientProxy正在将一个TransparentProxy返回到外部对象。

编辑:基于注释中的解释，我添加了一个返回外部基本实现的辅助GetOuterTransparentProxy方法。这仍然允许使用OOTB RealProxy.Invoke实现，同时公开可重用的外部TransparentProxy。