public EmitMethodInvocationExpression(EmitMethod method, params EmitExpression[] arguments) { if (!method.IsStatic) throw new Exception("Non-static method requires a target."); Method = method; Arguments.AddRange(arguments); }
public EmitMethodInvocationExpression(EmitExpression target, EmitMethod method, params EmitExpression[] arguments) { if (method.IsStatic && target != null) throw new Exception("Static method cannot have a target"); Target = target; Method = method; Arguments.AddRange(arguments); }
public EmitMethodInvocationExpression(EmitMethod method, params EmitExpression[] arguments) { if (!method.IsStatic) { throw new Exception("Non-static method requires a target."); } Method = method; Arguments.AddRange(arguments); }
public IEmitterType EmitMapMethod(IEmitterType sourceMemeber, IEmitterType targetMember) { Type mapperType = typeof(Mapper); MethodInfo mapMethod = mapperType.GetMethod(Mapper.MapMethodName, BindingFlags.Instance | BindingFlags.Public); FieldInfo mappersField = mapperType.GetField(Mapper.MappersFieldName, BindingFlags.Instance | BindingFlags.NonPublic); IEmitterType mappers = EmitField.Load(EmitThis.Load(mapperType), mappersField); IEmitterType mapper = EmitArray.Load(mappers, Id); IEmitterType result = EmitMethod.Call(mapMethod, mapper, sourceMemeber, targetMember); return(result); }
public IEmitterType EmitMapMethod(IEmitterType sourceMember, IEmitterType targetMember) { var mapperType = typeof(Mapper); var mapMethod = mapperType.GetMethod(Mapper.MAP_METHOD_NAME, BindingFlags.Instance | BindingFlags.Public); var mappersField = mapperType.GetField(Mapper.MAPPERS_FIELD_NAME, BindingFlags.Instance | BindingFlags.NonPublic); var mappers = EmitField.Load(EmitThis.Load(mapperType), mappersField); var mapper = EmitArray.Load(mappers, Id); var result = EmitMethod.Call(mapMethod, mapper, sourceMember, targetMember); return(result); }
public EmitMethodInvocationExpression(EmitExpression target, EmitMethod method, params EmitExpression[] arguments) { if (method.IsStatic && target != null) { throw new Exception("Static method cannot have a target"); } Target = target; Method = method; Arguments.AddRange(arguments); }
public void InvokeStaticMethod() { var method = CreateMethod(block => { EmitMethod methodInfo = typeof(StaticMethodClass).GetMethod("Mirror"); block.Return(methodInfo.Call("foo")); }); var result = (string)method.Invoke(null, null); Assert.AreEqual("foo", result); }
public void BooleanOrShortCircuitsFalse() { ShortCircuitsData.Reset(); EmitMethod returnTrue = typeof(ShortCircuitsData).GetMethod("ReturnTrue"); EmitMethod returnFalse = typeof(ShortCircuitsData).GetMethod("ReturnFalse"); var method = CreateMethod(block => block.Return(returnFalse.Call().BooleanOr(returnTrue.Call()))); var result = (bool)method.Invoke(null, null); Assert.AreEqual(1, ShortCircuitsData.NumberOfCallsToReturnTrue); Assert.AreEqual(1, ShortCircuitsData.NumberOfCallsToReturnFalse); Assert.IsTrue(result); }
public void PostDecrement() { EmitMethod tupleMethod = typeof(Tuple).GetMethods().Where(x => x.GetGenericArguments().Length == 2).Single().MakeGenericMethod(typeof(int), typeof(int)); var method = CreateMethod(block => { var variable = block.Declare(typeof(int)); block.Express(variable.Assign(2)); block.Return(tupleMethod.Call(variable.PostDecrement(), variable)); }); var result = (Tuple <int, int>)method.Invoke(null, null); Assert.AreEqual(2, result.Item1); Assert.AreEqual(1, result.Item2); }
private void EmitEnumerableToTarget(Type parentType, TypeBuilder typeBuilder, TypePair typePair, string methodName, string templateMethodName) { MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) }); Type sourceItemType = typePair.Source.GetCollectionItemType(); Type targetItemType = typePair.Target.GetCollectionItemType(); EmitConvertItem(typeBuilder, new TypePair(sourceItemType, targetItemType)); MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, targetItemType); IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1)); EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator())); }
private void EmitDictionaryToTarget(Type parentType, TypeBuilder typeBuilder, TypePair typePair, string methodName, string templateMethodName) { MethodBuilder methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) }); KeyValuePair <Type, Type> sourceTypes = typePair.Source.GetDictionaryItemTypes(); KeyValuePair <Type, Type> targetTypes = typePair.Target.GetDictionaryItemTypes(); EmitConvertItem(typeBuilder, new TypePair(sourceTypes.Key, targetTypes.Key), ConvertItemKeyMethod); EmitConvertItem(typeBuilder, new TypePair(sourceTypes.Value, targetTypes.Value)); var arguments = new[] { sourceTypes.Key, sourceTypes.Value, targetTypes.Key, targetTypes.Value }; MethodInfo methodTemplate = parentType.GetGenericMethod(templateMethodName, arguments); IEmitterType returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1)); EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator())); }
private void EmitEnumerableToTarget( Type parentType, TypeBuilder typeBuilder, TypePair typePair, TypePair collectionItemTypePair, string methodName, string templateMethodName) { var methodBuilder = typeBuilder.DefineMethod(methodName, OverrideProtected, typePair.Target, new[] { typeof(IEnumerable) }); EmitConvertItem(typeBuilder, collectionItemTypePair); var methodTemplate = parentType.GetGenericMethod(templateMethodName, collectionItemTypePair.Target); var returnValue = EmitMethod.Call(methodTemplate, EmitThis.Load(parentType), EmitArgument.Load(typeof(IEnumerable), 1)); EmitReturn.Return(returnValue).Emit(new CodeGenerator(methodBuilder.GetILGenerator())); }
public MemberInfo VisitMethod(EmitMethod method, TypeBuilder parent) { var methodBuilder = parent.DefineMethod( method.Name, ReflectionMethodAttributes.ToMethodAttributes(method.Visibility, method.IsAbstract, method.IsSealed, method.IsVirtual, false, method.IsStatic), method.ReturnType, method.Parameters.Select(x => (Type)x.ParameterType).ToArray()); var emitMethodBuilder = (EmitMethodBuilder)method; emitMethodBuilder.Compile(); var il = methodBuilder.GetILGenerator(); GenerateIl(il, emitMethodBuilder.Il); return(methodBuilder); }
public static EmitMethodInvocationExpression Call(this EmitMethod method, params EmitExpression[] arguments) { return(new EmitMethodInvocationExpression(method, arguments)); }
public static EmitMethodInvocationExpression Invoke(this EmitExpression target, EmitMethod method, params EmitExpression[] arguments) { return(new EmitMethodInvocationExpression(target, method, arguments)); }
public static EmitMethodInvocationExpression Invoke(this EmitExpression target, EmitMethod method, params EmitExpression[] arguments) { return new EmitMethodInvocationExpression(target, method, arguments); }
public EmitInstruction Emit(IEmitOpCodeMethod opCode, EmitMethod method) { var instruction = new EmitInstruction(opCode, method); AddInstruction(instruction); return instruction; }