ILGenerator.Emit动态 MSIL编程(三)之动态代理

  using System;

    using System.Linq;

    using System.Reflection;

    using System.Reflection.Emit;



    public sealed class DynamicProxy

    {

        private static readonly string AssemblyName = "DynamicProxy", 

                                       ModuleName = "DynamicProxy", 

                                       TypeName = "DynamicProxy";

        private AssemblyBuilder CreateDynamicAssembly<T>() where T : class

        {

            return AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName(AssemblyName + typeof(T).Name),

                AssemblyBuilderAccess.Run);

        }

        private ModuleBuilder CreateDynamicModule<T>() where T : class

        {

            return CreateDynamicAssembly<T>().DefineDynamicModule(ModuleName + typeof(T).Name);

        }

        /// <summary>

        /// 创建动态代理

        /// </summary>

        public T CreateDynamicType<T>() where T : class,new()

        {

            TypeBuilder typeBuilder = CreateDynamicModule<T>().DefineType(TypeName + typeof(T).Name, TypeAttributes.Public | 

                TypeAttributes.Class, typeof(T));

            TypeActuator<T>(typeBuilder);

            return Activator.CreateInstance(typeBuilder.CreateType()) as T;

        }

        private void BuildCtorMethod(Type classType, FieldBuilder fieldBuilder, TypeBuilder typeBuilder)

        {

            var structureBuilder = typeBuilder.DefineConstructor(MethodAttributes.Public, CallingConventions.Standard,null);

            var ilCtor = structureBuilder.GetILGenerator();

            ilCtor.Emit(OpCodes.Ldarg_0);

            ilCtor.Emit(OpCodes.Newobj, classType.GetConstructor(Type.EmptyTypes));

            ilCtor.Emit(OpCodes.Stfld, fieldBuilder);

            ilCtor.Emit(OpCodes.Ret);

        }

        private void BuildMethod(ILGenerator il, MethodInfo methodInfo, Type[] ParameterTypes)

        {

            il.Emit(OpCodes.Ldarg_0);

            for (int i = 0; i < ParameterTypes.Length; i++)

                il.Emit(OpCodes.Ldarg_S, (short)(i + 1));

            il.Emit(OpCodes.Call, methodInfo);

            il.Emit(OpCodes.Ret);

        }

        private void TypeActuator<T>(TypeBuilder builder) where T : class

        {

            FieldBuilder fieldBuilder = builder.DefineField("_DynamicProxyActuator", typeof(T), FieldAttributes.Private);

            BuildCtorMethod(typeof(T), fieldBuilder, builder);

            MethodInfo[] info = GetMethodInfo(typeof(T));

            foreach (MethodInfo methodInfo in info)

            {

                if (!methodInfo.IsVirtual && !methodInfo.IsAbstract) continue;

                if (methodInfo.Name == "ToString") continue;

                if (methodInfo.Name == "GetHashCode") continue;

                if (methodInfo.Name == "Equals") continue;

                var ParameterTypes = methodInfo.GetParameters().Select(p => p.ParameterType).ToArray();

                MethodBuilder methodBuilder = CreateMethod(builder, methodInfo.Name, MethodAttributes.Public | MethodAttributes.Virtual,

                    CallingConventions.Standard, methodInfo.ReturnType, ParameterTypes);

                var ilMethod = methodBuilder.GetILGenerator();

                BuildMethod(ilMethod, methodInfo, ParameterTypes);

            }

        }

        private MethodBuilder CreateMethod(TypeBuilder typeBuilder, string name, MethodAttributes attrs, CallingConventions callingConventions, 

            Type type, Type[] parameterTypes)

        {

            return typeBuilder.DefineMethod(name, attrs, callingConventions, type, parameterTypes);

        }

        private MethodInfo[] GetMethodInfo(Type type)

        {

            return type.GetMethods(BindingFlags.Public | BindingFlags.Instance);

        }

    }