.NET 剖析4.0上ExpandoObject动态扩展对象原理

最新推荐文章于 2024-07-03 09:53:06 发布

liulilittle

最新推荐文章于 2024-07-03 09:53:06 发布

阅读量2.3k

点赞数

分类专栏： C#

本文链接：https://blog.csdn.net/liulilittle/article/details/57090647

版权

C# 专栏收录该内容

94 篇文章 2 订阅

订阅专栏

在.NET/4.0它主打动态编程这应该是它的一大特性但既然作为一个.NET技术平台的开发人员那么有必要去了解其运行原理我不太清楚有没有人写过这方面的东西但显然这对我而言并不重要

下方通过一个动态字典的底层实现阐述

在blog上写的内容建议读众应好好读过C#高级编程（入门）、.NET本质论、深入理解.NET、Win32核心编程

上图是一张标准的动态对象扩展我为它扩展一个Say方法当然你可以为它扩展属性与字段这是可行的但建议只扩展方法与属性

它的用法是完全模拟.NET中dynamic下的ExpandoObject正如标题所提出的一般主要是剖析其原理这会涉及到一些中间代码（此处不提）、元数据表达式编程

但在此处并不是着重于中间代码这块虽然它的涉及面非常广如果把中间代码进行人工翻译会很麻烦我也花不起这个时间好那就通过ILSpy进行C#反译编

在上图中三行代码所需要真是代码远比看上去多得多那么换一种中代码这是一种用于阐述其工作原理巧妙方法

private static void Main(string[] args)
{
	object exp = new ExpandoObject();
	if (MainApplication.<Main>o__SiteContainer0.<>p__Site1 == null)
	{
		MainApplication.<Main>o__SiteContainer0.<>p__Site1 = CallSite<Func<CallSite, object, int, object>>.Create(Binder.SetMember(CSharpBinderFlags.None, "User", typeof(MainApplication), new CSharpArgumentInfo[]
		{
			CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.None, null),
			CSharpArgumentInfo.Create(CSharpArgumentInfoFlags.UseCompileTimeType | CSharpArgumentInfoFlags.Constant, null)
		}));
	}
	MainApplication.<Main>o__SiteContainer0.<>p__Site1.Target(MainApplication.<Main>o__SiteContainer0.<>p__Site1, exp, 10);
}

上述代码是一个向exp中扩展一个名为User属性的真实C#代码 ILSpy反译出可能有一些误差从上图你可以明确的看到我们虽然写了这么两行代码它底层所需要的实现远远比看上去的更多比直接反射更花费效率只是从这个方面看的话

        unsafe static void Main(string[] args)
        {
            dynamic exp = new ExpandoObject();
            exp.User = 10;
        }

如上述代码所示

CallSite<T>即调用点是一个.NET编译服务中提供的类它的作用则在提供动态且安全的委托调用（动态绑定的一种形式有点类似于实现反射的Binder进行安全调用绑定）它不是一个很常用的东西但如果在.NET/4.0中大量的动态编程那么就很常用了这个东西下面简单的写一个调用站点的例子举例

        public class SayCallSiteBinder : CallSiteBinder {
            public void Say() {
                Console.WriteLine("老司机带带我 我要上天堂");
            }
            public override Expression Bind(object[] args, ReadOnlyCollection<ParameterExpression> parameters, LabelTarget returnLabel) {
                return Expression.Call(Expression.Constant(this), typeof(SayCallSiteBinder).GetMethod("Say"), parameters);
            }
        }
        [STAThread]
        unsafe static void Main(string[] args) {
            CallSite<Action<CallSite>> site = CallSite<Action<CallSite>>.Create(new SayCallSiteBinder());
            site.Target(site);
        }

回到正题.NET/4.0中如果你进行了动态编程 dynamic语法这只是一种糖果仅此而已谈不上表达式而动态编程表达式可真的不是这个糖一样的东西后续会提到

C#编译会把所有用到dynamic进行代码封装姑且以拦截阐述会更好些但值得注意的地方在于即便是你在dynamic语法下调用了类的静态函数它也还是会被拦截（C#编译器的一种盲目性）

编译器是通过一种静态编译代码的手段即遇到这块类型代码进行特殊处理后在编译它们非常类似于AOP中静态注入技术当然这个是编译器本身支持的怎么说呢C#的语法糖太多但大多没有多大意义是好是坏说得清？

ExpandoObject它实现IDynamicMetaObjectProvider接口故名思意它是“动态元数据对象提供者” 它是干什么的？上面提到编译器会特殊处理dynamic语法的代码但同时它们会进行一个上下文绑定封装然后并且调用这个对象实现IDynamicMetaObjectProvider接口的GetMetaObject 传入一个Express的封装默认情况下被标记为dynamic语法类型的对象可能没有实现IDynamicMetaObjectProvider接口那么在Bind的处理过程中则以反射的方式进行动态绑定这个你可能需先参考最上面提供的ILSpy反译编代码

那么是不可能使用原生的元数据对象的它并没有任何有效的行为这个时候就需要去实现这个元数据对象也就是进行一个元数据编程比如上图代码中的ExpandoMetaObject（扩展元数据对象）

由于是编写一个“ExpandoObject”的动态扩展对象那么肯定会需要涉及动态的添加获取调用但需要一个集合进行托管实际上我这个代码写的并没有微软自家的复杂当然带来了执行效率会高一些

