public Type Build(AssemblyBuilderHelper assemblyBuilder) { if (assemblyBuilder == null) { throw new ArgumentNullException("assemblyBuilder"); } // Check InternalsVisibleToAttributes of the source type's assembly. // Even if the sourceType is public, it may have internal fields and props. // _friendlyAssembly = false; // Usually, there is no such attribute in the source assembly. // Therefore we do not cache the result. // var attributes = _originalType.Type.Assembly.GetCustomAttributes(typeof(InternalsVisibleToAttribute), true); foreach (InternalsVisibleToAttribute visibleToAttribute in attributes) { var an = new AssemblyName(visibleToAttribute.AssemblyName); if (AssemblyName.ReferenceMatchesDefinition(assemblyBuilder.AssemblyName, an)) { _friendlyAssembly = true; break; } } if (!_originalType.Type.IsVisible && !_friendlyAssembly) { return(typeof(ExprTypeAccessor <,>).MakeGenericType(_type, _originalType)); } var typeName = GetTypeName(); _typeBuilder = assemblyBuilder.DefineType(typeName, _accessorType); _typeBuilder.DefaultConstructor.Emitter .ldarg_0 .call(TypeHelper.GetDefaultConstructor(_accessorType)) ; BuildCreateInstanceMethods(); BuildTypeProperties(); BuildMembers(); BuildObjectFactory(); _typeBuilder.DefaultConstructor.Emitter .ret() ; var result = _typeBuilder.Create(); foreach (TypeBuilderHelper tb in _nestedTypes) { tb.Create(); } return(result); }
private static Type CreateResponseType(string typeName, Type returnType, AssemblyBuilderHelper assemblyBuilderHelper) { if (returnType == typeof(void)) { return(typeof(VoidResultResponse)); } var responseType = typeName + "Response"; var typeBuilderHelper = assemblyBuilderHelper.DefineType("Response." + responseType, typeof(Response)); var resultField = typeBuilderHelper.DefineField("result", returnType, FieldAttributes.Public); var constructorEmit = typeBuilderHelper.DefinePublicConstructor(returnType).Emitter; var defaulConstructor = typeof(Response).GetConstructor(Type.EmptyTypes); constructorEmit .ldarg_0 .call(defaulConstructor) .ldarg_0 .ldarg_1 .stfld(resultField) .ret(); constructorEmit = typeBuilderHelper.DefinePublicConstructor(Type.EmptyTypes).Emitter; constructorEmit .ldarg_0 .call(defaulConstructor) .ret(); var resultProperty = typeBuilderHelper.TypeBuilder.DefineProperty("Result", PropertyAttributes.None, returnType, new[] { returnType }); var getResultPropertyMethod = typeBuilderHelper.DefineMethod("get_Result", MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, returnType, Type.EmptyTypes); var getResultPropertyMethodEmit = getResultPropertyMethod.Emitter; getResultPropertyMethodEmit .ldarg_0 .ldfld(resultField) .ret(); var setResultPropertyMethod = typeBuilderHelper.DefineMethod("set_Result", MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, returnType); var setResultPropertyMethodEmit = setResultPropertyMethod.Emitter; setResultPropertyMethodEmit .ldarg_0 .ldarg_1 .stfld(resultField) .ret(); resultProperty.SetGetMethod(getResultPropertyMethod); resultProperty.SetSetMethod(setResultPropertyMethod); var getResultMethod = typeof(Response).GetMethod("GetResult"); var getResultMethodEmit = typeBuilderHelper.DefineMethod(getResultMethod).Emitter; getResultMethodEmit .ldarg_0 .ldfld(resultField) .boxIfValueType(returnType) .ret(); return(typeBuilderHelper.Create()); }
public Type Build(AssemblyBuilderHelper assemblyBuilder) { if (assemblyBuilder == null) throw new ArgumentNullException("assemblyBuilder"); // Check InternalsVisibleToAttributes of the source type's assembly. // Even if the sourceType is public, it may have internal fields and props. // _friendlyAssembly = false; // Usually, there is no such attribute in the source assembly. // Therefore we do not cache the result. // var attributes = _originalType.Type.Assembly.GetCustomAttributes(typeof(InternalsVisibleToAttribute), true); foreach (InternalsVisibleToAttribute visibleToAttribute in attributes) { var an = new AssemblyName(visibleToAttribute.AssemblyName); if (AssemblyName.ReferenceMatchesDefinition(assemblyBuilder.AssemblyName, an)) { _friendlyAssembly = true; break; } } if (!_originalType.Type.IsVisible && !_friendlyAssembly) return typeof (ExprTypeAccessor<,>).MakeGenericType(_type, _originalType); var typeName = GetTypeName(); _typeBuilder = assemblyBuilder.DefineType(typeName, _accessorType); _typeBuilder.DefaultConstructor.Emitter .ldarg_0 .call (TypeHelper.GetDefaultConstructor(_accessorType)) ; BuildCreateInstanceMethods(); BuildTypeProperties(); BuildMembers(); BuildObjectFactory(); _typeBuilder.DefaultConstructor.Emitter .ret() ; var result = _typeBuilder.Create(); foreach (TypeBuilderHelper tb in _nestedTypes) tb.Create(); return result; }
private static Type CreateRequestType(string typeName, ParameterInfo[] infos, AssemblyBuilderHelper assemblyBuilderHelper) { var requestTypeName = typeName + "Request"; var typeBuilderHelper = assemblyBuilderHelper.DefineType("Request." + requestTypeName, typeof(Request)); var requestDescriptionField = typeof(Request).GetField("requestDescription"); var fieldInfos = new FieldInfo[infos.Length]; var propertyInfos = new PropertyBuilder[infos.Length]; var constructorEmit = typeBuilderHelper.DefinePublicConstructor(Type.EmptyTypes).Emitter; var defaultConstructor = typeof(Request).GetConstructor(Type.EmptyTypes); constructorEmit .ldarg_0 .call(defaultConstructor) .ldarg_0 .ldstr(typeName) .stfld(requestDescriptionField) .ret(); for (var i = 0; i < infos.Length; i++) { fieldInfos[i] = typeBuilderHelper.DefineField(infos[i].Name, infos[i].ParameterType, FieldAttributes.Public); var propertyName = char.IsLower(infos[i].Name[0]) ? char.ToUpper(infos[i].Name[0]) + infos[i].Name.Substring(1) : infos[i].Name + "_"; propertyInfos[i] = typeBuilderHelper.TypeBuilder.DefineProperty(propertyName, PropertyAttributes.None, infos[i].ParameterType, new[] { infos[i].ParameterType }); var getPropertyMethod = typeBuilderHelper.DefineMethod("get_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, infos[i].ParameterType, Type.EmptyTypes); var getPropertyMethodEmit = getPropertyMethod.Emitter; getPropertyMethodEmit .ldarg_0 .ldfld(fieldInfos[i]) .ret(); var setPropertyMethod = typeBuilderHelper.DefineMethod("set_" + propertyName, MethodAttributes.Public | MethodAttributes.SpecialName | MethodAttributes.HideBySig, null, infos[i].ParameterType); var setPropertyMethodEmit = setPropertyMethod.Emitter; setPropertyMethodEmit .ldarg_0 .ldarg_1 .stfld(fieldInfos[i]) .ret(); propertyInfos[i].SetGetMethod(getPropertyMethod); propertyInfos[i].SetSetMethod(setPropertyMethod); } return(typeBuilderHelper.Create()); }
private IDbFunctionHelper CreateDbFunctionHelper(Type type) { var typeBuilderHelper = assemblyBuilderHelper.DefineType(type.Name + "Helper", typeof(object), typeof(IDbFunctionHelper)); CreateProperty(typeBuilderHelper); CreateUpdateFunction(type, typeBuilderHelper); CreateInsertFunction(type, typeBuilderHelper); CreateReadObjectFunction(type, typeBuilderHelper); var desType = typeBuilderHelper.Create(); var result = (IDbFunctionHelper)Activator.CreateInstance(desType); result.DbObjectContainer = dbObjectContainer; return(result); }
public Materializer <T> CreateMaterializer <T>() { var baseType = typeof(Materializer <T>); var localType = TypeCache.Get <T>(); var emptyArgsArray = new Type[] {}; var typeBuilderHelper = AssemblyBuilder.DefineType(localType.Type.Name + "Materializer", baseType); //constructor typeBuilderHelper.DefaultConstructor.Emitter.ldarg_0.call(baseType.GetConstructor(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, emptyArgsArray, null)).ret(); //getobject impl var defineMethod = typeBuilderHelper.DefineMethod(baseType.GetMethod("GetObject")); var emitter = defineMethod.Emitter; var returnVar = emitter.DeclareLocal(localType.Type); //create new T emitter .newobj(localType.Type.GetConstructor(emptyArgsArray)) .stloc(returnVar); foreach (var propertyInfo in localType.Properties) { emitter = emitter .ldloc_0 .ldarg_0 .ldarg_1 .ldstr(propertyInfo.Name) .ldloc_0 .callvirt(propertyInfo.GetGetMethod()) .call(baseType.GetMethod("GetValue").MakeGenericMethod(propertyInfo.PropertyType)) .callvirt(propertyInfo.GetSetMethod()) .nop; } emitter .ldloc_0 .ret(); var type = typeBuilderHelper.Create(); AssemblyBuilder.Save(); return((Materializer <T>)Activator.CreateInstance(type)); }
public Type Build(AssemblyBuilderHelper assemblyBuilder) { _typeBuilder = assemblyBuilder.DefineType(GetTypeName(), typeof(DuckType), _interfaceType); if (!BuildMembers(_interfaceType)) { return(null); } foreach (Type t in _interfaceType.GetInterfaces()) { if (!BuildMembers(t)) { return(null); } } return(_typeBuilder.Create()); }
public static void CreateProxy(object service, AssemblyBuilderHelper assemblyBuilderHelper) { if (service == null) { throw new ArgumentNullException("Cannot create null proxy"); } var serviceType = service.GetType(); var proxyTypeName = serviceType.Namespace + "." + serviceType.Name + "Proxy"; var proxyType = assemblyBuilderHelper.DefineType(proxyTypeName, typeof(IProxy)); var serviceContainerField = typeof(IProxy).GetField("container", BindingFlags.Instance | BindingFlags.NonPublic); var poolField = typeof(IProxy).GetField("pool", BindingFlags.Instance | BindingFlags.NonPublic); var defaultConstructor = typeof(IProxy).GetConstructor(Type.EmptyTypes); var construtorEmit = proxyType.DefinePublicConstructor(typeof(ServiceContainer), typeof(SocketPool)).Emitter; construtorEmit .ldarg_0 .call(defaultConstructor) .ldarg_0 .ldarg_1 .stfld(serviceContainerField) .ldarg_0 .ldarg_2 .stfld(poolField) .ret(); var methods = serviceType.GetMethods(BindingFlags.Instance | BindingFlags.Public); for (var i = 0; i < methods.Length; i++) { var method = methods[i]; if (method.GetCustomAttributes(typeof(ServiceMethodAttribute), false).Length == 0) { continue; } var returnType = method.ReturnType; var requestTypeName = "Request." + serviceType.Name + "_" + method.Name + i + "Request"; var requestType = assemblyBuilderHelper.AssemblyBuilder.GetType(requestTypeName); if (requestType == null) { throw new ApplicationException("Cannot find request type: " + requestTypeName); } var responseTypeName = "Response." + serviceType.Name + "_" + method.Name + i + "Response"; var responseType = returnType != typeof(void) ? assemblyBuilderHelper.AssemblyBuilder.GetType(responseTypeName) : typeof(VoidResultResponse); if (responseType == null) { throw new ApplicationException("Cannot find response type: " + responseTypeName); } var paramInfos = method.GetParameters(); var synParamTypes = new Type[paramInfos.Length]; var asyncParamTypes = new Type[paramInfos.Length + 2]; asyncParamTypes[0] = typeof(WaitCallback); //callback function asyncParamTypes[1] = typeof(object); //context param for (var j = 0; j < synParamTypes.Length; j++) { synParamTypes[j] = paramInfos[j].ParameterType; asyncParamTypes[j + 2] = paramInfos[j].ParameterType; } //Generate synchronous proxy method var synchronousMethodEmit = synParamTypes.Length == 0 ? proxyType.DefineMethod(method.Name, MethodAttributes.Public, returnType, Type.EmptyTypes).Emitter : proxyType.DefineMethod(method.Name, MethodAttributes.Public, returnType, synParamTypes).Emitter; var syncRequestLocal = synchronousMethodEmit.DeclareLocal(requestType); synchronousMethodEmit .newobj(requestType) .stloc(syncRequestLocal); synchronousMethodEmit = synchronousMethodEmit.ldarg_0; for (var j = 1; j <= paramInfos.Length; j++) { synchronousMethodEmit .ldloc(syncRequestLocal) .ldarg(j) .stfld(requestType.GetField(paramInfos[j - 1].Name)); } if (returnType == typeof(void)) { synchronousMethodEmit .ldloc(syncRequestLocal) .call(typeof(IProxy).GetMethod("DoRequest", BindingFlags.Instance | BindingFlags.NonPublic)) .ret(); } else { var doRequestMethod = typeof(IProxy).GetMethod("RequestSync", BindingFlags.Instance | BindingFlags.NonPublic).MakeGenericMethod( returnType); synchronousMethodEmit .ldloc(syncRequestLocal) .call(doRequestMethod) .ret(); } //Generate asynchronous proxy method var asynchronousMethodEmit = proxyType.DefineMethod("Begin" + method.Name, MethodAttributes.Public, null, asyncParamTypes).Emitter; var asynRequestLocal = asynchronousMethodEmit.DeclareLocal(requestType); asynchronousMethodEmit .newobj(requestType) .stloc(asynRequestLocal); asynchronousMethodEmit = asynchronousMethodEmit.ldarg_0; for (var j = 1; j <= paramInfos.Length; j++) { asynchronousMethodEmit .ldloc(asynRequestLocal) .ldarg(j + 2) .stfld(requestType.GetField(paramInfos[j - 1].Name)); } asynchronousMethodEmit .ldloc(asynRequestLocal) .ldarg_1 .ldarg_2 .call(typeof(IProxy).GetMethod("BeginRequest", BindingFlags.Instance | BindingFlags.NonPublic)) .ret(); } proxyType.Create(); }
public static IExecutor CreateExecutor(object service, MethodInfo method, int methodIndex, AssemblyBuilderHelper assemblyBuilderHelper) { if (service == null) { throw new ArgumentNullException("Cannot create null executor"); } var type = service.GetType(); var typeName = type.Name + "_" + method.Name + methodIndex; var typeBuilderHelper = assemblyBuilderHelper.DefineType("Executor." + typeName, typeof(object), typeof(IExecutor)); var serviceFieldBuilder = typeBuilderHelper.DefineField(type.Name, type, FieldAttributes.Public); var emit = typeBuilderHelper.DefineMethod(typeof(IExecutor).GetMethod("Execute")).Emitter; var returnType = method.ReturnType; var paramInfos = method.GetParameters(); var requestType = CreateRequestType(typeName, paramInfos, assemblyBuilderHelper); var responseType = CreateResponseType(typeName, returnType, assemblyBuilderHelper); var getExecutorKeyEmit = typeBuilderHelper.DefineMethod(typeof(IExecutor).GetMethod("get_ExecutorKey")).Emitter; getExecutorKeyEmit .ldstr(typeName) .ret(); emit .ldarg_0 .ldfld(serviceFieldBuilder); for (var j = 0; j < paramInfos.Length; j++) { var paramInfo = paramInfos[j]; var fieldInfo = requestType.GetField(paramInfo.Name); emit = emit .ldarg_1 .ldfld(fieldInfo); } if (returnType != typeof(void)) { var resultLocal = emit.DeclareLocal(returnType); var responseLocal = emit.DeclareLocal(responseType); emit .call(method) .stloc(resultLocal) .newobj(responseType) .stloc(responseLocal) .ldloc(responseLocal) .ldloc(resultLocal) .stfld(responseType.GetField("result")) .ldloc(responseLocal) .ret(); } else { emit .call(method) .newobj(typeof(VoidResultResponse)) .ret(); } var executorType = typeBuilderHelper.Create(); var executor = (IExecutor)TypeAccessor.CreateInstance(executorType); var serviceField = executorType.GetField(type.Name); serviceField.SetValue(executor, service); return(executor); }
public static Type CreateType(Type type, AssemblyBuilderHelper assemblyBuilderHelper) { var typeName = type.Name; var typeNamespace = type.Namespace + ".Serializable"; var typeBuilderHelper = assemblyBuilderHelper.DefineType(typeNamespace + "." + typeName, type, typeof(ISerializable)); typeBuilderHelper.SetCustomAttribute(typeof(SerializableAttribute)); var constructorEmit = typeBuilderHelper.DefaultConstructor.Emitter; var defaultConstructor = type.GetConstructor(Type.EmptyTypes); constructorEmit .ldarg_0 .call(defaultConstructor) .ret(); constructorEmit = typeBuilderHelper.DefinePublicConstructor(type, typeof(IDictionary <object, ISerializable>)).Emitter; constructorEmit .ldarg_0 .call(defaultConstructor) .ldarg_2 .ldarg_1 .ldarg_0 .call(typeof(IDictionary <object, ISerializable>).GetMethod("Add", new[] { typeof(object), typeof(ISerializable) })); //Serialize var propperties = type.GetProperties(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic); var serializerEmit = typeBuilderHelper.DefineMethod(typeof(ISerializable).GetMethod("Serialize", new Type[] { typeof(BinaryWriter), typeof(IDictionary <object, int>), typeof(int) })).Emitter; var deserializeEmit = typeBuilderHelper.DefineMethod(typeof(ISerializable).GetMethod("Deserialize", new Type[] { typeof(BinaryReader), typeof(IDictionary <int, object>) })).Emitter; //Write type name so we can construct it again serializerEmit .ldarg_1 .ldstr(type.FullName + ", " + type.Assembly) .call(typeof(BinaryWriter).GetMethod("Write", new[] { typeof(string) })) //Add current object to the object graph .ldarg_2 .ldarg_0 .ldarg_3 .call(typeof(IDictionary <object, int>).GetMethod("Add", new[] { typeof(object), typeof(int) })) .ldarg_3 .ldc_i4_1 .add .starg(3); //Serialize/Deserialize properties foreach (var property in propperties) { var propertyType = property.PropertyType; if (property.GetCustomAttributes(typeof(NonSerializeAttribute), true).Length > 0 || !property.CanWrite || !property.CanRead) { continue; } if (propertyType.IsPrimitive || propertyType == typeof(string) || propertyType == typeof(DateTime) || propertyType == typeof(decimal)) { constructorEmit .ldarg_0 .ldarg_1 .call(property.GetGetMethod()) .call(property.GetSetMethod()); primitiveSerializeEmitter.Emit(property, ref serializerEmit, ref deserializeEmit); } else if (propertyType.IsArray) { var elementType = propertyType.GetElementType(); if (elementType.IsPrimitive || elementType == typeof(string) || elementType == typeof(DateTime) || elementType == typeof(decimal) || elementType.IsSubclassOf(typeof(ISerializable))) { constructorEmit .ldarg_0 .ldarg_1 .call(property.GetGetMethod()) .call(property.GetSetMethod()); } else if (elementType.IsClass) { var originalArrayLocal = constructorEmit.DeclareLocal(propertyType); var originalArrayLocalNull = constructorEmit.DefineLabel(); var originalArrayLocalNotNull = constructorEmit.DefineLabel(); var arrayLocal = constructorEmit.DeclareLocal(propertyType); var ilocal = constructorEmit.DeclareLocal(typeof(int)); var lenLocal = constructorEmit.DeclareLocal(typeof(int)); var beginForLabel = constructorEmit.DefineLabel(); var beginForBodyLabel = constructorEmit.DefineLabel(); constructorEmit .ldarg_1 .call(property.GetGetMethod()) .stloc(originalArrayLocal) .ldloc(originalArrayLocal) .brtrue(originalArrayLocalNotNull) .ldarg_0 .ldnull .call(property.GetSetMethod()) .br(originalArrayLocalNull) .MarkLabel(originalArrayLocalNotNull) .ldloc(originalArrayLocal) .ldlen .conv_i4 .stloc(lenLocal) .ldloc(lenLocal) .newarr(elementType) .stloc(arrayLocal) .ldarg_0 .ldloc(arrayLocal) .call(property.GetSetMethod()) .ldc_i4_0 .stloc(ilocal) .br(beginForLabel) .MarkLabel(beginForBodyLabel) .ldloc(arrayLocal) .ldloc(ilocal) .ldloc(originalArrayLocal) .ldloc(ilocal) .ldelem_ref .ldarg_2 .call(typeof(Converter).GetMethod("Convert", new Type[] { typeof(object), typeof(IDictionary <object, ISerializable>) })) .castclass(elementType) .stelem_ref .ldloc(ilocal) .ldc_i4_1 .add .stloc(ilocal) .MarkLabel(beginForLabel) .ldloc(ilocal) .ldloc(lenLocal) .blt(beginForBodyLabel) .MarkLabel(originalArrayLocalNull); } else { throw new ArgumentException("Element of list not supported: " + elementType); } arraySerializeEmitter.Emit(property, ref serializerEmit, ref deserializeEmit); } else if (propertyType.IsGenericType && (propertyType.GetGenericTypeDefinition() == typeof(IDictionary <,>) || propertyType.GetGenericTypeDefinition() == typeof(Dictionary <,>))) { constructorEmit .ldarg_0 .ldarg_1 .call(property.GetGetMethod()) .call(property.GetSetMethod()); dictGenericEmitter.Emit(property, ref serializerEmit, ref deserializeEmit); } else if (propertyType.IsGenericType && (propertyType.GetGenericTypeDefinition() == typeof(IList <>) || propertyType.GetGenericTypeDefinition() == typeof(List <>))) { var elementType = propertyType.GetGenericArguments()[0]; if (elementType.IsPrimitive || elementType == typeof(string) || elementType == typeof(DateTime) || elementType == typeof(decimal) || elementType.IsSubclassOf(typeof(ISerializable))) { constructorEmit .ldarg_0 .ldarg_1 .call(property.GetGetMethod()) .call(property.GetSetMethod()); } else if (elementType.IsClass) { var originalListLocal = constructorEmit.DeclareLocal(propertyType); var originalListLocalNull = constructorEmit.DefineLabel(); var originalListLocalNotNull = constructorEmit.DefineLabel(); var listLocal = constructorEmit.DeclareLocal(propertyType); var ilocal = constructorEmit.DeclareLocal(typeof(int)); var lenLocal = constructorEmit.DeclareLocal(typeof(int)); var beginForLabel = constructorEmit.DefineLabel(); var beginForBodyLabel = constructorEmit.DefineLabel(); var getCountMethod = typeof(ICollection <>).MakeGenericType(elementType).GetMethod("get_Count"); var addElementMethod = typeof(ICollection <>).MakeGenericType(elementType).GetMethod("Add"); var propertyInstanceType = propertyType.IsInterface ? typeof(List <>).MakeGenericType(elementType) : propertyType; constructorEmit .ldarg_1 .call(property.GetGetMethod()) .stloc(originalListLocal) .ldloc(originalListLocal) .brtrue(originalListLocalNotNull) .ldarg_0 .ldnull .call(property.GetSetMethod()) .br(originalListLocalNull) .MarkLabel(originalListLocalNotNull) .ldloc(originalListLocal) .call(getCountMethod) .stloc(lenLocal) .ldloc(lenLocal) .newobj(propertyInstanceType, typeof(int)) .stloc(listLocal) .ldarg_0 .ldloc(listLocal) .call(property.GetSetMethod()) .ldc_i4_0 .stloc(ilocal) .br(beginForLabel) .MarkLabel(beginForBodyLabel) .ldloc(listLocal) .ldloc(originalListLocal) .ldloc(ilocal) .call(propertyType.GetMethod("get_Item")) .ldarg_2 .call(typeof(Converter).GetMethod("Convert", new Type[] { typeof(object), typeof(IDictionary <object, ISerializable>) })) .castclass(elementType) .call(addElementMethod) .ldloc(ilocal) .ldc_i4_1 .add .stloc(ilocal) .MarkLabel(beginForLabel) .ldloc(ilocal) .ldloc(lenLocal) .blt(beginForBodyLabel) .MarkLabel(originalListLocalNull); } else { throw new ArgumentException("Element of list not supported: " + elementType); } iListGenericEmitter.Emit(property, ref serializerEmit, ref deserializeEmit); } else if (propertyType.IsClass) { constructorEmit .ldarg_0 .ldarg_1 .call(property.GetGetMethod()) .ldarg_2 .call(typeof(Converter).GetMethod("Convert", new[] { typeof(object), typeof(IDictionary <object, ISerializable>) })) .castclass(propertyType) .call(property.GetSetMethod()); objectGenericEmitter.Emit(property, ref serializerEmit, ref deserializeEmit); } } serializerEmit.ret(); deserializeEmit.ret(); constructorEmit.ret(); var serializableType = typeBuilderHelper.Create(); SerializableTypeManager.Instance.Add(type, serializableType); return(serializableType); }
public static IExecutor CreateExecutor(object service, MethodInfo method) { if (service == null) { throw new ArgumentNullException("Cannot create a null executor"); } var type = service.GetType(); var typeName = type.Name + method.Name; var assemblyBuilderHelper = new AssemblyBuilderHelper(typeName + "_Executor" + ".dll"); var typeBuilderHelper = assemblyBuilderHelper.DefineType(typeName, typeof(object), typeof(IExecutor)); var serviceFieldBuilder = typeBuilderHelper.DefineField(type.Name, type, FieldAttributes.Public); var methods = type.GetMethods(BindingFlags.Public | BindingFlags.Instance); var emit = typeBuilderHelper.DefineMethod(typeof(IExecutor).GetMethod("Execute")).Emitter; var returnType = method.ReturnType; var paramInfos = method.GetParameters(); emit .ldarg_0 .ldfld(serviceFieldBuilder); for (var j = 0; j < paramInfos.Length; j++) { var paramInfo = paramInfos[j]; var paramType = paramInfo.ParameterType; emit = emit .ldarg_1 .ldc_i4(j) .ldelem_ref; if (paramType.IsValueType) { emit .unbox_any(paramType); } else if (paramType.IsClass || paramType.IsInterface) { emit.castclass(paramType); } } emit.call(method); if (returnType != typeof(void)) { emit .boxIfValueType(returnType) .ret(); } else { emit .ldnull .ret(); } var executorType = typeBuilderHelper.Create(); var executor = (IExecutor)TypeAccessor.CreateInstance(executorType); var serviceField = executorType.GetField(type.Name); serviceField.SetValue(executor, service); #if DEBUG assemblyBuilderHelper.Save(); #endif return(executor); }
public Type Build(Type sourceType, AssemblyBuilderHelper assemblyBuilder) { if (sourceType == null) { throw new ArgumentNullException("sourceType"); } if (assemblyBuilder == null) { throw new ArgumentNullException("assemblyBuilder"); } // Check InternalsVisibleToAttributes of the source type's assembly. // Even if the sourceType is public, it may have internal fields and props. // _friendlyAssembly = false; // Usually, there is no such attribute in the source assembly. // Therefore we do not cache the result. // object[] attributes = sourceType.Assembly.GetCustomAttributes(typeof(InternalsVisibleToAttribute), true); foreach (InternalsVisibleToAttribute visibleToAttribute in attributes) { AssemblyName an = new AssemblyName(visibleToAttribute.AssemblyName); if (AssemblyName.ReferenceMatchesDefinition(assemblyBuilder.AssemblyName, an)) { _friendlyAssembly = true; break; } } if (!sourceType.IsVisible && !_friendlyAssembly) { throw new TypeBuilderException(string.Format("Can not build type accessor for non-public type '{0}'.", sourceType.FullName)); } string typeName = GetTypeAccessorClassName(_type); _typeBuilder = assemblyBuilder.DefineType(typeName, _accessorType); _typeBuilder.DefaultConstructor.Emitter .ldarg_0 .call(TypeHelper.GetDefaultConstructor(_accessorType)) ; BuildCreateInstanceMethods(); BuildTypeProperties(); BuildMembers(); BuildObjectFactory(); _typeBuilder.DefaultConstructor.Emitter .ret() ; Type result = _typeBuilder.Create(); foreach (TypeBuilderHelper tb in _nestedTypes) { tb.Create(); } return(result); }