3

I'm writing a Javascript <-> C# bridge and ran into the following problem:

There's a class JSObject:

public class JSObject : DynamicObject
{
    public JSEngineAPI wrappedObject { get; set; }

    public JSObject(JSEngineAPI WrappedObject);
    public override bool TryConvert(ConvertBinder binder, out object result);
    public override bool TryGetMember(GetMemberBinder binder, out object result);
    ...
}

and let's assume there's a simple test case like

public class TestClass
{
    public string message = "This is a C# string";
}

public class TestApp
{
    public string testComplexObject(TestClass obj)
    {
        return obj.message;
    }
}

Now I want to be able to do

JSObject jsObj = ...;
string message = testComplexObject(jsObj);

Doing obj.message should perform a TryGetMember() call. Effectively the jsObj should pretend to be a TestClass instance. Note that the call to testComplexObject is just an example, later I need to be able to support calling arbitrary functions with arbitrary arguments.

I've tried various ways to make this work, but none of them worked. So I wonder about a good way to achieve this.

I've thought about creating a class at runtime which inherits from TestClass. This dynamic class will contain generated members which overload their base class pendants. Each of these methods would forward to the JSObject/JSEngineAPI to perform the real work. Then I could pass an instance of this dynamic class into the testComplexObject method.

However this sounds rather involved and I'd love to know if there are easier/other approaches to this.

EDIT #1: I guess if you take away the "DynamicObject" part this question is a bit like how can I create a proxy for type T at runtime?

EDIT #2: I've also looked into RealProxy and IDynamicMetaObjectProvider now and wonder if these are of any help.

Thanks for your time, -Matthias

Justin
  • 84,773
  • 49
  • 224
  • 367
nitrogenycs
  • 962
  • 9
  • 13
  • As far as I know, it's impossible to treat a dynamic object as an instance of a different type of object, you'll need to perform conversions or make the wrapper object derive from the target type. Have you considered making the method take in interface instead? Then your dynamic object can just implement the interface and you can do your operations. Or even just make it dynamic, then it will use the correct methods as you implement them. – Jeff Mercado Mar 28 '11 at 22:18
  • Thanks for your comment, Jeff. I cannot make it take an interface. Basically my bridge aims to expose arbitrary C# libraries to javascript. Unfortunately these C# libraries will not be limited to interface-typed parameters and objects. If C# had multiple inheritance I could probably inherit from DynamicObject and TestClass. – nitrogenycs Mar 28 '11 at 22:23
  • How about making the parameter `dynamic`, then it would work and you can still pass in actual instances of your `TestClass`. – Jeff Mercado Mar 28 '11 at 22:50
  • @Jeff M: I can't change the signature of the testComplexObject method at all. It's an example of an arbitrary C# function I want to call. – nitrogenycs Mar 28 '11 at 22:57

1 Answers1

3

As the signature of the method cannot be changed, you could create a proxy to stand in for your dynamic object. This will be effective only if the objects are PODs or you stick to virtual methods that you could override. Otherwise your methods could end up not being used. It will implement the the desired type but will pass all accesses to your actual object. Using this will be easy if you add some conversion methods to your dynamic object. Something like this:

public class JSObject : DynamicObject
{
    class TestClassProxy : TestClass
    {
        private dynamic wrapper;
        public TestClassProxy(dynamic obj)
        {
            wrapper = obj;
            // assign copies of the fields
            message = obj.message;
        }
        // override all required methods and properties
        public override void SampleMethod()
        {
            wrapper.SampleMethod();
        }
        public override int SomeValue
        {
            get { return wrapper.SomeValue; }
            set { wrapper.SomeValue = value; }
        }
        // etc...
    }

    public override bool TryConvert(ConvertBinder binder, out object result)
    {
        if (binder.Type == typeof(TestClass))
        {
            result = new TestClassProxy(this);
            return true;
        }
        // your other conversions
        return base.TryConvert(binder, out result);
    }
    // etc...
}

If you need to do more with your objects, I don't know how else you could get around this other than changing the method's signature.

Jeff Mercado
  • 129,526
  • 32
  • 251
  • 272