try to use python.net as the bridge.

Pythonnet.Runtime/delegateobject.cs

@@ -0,0 +1,120 @@
+// ==========================================================================
+// This software is subject to the provisions of the Zope Public License,
+// Version 2.0 (ZPL).  A copy of the ZPL should accompany this distribution.
+// THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
+// WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+// WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS
+// FOR A PARTICULAR PURPOSE.
+// ==========================================================================
+
+using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
+
+namespace Python.Runtime {
+
+    /// <summary>
+    /// Managed class that provides the implementation for reflected delegate
+    /// types. Delegates are represented in Python by generated type objects. 
+    /// Each of those type objects is associated an instance of this class, 
+    /// which provides its implementation.
+    /// </summary>
+
+    internal class DelegateObject : ClassBase {
+
+        MethodBinder binder;
+
+        internal DelegateObject(Type tp) : base(tp) {
+            binder = new MethodBinder(tp.GetMethod("Invoke"));
+        }
+
+
+        //====================================================================
+        // Given a PyObject pointer to an instance of a delegate type, return
+        // the true managed delegate the Python object represents (or null).
+        //====================================================================
+
+        private static Delegate GetTrueDelegate(IntPtr op) {
+            CLRObject o = GetManagedObject(op) as CLRObject;
+            if (o != null) {
+                Delegate d = o.inst as Delegate;
+                return d;
+            }
+            return null;
+        }
+
+
+        internal override bool CanSubclass() {
+            return false;
+        }
+
+
+        //====================================================================
+        // DelegateObject __new__ implementation. The result of this is a new
+        // PyObject whose type is DelegateObject and whose ob_data is a handle
+        // to an actual delegate instance. The method wrapped by the actual
+        // delegate instance belongs to an object generated to relay the call
+        // to the Python callable passed in.
+        //====================================================================
+
+        public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw) {
+            DelegateObject self = (DelegateObject)GetManagedObject(tp);
+
+            if (Runtime.PyTuple_Size(args) != 1) {
+                string message = "class takes exactly one argument";
+                return Exceptions.RaiseTypeError(message);
+            }
+
+            IntPtr method = Runtime.PyTuple_GetItem(args, 0);
+
+            if (Runtime.PyCallable_Check(method) != 1) {
+                return Exceptions.RaiseTypeError("argument must be callable");
+            }
+
+            Delegate d = PythonEngine.DelegateManager.GetDelegate(self.type, method);
+            return CLRObject.GetInstHandle(d, self.pyHandle);
+        }
+
+
+
+        //====================================================================
+        // Implements __call__ for reflected delegate types.
+        //====================================================================
+
+        public static IntPtr tp_call(IntPtr ob, IntPtr args, IntPtr kw) {
+            // todo: add fast type check!
+            IntPtr pytype = Runtime.PyObject_TYPE(ob);
+            DelegateObject self = (DelegateObject)GetManagedObject(pytype);
+            CLRObject o = GetManagedObject(ob) as CLRObject;
+
+            if (o == null) {
+                return Exceptions.RaiseTypeError("invalid argument");
+            }
+            
+            Delegate d = o.inst as Delegate;
+
+            if (d == null) {
+                return Exceptions.RaiseTypeError("invalid argument");
+            }
+            return self.binder.Invoke(ob, args, kw);
+        }
+
+
+        //====================================================================
+        // Implements __cmp__ for reflected delegate types.
+        //====================================================================
+
+        public static new int tp_compare(IntPtr ob, IntPtr other) {
+            Delegate d1 = GetTrueDelegate(ob);
+            Delegate d2 = GetTrueDelegate(other);
+            if (d1 == d2) {
+                return 0;
+            }
+            return -1;
+        }
+
+
+    }        
+
+
+}