C＃以一般方式调用使用反射的方法

Question

I have two processes (A and B), both have a method Foo(SomeClass paramA, SomeOtherClass paramB). The processes communicate using Windows Pipes (not WCF) and can send and receive messages of type:

public class PipeMessageArgs
{
     public PipeMessageArgs(string i_MethodName, List<object> i_Args)
      {
          MethodName = i_MethodName;
          Args = i_Args;
      }

      public string MethodName { get; private set; }
      public List<object> Args { get; private set; }
}

When calling Foo on A, I want to invoke Foo on B, with the same values.

This is the calling code in A:

public void Foo(SomeClass paramA, SomeOtherClass paramB)
{
    var args = new List<object> { paramA, paramB };
    m_Server.PushMessage(new PipeMessageArgs(MethodBase.GetCurrentMethod().Name, args));
}

This is the invoking code in B:

void ClientOnReceiveMessage(NamedPipeConnection i_Connection, object i_Message)
{
    var pipeMessageArgs = i_Message as PipeMessageArgs;
    GetType().GetMethod(pipeMessageArgs.MethodName).Invoke(this, pipeMessageArgs.Args.ToArray());
}

But as you can see, I have to manually create a list of parameters for each call so if I forget a parameter or get the order wrong, things will not work. Given that I cannot use reflection to get the values, and I do not want to use the profiler (performance is an issue), what is the best way to make it more generic?

Edit: I cannot use WCF for too many reasons (actually, I am moving away from WCF). I am using pipes, namely PipeStream.

Edit2: What I want is a solution that does not rely on manually creating arrays of parameters; something that can create this array automatically for me.

Answer 1

I ended up using RealProxy . RealProxy is mainly used for remoting but can allow you to create proxy for classes. You can then add functionality before each method call (also properties calls). I used this very nice blog post to implement it.

This is my proxy:

public class InvokingProxy : RealProxy
    {
        private readonly INamedPipe _namedPipe;

        InvokingProxy(object i_Target, INamedPipe i_NamedPipe) : base(i_Target.GetType())
        {
            _namedPipe = i_NamedPipe;
        }

        public override IMessage Invoke(IMessage i_Msg)
        {
            var methodCall = i_Msg as IMethodCallMessage;

            if (methodCall != null)
            {
                return HandleMethodCall(methodCall);
            }

            return null;
        }

        IMessage HandleMethodCall(IMethodCallMessage i_MethodCall)
        {
            _namedPipe.PushMessage(new PipeMessageArgs(i_MethodCall.MethodName, i_MethodCall.InArgs));
            return new ReturnMessage(null, null, 0, i_MethodCall.LogicalCallContext, i_MethodCall);
        }

        public static T Wrap<T>(T i_Target, INamedPipe i_NamedPipe) where T : MarshalByRefObject
        {
            return (T)new InvokingProxy(i_Target, i_NamedPipe).GetTransparentProxy();
        }
    }

I use i_MethodCall.InArgs to get the in-arguments, that's the hear of the issue. Also notice how HandleMethodCall uses the pipe to push a message instead of actually calling the requested method. This means that my 'API' class is actually just empty methods with no implementation (I can always add more implementation there and invoke the method before/after the pipe action):

class Api : MarshalByRefObject, IApi
    {
        public void Foo(SomeClass paramA, SomeOtherClass paramB)
        {
        }

        public void Bar(SomeClassX paramA, SomeOtherClassY paramB)
        {
        }
    }
}

Also, as a requirement of RealProxy. the class has to inherit from MarshalByRefObject which was fine by me as it has no other functionality. Read more about it in the blog post I linked.