c# - 将动态对象解析委托(delegate)给其他实例

Question

我目前在 .NET 2.0 应用程序中托管 IronPython。

我想创建一个类(在 C# 中)，它的实例可以被插件实例“扩展”。这意味着，我的实例上无法解析的每个成员访问都应转发给提供该成员的适当插件实例。然后，我的对象将包含一个包含这些插件实例的私有(private)容器。

AFAICS，方法是从 DynamicObject 派生。到目前为止，第一步很简单，只要 python 代码使用我的实例的“未知”成员，就会调用 TryGetMember。我还可以返回可从 python 代码中使用的对象和委托(delegate)。

但是，不知何故，我在尝试使用 DLR 对插件实例和 e 执行“子搜索”时卡住了。 G. 以 IronPython 期望的方式返回插件实例的方法或属性。

欢迎任何提示!

谢谢!

编辑:我原来的问题表达得不够清楚，抱歉。这里有几点:

• 解决方案必须使用纯 .NET 2.0 运行，不允许使用 .NET 3.5 或 4.0。
• 插件列表是针对每个实例的(这意味着每个实例都可以有不同但不可变的插件对象列表)。
• 插件对象应该是映射了所有公共(public)成员(或至少是方法和属性)的纯 C# 对象。
• 碰撞检测并不重要。

再次感谢。

Answer 1

听起来您想要做的是将您的插件实例类型化为对象或动态(而不是将它们类型化为您有效地通过 TryGetMember 请求的某个接口(interface))，然后对另一个对象执行动态绑定(bind)。幸运的是，DLR 互操作协议(protocol)正好允许这种情况!它需要下拉到 IDynamicMetaObjectProvider 层而不是使用 DynamicObject 但它实际上非常简单。我将向您展示一个使用 C# 4.0 端到端工作的 InvokeMember 的简单示例。您需要去做剩下的操作——特别是 IronPython 将使用 GetMember 而不是 InvokeMember。但这是一个直接的过程。

首先解释一下你是如何做到的。在 IDMOP 级别，DLR 处理元对象，语言从元对象请求操作，这些元对象返回更多的元对象。您还可以要求该语言执行它的默认绑定(bind)，最重要的是，您可以向它提供在出现问题时该怎么做的建议。

在此基础上，您可以要求语言尝试绑定(bind)到您的每个插件和您自己的对象。根据您是否希望插件具有优先权或您的动态对象，您可以最后执行对自己的绑定(bind)。此示例基于成员名称演示了这两种技术。

所以事不宜迟，这里是:

using System;
using System.Dynamic;
using System.Linq.Expressions;

namespace ConsoleApplication10 {
    class Program {
        static void Main(string[] args) {
            dynamic dynamicObj = new MyDynamicObject(new TestPlugin());
            dynamicObj.Foo();
            dynamicObj.Bar();
            Console.ReadLine();
        }

    }

    public class TestPlugin {
        public void Foo() {
            Console.WriteLine("TestPlugin Foo");
        }

        public void Bar() {
            Console.WriteLine("TestPlugin Bar");
        }
    }

    class MyDynamicObject : IDynamicMetaObjectProvider {
        internal readonly object[] _plugins;

        public void Foo() {
            Console.WriteLine("MyDynamicObject Foo");
        }

        public void Bar() {
            Console.WriteLine("MyDynamicObject Bar");
        }

        public MyDynamicObject(params object[] plugins) {
            _plugins = plugins;
        }

        class Meta : DynamicMetaObject {
            public Meta(Expression parameter, BindingRestrictions restrictions, MyDynamicObject self)
                : base(parameter, restrictions, self) {
            }

            public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args) {                
                // get the default binding the language would return if we weren't involved
                // This will either access a property on MyDynamicObject or it will report
                // an error in a language appropriate manner.
                DynamicMetaObject errorSuggestion = binder.FallbackInvokeMember(this, args);

                // run through the plugins and replace our current rule.  Running through
                // the list forward means the last plugin has the highest precedence because
                // it may throw away the previous rules if it succeeds.
                for (int i = 0; i < Value._plugins.Length; i++) {
                    var pluginDo = DynamicMetaObject.Create(Value._plugins[i],
                        Expression.Call(
                            typeof(MyDynamicObjectOps).GetMethod("GetPlugin"),
                            Expression,
                            Expression.Constant(i)
                        )
                    );

                    errorSuggestion = binder.FallbackInvokeMember(pluginDo, args, errorSuggestion);                    
                }

                // Do we want DynamicMetaObject to have precedence?  If so then we can do
                // one more bind passing what we've produced so far as the rule.  Or if the
                // plugins have precedence we could just return the value.  We'll do that
                // here based upon the member name.

                if (binder.Name == "Foo") {
                    return binder.FallbackInvokeMember(this, args, errorSuggestion);
                }

                return errorSuggestion;
            }

            public new MyDynamicObject Value {
                get {
                    return (MyDynamicObject)base.Value;
                }
            }
        }



        #region IDynamicMetaObjectProvider Members

        public DynamicMetaObject GetMetaObject(System.Linq.Expressions.Expression parameter) {
            return new Meta(parameter, BindingRestrictions.Empty, this);
        }

        #endregion
    }

    public static class MyDynamicObjectOps {
        public static object GetPlugin(object myDo, int index) {
            return ((MyDynamicObject)myDo)._plugins[index];
        }
    }
}

运行此打印:

MyDynamicObject Foo测试插件栏

显示对于 Foo 成员，我们更喜欢绑定(bind)到实际对象，而对于 Bar 成员，我们更喜欢 Bar。如果您添加对第三个 Baz 成员的访问，它会产生 C# 的运行时联编程序异常。如果这是从 IronPython 调用的，我们会为 Python 程序生成一个 AttributeError(.NET 中的 MissingMemberException)，并且 JavaScript 实现应该向他们的程序返回 undefined。

因此，您不仅可以获得可扩展的插件系统，还可以轻松获得使用您的对象的任何语言的正确行为。