实现.net下的动态代理(续)多对象Mixin

实现.net下的动态代理 一文使用动态代理实现了 Ducking Typing，解决了文中的第一个问题，下面，向第二个问题进军——mixin。

一、应用场景

(1) 假定有一个接口TInterface，一个类B，类C。类B与类C分别实现了部分TInterface：

 1    public interface TInterface
 2    {
 3        String A { get; }
 4        String B(int a, int b);
 5    }
 6
 7    public class ClassB
 8    {
 9        public String A
        {
            get
            {
                return String.Empty;
            }
            set
            { }
        }
    }

    public class ClassC
    {
        public String B(int a, int b)
        {
            return (a + b).ToString();
        }
    }

假设b和c分别是B和C的一个实例，通过 TypeTemplate.Create<TInterface>(b,c) 方法将b和c包装一下，即可生成一个TInterface实例：

            ClassB b = new ClassB();
            ClassC c = new ClassC();
            TInterface i2 = TypeTemplate.Create<TInterface>(b, c);

(2) 通过Mixin，我们还可以在运行时动态替换接口的指定方法或属性：

 1    public interface Human
 2    {
 3        String Heart();
 4        String Lung();
 5        String Name();
 6    }
 7
 8    public class ZhouBapi : Human
 9    {
        public String Heart() { return "好心"; }
        public String Lung() { return "好肺"; }
        public String Name() { return "周扒皮"; }
    }

    public class Huaidan
    {
        public String Heart() { return "狼心"; }
        public String Lung() { return "狗肺"; }
    }

    class Program
    {
        static void Show(Human body)
        {
            Console.WriteLine(String.Format("我叫{0}，我是{1}{2}", body.Name(), body.Heart(), body.Lung()));
        }

        static void ShowHuaidan(Human body)
        {
            Console.WriteLine(String.Format("{0}，我看你是{1}{2}", body.Name(), body.Heart(), body.Lung()));
        }

        static void Main(string[] args)
        {
            Human zhou = new ZhouBapi();
            Console.Write("周扒皮: ");
            Show(zhou);
            zhou = TypeTemplate.Create<Human>(new Huaidan(), zhou);
            Console.Write("人民群众:");
            ShowHuaidan(zhou);
            Console.Read();
        }
    }

输出为：

周扒皮: 我叫周扒皮，我是好心好肺
人民群众:周扒皮，我看你是狼心狗肺

二、实现

