public Type Create(Type typeToProxy) { if (definedTypes.ContainsKey(typeToProxy)) { return((Type)definedTypes[typeToProxy]); } if (!HasAopDefinitions(typeToProxy)) { return(typeToProxy); } Type generatedType = generator.CreateType(type => { type.Named(typeToProxy.Name + Guid.NewGuid()); type.InheritFrom(typeToProxy); GeneratedField field = null; if (useServiceLocator) { field = type.AddField <Microsoft.Practices.ServiceLocation.IServiceLocator>("serviceLocator"); type.AddConstructor(constructor => constructor.CreateArgument <Microsoft.Practices.ServiceLocation.IServiceLocator>().AssignTo(field)); } ProxyMethods(type, typeToProxy, field); }); return(generatedType); }
public void GenerateField(IFieldGenerator generator) { for (int y = 0; y < this.matrixNumber; y++) { for (int x = 0; x < this.matrixNumber; x++) { this.cells[y, x].Clear(); } } Actor.ClearEnemies(); ClearRoom(); generator.Generate(); Broker.Global.Publish(GeneratedField.Get()); }
private GeneratedField GenerateField(FieldInfo info) { GeneratedField result = new GeneratedField(); result.info = info; IAccessorCreator creator = store[info.type]; result.getter = creator.MakeGetter(info); result.setter = creator.MakeSetter(info); result.getterDeclaration = result.getter.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)[0]; result.setterDeclaration = result.setter.Split(new string[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries)[0]; return(result); }
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); } })); } } }
private void RecursivelyGenerateCalls(object[] attributes, int currentIndex, DelegateBodyContext lambda, MethodInfo methodInfo, GeneratedField field) { if (currentIndex >= attributes.Length) { return; } var attribute = attributes[currentIndex]; lambda.CreateNestedLambda(nestedLambda => RecursivelyGenerateCalls(attributes, currentIndex + 1, lambda, methodInfo, field), (exitContext, exitVariable, function, callingType) => { var encapsulating = exitContext.CreateVariable <IProcessEncapsulatingAttribute>(); if (useServiceLocator) { var locator = exitContext.CreateVariable <Microsoft.Practices.ServiceLocation.IServiceLocator>(); locator.AssignFrom(field, callingType); encapsulating.AssignFrom(() => locator.Invoke(typeof(Microsoft.Practices.ServiceLocation.IServiceLocator).GetMethod("GetInstance", new Type[0]).MakeGenericMethod(attribute.GetType()))); } else { encapsulating.AssignFrom(exitContext.Instantiate(attribute.GetType())); } var func = exitContext.CreateFunc(methodInfo.ReturnType, function()); if (methodInfo.ReturnType != typeof(void)) { new DefaultProcessEncapsulatingInterceptionStrategy().Intercept(methodInfo, attribute, func, exitVariable, encapsulating); } else { new DefaultProcessEncapsulatingActionInterceptionStrategy().Intercept(methodInfo, attribute, func, null, encapsulating); } }); }
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); }
public FieldLoadAction(GeneratedMethod method, Func <FieldInfo> field, GeneratedField parent) { this.method = method; this.field = field; this.parent = parent; }
public FieldLoadAction(GeneratedMethod method, Func<FieldInfo> field, GeneratedField parent) { this.method = method; this.field = field; this.parent = parent; }