예제 #1
0
 public SetValueOnObjectAction(GeneratedMethod method, GeneratedVariable variable, object value, MethodInfo info)
 {
     this.method = method;
     this.variable = variable;
     this.value = value;
     this.info = info;
 }
예제 #2
0
        public void Should_Be_Able_To_Add_A_Method_And_Instantiate_A_Type_And_Invoke_A_Method()
        {
            Type generatedType = generator.CreateType(type =>
            {
                type.Named("TestType8");
                type.AddMethod(method =>
                {
                    method.Named("TestMethod");
                    method.Returns(typeof(void));
                    method.CreateArgument <string>();
                    method.WithBody(body =>
                    {
                        GeneratedVariable variable    = body.CreateVariable <Processor>();
                        GeneratedVariable returnValue = body.CreateVariable <string>();

                        variable.AssignFrom(body.Instantiate <Processor>());
                        returnValue.AssignFrom(() => variable.Invoke <Processor>(processor => processor.Process(null, null)));
                        body.Return(returnValue);
                    });
                });
            });

            Assert.IsNotNull(generatedType.GetMethod("TestMethod"));
            Assert.AreEqual(1, generatedType.GetMethod("TestMethod").GetParameters().Length);
            generatedType.GetMethod("TestMethod").Invoke(Activator.CreateInstance(generatedType), new[] { "yay" });
        }
예제 #3
0
        public void Should_Be_Able_To_Add_An_Override_Method_And_Instantiate_A_Type_And_Invoke_A_Method()
        {
            Type generatedType = generator.CreateType(type =>
            {
                type.Named("TestType7");
                type.InheritFrom <BaseType>();
                type.OverrideMethod <BaseType>(baseType => baseType.DoSomething(null), method =>
                {
                    method.WithBody(body =>
                    {
                        GeneratedVariable variable    = body.CreateVariable <Processor>();
                        GeneratedVariable returnValue = body.CreateVariable <string>();

                        variable.AssignFrom(body.Instantiate <Processor>());
                        returnValue.AssignFrom(() => variable.Invoke <Processor>(processor => processor.Process(null, null)));

                        GeneratedVariable baseValue = body.CreateVariable <string>();
                        baseValue.AssignFrom(() => body.CallBase(method.Method));
                        body.Return(baseValue);
                    });
                });
            });

            Assert.IsNotNull(generatedType.GetMethod("DoSomething"));
            Assert.AreEqual(1, generatedType.GetMethod("DoSomething").GetParameters().Length);
            Assert.AreEqual("yay", generatedType.GetMethod("DoSomething").Invoke(Activator.CreateInstance(generatedType), new[] { "yay" }));
        }
예제 #4
0
 public SetValueOnObjectAction(GeneratedMethod method, GeneratedVariable variable, object value, MethodInfo info)
 {
     this.method   = method;
     this.variable = variable;
     this.value    = value;
     this.info     = info;
 }
예제 #5
0
 public SetValueAtIndexAction(GeneratedMethod method, GeneratedArray array, GeneratedVariable variable, int index)
 {
     this.method   = method;
     this.array    = array;
     this.variable = variable;
     this.index    = index;
 }
예제 #6
0
 public SetValueAtIndexAction(GeneratedMethod method, GeneratedArray array, GeneratedVariable variable, int index)
 {
     this.method = method;
     this.array = array;
     this.variable = variable;
     this.index = index;
 }
        public void Intercept(MethodInfo methodInfo, object attribute, GeneratedVariable processor, GeneratedVariable variable, GeneratedVariable encapsulating)
        {
            var defaultAttribute = attribute as IDefaultProcessEncapsulatingAttribute;

            var funcProcessor = GetMethodInfo(() => defaultAttribute.Process<object>(null), methodInfo.ReturnType);
            if(processor != null)
                variable.AssignFrom(() => encapsulating.Invoke(funcProcessor, processor));
            else
                variable.AssignFrom(() => encapsulating.Invoke(funcProcessor));
        }
        public void Intercept(MethodInfo methodInfo, object attribute, GeneratedVariable processor, GeneratedVariable variable, GeneratedVariable encapsulating)
        {
            var defaultAttribute = attribute as IDefaultProcessEncapsulatingActionAttribute;

            var funcProcessor = GetMethodInfo(() => defaultAttribute.Process(null));
            if(processor != null)
                encapsulating.Invoke(funcProcessor, processor);
            else
                encapsulating.Invoke(funcProcessor);
        }
예제 #9
0
        private GeneratedVariable GenerateEncapsulatedCalls(MethodInfo methodInfo, MethodBodyContext body, GeneratedVariable serviceLocator, GeneratedField field)
        {
            var attributes = methodInfo.GetCustomAttributes(typeof(IProcessEncapsulatingAttribute), true);

            GeneratedVariable variable = null;

            if (attributes.Length == 0)
            {
                if (methodInfo.ReturnType == typeof(void))
                {
                    body.CallBase(methodInfo);
                }
                else
                {
                    variable = body.CreateVariable(methodInfo.ReturnType);
                    variable.AssignFrom(() => body.CallBase(methodInfo));
                }

                return(variable);
            }

            var encapsulating = body.CreateVariable <IProcessEncapsulatingAttribute>();

            if (useServiceLocator)
            {
                encapsulating.AssignFrom(() => serviceLocator.Invoke(typeof(Microsoft.Practices.ServiceLocation.IServiceLocator).GetMethod("GetInstance", new Type[0]).MakeGenericMethod(attributes[0].GetType())));
            }
            else
            {
                encapsulating.AssignFrom(body.Instantiate(attributes[0].GetType()));
            }
            MethodInfo target         = null;
            var        lambdaVariable = body.CreateLambda(lambda =>
            {
                target = lambda.Target(methodInfo);

                RecursivelyGenerateCalls(attributes, 1, lambda, methodInfo, field);
            });

            var func = lambdaVariable.CreateFunc(target);

            if (methodInfo.ReturnType != typeof(void))
            {
                variable = body.CreateVariable(methodInfo.ReturnType);
                new DefaultProcessEncapsulatingInterceptionStrategy().Intercept(methodInfo, attributes[0], func, variable, encapsulating);
            }
            else
            {
                new DefaultProcessEncapsulatingActionInterceptionStrategy().Intercept(methodInfo, attributes[0], func, null, encapsulating);
            }

            return(variable);
        }
