public static void InitializeArgumentsByPosition(ArgumentReference[] args) { for(int i=0; i < args.Length; ++i) { args[i].Position = i+1; } }
/// <summary> /// Generates one public constructor receiving /// the <see cref="IInterceptor"/> instance and instantiating a hashtable /// </summary> protected virtual EasyConstructor GenerateConstructor( ConstructorInfo baseConstructor ) { ArrayList arguments = new ArrayList(); ArgumentReference arg1 = new ArgumentReference( Context.Interceptor ); ArgumentReference arg2 = new ArgumentReference( typeof(object[]) ); arguments.Add( arg1 ); ParameterInfo[] parameters = baseConstructor.GetParameters(); if (Context.HasMixins) { arguments.Add( arg2 ); } ArgumentReference[] originalArguments = ArgumentsUtil.ConvertToArgumentReference(parameters); arguments.AddRange(originalArguments); EasyConstructor constructor = MainTypeBuilder.CreateConstructor( (ArgumentReference[]) arguments.ToArray( typeof(ArgumentReference) ) ); GenerateConstructorCode(constructor.CodeBuilder, arg1, SelfReference.Self, arg2); constructor.CodeBuilder.InvokeBaseConstructor( baseConstructor, originalArguments ); constructor.CodeBuilder.AddStatement( new ReturnStatement() ); return constructor; }
public static Expression[] ConvertArgumentReferenceToExpression(ArgumentReference[] args) { Expression[] expressions = new Expression[args.Length]; for(int i=0; i < args.Length; ++i) { expressions[i] = args[i].ToExpression(); } return expressions; }
public EasyRuntimeMethod(AbstractEasyType maintype, string name, ReturnReferenceExpression returnRef, ArgumentReference[] arguments) { MethodAttributes atts = MethodAttributes.HideBySig|MethodAttributes.Public|MethodAttributes.Virtual; Type[] args = ArgumentsUtil.InitializeAndConvert( arguments ); _builder = maintype.TypeBuilder.DefineMethod( name, atts, returnRef.Type, args); _builder.SetImplementationFlags( MethodImplAttributes.Runtime|MethodImplAttributes.Managed); }
public static ArgumentReference[] ConvertToArgumentReference(ParameterInfo[] args) { ArgumentReference[] arguments = new ArgumentReference[args.Length]; for(int i=0; i < args.Length; ++i) { arguments[i] = new ArgumentReference( args[i].ParameterType ); } return arguments; }
public static Type[] InitializeAndConvert(ArgumentReference[] args) { Type[] types = new Type[args.Length]; for(int i=0; i < args.Length; ++i) { args[i].Position = i+1; types[i] = args[i].Type; } return types; }
public void Conditionals() { EasyType typebuilder = new EasyType( module, "mytype" ); FieldReference cachefield = typebuilder.CreateField( "cache", typeof(IDictionary) ); ArgumentReference arg = new ArgumentReference( typeof(bool) ); EasyConstructor constructor = typebuilder.CreateConstructor( arg ); constructor.CodeBuilder.InvokeBaseConstructor(); ConditionExpression exp = new ConditionExpression(OpCodes.Brtrue_S, arg.ToExpression()); exp.AddTrueStatement( new AssignStatement(cachefield, new NewInstanceExpression( typeof(HybridDictionary), new Type[0] ) ) ); exp.AddFalseStatement( new AssignStatement(cachefield, new NewInstanceExpression( typeof(Hashtable), new Type[0] ) ) ); constructor.CodeBuilder.AddStatement( new ExpressionStatement(exp) ); constructor.CodeBuilder.AddStatement( new ReturnStatement() ); ReturnReferenceExpression ret = new ReturnReferenceExpression(typeof(IDictionary)); EasyMethod getCache = typebuilder.CreateMethod( "GetCache", ret ); getCache.CodeBuilder.AddStatement( new ReturnStatement( cachefield ) ); Type newType = typebuilder.BuildType(); object instance = Activator.CreateInstance( newType, new object[] { true } ); MethodInfo method = instance.GetType().GetMethod("GetCache"); object dic = method.Invoke( instance, new object[0] ); Assert.IsTrue( dic is HybridDictionary ); instance = Activator.CreateInstance( newType, new object[] { false } ); dic = method.Invoke( instance, new object[0] ); Assert.IsTrue( dic is Hashtable ); RunPEVerify(); }
protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference arg1, ArgumentReference arg2) { Type[] key_and_object = new Type[] {typeof (String), typeof (Object)}; Type[] key_and_bool = new Type[] {typeof (String), typeof (bool)}; MethodInfo addValueMethod = typeof (SerializationInfo).GetMethod("AddValue", key_and_object); MethodInfo addValueBoolMethod = typeof (SerializationInfo).GetMethod("AddValue", key_and_bool); codebuilder.AddStatement( new ExpressionStatement( new VirtualMethodInvocationExpression(arg1, addValueBoolMethod, new FixedReference("__delegateToBase").ToExpression(), new FixedReference( _delegateToBaseGetObjectData ? 1 : 0 ).ToExpression() ) ) ); if (_delegateToBaseGetObjectData) { MethodInfo baseGetObjectData = _baseType.GetMethod("GetObjectData", new Type[] { typeof(SerializationInfo), typeof(StreamingContext) }); codebuilder.AddStatement( new ExpressionStatement( new MethodInvocationExpression( baseGetObjectData, arg1.ToExpression(), arg2.ToExpression() )) ); } else { LocalReference members_ref = codebuilder.DeclareLocal( typeof(MemberInfo[]) ); LocalReference data_ref = codebuilder.DeclareLocal( typeof(object[]) ); MethodInfo getSerMembers = typeof(FormatterServices).GetMethod("GetSerializableMembers", new Type[] { typeof(Type) }); MethodInfo getObjData = typeof(FormatterServices).GetMethod("GetObjectData", new Type[] { typeof(object), typeof(MemberInfo[]) }); codebuilder.AddStatement( new AssignStatement( members_ref, new MethodInvocationExpression( null, getSerMembers, new TypeTokenExpression( _baseType ) )) ); codebuilder.AddStatement( new AssignStatement( data_ref, new MethodInvocationExpression( null, getObjData, SelfReference.Self.ToExpression(), members_ref.ToExpression() )) ); codebuilder.AddStatement( new ExpressionStatement( new VirtualMethodInvocationExpression(arg1, addValueMethod, new FixedReference("__data").ToExpression(), data_ref.ToExpression() ) ) ); } }
protected virtual void ImplementGetObjectData(Type[] interfaces) { // To prevent re-implementation of this interface. _generated.Add(typeof(ISerializable)); Type[] get_type_args = new Type[] {typeof(String), typeof(bool), typeof(bool)}; Type[] key_and_object = new Type[] {typeof(String), typeof(Object)}; MethodInfo addValueMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_object); ArgumentReference arg1 = new ArgumentReference(typeof(SerializationInfo)); ArgumentReference arg2 = new ArgumentReference(typeof(StreamingContext)); EasyMethod getObjectData = MainTypeBuilder.CreateMethod("GetObjectData", new ReturnReferenceExpression(typeof(void)), arg1, arg2); LocalReference typeLocal = getObjectData.CodeBuilder.DeclareLocal(typeof(Type)); getObjectData.CodeBuilder.AddStatement(new AssignStatement( typeLocal, new MethodInvocationExpression(null, typeof(Type).GetMethod("GetType", get_type_args), new FixedReference( Context.ProxyObjectReference. AssemblyQualifiedName).ToExpression(), new FixedReference(1).ToExpression(), new FixedReference(0).ToExpression()))); getObjectData.CodeBuilder.AddStatement(new ExpressionStatement( new VirtualMethodInvocationExpression( arg1, typeof(SerializationInfo).GetMethod("SetType"), typeLocal.ToExpression()))); getObjectData.CodeBuilder.AddStatement(new ExpressionStatement( new VirtualMethodInvocationExpression(arg1, addValueMethod, new FixedReference("__interceptor"). ToExpression(), InterceptorField.ToExpression()))); getObjectData.CodeBuilder.AddStatement(new ExpressionStatement( new VirtualMethodInvocationExpression(arg1, addValueMethod, new FixedReference("__mixins"). ToExpression(), MixinField.ToExpression()))); LocalReference interfacesLocal = getObjectData.CodeBuilder.DeclareLocal(typeof(String[])); getObjectData.CodeBuilder.AddStatement( new AssignStatement(interfacesLocal, new NewArrayExpression(interfaces.Length, typeof(String)))); for(int i = 0; i < interfaces.Length; i++) { getObjectData.CodeBuilder.AddStatement(new AssignArrayStatement( interfacesLocal, i, new FixedReference(interfaces[i].AssemblyQualifiedName).ToExpression())); } getObjectData.CodeBuilder.AddStatement(new ExpressionStatement( new VirtualMethodInvocationExpression(arg1, addValueMethod, new FixedReference("__interfaces"). ToExpression(), interfacesLocal.ToExpression()))); getObjectData.CodeBuilder.AddStatement(new ExpressionStatement( new VirtualMethodInvocationExpression(arg1, addValueMethod, new FixedReference("__baseType"). ToExpression(), new TypeTokenExpression(_baseType)))); CustomizeGetObjectData(getObjectData.CodeBuilder, arg1, arg2); getObjectData.CodeBuilder.AddStatement(new ReturnStatement()); }
protected virtual void ImplementCacheInvocationCache() { MethodInfo get_ItemMethod = typeof(HybridDictionary).GetMethod("get_Item", new Type[] {typeof(object)}); MethodInfo set_ItemMethod = typeof(HybridDictionary).GetMethod("Add", new Type[] {typeof(object), typeof(object)}); Type[] args = new Type[] {typeof(ICallable), typeof(MethodInfo)}; Type[] invocation_const_args = new Type[] {typeof(ICallable), typeof(object), typeof(MethodInfo), typeof(object)}; ArgumentReference arg1 = new ArgumentReference(typeof(ICallable)); ArgumentReference arg2 = new ArgumentReference(typeof(MethodInfo)); ArgumentReference arg3 = new ArgumentReference(typeof(object)); _method2Invocation = MainTypeBuilder.CreateMethod("_Method2Invocation", new ReturnReferenceExpression(Context.Invocation), MethodAttributes.Family | MethodAttributes.HideBySig, arg1, arg2, arg3); LocalReference invocation_local = _method2Invocation.CodeBuilder.DeclareLocal(Context.Invocation); LockBlockExpression block = new LockBlockExpression(SelfReference.Self); block.AddStatement(new AssignStatement(invocation_local, new ConvertExpression(Context.Invocation, new VirtualMethodInvocationExpression(CacheField, get_ItemMethod, arg2.ToExpression())))); ConditionExpression cond1 = new ConditionExpression(OpCodes.Brfalse_S, invocation_local.ToExpression()); cond1.AddTrueStatement(new AssignStatement( invocation_local, new NewInstanceExpression(InvocationType.GetConstructor(invocation_const_args), arg1.ToExpression(), SelfReference.Self.ToExpression(), arg2.ToExpression(), arg3.ToExpression()))); cond1.AddTrueStatement(new ExpressionStatement( new VirtualMethodInvocationExpression(CacheField, set_ItemMethod, arg2.ToExpression(), invocation_local.ToExpression()))); block.AddStatement(new ExpressionStatement(cond1)); _method2Invocation.CodeBuilder.AddStatement(new ExpressionStatement(block)); _method2Invocation.CodeBuilder.AddStatement(new ReturnStatement(invocation_local)); }
protected virtual MethodInfo GenerateCallbackMethodIfNecessary(MethodInfo method, Reference invocationTarget) { if (Context.HasMixins && _interface2mixinIndex.Contains(method.DeclaringType)) { return method; } String name = String.Format("callback__{0}", method.Name); ParameterInfo[] parameters = method.GetParameters(); ArgumentReference[] args = new ArgumentReference[parameters.Length]; for(int i = 0; i < args.Length; i++) { args[i] = new ArgumentReference(parameters[i].ParameterType); } EasyMethod easymethod = MainTypeBuilder.CreateMethod(name, new ReturnReferenceExpression(method.ReturnType), MethodAttributes.HideBySig | MethodAttributes.Public, args); Expression[] exps = new Expression[parameters.Length]; for(int i = 0; i < args.Length; i++) { exps[i] = args[i].ToExpression(); } if (invocationTarget == null) { easymethod.CodeBuilder.AddStatement( new ReturnStatement( new MethodInvocationExpression(method, exps))); } else { easymethod.CodeBuilder.AddStatement( new ReturnStatement( new MethodInvocationExpression(invocationTarget, method, exps))); } return easymethod.MethodBuilder; }
protected virtual void CustomizeGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference arg1, ArgumentReference arg2) { }
public void EmptyMethodWithEnumTypeRefArg() { EasyType typebuilder = new EasyType(module, "mytype"); SByteEnum refArgInst = SByteEnum.Two; Type refType = GetEnumRefType(ref refArgInst); Assert.IsTrue(refType.IsByRef); ArgumentReference refArg = new ArgumentReference(refType); ReturnReferenceExpression ret = new ReturnReferenceExpression(typeof(int)); EasyMethod emptyMethod = typebuilder.CreateMethod("DoSomething", ret, refArg); Type newType = typebuilder.BuildType(); Assert.IsNotNull(newType); object instance = Activator.CreateInstance(newType); Assert.IsNotNull(instance); MethodInfo method = instance.GetType().GetMethod("DoSomething"); method.Invoke(instance, new object[] { refArgInst }); Assert.AreEqual(SByteEnum.Two, refArgInst, "Argument made round-trip successfully"); RunPEVerify(); }
public void MethodInvokingMethod() { EasyType typebuilder = new EasyType( module, "mytype" ); ArgumentReference rarg1 = new ArgumentReference(typeof(int)); ArgumentReference rarg2 = new ArgumentReference(typeof(int)); ReturnReferenceExpression rret = new ReturnReferenceExpression(typeof(int)); EasyMethod realCalcMethod = typebuilder.CreateMethod( "RealCalc", rret, rarg1, rarg2 ); realCalcMethod.CodeBuilder.AddStatement( new ReturnStatement( new BinaryExpression( BinaryExpression.Add, rarg1.ToExpression(), rarg2.ToExpression() ) ) ); ArgumentReference arg1 = new ArgumentReference(typeof(int)); ArgumentReference arg2 = new ArgumentReference(typeof(int)); ReturnReferenceExpression ret = new ReturnReferenceExpression(typeof(int)); EasyMethod calcMethod = typebuilder.CreateMethod( "Calc", ret, arg1, arg2 ); calcMethod.CodeBuilder.AddStatement( new ReturnStatement( new MethodInvocationExpression( realCalcMethod, arg1.ToExpression(), arg2.ToExpression() ) ) ); Type newType = typebuilder.BuildType(); Assert.IsNotNull( newType ); object instance = Activator.CreateInstance( newType, new object[0] ); Assert.IsNotNull( instance ); MethodInfo method = instance.GetType().GetMethod("Calc"); Assert.AreEqual( 2, method.Invoke( instance, new object[] { 1,1 } ) ); Assert.AreEqual( 5, method.Invoke( instance, new object[] { 3,2 } ) ); method = instance.GetType().GetMethod("RealCalc"); Assert.AreEqual( 2, method.Invoke( instance, new object[] { 1,1 } ) ); Assert.AreEqual( 5, method.Invoke( instance, new object[] { 3,2 } ) ); RunPEVerify(); }
private void GenerateCall() { ArgumentReference arg = new ArgumentReference( typeof(object[]) ); _callmethod = CreateMethod( "Call", new ReturnReferenceExpression(typeof(object)), arg ); // LocalReference localRef = method.CodeBuilder.DeclareLocal( typeof(object) ); TypeReference[] dereferencedArguments = IndirectReference.WrapIfByRef(_args); LocalReference[] localCopies = new LocalReference[_args.Length]; Expression[] invocationArguments = new Expression[_args.Length]; // Load arguments from the object array. for (int i = 0; i < _args.Length; i++) { if (_args[i].Type.IsByRef) { localCopies[i] = _callmethod.CodeBuilder.DeclareLocal(dereferencedArguments[i].Type); _callmethod.CodeBuilder.AddStatement(new AssignStatement(localCopies[i], new ConvertExpression(dereferencedArguments[i].Type, new LoadRefArrayElementExpression(i, arg)))); invocationArguments[i] = localCopies[i].ToAddressOfExpression(); } else { invocationArguments[i] = new ConvertExpression(dereferencedArguments[i].Type, new LoadRefArrayElementExpression(i, arg)); } } // Invoke the method. MethodInvocationExpression methodInv = new MethodInvocationExpression( _invokeMethod, invocationArguments ); Expression result = null; if (_returnType.Type == typeof(void)) { _callmethod.CodeBuilder.AddStatement(new ExpressionStatement(methodInv)); result = NullExpression.Instance; } else { LocalReference resultLocal = _callmethod.CodeBuilder.DeclareLocal(typeof(object)); _callmethod.CodeBuilder.AddStatement(new AssignStatement(resultLocal, new ConvertExpression(typeof(object), _returnType.Type, methodInv))); result = resultLocal.ToExpression(); } // Save ByRef arguments into the object array. for (int i = 0; i < _args.Length; i++) { if (_args[i].Type.IsByRef) { _callmethod.CodeBuilder.AddStatement(new AssignArrayStatement(arg, i, new ConvertExpression(typeof(object), dereferencedArguments[i].Type, localCopies[i].ToExpression()))); } } // Return. _callmethod.CodeBuilder.AddStatement( new ReturnStatement( result ) ); }
public void ArrayRefs() { EasyType typebuilder = new EasyType( module, "mytype" ); FieldReference field1 = typebuilder.CreateField( "field1", typeof(object) ); FieldReference field2 = typebuilder.CreateField( "field2", typeof(object) ); ArgumentReference arg = new ArgumentReference( typeof(object[]) ); EasyConstructor constructor = typebuilder.CreateConstructor( arg ); constructor.CodeBuilder.InvokeBaseConstructor(); constructor.CodeBuilder.AddStatement( new AssignStatement(field1, new LoadRefArrayElementExpression( 0, arg ) ) ); constructor.CodeBuilder.AddStatement( new AssignStatement(field2, new LoadRefArrayElementExpression( 1, arg ) ) ); constructor.CodeBuilder.AddStatement( new ReturnStatement() ); ReturnReferenceExpression ret1 = new ReturnReferenceExpression(typeof(object)); EasyMethod getField1 = typebuilder.CreateMethod( "GetField1", ret1 ); getField1.CodeBuilder.AddStatement( new ReturnStatement( field1 ) ); ReturnReferenceExpression ret2 = new ReturnReferenceExpression(typeof(object)); EasyMethod getField2 = typebuilder.CreateMethod( "GetField2", ret2 ); getField2.CodeBuilder.AddStatement( new ReturnStatement( field2 ) ); Type newType = typebuilder.BuildType(); object[] innerArgs = new object[] { "hammett", "verissimo" }; object instance = Activator.CreateInstance( newType, new object[] { innerArgs } ); MethodInfo method = instance.GetType().GetMethod("GetField1"); object result = method.Invoke( instance, new object[0] ); Assert.AreEqual( "hammett", result ); method = instance.GetType().GetMethod("GetField2"); result = method.Invoke( instance, new object[0] ); Assert.AreEqual( "verissimo", result ); RunPEVerify(); }
public void CreateSimpleTypeWithConstructor() { EasyType typebuilder = new EasyType( module, "mytype" ); ArgumentReference arg1 = new ArgumentReference( typeof(String) ); ArgumentReference arg2 = new ArgumentReference( typeof(int) ); typebuilder.CreateConstructor( arg1, arg2 ); Type newType = typebuilder.BuildType(); Assert.IsNotNull( newType ); object instance = Activator.CreateInstance( newType, new object[] { "message", 10 } ); Assert.IsNotNull( instance ); RunPEVerify(); }
protected void GenerateSerializationConstructor() { ArgumentReference arg1 = new ArgumentReference( typeof(SerializationInfo) ); ArgumentReference arg2 = new ArgumentReference( typeof(StreamingContext) ); EasyConstructor constr = MainTypeBuilder.CreateConstructor( arg1, arg2 ); constr.CodeBuilder.AddStatement( new ExpressionStatement( new ConstructorInvocationExpression( _serializationConstructor, arg1.ToExpression(), arg2.ToExpression() )) ); Type[] object_arg = new Type[] { typeof (String), typeof(Type) }; MethodInfo getValueMethod = typeof (SerializationInfo).GetMethod("GetValue", object_arg); VirtualMethodInvocationExpression getInterceptorInvocation = new VirtualMethodInvocationExpression(arg1, getValueMethod, new FixedReference("__interceptor").ToExpression(), new TypeTokenExpression( Context.Interceptor ) ); VirtualMethodInvocationExpression getMixinsInvocation = new VirtualMethodInvocationExpression(arg1, getValueMethod, new FixedReference("__mixins").ToExpression(), new TypeTokenExpression( typeof(object[]) ) ); constr.CodeBuilder.AddStatement( new AssignStatement( InterceptorField, getInterceptorInvocation) ); constr.CodeBuilder.AddStatement( new AssignStatement( CacheField, new NewInstanceExpression( typeof(HybridDictionary).GetConstructor( new Type[0] )) ) ); constr.CodeBuilder.AddStatement( new AssignStatement( MixinField, getMixinsInvocation) ); // Initialize the delegate fields foreach(CallableField field in _cachedFields) { field.WriteInitialization(constr.CodeBuilder, SelfReference.Self, MixinField); } constr.CodeBuilder.AddStatement( new ReturnStatement() ); }
protected override void CustomizeGetObjectData(AbstractCodeBuilder codebuilder, ArgumentReference arg1, ArgumentReference arg2) { Type[] key_and_object = new Type[] {typeof(String), typeof(Object)}; MethodInfo addValueMethod = typeof(SerializationInfo).GetMethod("AddValue", key_and_object); codebuilder.AddStatement(new ExpressionStatement( new VirtualMethodInvocationExpression(arg1, addValueMethod, new FixedReference("__target").ToExpression(), _targetField.ToExpression()))); }
private void GenerateConstructor() { ArgumentReference arg1 = new ArgumentReference( typeof(object) ); ArgumentReference arg2 = new ArgumentReference( typeof(IntPtr) ); _constructor = CreateRuntimeConstructor( arg1, arg2 ); }
public void CreateMoreComplexCallable() { EasyType typebuilder = new EasyType( module, "mytype" ); ArgumentReference arg1 = new ArgumentReference( typeof(int) ); ArgumentReference arg2 = new ArgumentReference( typeof(DateTime) ); ArgumentReference arg3 = new ArgumentReference( typeof(object) ); EasyCallable callable = typebuilder.CreateCallable( new ReturnReferenceExpression(typeof(string)), arg1, arg2, arg3 ); FieldReference field1 = typebuilder.CreateField( "field1", callable.TypeBuilder ); SimpleCallback sc = new SimpleCallback(); ArgumentReference arg = new ArgumentReference( typeof(SimpleCallback) ); EasyConstructor constructor = typebuilder.CreateConstructor( arg ); constructor.CodeBuilder.InvokeBaseConstructor(); constructor.CodeBuilder.AddStatement( new AssignStatement(field1, new NewInstanceExpression( callable, arg.ToExpression(), new MethodPointerExpression( arg, typeof(SimpleCallback).GetMethod("RunAs") ) ) ) ); constructor.CodeBuilder.AddStatement( new ReturnStatement() ); arg1 = new ArgumentReference( typeof(int) ); arg2 = new ArgumentReference( typeof(DateTime) ); arg3 = new ArgumentReference( typeof(object) ); ReturnReferenceExpression ret1 = new ReturnReferenceExpression(typeof(string)); EasyMethod getField1 = typebuilder.CreateMethod( "Exec", ret1, arg1, arg2, arg3 ); getField1.CodeBuilder.AddStatement( new ReturnStatement( new ConvertExpression( typeof(String), new MethodInvocationExpression( field1, callable.Callmethod, new ReferencesToObjectArrayExpression(arg1, arg2, arg3) ) ) ) ); Type newType = typebuilder.BuildType(); RunPEVerify(); object instance = Activator.CreateInstance( newType, new object[] { sc } ); MethodInfo method = instance.GetType().GetMethod("Exec"); object result = method.Invoke( instance, new object[] { 1, DateTime.Now, "" } ); Assert.AreEqual( "hello2", result ); }
/// <summary> /// Generates one public constructor receiving /// the <see cref="IInterceptor"/> instance and instantiating a HybridCollection /// </summary> protected override EasyConstructor GenerateConstructor() { ArgumentReference arg1 = new ArgumentReference(Context.Interceptor); ArgumentReference arg2 = new ArgumentReference(typeof(object)); ArgumentReference arg3 = new ArgumentReference(typeof(object[])); EasyConstructor constructor; if (Context.HasMixins) { constructor = MainTypeBuilder.CreateConstructor(arg1, arg2, arg3); } else { constructor = MainTypeBuilder.CreateConstructor(arg1, arg2); } GenerateConstructorCode(constructor.CodeBuilder, arg1, SelfReference.Self, arg3); constructor.CodeBuilder.InvokeBaseConstructor(); constructor.CodeBuilder.AddStatement(new AssignStatement( _targetField, arg2.ToExpression())); constructor.CodeBuilder.AddStatement(new ReturnStatement()); return constructor; }
public void FieldsStoreAndLoad() { EasyType typebuilder = new EasyType( module, "mytype" ); FieldReference field1 = typebuilder.CreateField( "field1", typeof(int) ); FieldReference field2 = typebuilder.CreateField( "field2", typeof(string) ); { ArgumentReference arg1 = new ArgumentReference(typeof(int)); ArgumentReference arg2 = new ArgumentReference(typeof(string)); EasyConstructor constr = typebuilder.CreateConstructor( arg1, arg2 ); constr.CodeBuilder.InvokeBaseConstructor(); constr.CodeBuilder.AddStatement( new AssignStatement( field1, arg1.ToExpression() ) ); constr.CodeBuilder.AddStatement( new AssignStatement( field2, arg2.ToExpression() ) ); constr.CodeBuilder.AddStatement( new ReturnStatement() ); } { ReturnReferenceExpression ret1 = new ReturnReferenceExpression( typeof(int) ); EasyMethod m1 = typebuilder.CreateMethod( "GetField1", ret1 ); m1.CodeBuilder.AddStatement( new ReturnStatement( field1 ) ); ReturnReferenceExpression ret2 = new ReturnReferenceExpression( typeof(string) ); EasyMethod m2 = typebuilder.CreateMethod( "GetField2", ret2 ); m2.CodeBuilder.AddStatement( new ReturnStatement( field2 ) ); } Type newType = typebuilder.BuildType(); Assert.IsNotNull( newType ); object instance = Activator.CreateInstance( newType, new object[] { 10, "hello" } ); Assert.IsNotNull( instance ); MethodInfo method1 = instance.GetType().GetMethod("GetField1"); MethodInfo method2 = instance.GetType().GetMethod("GetField2"); Assert.AreEqual( 10, method1.Invoke( instance, new object[0] )); Assert.AreEqual( "hello", method2.Invoke( instance, new object[0] )); RunPEVerify(); }