以下是详细实现代码：

  1using System;
  2using System.Collections.Generic;
  3using System.Text;
  4using System.Reflection;
  5using System.Reflection.Emit;
  6
  7namespace Orc.Generics
  8{
  9    public sealed class TypeTemplate
 10    {
 11        public class ObjectContainer
 12        {
 13            private List<Object> Container = new List<object>();
 14            private List<Type> TypeContainer = new List<Type>();
 15
 16            public ObjectContainer(Object[] objs, Type[] tlist)
 17            {
 18                Container.AddRange(objs);
 19                TypeContainer.AddRange(tlist);
 20            }
 21
 22            public Object Get(Int32 index)
 23            {
 24                if (index >= 0 && index < Container.Count)
 25                    return Container[index];
 26                else
 27                    return null;
 28            }
 29
 30            public Type GetType(Int32 index)
 31            {
 32                if (index >= 0 && index < TypeContainer.Count)
 33                    return TypeContainer[index];
 34                else
 35                    return null;
 36            }
 37
 38            public static MethodInfo GetGetMethodInfo()
 39            {
 40                MethodInfo[] mis = typeof(ObjectContainer).GetMethods(BindingFlags.Public | BindingFlags.Instance);
 41                foreach (var mi in mis)
 42                {
 43                    if (mi.Name == "Get") return mi;
 44                }
 45                return null;
 46            }
 47        }
 48
 49        private class MethodInfoHolder
 50        {
 51            public Int32 ObjectIndex { get; private set; }
 52            public MethodInfo MethodInfo { get; private set; }
 53            public Type ObjectType { get; private set; }
 54            public MethodInfoHolder(MethodInfo pi, Int32 index, Type type)
 55            {
 56                MethodInfo = pi;
 57                ObjectIndex = index;
 58                ObjectType = type;
 59            }
 60        }
 61
 62        public delegate void Handler<TImple>(TImple imple) where TImple: class;
 63
 64        public static TInterface Create<TInterface, TImple>(TImple instance) 
 65            where TInterface : class
 66            where TImple : class
 67        {
 68            Type type = DynamicTypeGen<TInterface>( new Object[] { instance }, new Type[] { instance.GetType()});
 69            return Activator.CreateInstance(type, new ObjectContainer(new Object[] { instance }, new Type[] { instance.GetType() })) as TInterface;
 70        }
 71
 72        public static TInterface Create<TInterface>(params Object[] impleInstances)
 73            where TInterface : class
 74        {
 75            List<Type> tlist = new List<Type>();
 76            foreach (var item in impleInstances)
 77            {
 78                tlist.Add(item.GetType());
 79            }
 80            Type type = DynamicTypeGen<TInterface>(impleInstances, tlist.ToArray());
 81            return Activator.CreateInstance(type, new ObjectContainer( impleInstances, tlist.ToArray())) as TInterface;
 82        }
 83
 84        public static TInterface CreateIntercepted<TInterface, TImple>(TImple instance, Handler<TImple> before, Handler<TImple> after)
 85            where TInterface : class
 86            where TImple : class
 87        {
 88            throw new NotImplementedException();
 89        }
 90
 91        public static Type DynamicTypeGen<TInterface>(Object[] instances, Type[] typeList)
 92            where TInterface: class
 93        {
 94            Type tInterface = typeof(TInterface);
 95
 96            PropertyInfo[] pisInterface = tInterface.GetProperties(BindingFlags.Public | BindingFlags.Instance);
 97            MethodInfo[] misInterface = tInterface.GetMethods(BindingFlags.Public | BindingFlags.Instance);
 98            List<MethodInfo> misInterfaceList = new List<MethodInfo>();
 99            
            List<Type> tList = new List<Type>();
            foreach (var obj in instances)
            {
                tList.Add(obj.GetType());
            }

            Type[] tArray = tList.ToArray();

            foreach (var item in misInterface)
            {
                if (item.IsSpecialName == false) misInterfaceList.Add(item);
            }

            List<MethodInfoHolder> miHolderList = new List<MethodInfoHolder>();
            for (int i = 0; i < tArray.Length; i++)
            {
                MethodInfo[] misImple = tArray[i].GetMethods(BindingFlags.Public | BindingFlags.Instance);
                foreach (var item in misImple)
                {
                    MethodInfoHolder h = new MethodInfoHolder(item, i, typeList[i]);
                    miHolderList.Add(h);
                }
            }

            AssemblyName aName = new AssemblyName("Orc.Generics.DynamicTypes");
            AssemblyBuilder ab =
                AppDomain.CurrentDomain.DefineDynamicAssembly(
                    aName,
                    AssemblyBuilderAccess.RunAndSave);
            
            ModuleBuilder mb =
                ab.DefineDynamicModule(aName.Name, aName.Name + ".dll");

            TypeBuilder tb = mb.DefineType(GetDynamicTypeName<TInterface>(instances),
                TypeAttributes.Public, null, new Type[] { tInterface });
            FieldBuilder fbInstances = tb.DefineField(
                "_container",
                typeof(TypeTemplate.ObjectContainer),
                FieldAttributes.Private);

            ConstructorBuilder ctor1 = tb.DefineConstructor(
                MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.RTSpecialName,
                CallingConventions.Standard,
                new Type[1] { typeof(TypeTemplate.ObjectContainer) });

            ILGenerator ctor1IL = ctor1.GetILGenerator();
            ctor1IL.Emit(OpCodes.Ldarg_0);
            ctor1IL.Emit(OpCodes.Call, typeof(object).GetConstructor(Type.EmptyTypes));
            ctor1IL.Emit(OpCodes.Ldarg_0);
            ctor1IL.Emit(OpCodes.Ldarg_1);
            ctor1IL.Emit(OpCodes.Stfld, fbInstances);
            ctor1IL.Emit(OpCodes.Ret);

            foreach (var item in pisInterface)
            {
                MethodInfoHolder getMi = FindGetMethodInfo(miHolderList, item);
                MethodInfoHolder setMi = FindSetMethodInfo(miHolderList, item);
                CreateProperty(tb, fbInstances, item, getMi, setMi);
            }

            foreach (var item in misInterfaceList)
            {
                MethodInfoHolder instanceMi = FindMethodInfo(miHolderList, item);
                CreateMethod(tb, fbInstances, item, instanceMi);
            }
            Type type = tb.CreateType();
            ab.Save(aName.Name + ".dll");
            return type;
        }

        private static MethodInfoHolder FindGetMethodInfo(IEnumerable<MethodInfoHolder> miList, PropertyInfo pi)
        {
            foreach (var item in miList)
            {
                if (item.MethodInfo.Name.Equals("get_" + pi.Name) && item.MethodInfo.IsSpecialName) return item;
            }

            return null;
        }

        private static MethodInfoHolder FindSetMethodInfo(IEnumerable<MethodInfoHolder> miList, PropertyInfo pi)
        {
            foreach (var item in miList)
            {
                if (item.MethodInfo.Name.Equals("set_" + pi.Name) && item.MethodInfo.IsSpecialName) return item;
            }
            
            return null;
        }

        private static MethodInfoHolder FindMethodInfo(IEnumerable<MethodInfoHolder> miList, MethodInfo mi)
        {
            foreach (var item in miList)
            {
                if (MethodInfoEqual(item.MethodInfo,mi)) return item;
            }

            return null;
        }

        private static Boolean MethodInfoEqual(MethodInfo mi1, MethodInfo mi2)
        {
            if (mi1.IsSpecialName == true || mi2.IsSpecialName == true) return false;
            if (mi1.Name != mi2.Name) return false;
            if (mi1.ReturnType != mi2.ReturnType) return false;
            ParameterInfo[] pis1 = mi1.GetParameters();
            ParameterInfo[] pis2 = mi2.GetParameters();
            if (pis1.Length != pis2.Length) return false;
            for (int i = 0; i < pis1.Length; i++)
            {
                ParameterInfo pi1 = pis1[i];
                ParameterInfo pi2 = pis2[i];
                if (pi1.ParameterType != pi2.ParameterType) return false;
            }
            return true;
        }

        private static void CreateProperty(TypeBuilder tb, FieldBuilder fbInstance, PropertyInfo pi, MethodInfoHolder getMi, MethodInfoHolder setMi)
        {
            String name = pi.Name;
            Type type = pi.PropertyType;

            PropertyBuilder pb = tb.DefineProperty(
                name,
                PropertyAttributes.HasDefault,
                type,
                null);

            MethodAttributes getSetAttr = MethodAttributes.Public |
                MethodAttributes.SpecialName | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final ;
            MethodBuilder mbGetAccessor = tb.DefineMethod(
                "get_" + name,
                getSetAttr,
                type,
                Type.EmptyTypes);

            ILGenerator getIL = mbGetAccessor.GetILGenerator();
            
            if (getMi == null)
            {
                getIL.Emit(OpCodes.Newobj, typeof(NotImplementedException).GetConstructor(new Type[]{}));
                getIL.Emit(OpCodes.Throw);
            }
            else
            {
                getIL.Emit(OpCodes.Ldarg_0);
                getIL.Emit(OpCodes.Ldfld, fbInstance);
                getIL.Emit(OpCodes.Ldc_I4, getMi.ObjectIndex);
                getIL.Emit(OpCodes.Callvirt, ObjectContainer.GetGetMethodInfo());
                getIL.Emit(OpCodes.Isinst, getMi.ObjectType);
                getIL.Emit(OpCodes.Callvirt, getMi.MethodInfo);
                getIL.Emit(OpCodes.Ret);
            }

            MethodBuilder mbSetAccessor = tb.DefineMethod(
                "set_"+ name,
                getSetAttr,
                null,
                new Type[] { type });

            ILGenerator setIL = mbSetAccessor.GetILGenerator();
            if (setMi == null)
            {
                setIL.Emit(OpCodes.Newobj, typeof(NotImplementedException).GetConstructor(new Type[] { }));
                setIL.Emit(OpCodes.Throw);
            }
            else
            {
                setIL.Emit(OpCodes.Ldarg_0);
                setIL.Emit(OpCodes.Ldfld, fbInstance);
                setIL.Emit(OpCodes.Ldc_I4, setMi.ObjectIndex);
                setIL.Emit(OpCodes.Callvirt, ObjectContainer.GetGetMethodInfo());
                setIL.Emit(OpCodes.Isinst, setMi.ObjectType);
                setIL.Emit(OpCodes.Ldarg_1);
                setIL.Emit(OpCodes.Callvirt, setMi.MethodInfo);
                setIL.Emit(OpCodes.Ret);
            }

            pb.SetGetMethod(mbGetAccessor);
            pb.SetSetMethod(mbSetAccessor);
        }

        private static void CreateMethod(TypeBuilder tb, FieldBuilder fbInstance, MethodInfo mi, MethodInfoHolder instanceMi)
        {
            List<Type> paramTyleList = new List<Type>();
            foreach(var item in mi.GetParameters())
                paramTyleList.Add(item.ParameterType);

            MethodBuilder mb = tb.DefineMethod(
              mi.Name,
              MethodAttributes.Public | MethodAttributes.HideBySig | MethodAttributes.NewSlot | MethodAttributes.Virtual | MethodAttributes.Final,
              mi.ReturnType,
              paramTyleList.ToArray());

            ILGenerator il = mb.GetILGenerator();
            if (instanceMi == null)
            {
                il.Emit(OpCodes.Newobj, typeof(NotImplementedException).GetConstructor(new Type[] { }));
                il.Emit(OpCodes.Throw);
            }
            else
            {
                il.Emit(OpCodes.Ldarg_0);
                il.Emit(OpCodes.Ldfld, fbInstance);
                il.Emit(OpCodes.Ldc_I4, instanceMi.ObjectIndex);
                il.Emit(OpCodes.Callvirt, ObjectContainer.GetGetMethodInfo());
                il.Emit(OpCodes.Isinst, instanceMi.ObjectType);
                switch (paramTyleList.Count)
                {
                    case 0:
                        break;
                    case 1:
                        il.Emit(OpCodes.Ldarg_1);
                        break;
                    case 2:
                        il.Emit(OpCodes.Ldarg_1);
                        il.Emit(OpCodes.Ldarg_2);
                        break;
                    case 3:
                        il.Emit(OpCodes.Ldarg_1);
                        il.Emit(OpCodes.Ldarg_2);
                        il.Emit(OpCodes.Ldarg_3);
                        break;
                    default:
                        il.Emit(OpCodes.Ldarg_1);
                        il.Emit(OpCodes.Ldarg_2);
                        il.Emit(OpCodes.Ldarg_3);

                        Int32 sCount = Math.Min(paramTyleList.Count, 127);
                        for (int i = 4; i <= sCount; i++)
                        {
                            il.Emit(OpCodes.Ldarg_S, i);
                        }

                        for (int i = 128; i <= paramTyleList.Count; i++)
                        {
                            il.Emit(OpCodes.Ldarg, i);
                        }

                        break;
                }

                il.Emit(OpCodes.Callvirt, instanceMi.MethodInfo);
                il.Emit(OpCodes.Ret);
            }
        }

        private static String GetDynamicTypeName<TInterface>(params Object[] instances)
    where TInterface : class
        {
            StringBuilder sb = new StringBuilder();
            sb.Append("_DynamicTypes");
            sb.Append(typeof(TInterface).ToString());
            foreach (var obj in instances)
            {
                sb.Append("_");
                sb.Append(obj.GetType().ToString());
            }
            return sb.ToString();
        }
    }

    public interface TInterface
    {
        String A { get; }
        String B(int a, int b);
    }

    public class ClassB
    {
        public String A
        {
            get
            {
                return String.Empty;
            }
            set
            { }
        }
    }

    public class ClassC
    {
        public String B(int a, int b)
        {
            return (a + b).ToString();
        }
    }

    public class ClassA
    {
        public String A 
        {
            get
            {
                return String.Empty;
            }
            set
            { }
        }

        public String B(int a, int b)
        {
            return (a+b).ToString();
        }
    }

    public class InterfaceImple_ClassA : TInterface
    {
        private TypeTemplate.ObjectContainer __container;

        public InterfaceImple_ClassA(TypeTemplate.ObjectContainer container)
        {
            __container = container;
        }

        public String A
        {
            get { return (__container.Get(1) as ClassA).A; }
            set { (__container.Get(1) as ClassA).A = value; }
        }

        public String B(int a, int b)
        {
            return (__container.Get(1) as ClassA).B(a, b);
        }
    }

    public class InterfaceImple_ClassA_Factory
    {
        public readonly String Name = "InterfaceImple_ClassA_Factory";
        public InterfaceImple_ClassA Create(ClassA a)
        {
            return null;
            // return new InterfaceImple_ClassA(new Object[] {a});
        }
    }
}

