public EasyMethod CreateRemoveOnMethod(MethodAttributes atts, params Type[] parameters) { if (this.m_removeOnMethod == null) { this.m_removeOnMethod = new EasyMethod(this.m_maintype, "remove_" + this.Name, atts, new ReturnReferenceExpression(typeof(void)), ArgumentsUtil.ConvertToArgumentReference(parameters)); } return(this.m_removeOnMethod); }
public EasyMethod CreateSetMethod(MethodAttributes attrs, params Type[] parameters) { if (this._setMethod == null) { this._setMethod = new EasyMethod(this._maintype, "set_" + this._builder.Name, attrs, new ReturnReferenceExpression(typeof(void)), ArgumentsUtil.ConvertToArgumentReference(parameters)); } return(this._setMethod); }
public EasyMethod CreateRemoveOnMethod(MethodAttributes atts, params Type[] parameters) { if (m_removeOnMethod == null) { m_removeOnMethod = new EasyMethod(m_maintype, "remove_" + Name, atts, new ReturnReferenceExpression(typeof(void)), ArgumentsUtil.ConvertToArgumentReference(parameters)); } return m_removeOnMethod; }
public EasyMethod CreateAddOnMethod(MethodAttributes atts, params Type[] parameters) { if (m_addOnMethod == null) { m_addOnMethod = new EasyMethod(m_maintype, "add_" + Name, atts, new ReturnReferenceExpression(typeof(void)), ArgumentsUtil.ConvertToArgumentReference(parameters)); } return(m_addOnMethod); }
public EasyMethod CreateGetMethod(MethodAttributes attrs, params Type[] parameters) { if (_getMethod != null) { return(_getMethod); } _getMethod = new EasyMethod(_maintype, "get_" + _builder.Name, attrs, new ReturnReferenceExpression(ReturnType), ArgumentsUtil.ConvertToArgumentReference(parameters)); return(_getMethod); }
public EasyMethod CreateSetMethod(MethodAttributes attrs, params Type[] parameters) { if (_setMethod != null) { return _setMethod; } _setMethod = new EasyMethod(_maintype, "set_" + _builder.Name, attrs, new ReturnReferenceExpression(typeof(void)), ArgumentsUtil.ConvertToArgumentReference(parameters)); return _setMethod; }
private void GenerateCall() { ArgumentReference arrayReference = new ArgumentReference(typeof(object[])); this._callmethod = base.CreateMethod("Call", new ReturnReferenceExpression(typeof(object)), new ArgumentReference[] { arrayReference }); TypeReference[] referenceArray = IndirectReference.WrapIfByRef(this._args); LocalReference[] referenceArray2 = new LocalReference[this._args.Length]; Expression[] args = new Expression[this._args.Length]; for (int i = 0; i < this._args.Length; i++) { if (this._args[i].Type.IsByRef) { referenceArray2[i] = this._callmethod.CodeBuilder.DeclareLocal(referenceArray[i].Type); this._callmethod.CodeBuilder.AddStatement(new AssignStatement(referenceArray2[i], new ConvertExpression(referenceArray[i].Type, new LoadRefArrayElementExpression(i, arrayReference)))); args[i] = referenceArray2[i].ToAddressOfExpression(); } else { args[i] = new ConvertExpression(referenceArray[i].Type, new LoadRefArrayElementExpression(i, arrayReference)); } } MethodInvocationExpression expression = new MethodInvocationExpression(this._invokeMethod, args); Expression instance = null; if (this._returnType.Type == typeof(void)) { this._callmethod.CodeBuilder.AddStatement(new ExpressionStatement(expression)); instance = NullExpression.Instance; } else { LocalReference target = this._callmethod.CodeBuilder.DeclareLocal(typeof(object)); this._callmethod.CodeBuilder.AddStatement(new AssignStatement(target, new ConvertExpression(typeof(object), this._returnType.Type, expression))); instance = target.ToExpression(); } for (int j = 0; j < this._args.Length; j++) { if (this._args[j].Type.IsByRef) { this._callmethod.CodeBuilder.AddStatement(new AssignArrayStatement(arrayReference, j, new ConvertExpression(typeof(object), referenceArray[j].Type, referenceArray2[j].ToExpression()))); } } this._callmethod.CodeBuilder.AddStatement(new ReturnStatement(instance)); }
public void Add(EasyMethod method) { InnerList.Add( method ); }
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 Add(EasyMethod method) { InnerList.Add(method); }
public EasyMethod CreateMethod( String name, MethodAttributes attrs, ReturnReferenceExpression returnType, params Type[] args) { EasyMethod member = new EasyMethod( this, name, attrs, returnType, ArgumentsUtil.ConvertToArgumentReference(args) ); _methods.Add(member); return member; }
public EasyMethod CreateMethod( String name, ReturnReferenceExpression returnType, MethodAttributes attributes, params ArgumentReference[] arguments ) { EasyMethod member = new EasyMethod( this, name, attributes, returnType, arguments ); _methods.Add(member); return member; }
/// <summary> /// Writes the method implementation. This /// method generates the IL code for property get/set method and /// ordinary methods. /// </summary> /// <param name="method">The method to implement.</param> /// <param name="builder"><see cref="EasyMethod"/> being constructed.</param> protected virtual void WriteInterceptorInvocationMethod(MethodInfo method, EasyMethod builder) { ArgumentReference[] arguments = builder.Arguments; TypeReference[] dereferencedArguments = IndirectReference.WrapIfByRef(builder.Arguments); LocalReference local_inv = builder.CodeBuilder.DeclareLocal(Context.Invocation); EasyCallable callable = _method2Delegate[method] as EasyCallable; FieldReference fieldDelegate = ObtainCallableFieldBuilderDelegate(callable); builder.CodeBuilder.AddStatement( new AssignStatement(local_inv, new MethodInvocationExpression(_method2Invocation, fieldDelegate.ToExpression(), new MethodTokenExpression(GetCorrectMethod(method)), GetPseudoInvocationTarget(method)))); LocalReference ret_local = builder.CodeBuilder.DeclareLocal(typeof(object)); LocalReference args_local = builder.CodeBuilder.DeclareLocal(typeof(object[])); // Store arguments into an object array. builder.CodeBuilder.AddStatement( new AssignStatement(args_local, new ReferencesToObjectArrayExpression(dereferencedArguments))); // Invoke the interceptor. builder.CodeBuilder.AddStatement( new AssignStatement(ret_local, new VirtualMethodInvocationExpression(InterceptorField, Context.Interceptor.GetMethod("Intercept"), local_inv.ToExpression(), args_local.ToExpression()))); // Load possibly modified ByRef arguments from the array. for(int i = 0; i < arguments.Length; i++) { if (arguments[i].Type.IsByRef) { builder.CodeBuilder.AddStatement( new AssignStatement(dereferencedArguments[i], new ConvertExpression(dereferencedArguments[i].Type, new LoadRefArrayElementExpression(i, args_local)))); } } if (builder.ReturnType == typeof(void)) { builder.CodeBuilder.AddStatement(new ReturnStatement()); } else { builder.CodeBuilder.AddStatement(new ReturnStatement( new ConvertExpression(builder.ReturnType, ret_local.ToExpression()))); } }
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)); }
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)); }