Inheritance: Castle.DynamicProxy.Builder.CodeBuilder.SimpleAST.Expression
Ejemplo n.º 1
0
        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));
        }
Ejemplo n.º 2
0
		public void BlockWithLock()
		{
			EasyType typebuilder = new EasyType( module, "mytype" );

			FieldReference cachefield = typebuilder.CreateField( "cache", typeof(ArrayList) );

			EasyConstructor constructor = typebuilder.CreateConstructor( );
			constructor.CodeBuilder.InvokeBaseConstructor();

			LockBlockExpression block = new LockBlockExpression( SelfReference.Self );

			block.AddStatement( new AssignStatement(cachefield, 
				new NewInstanceExpression( typeof(ArrayList), new Type[0] ) ) );
			
			constructor.CodeBuilder.AddStatement( new ExpressionStatement(block) );
			constructor.CodeBuilder.AddStatement( new ReturnStatement() );

			ReturnReferenceExpression ret = new ReturnReferenceExpression(typeof(ArrayList));
			EasyMethod getCache = typebuilder.CreateMethod( "GetCache", ret );
			getCache.CodeBuilder.AddStatement( new ReturnStatement( cachefield ) );

			Type newType = typebuilder.BuildType();
			Assert.IsNotNull( newType );
			object instance = Activator.CreateInstance( newType, new object[0] );
			Assert.IsNotNull( instance );

			MethodInfo method = instance.GetType().GetMethod("GetCache");
			Assert.IsNotNull( method.Invoke( instance, new object[0] ) );

			RunPEVerify();
		}