测试代码：

 1        [TestMethod]
 2        public void TestCreate()
 3        {
 4            ClassA a = new ClassA();
 5            TInterface i1 = TypeTemplate.Create<TInterface, ClassA>(a);
 6            Assert.AreNotEqual(null, i1);
 7            Assert.AreEqual("3", i1.B(1, 2));
 8            Assert.AreEqual(String.Empty, i1.A);
 9
            ClassB b = new ClassB();
            ClassC c = new ClassC();
            TInterface i2 = TypeTemplate.Create<TInterface>(b, c);
            Assert.AreNotEqual(null, i2);
            Assert.AreEqual("3", i2.B(1, 2));
            Assert.AreEqual(String.Empty, i2.A);
        }

三、说明：

（1）通过上述方法可以很方便的创建对现有实例的Wrapper，使其适应一个新的接口；

（2）TypeTemplate.Create<TInterface>(params Object[] impleInstances) 排位在前的 impleInstance 的接口方法/属性将掩盖它后面的 impleInstance 的接口方法/属性，这样可以在运行时动态改变接口的行为。

（3）这种MixIn方案比不上动态语言的MixIn，主要是必须要有一个interface，才能MixIn。如果能将interface也根据被代理的对象的行为动态生成，那就很爽了。怎么实现，是一个问题。