public void Convert_WithDelegate() { var type = DynamicAssemblyManager.DefineMapperType("MyClassType"); var field = type.DefineField("Lambda", typeof(Func<int>), FieldAttributes.Static | FieldAttributes.Public); Func<int> getValue = () => 10; var source = AstBuildHelper.CallMethod(field.FieldType.GetMethod("Invoke", new Type[0]), AstBuildHelper.ReadFieldRA(null, type.GetField("Lambda")), new List<IAstStackItem>()); var writer = AstBuildHelper.WriteMember(typeof(DestinationObject).GetProperty("Destination"), AstBuildHelper.ReadArgumentRA(1, typeof(DestinationObject)), source); var convertMethod = type.DefineMethod("ConvertLambda", MethodAttributes.Public | MethodAttributes.Static, null, new Type[]{typeof(SourceObject), typeof(DestinationObject)}); convertMethod.DefineParameter(1, ParameterAttributes.None, "source"); convertMethod.DefineParameter(2, ParameterAttributes.None, "destination"); var context = new CompilationContext(convertMethod.GetILGenerator()); writer.Compile(context); new AstReturnVoid().Compile(context); type.CreateType(); DynamicAssemblyManager.SaveAssembly(); var destinationObj = new DestinationObject(); object dynamicType = Activator.CreateInstance(type, false); type.GetField("Lambda").SetValue(dynamicType, getValue); type.InvokeMember("ConvertLambda", BindingFlags.InvokeMethod, null, dynamicType, new object[]{null, destinationObj}); Assert.AreEqual(10, destinationObj.Destination); }
public void Convert_Method() { var source = AstBuildHelper.ReadMemberRV(AstBuildHelper.ReadArgumentRA(0, typeof(SourceObject)), typeof(SourceObject).GetProperty("Source")); var writer = AstBuildHelper.WriteMember(typeof(DestinationObject).GetProperty("Destination"), AstBuildHelper.ReadArgumentRA(1, typeof(DestinationObject)), source); var type = DynamicAssemblyManager.DefineMapperType("MyClassType"); var convertMethod = type.DefineMethod("Convert", MethodAttributes.Public | MethodAttributes.Static, null, new Type[]{typeof(SourceObject), typeof(DestinationObject)}); convertMethod.DefineParameter(1, ParameterAttributes.None, "source"); convertMethod.DefineParameter(2, ParameterAttributes.None, "destination"); var context = new CompilationContext(convertMethod.GetILGenerator()); writer.Compile(context); new AstReturnVoid().Compile(context); type.CreateType(); DynamicAssemblyManager.SaveAssembly(); var sourceObj = new SourceObject{Source = 10}; var destinationObj = new DestinationObject(); object dynamicType = Activator.CreateInstance(type, false); type.InvokeMember("Convert", BindingFlags.InvokeMethod, null, dynamicType, new object[]{sourceObj, destinationObj}); Assert.AreEqual(sourceObj.Source, destinationObj.Destination); }
private static Type BuildActionCallerType(string typeName, MethodInfo mi) { var par = mi.GetParameters(); Type actionCallerType = null; if (par.Length == 0) { actionCallerType = typeof(MethodInvokerAction_0); } if (par.Length == 1) { actionCallerType = typeof(MethodInvokerAction_1); } if (par.Length == 2) { actionCallerType = typeof(MethodInvokerAction_2); } if (par.Length == 3) { actionCallerType = typeof(MethodInvokerAction_3); } else { new EmitMapperException("too many method parameters"); } var tb = DynamicAssemblyManager.DefineType(typeName, actionCallerType); MethodBuilder methodBuilder = tb.DefineMethod( "CallAction", MethodAttributes.Public | MethodAttributes.Virtual, null, Enumerable.Range(0, par.Length).Select(i => typeof(object)).ToArray() ); new AstComplexNode { nodes = new List <IAstNode> { CreateCallMethod(mi, par), new AstReturnVoid() } }.Compile(new CompilationContext(methodBuilder.GetILGenerator())); return(tb.CreateTypeInfo()); }
/// <summary> /// Creates an instance of Mapper for collections. /// </summary> /// <param name="MapperName">Mapper name. It is used for registration in Mappers repositories.</param> /// <param name="mapperMannager">Mappers manager</param> /// <param name="TypeFrom">Source type</param> /// <param name="TypeTo">Destination type</param> /// <param name="SubMapper"></param> /// <returns></returns> public static MapperForCollectionImpl CreateInstance( string MapperName, ObjectMapperManager mapperMannager, Type TypeFrom, Type TypeTo, ObjectsMapperDescr SubMapper, IMappingConfigurator mappingConfigurator ) { TypeBuilder tb = DynamicAssemblyManager.DefineType( "GenericListInv_" + MapperName, typeof(MapperForCollectionImpl) ); if (TypeTo.IsGenericType() && TypeTo.GetGenericTypeDefinition() == typeof(List <>)) { MethodBuilder methodBuilder = tb.DefineMethod( "CopyToListInvoke", MethodAttributes.Family | MethodAttributes.Virtual, typeof(object), new Type[] { typeof(IEnumerable) } ); InvokeCopyImpl(TypeTo, "CopyToList").Compile(new CompilationContext(methodBuilder.GetILGenerator())); methodBuilder = tb.DefineMethod( "CopyToListScalarInvoke", MethodAttributes.Family | MethodAttributes.Virtual, typeof(object), new Type[] { typeof(object) } ); InvokeCopyImpl(TypeTo, "CopyToListScalar").Compile( new CompilationContext(methodBuilder.GetILGenerator()) ); } MapperForCollectionImpl result = (MapperForCollectionImpl)Activator.CreateInstance(tb.CreateTypeInfo().AsType()); result.Initialize(mapperMannager, TypeFrom, TypeTo, mappingConfigurator, null); result.subMapper = SubMapper; return(result); }
private static Type BuildFuncCallerType(string typeName, MethodInfo mi) { var par = mi.GetParameters(); Type funcCallerType = null; if (par.Length == 0) { funcCallerType = typeof(MethodInvokerFunc_0); } if (par.Length == 1) { funcCallerType = typeof(MethodInvokerFunc_1); } if (par.Length == 2) { funcCallerType = typeof(MethodInvokerFunc_2); } if (par.Length == 3) { funcCallerType = typeof(MethodInvokerFunc_3); } else { new EmitMapperException("too many method parameters"); } var tb = DynamicAssemblyManager.DefineType(typeName, funcCallerType); MethodBuilder methodBuilder = tb.DefineMethod( "CallFunc", MethodAttributes.Public | MethodAttributes.Virtual, typeof(object), Enumerable.Range(0, par.Length).Select(i => typeof(object)).ToArray() ); new AstReturn { returnType = typeof(object), returnValue = CreateCallMethod(mi, par) }.Compile(new CompilationContext(methodBuilder.GetILGenerator())); return(tb.CreateTypeInfo()); }
public void Test_DynamicAssemblyManager() { try { DynamicAssemblyManager.SaveAssembly(); } catch (Exception e) { string message = e.Message; if (message == ".net standard 2.0 不支持assemblyBuilder.Save 方法") { Assert.Pass(); } else { Assert.Fail(); } } }
public void Create_IfNull() { var type = DynamicAssemblyManager.DefineMapperType("MyClassType"); var convertMethod = type.DefineMethod("Create_IfNull", MethodAttributes.Public, null, new []{typeof(SourceObject), typeof(DestinationObject), typeof(IResourceMapper<object>), typeof(object)}); convertMethod.DefineParameter(1, ParameterAttributes.None, "source"); convertMethod.DefineParameter(2, ParameterAttributes.None, "destination"); convertMethod.DefineParameter(3, ParameterAttributes.None, "mapper"); convertMethod.DefineParameter(4, ParameterAttributes.None, "context"); var context = new CompilationContext(convertMethod.GetILGenerator()); new AstWriteArgument(1, typeof(DestinationObject), new AstIfNull( (IAstRef)AstBuildHelper.ReadArgumentRA(1, typeof(DestinationObject)), new AstNewObject(typeof(DestinationObject), new IAstStackItem[0]))) .Compile(context); new AstReturnVoid().Compile(context); type.CreateType(); DynamicAssemblyManager.SaveAssembly(); }
public EmitBuilder(IResourceMapper <TContext> mapper) : base(mapper) { _type = DynamicAssemblyManager.DefineMapperType("ResourceMapper"); _mapperField = _type.DefineField("Mapper", typeof(IResourceMapper <TContext>), FieldAttributes.Public | FieldAttributes.Static); _constructorValues.Add(_mapperField.Name, _mapper); }