这里则是通过构造注入的参数但显然这里需要进行一个上下文绑定这根据具体的情况来定义当然个体的建议则是尽可能绑定dynamic语法所访问的变量

这里重写三个函数BindSetMember、BindGetMember、BindInvokeMember分别对应调用方法访问属性、字段的的重写但三者我是用了一个通用函数进行处理这是为了提高代码复用率

同时值得注意的是从上述的简单的元数据表达式编程你可以明确的看到它是通过调用的方式把自身的行为转移给了另一个事件处理源通过dynamic实现AOP的拦截是毫无问题的（只是性能非常成本高昂）
但是当你使用dynamic语法时调用一次那么它就会生成一个元数据对象的封装调用十次它就会生成十次当然复杂的情况一行代码就可能让它调用很多次不得不提它会进行动态的lambda express的代码编译（而这个效率很慢一般我们通常是进行缓存而不是多次编译）如果你非要使用这个东西那么可以你先确认这个性能开销是不是可以接受的否则建议你通过反射达到类似的效果同时如果你需要实现的动态功能越复杂所需写的元数据表达式就越复杂是的、元数据表达式很难写它也很难令人理解

但不论是反射还是元数据动态编程都需要进行优化否则它们的效率很难会搞起来出现这种问题那么问责应该找人而不是机器怪技术

在VS中如果需要提供对动态对象的动态视图支持你应该需要在元数据对象中实现GetDynamicMemberNames那么VS就可以对动态对象提供的可视化的动态视图

下述为动态扩展对象的源代码

namespace STDLOGIC_SERVER.Data.Dynamic
{
    using System;
    using System.Collections;
    using System.Collections.Generic;
    using System.Diagnostics;
    using System.Dynamic;
    using System.Linq.Expressions;
    using System.Reflection;

    public sealed class ExpandoObject : IDynamicMetaObjectProvider, IEnumerable<string>
    {
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private IDictionary<string, object> _dict = new Dictionary<string, object>();

        private class ExpandoMetaObject : DynamicMetaObject
        {
            private static readonly MethodInfo set = typeof(ExpandoMetaObject).GetMethod("Set", BindingFlags.NonPublic | 
                BindingFlags.Instance);
            private static readonly MethodInfo get = typeof(ExpandoMetaObject).GetMethod("Get", BindingFlags.NonPublic |
                BindingFlags.Instance);
            private static readonly MethodInfo invoke = typeof(ExpandoMetaObject).GetMethod("Invoke", BindingFlags.NonPublic |
                BindingFlags.Instance);

            private IDictionary<string, object> dict = null;

            public ExpandoMetaObject(ExpandoObject expando, Expression express)
                : base(express, BindingRestrictions.Empty, expando)
            {
                dict = expando._dict;
            }

            public override DynamicMetaObject BindGetMember(GetMemberBinder binder)
            {
                return InvokeMember(binder.Name, get);
            }

            public override DynamicMetaObject BindSetMember(SetMemberBinder binder, DynamicMetaObject value)
            {
                return InvokeMember(binder.Name, set, value.Value);
            }

            private DynamicMetaObject InvokeMember(string key, MethodInfo met, params object[] values)
            {
                object args = null; if (met == invoke) args = values; else if (values != null && values.Length > 0) args = values[0];
                return new DynamicMetaObject(Expression.Call(Expression.Constant(this), met,
                    Expression.Constant(key, typeof(string)),
                    Expression.Convert(Expression.Constant(args), typeof(object))),
                    BindingRestrictions.GetTypeRestriction(base.Expression, base.LimitType));
            }

            public override DynamicMetaObject BindInvokeMember(InvokeMemberBinder binder, DynamicMetaObject[] args)
            {
                object[] s = new object[args.Length];
                for (int i = 0; i < s.Length; i++)
                {
                    s[i] = args[i].Value;
                }
                return InvokeMember(binder.Name, invoke, s);
            }

            private object Invoke(string key, object values)
            {
                object obj = null;
                lock (this)
                {
                    if (dict.ContainsKey(key))
                    {
                        obj = dict[key];
                    }
                }
                Delegate d = obj as Delegate;
                if (d == null)
                {
                    throw new MethodAccessException();
                }
                return d.DynamicInvoke(values as object[]);
            }

            public override IEnumerable<string> GetDynamicMemberNames()
            {
                lock (dict)
                {
                    return dict.Keys;
                }
            }

            private object Get(string key, object value)
            {
                lock (dict)
                {
                    if (!dict.ContainsKey(key))
                    {
                        throw new MemberAccessException(key);
                    }
                    return dict[key];
                }
            }

            private object Set(string key, object value)
            {
                lock (dict)
                {
                    if (dict.ContainsKey(key))
                    {
                        dict[key] = value;
                    }
                    else
                    {
                        dict.Add(key, value);
                    }
                }
                return null;
            }
        }

        DynamicMetaObject IDynamicMetaObjectProvider.GetMetaObject(Expression express)
        {
            return new ExpandoMetaObject(this, express);
        }

        IEnumerator IEnumerable.GetEnumerator()
        {
            foreach (string key in this)
            {
                yield return key;
            }
        }

        IEnumerator<string> IEnumerable<string>.GetEnumerator()
        {
            lock (_dict)
            {
                var keys = _dict.Keys;
                return keys.GetEnumerator();
            }
        }
    }
}