예제 #10
0
        public void Intercept(MethodInfo methodInfo, object attribute, GeneratedVariable processor, GeneratedVariable variable, GeneratedVariable encapsulating)
        {
            var defaultAttribute = attribute as IDefaultProcessEncapsulatingAttribute;

            var funcProcessor = GetMethodInfo(() => defaultAttribute.Process <object>(null), methodInfo.ReturnType);

            if (processor != null)
            {
                variable.AssignFrom(() => encapsulating.Invoke(funcProcessor, processor));
            }
            else
            {
                variable.AssignFrom(() => encapsulating.Invoke(funcProcessor));
            }
        }
        public void Intercept(MethodInfo methodInfo, object attribute, GeneratedVariable processor, GeneratedVariable variable, GeneratedVariable encapsulating)
        {
            var defaultAttribute = attribute as IDefaultProcessEncapsulatingActionAttribute;

            var funcProcessor = GetMethodInfo(() => defaultAttribute.Process(null));

            if (processor != null)
            {
                encapsulating.Invoke(funcProcessor, processor);
            }
            else
            {
                encapsulating.Invoke(funcProcessor);
            }
        }
예제 #12
0
        private void ProxyMethods(BaseTypeGenerationContext type, Type typeToProxy, GeneratedField field)
        {
            var methods = typeToProxy.GetMethods(BindingFlags.Public | BindingFlags.Instance);

            for (int i = 0; i < methods.Length; i++)
            {
                var methodInfo = methods[i];
                if (methodInfo.IsVirtual && methodInfo.GetBaseDefinition().DeclaringType != typeof(object))
                {
                    type.OverrideMethod(methodInfo, method => method.WithBody(body =>
                    {
                        if (methodInfo.GetCustomAttributes(typeof(IAopAttribute), true).Length == 0)
                        {
                            body.CallBase(methodInfo);
                            return;
                        }

                        GeneratedVariable locator = null;

                        if (useServiceLocator)
                        {
                            locator = body.CreateVariable <Microsoft.Practices.ServiceLocation.IServiceLocator>();
                            locator.AssignFrom(field);
                        }

                        GeneratePreProcessors(body, methodInfo, locator);

                        var returnValue = GenerateEncapsulatedCalls(methodInfo, body, locator, field);

                        GeneratePostProcessors(body, methodInfo, locator);

                        if (returnValue != null)
                        {
                            body.Return(returnValue);
                        }
                    }));
                }
            }
        }
예제 #13
0
 public void Intercept(GeneratedVariable postProcessor)
 {
     postProcessor.Invoke <IDefaultPostProcessingAttribute>(processor => processor.Process());
 }
 public void Intercept(GeneratedVariable preProcessor)
 {
     preProcessor.Invoke<IDefaultPreProcessingAttribute>(processor => processor.Process());
 }
예제 #15
0
 public void Target(GeneratedVariable variable, MethodInfo method)
 {
     actions.Add(new LoadVariableFunctionAction(() => this, variable.LocalIndex, method));
 }
예제 #16
0
 public Type CreateDelegate(GeneratedVariable variable, Func<MethodBuilderBundle> info, Type returnType)
 {
     this.actions.Add(new LoadVariableFunctionAction(() => this, variable.LocalIndex, info));
     var action = new CreateDelegateAction(returnType);
     this.actions.Add(action);
     return action.DelegateType;
 }
예제 #17
0
 public Type CreateDelegate(GeneratedVariable variable, MethodInfo info)
 {
     this.actions.Add(new LoadVariableFunctionAction(() => this, variable.LocalIndex, info));
     var action = new CreateDelegateAction(info.ReturnType);
     this.actions.Add(action);
     return action.DelegateType;
 }
예제 #18
0
        private void GeneratePostProcessors(MethodBodyContext body, ICustomAttributeProvider methodInfo, GeneratedVariable serviceLocator)
        {
            var attributes = methodInfo.GetCustomAttributes(typeof(IPostProcessingAttribute), true);

            for (int i = 0; i < attributes.Length; i++)
            {
                var attribute     = attributes[i];
                var postProcessor = body.CreateVariable <IPostProcessingAttribute>();
                if (useServiceLocator)
                {
                    postProcessor.AssignFrom(() => serviceLocator.Invoke(typeof(Microsoft.Practices.ServiceLocation.IServiceLocator).GetMethod("GetInstance", new Type[0]).MakeGenericMethod(attribute.GetType())));
                }
                else
                {
                    postProcessor.AssignFrom(body.Instantiate(attribute.GetType()));
                }

                postProcessor.Invoke <IDefaultPostProcessingAttribute>(processor => processor.Process());
            }
        }
예제 #19
0
 public void SetValueAtIndex(GeneratedVariable variable, int index)
 {
     actions.Add(new SetValueAtIndexAction(method, this, variable, index));
 }