public static IProducer GetOrCreateDefaultProducer(Type type) { IProducer producer; AccessorMgr.m_defaultCtors.TryGetValue(type, out producer); return(AccessorMgr.CreateDefaultCtor(type)); }
private static Dictionary <MemberInfo, IGetterSetter> CreateAccessors(Type type) { Dictionary <MemberInfo, IGetterSetter> dictionary = new Dictionary <MemberInfo, IGetterSetter>(); MemberInfo[] members = type.GetMembers(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic); ModuleBuilder module1 = AccessorMgr.GetOrCreateModule(); foreach (MemberInfo key in members) { if (((DontCopyAttribute[])key.GetCustomAttributes(typeof(DontCopyAttribute), false)).Length == 0) { IGetterSetter module2; if (key.MemberType == MemberTypes.Property) { module2 = AccessorMgr.AddToModule(module1, (PropertyInfo)key); } else if (key.MemberType == MemberTypes.Field) { module2 = AccessorMgr.AddToModule(module1, (FieldInfo)key); } else { continue; } dictionary.Add(key, module2); } } return(dictionary); }
internal static IProducer AddToModule(ModuleBuilder module, ConstructorInfo ctor) { if (ctor.DeclaringType.IsValueType) { throw new ArgumentException("Cannot emit Constructors of value-types (yet): " + (object)ctor.DeclaringType); } Type declaringType = ctor.DeclaringType; string str = AccessorMgr.NextTypeName(ctor.GetFullMemberName()); TypeBuilder typeBuilder = module.DefineType(str, TypeAttributes.Public); typeBuilder.AddInterfaceImplementation(typeof(IProducer)); Type[] parameterTypes = new Type[0]; Type returnType = typeof(object); ILGenerator ilGenerator = typeBuilder.DefineMethod("Produce", MethodAttributes.Public | MethodAttributes.Virtual, returnType, parameterTypes).GetILGenerator(); ilGenerator.DeclareLocal(declaringType); ilGenerator.Emit(OpCodes.Newobj, ctor); ilGenerator.Emit(OpCodes.Stloc_0); ilGenerator.Emit(OpCodes.Ldloc_0); ilGenerator.Emit(OpCodes.Ret); typeBuilder.CreateType(); IProducer instance = module.Assembly.CreateInstance(str) as IProducer; if (instance == null) { throw new Exception("Unable to create producer."); } return(instance); }
public static ModuleBuilder GetOrCreateModule() { if ((Module)AccessorMgr._module == (Module)null) { AccessorMgr._module = AccessorMgr.CreateModule(); } return(AccessorMgr._module); }
private static IProducer CreateDefaultCtor(Type type) { IProducer module = AccessorMgr.AddToModule(AccessorMgr.GetOrCreateModule(), type.GetConstructor(new Type[0])); AccessorMgr.m_defaultCtors.Add(type, module); return(module); }
public static Dictionary <MemberInfo, IGetterSetter> GetOrCreateAccessors(Type type) { Dictionary <MemberInfo, IGetterSetter> accessors; if (!AccessorMgr.m_accessors.TryGetValue(type, out accessors)) { AccessorMgr.m_accessors.Add(type, accessors = AccessorMgr.CreateAccessors(type)); } return(accessors); }
/// <summary> /// Copies all public properties that have a setter and a getter and exist in the types of both objects from input to output. /// Ignores all properties that have the <see cref="T:WCell.Util.DynamicAccess.DontCopyAttribute" />. /// </summary> /// <returns></returns> public static IGetterSetter GetOrCreateAccessor(Type type, PropertyInfo info) { IGetterSetter getterSetter; if (!AccessorMgr.GetOrCreateAccessors(type).TryGetValue((MemberInfo)info, out getterSetter)) { throw new Exception("Tried to get accessor for invalid Property: " + (object)info); } return(getterSetter); }
public static IGetterSetter AddToModule(ModuleBuilder module, FieldInfo field) { string str = AccessorMgr.NextTypeName(field.GetFullMemberName()); Type declaringType = field.DeclaringType; Type fieldType = field.FieldType; TypeBuilder typeBuilder = module.DefineType(str, TypeAttributes.Public); typeBuilder.AddInterfaceImplementation(typeof(IGetterSetter)); Type[] parameterTypes1 = new Type[1] { typeof(object) }; Type returnType = typeof(object); ILGenerator ilGenerator1 = typeBuilder.DefineMethod("Get", MethodAttributes.Public | MethodAttributes.Virtual, returnType, parameterTypes1).GetILGenerator(); ilGenerator1.DeclareLocal(typeof(object)); ilGenerator1.Emit(OpCodes.Ldarg_1); ilGenerator1.Emit(OpCodes.Castclass, declaringType); ilGenerator1.Emit(OpCodes.Ldfld, field); if (fieldType.IsValueType) { ilGenerator1.Emit(OpCodes.Box, fieldType); } ilGenerator1.Emit(OpCodes.Stloc_0); ilGenerator1.Emit(OpCodes.Ldloc_0); ilGenerator1.Emit(OpCodes.Ret); Type[] parameterTypes2 = new Type[2] { typeof(object), typeof(object) }; ILGenerator ilGenerator2 = typeBuilder.DefineMethod("Set", MethodAttributes.Public | MethodAttributes.Virtual, (Type)null, parameterTypes2).GetILGenerator(); ilGenerator2.DeclareLocal(fieldType); ilGenerator2.Emit(OpCodes.Ldarg_1); ilGenerator2.Emit(OpCodes.Castclass, declaringType); ilGenerator2.Emit(OpCodes.Ldarg_2); if (fieldType.IsValueType) { ilGenerator2.Emit(OpCodes.Unbox_Any, fieldType); } ilGenerator2.Emit(OpCodes.Stfld, field); ilGenerator2.Emit(OpCodes.Ret); typeBuilder.CreateType(); IGetterSetter instance = module.Assembly.CreateInstance(str) as IGetterSetter; if (instance == null) { throw new Exception("Unable to create Field accessor."); } return(instance); }
private static void Test() { AccessorMgr.X x1 = new AccessorMgr.X(); FieldInfo field = x1.GetType().GetField("a"); ConstructorInfo constructor = x1.GetType().GetConstructor(new Type[0]); AccessorMgr.EmitAssembly(field); IProducer producer = AccessorMgr.EmitAssembly(constructor); AccessorMgr.X x2; Utility.Measure("Create object", 2000000, (Action)(() => x2 = new AccessorMgr.X())); AccessorMgr.X x3; Utility.Measure("Dynamically create object", 2000000, (Action)(() => x3 = (AccessorMgr.X)producer.Produce())); Utility.Measure("Create object through reflection", 2000000, (Action)(() => Activator.CreateInstance <AccessorMgr.X>())); }
public static Dictionary <MemberInfo, IGetterSetter> GetOrCreateAccessors <T>() { return(AccessorMgr.GetOrCreateAccessors(typeof(T))); }
public static IGetterSetter AddToModule(ModuleBuilder module, PropertyInfo prop) { string str = AccessorMgr.NextTypeName(prop.GetFullMemberName()); Type declaringType = prop.DeclaringType; TypeBuilder typeBuilder = module.DefineType(str, TypeAttributes.Public); typeBuilder.AddInterfaceImplementation(typeof(IGetterSetter)); Type[] parameterTypes1 = new Type[1] { typeof(object) }; Type returnType1 = typeof(object); ILGenerator ilGenerator1 = typeBuilder.DefineMethod("Get", MethodAttributes.Public | MethodAttributes.Virtual, returnType1, parameterTypes1).GetILGenerator(); MethodInfo getMethod = prop.GetGetMethod(); if (getMethod != (MethodInfo)null) { ilGenerator1.DeclareLocal(typeof(object)); ilGenerator1.Emit(OpCodes.Ldarg_1); ilGenerator1.Emit(OpCodes.Castclass, declaringType); ilGenerator1.EmitCall(OpCodes.Call, getMethod, (Type[])null); if (getMethod.ReturnType.IsValueType) { ilGenerator1.Emit(OpCodes.Box, getMethod.ReturnType); } ilGenerator1.Emit(OpCodes.Stloc_0); ilGenerator1.Emit(OpCodes.Ldloc_0); } else { ilGenerator1.ThrowException(typeof(MissingMethodException)); } ilGenerator1.Emit(OpCodes.Ret); Type[] parameterTypes2 = new Type[2] { typeof(object), typeof(object) }; Type returnType2 = (Type)null; ILGenerator ilGenerator2 = typeBuilder.DefineMethod("Set", MethodAttributes.Public | MethodAttributes.Virtual, returnType2, parameterTypes2).GetILGenerator(); MethodInfo setMethod = prop.GetSetMethod(); if (setMethod != (MethodInfo)null) { Type parameterType = setMethod.GetParameters()[0].ParameterType; ilGenerator2.DeclareLocal(parameterType); ilGenerator2.Emit(OpCodes.Ldarg_1); ilGenerator2.Emit(OpCodes.Castclass, declaringType); ilGenerator2.Emit(OpCodes.Ldarg_2); if (parameterType.IsValueType) { ilGenerator2.Emit(OpCodes.Unbox, parameterType); OpCode opcode; if (AccessorMgr.PropTypesHashes.TryGetValue(parameterType, out opcode)) { ilGenerator2.Emit(opcode); } else { ilGenerator2.Emit(OpCodes.Ldobj, parameterType); } } else { ilGenerator2.Emit(OpCodes.Castclass, parameterType); } ilGenerator2.EmitCall(OpCodes.Callvirt, setMethod, (Type[])null); } else { ilGenerator2.ThrowException(typeof(MissingMethodException)); } ilGenerator2.Emit(OpCodes.Ret); typeBuilder.CreateType(); IGetterSetter instance = module.Assembly.CreateInstance(str) as IGetterSetter; if (instance == null) { throw new Exception("Unable to create property accessor for \"" + (object)prop + "\" of type: " + prop.DeclaringType.FullName); } return(instance); }
private static IProducer EmitAssembly(ConstructorInfo ctor) { return(AccessorMgr.AddToModule(AccessorMgr.GetOrCreateModule(), ctor)); }
private static IGetterSetter EmitAssembly(FieldInfo field) { return(AccessorMgr.AddToModule(AccessorMgr.GetOrCreateModule(), field)); }