Question

In IronPython I am trying to call a PythonFunction with different numbers of arguments from C#. For instance;

I want to do:

def foo(a, b):
     print a, b

def bar(a, b, c = None):
     print a, b, c

p = App.DynamicEvent()
p.addHandler(foo)
p.addHandler(bar)
p.invoke("Not", "Working")

where addHandler takes a single argument and somehow stores it in a list of methods to be invoked and invoke has a signature like this:

public virtual void invoke(params object[] tArgs)

Because I want to avoid making it specific to the PythonEngine (and thus engine.Operations.Invoke()), I’ve tried several ways of storing and implementing these things as delegates but I think the crux of my problem is that I don’t know how to store some kind of MulticastDelegate base type that is compatible with a PythonFunction?

Perhaps I want to implement my own DynamicInvoke method? Any thoughts and experience would be greatly appreciated!

The reason for wanting to do this is that I want to transparently map calls made from a sealed Javascript engine into IronPython via C#. i.e. in the Javascript call: Client.doThing("something", 4, {"key:"value"})
and handle it in the python with:

def doThing(s, i, d):
    pass

using the following dynamic event binding:

doThingEvent = App.DynamicEvent()
doThingEvent.addHandler(doThing)
WebBrowser.handleMethod("doThing", doThingEvent);

Answer 1

My first idea was as digEmAll suggested but I came up with a better solution that doesn’t require the casting to System.Action or any invoke-time type checking or branching. Just overload addHandler to take a PythonFunction as well as a Delegate, meaning you can use your original code:

def foo(a, b):
     print a, b

def bar(a, b, c = None):
     print a, b, c

p = DynamicEvent(engine)
p.addHandler(foo)
p.addHandler(bar)

p.invoke("a", "b")
p.invoke("a", "b", "c")

With this C# code:

public class DynamicEvent
{
    private Dictionary<int, Action<object[]>> delegates = new Dictionary<int, Action<object[]>>();
    public ScriptEngine Engine { get; set; }


    public DynamicEvent(ScriptEngine engine)
    {
        Engine = engine;
    }

    public void addHandler(PythonFunction pythonFunction)
    {
        int args = (int) pythonFunction.func_code.co_nlocals;
        delegates.Add(args, a => Engine.Operations.Invoke(pythonFunction, a));
    }

    public void addHandler(Delegate d)
    {
        int args = d.Method.GetParameters().Length;
        delegates.Add(args, a => d.DynamicInvoke(a));
    }

    public void invoke(params object[] args)
    {
        Action<object[]> action;
        if(!delegates.TryGetValue(args.Length, out action))
            throw new ArgumentException("There is no handler that takes " + args.Length + " arguments!");

        action(args);
    }
}

Note that you need to add the engine to the script’s scope so you can use it in the constructor.

Hope that helped!

---

Note: It is possible to get a Delegate and execute it from a PythonFunction like this:

Delegate target = pythonFunction.__code__.Target;
var result = target.DynamicInvoke(new object[] {pythonFunction, args});

but it is more platform dependant than using Engine.Operations.Invoke() and the Delegate signature is different to a ‘regular’ Delegate.