private PropertyInfo ImplementReadPrimaryKeyAndGetPkProperty( IClassBuilder entityClass, EntityBehavior behavior, Type entityType) { var pkProperty = ReflectionUtil.GetProperty(entityType, behavior.PrimaryKeyProperty); if (pkProperty == null) { throw new InvalidOperationException($"{entityType.Name} is missing {behavior.PrimaryKeyProperty} property"); } var idField = entityClass.HasField(pkProperty.PropertyType); var idProp = entityClass.HasProperty(pkProperty.Name, pkProperty.PropertyType).WithModifier("public"); idProp.HasGetter().Write("return ").Write(idField).EndStatement(); idProp.HasSetter().Assign(idField, a => a.Write("value")).EndStatement(); var primaryKeyValueProperty = entityClass.HasProperty(nameof(IEntity.PrimaryKeyValue), typeof(object)) .WithModifier("public"); primaryKeyValueProperty.HasGetter().Write("return ").Write(idProp).EndStatement(); var primaryKeyValueSetter = primaryKeyValueProperty.HasSetter(); primaryKeyValueSetter.Write(idProp).Write(" = ").Write("(").Write(pkProperty.PropertyType).Write(")").Write(primaryKeyValueSetter.ValueParameter).EndStatement(); var readPkMethod = entityClass.HasMethod(nameof(IEntity.ReadPrimaryKey)).WithModifier("public").Returns <bool>(); var readerParam = readPkMethod.WithParam <IDataRecord>("reader"); readPkMethod.Body.If( c => c.Write(readerParam) .Write(".") .Invoke( nameof(IDataRecord.IsNull), p => p.WithParam(code => code.Write("\"").Write(pkProperty.Name).Write("\""))), then => then.Write("return false").EndStatement()).NewLine(); readPkMethod.Body.Assign( idField, a => a.Write(readerParam) .Write(".Get<") .Write(pkProperty.PropertyType) .Write(">(\"") .Write(pkProperty.Name) .Write("\")")).EndStatement(); readPkMethod.Body.Write("return true").EndStatement(); return(pkProperty); }
private void ImplementIsDirtyProperty(IClassBuilder entityClass) { var isDirtyField = entityClass.HasField <bool>("isDirty"); var prop = entityClass.HasProperty <bool>("IsDirty").WithModifier("public"); prop.HasGetter().Write("return ").Write(isDirtyField).EndStatement(); var setter = prop.HasSetter(); setter.Assign(isDirtyField, asi => asi.Write(setter.ValueParameter)); }
private void DefaultImplementProperty(IClassBuilder cls, PropertyInfo property) { var storageField = cls.HasField($"storage{property.Name}_{Guid.NewGuid():N}", property.PropertyType); cls.WithConstructor() .Body.Assign( storageField, assignment => assignment.Write("default(").Write(property.PropertyType).Write(")")); var prop = cls.HasProperty(property.Name, property.PropertyType).WithModifier("public"); prop.HasGetter().Write("return ").Write(storageField).EndStatement(); prop.HasSetter().Assign(storageField, a => a.Write("value")); }
private Dictionary <string, INamedReference> ProjectFactories(IEnumerable <InstanceRecord> records, IClassBuilder locator, out IConstructorBuilder ctor) { var result = new Dictionary <string, INamedReference>(); ctor = locator.WithConstructor().WithModifier("public"); var parentLocatorParam = ctor.WithParam <IServiceLocator>("parentLocator"); ctor.CallsBase().WithParam(parentLocatorParam); var factoriesParam = ctor.WithParam("factories", typeof(Dictionary <string, Func <IServiceLocator, object> >)); var constructor = ctor; Action <NamedFactory> addFactory = factory => { var field = locator.HasField <Func <IServiceLocator, object> >() .WithModifier("readonly") .WithModifier("private"); constructor.Body.Assign( field, a => a.Write(factoriesParam).Write("[\"").Write(factory.Name).Write("\"]")); result.Add(factory.Name, field); }; foreach (var record in records) { if (record.Factory != null) { addFactory(record.Factory); } if (record.ConstructorParameters != null) { foreach (var ctorFactory in record.ConstructorParameters.Where(p => p.ValueProvider != null).Select(p => p.ValueProvider)) { addFactory(ctorFactory); } } } return(result); }
protected virtual void ImplementExecuteMethod(IClassBuilder proxyclass, Type controllerType, Type callBuilderType, INamedReference interceptorField) { var execMethod = proxyclass.HasMethod(nameof(IController.Execute)).WithModifier("public").ReturnsVoid(); var contextParam = execMethod.WithParam("__context", typeof(RequestContext)); execMethod.Body.If( condition => condition.Invoke( interceptorField, nameof(IControllerInterceptor.OnRequest), inv => inv.WithParam("this").WithParam(contextParam)), then => then.Write("return").EndStatement()); var factories = new Dictionary <Type, INamedReference>(); Func <Type, INamedReference> fieldsFactory = type => { INamedReference result; if (!factories.TryGetValue(type, out result)) { result = proxyclass.HasField(type) .WithModifier("private") .WithModifier("static") .WithModifier("readonly") .WithAssignment(asg => asg.Write("new ").Write(type).Write("()")); factories[type] = result; } return(result); }; var writer = Activator.CreateInstance(callBuilderType) as IControllerMethodCallBuilder; if (writer == null) { throw new InvalidOperationException($"{callBuilderType.Name} is not of type {nameof(IControllerMethodCallBuilder)}"); } writer.BuildCall(proxyclass, execMethod, contextParam, controllerType, fieldsFactory, interceptorField); }
private void ImplementDefaultProperty(IClassBuilder entityClass, PropertyInfo sourceProperty, bool setDirtyFlag = false) { var backingField = entityClass.HasField(sourceProperty.PropertyType); var property = entityClass.HasProperty(sourceProperty.Name, sourceProperty.PropertyType).WithModifier("public"); property.HasGetter().Write("return ").Write(backingField).EndStatement(); var setter = property.HasSetter(); if (setDirtyFlag) { setter.If( c => c.Write(backingField).Write(" == ").Write(setter.ValueParameter), then => then.Write("return").EndStatement()); setter.Write("IsDirty = true").EndStatement(); } setter.Assign(backingField, a => a.Write(setter.ValueParameter)).EndStatement(); }
public INamedReference GenerateFactoryMethod( IServiceSetupRecord setup, Dictionary <string, INamedReference> ctorParamValueFactoryFields, INamedReference valueFactoryField, IClassBuilder locatorBuilder, INamedReference previousPluginMethod) { if (setup.GetBehavior(s_defaultBehavior).AlwaysNewInstance) { return(previousPluginMethod); } var field = locatorBuilder.HasField(setup.InterfaceType).WithModifier("private"); var fMethod = locatorBuilder.HasMethod($"Singleton_{TypeNameHelper.GetTypeMark(setup.InterfaceType)}_{Guid.NewGuid():N}").Returns(setup.InterfaceType); fMethod.Body.Write(" return ") .LazyReadOrAssign(field, a => a.Invoke(previousPluginMethod, inv => { })) .EndStatement(); return(fMethod); }
private void ImplementReferenceEntityProperties(IClassBuilder entityClass, Type entityType, IEntityNamingConvention convention) { var getReferencePropertiesMethod = entityClass.HasMethod(nameof(IEntity.GetReferenceProperties)) .Returns <IEnumerable <Tuple <string, Type> > >() .WithModifier("public"); var openPropertyMethod = entityClass.HasMethod(nameof(IEntity.OpenProperty)).Returns <IEntitySet>().WithModifier("public"); var openPropertyNameParam = openPropertyMethod.WithParam <string>("propertyName"); foreach (var property in ReflectionUtil.GetAllProperties(entityType)) { var foreignEntityType = convention.TryGetRefEntityType(property); if (foreignEntityType == null) { continue; } var refNameTypeField = entityClass.HasField <Tuple <string, Type> >().WithModifier("private").WithModifier("readonly").WithAssignment(a => a.InvokeConstructor( typeof(Tuple <string, Type>), inv => inv.WithParam(p => p.String(property.Name)) .WithParam(p => p.Typeof(foreignEntityType)))); getReferencePropertiesMethod.Body.Write("yield return ").Write(refNameTypeField).EndStatement(); INamedReference backingField; if (typeof(IEnumerable).IsAssignableFrom(property.PropertyType)) { backingField = entityClass.HasField <EntityList>() .WithAssignment(a => a.InvokeConstructor(typeof(EntityList), x => { })); entityClass.HasProperty(property.Name, property.PropertyType) .WithModifier("public") .HasGetter() .Write("return ") .Write(typeof(System.Linq.Enumerable)) .Write(".") .Write("OfType<") .Write(foreignEntityType) .Write(">(") .Write(backingField) .Write(")") .EndStatement(); } else { backingField = entityClass.HasField <EntityHolder>() .WithAssignment(a => a.InvokeConstructor(typeof(EntityHolder), x => { })); entityClass.HasProperty(property.Name, property.PropertyType) .WithModifier("public") .HasGetter() .Write("return ") .Write(backingField) .Write(".Value") .Write(" as ") .Write(foreignEntityType) .EndStatement(); } openPropertyMethod.Body.If( c => c.Compare(openPropertyNameParam, b => b.String(property.Name)), then => then.Write("return ").Write(backingField).EndStatement()).NewLine(); } openPropertyMethod.Body.Write("throw ") .InvokeConstructor( typeof(InvalidOperationException), i => i.WithParam(p => p.String("Unknown property requested"))) .EndStatement(); getReferencePropertiesMethod.Body.Write("yield break").EndStatement(); }
protected virtual void ImplementCall( Type controllerType, MethodInfo method, INamedReference contextParameter, INamedReference resultVar, Func <Type, INamedReference> privateObjectsFactory, IClassBuilder proxyBuilder, INamedReference interceptorField, ICodeBlockBuilder block) { var argumentsArray = block.Var(ini => ini.Write($"new System.Object[{method.GetParameters().Length}]")); block.Write("try {\r\n"); var methodInfoField = proxyBuilder.HasField(typeof(MethodInfo)) .WithModifier("static") .WithModifier("private") .WithModifier("readonly") .WithAssignment( asg => asg.Write(typeof(ReflectonWrapper)) .Write(".") .Write(nameof(ReflectonWrapper.GetMethodInfo)) .Write("(") .Typeof(controllerType) .Write(",") .String(method.Name) .Write(")")); var paramVars = new List <INamedReference>(method.GetParameters().Length); var parameterIndex = 0; foreach (var param in method.GetParameters()) { var paramInfoField = proxyBuilder.HasField(typeof(ParameterInfo)) .WithModifier("static") .WithModifier("private") .WithModifier("readonly") .WithAssignment( asg => asg.Write(typeof(ReflectonWrapper)) .Write(".") .Write(nameof(ReflectonWrapper.GetParameterInfo)) .Write("(") .Typeof(controllerType) .Write(",") .String(method.Name) .Write(",") .String(param.Name) .Write(")")); var paramReaderType = GetParameterReaderType(param); var readerField = privateObjectsFactory(paramReaderType); var paramVar = block.Var(asg => ComposeParameterRead(asg, readerField, param, methodInfoField, paramInfoField, contextParameter, interceptorField)); paramVars.Add(paramVar); block.Write(argumentsArray).Write($"[{parameterIndex}] = ").Write(paramVar).EndStatement(); parameterIndex++; } var isVoid = method.ReturnType == typeof(void); var resultWriterField = privateObjectsFactory(GetResultWriterType(method)); block.Invoke( interceptorField, nameof(IControllerInterceptor.Call), args => args.WithParam("this") .WithParam(methodInfoField) .WithParam(contextParameter) .WithParam(argumentsArray) .WithParam(isVoid ? "true" : "false") .WithParam( call => { call.Write("() => {"); if (!isVoid) { call.Write("return "); } call.Invoke( method.Name, argu => { foreach (var argument in paramVars) { argu.WithParam(argument); } }).EndStatement(); if (isVoid) { call.Write("return null").EndStatement(); } call.Write(" }"); }).WithParam( result => { result.Write("__r => ") .Invoke( resultWriterField, nameof(IResultWriter.WriteResult), rinvo => rinvo.WithParam(methodInfoField) .WithParam(contextParameter) .WithParam("__r") .WithParam(isVoid ? "true" : "false")); })).EndStatement(); block.Write("} catch(System.Exception callException) {\r\n"); block.Invoke( interceptorField, nameof(IControllerInterceptor.OnException), arguments => arguments.WithParam("this") .WithParam(methodInfoField) .WithParam(contextParameter) .WithParam(argumentsArray) .WithParam("callException")).EndStatement(); block.Write("}\r\n"); block.Write("return").EndStatement(); }