private void SetPropertyBuilder <TNestedBuilder>(string key, TNestedBuilder builder) where TNestedBuilder : IBuilder { if (PropertyBuilders.ContainsKey(key)) { PropertyBuilders.Remove(key); } PropertyBuilders.Add(key, builder); }
/// <summary> /// Gets the value/instance set for the specified key. /// </summary> /// <typeparam name="T">Type of the value/instance.</typeparam> /// <param name="key">Key for the value/instance</param> /// <param name="orUse">Func that returns a default value if nothing was registered for the specified key.</param> /// <returns></returns> protected T GetProperty <T>(string key, Func <T> orUse) { if (!PropertyBuilders.ContainsKey(key)) { return(orUse()); } return((T)PropertyBuilders[key].Create()); }
/// <summary> /// Checks if property value (or builder that returns a value) has been registered for the specified key. /// </summary> /// <param name="key">Key to check.</param> /// <returns>True if a property value can be resolved, otherwise, false.</returns> protected bool HasProperty(string key) { if (PropertyBuilders.ContainsKey(key)) { return(true); } return(false); }
/// <summary> /// Adds a property. /// </summary> /// <param name="name">The name.</param> /// <param name="type">The type.</param> /// <param name="readOnly">if set to <c>true</c> [read only].</param> /// <param name="attributes">The attributes.</param> /// <returns></returns> public ClassBuilder WithProperty(string name, Type type, bool readOnly, params Expression <Func <Attribute> >[] attributes) { PropertyBuilders.Add(new PropertyBuilder(name, type, attributes, readOnly)); return(this); }
/// <summary> /// Adds multiple properties. /// </summary> /// <param name="propertyBuilders">The property builders.</param> /// <returns></returns> public ClassBuilder WithProperty(IEnumerable <PropertyBuilder> propertyBuilders) { foreach (var propertyBuilder in propertyBuilders) { PropertyBuilders.Add(propertyBuilder); } return(this); }
/// <summary> /// Gets the builder associated with the specified property. /// </summary> /// <typeparam name="T">Property type</typeparam> /// <param name="prop">Lamnda expression pointing to the property.</param> /// <param name="orUse">Func that returns a default if no builder was registered for the specified property.</param> /// <returns></returns> protected TBuilder GetPropertyBuilder <TBuilder>(Expression <Func <TSubject, object> > prop, Func <TBuilder> orUse) { string key = GetPropertyName(prop); if (PropertyBuilders.ContainsKey(key)) { return((TBuilder)PropertyBuilders[key]); } return(orUse()); }
public void GenericMethodInGenericTypes() { var ns = NamespaceSignature.Parse("MyNamespace"); var t1 = new GenericParameter(Guid.NewGuid(), "T1"); var t2 = new GenericParameter(Guid.NewGuid(), "T2"); var tresult = new GenericParameter(Guid.NewGuid(), "TResult"); var rootType = TypeSignature.Class("MyType", ns, Accessibility.APublic, true, false, t1); var(f, p) = PropertyBuilders.CreateAutoProperty(rootType, "A", t1, isReadOnly: false); var map_fn_type = new FunctionType(new [] { new MethodParameter(t1, "a") }, tresult); var map_sgn = MethodSignature.Instance("Map", rootType, Accessibility.APublic, rootType.Specialize(tresult), new [] { tresult }, new MethodParameter(map_fn_type.TryGetDelegate(), "func") ); var tmp = ParameterExpression.Create(map_sgn.ResultType, "result"); var map_def = MethodDef.Create(map_sgn, (@this, fn) => Expression.Block( new [] { tmp.Ref() .CallMethod(p.Setter.Signature.Specialize(new TypeReference[] { tresult }, null), fn.Read().FunctionConvert(map_fn_type).Invoke(@this.Ref().CallMethod(p.Getter.Signature.SpecializeFromDeclaringType())) ) }, result: tmp ) .Where(tmp, Expression.NewObject(MethodSignature.ImplicitConstructor(rootType).Specialize(new TypeReference[] { tresult }, null))) ); var type = TypeSignature.Class("MyNestedType", rootType, Accessibility.APublic, true, false, t2); var t3 = new GenericParameter(Guid.NewGuid(), "T3"); var method = MethodSignature.Instance( "M", type, Accessibility.APublic, returnType: type.Specialize(t1, t3), typeParameters: new [] { t3 }); var td = TypeDef.Empty(type) .AddMember(MethodDef.Create(method, @this => Expression.NewObject( MethodSignature.ImplicitConstructor(type).Specialize(new TypeReference[] { t1, t3 }, null), ImmutableArray <Expression> .Empty ) )) ; cx.AddType(TypeDef.Empty(rootType).AddMember(td, f, p, map_def)); check.CheckOutput(cx); }
protected CollectionBuilder <TChild, TChildBuilder> GetCollection <TChild, TChildBuilder>(Expression <Func <TSubject, object> > prop) where TChild : class where TChildBuilder : Builder <TChild> { CollectionBuilder <TChild, TChildBuilder> col = null; var key = GetPropertyName(prop); if (PropertyBuilders.ContainsKey(key)) { col = PropertyBuilders[key] as CollectionBuilder <TChild, TChildBuilder>; } return(col ?? new CollectionBuilder <TChild, TChildBuilder>(this)); }
/// <summary> /// Gets the result as code instead of an type. /// </summary> /// <returns></returns> public string GetAsCode() { var propertiesBuilt = PropertyBuilders.Select(i => { if (IsInterface) { i.AsInterface(); } return(i.Build().ToString()); }).ToArray(); var typesInUse = PropertyBuilders.Select(i => i.PropertyType).Concat(PropertyBuilders .Where(i => i.Attributes != null) .SelectMany(o => o.Attributes.Select(j => j.Compile().Invoke().GetType()))); var uniqueUsings = typesInUse.Select(o => o.Namespace).Distinct(); return(BuildClassOrInterface(uniqueUsings, propertiesBuilt, Name, IsInterface)); }
public void GenericClass() { var paramT = GenericParameter.Create("T"); var myContainerSgn = TypeSignature.Class( "MyContainer", NamespaceSignature.Parse("NS"), Accessibility.APublic, genericParameters: new [] { paramT } ); var(item_field, item_prop) = PropertyBuilders.CreateAutoProperty( myContainerSgn, name: "Item", propertyType: paramT, isReadOnly: false ); var listType = TypeSignature.FromType(typeof(List <>)) .Specialize(paramT); var toListSgn = MethodSignature.Instance( "ToList", myContainerSgn, Accessibility.APublic, returnType: listType ); var toListDef = MethodDef.Create(toListSgn, thisParam => { var resultVar = ParameterExpression.Create(listType, "result"); var listCtor = MethodReference.FromLambda(() => new List <int>()) .Signature .Specialize(paramT); var listAdd = MethodReference.FromLambda <List <int> >(l => l.Add(0)) .Signature .Specialize(paramT); return(Expression.LetIn( // result = new List<T>() resultVar, Expression.NewObject(listCtor), new [] { // result.Add(this.Item) resultVar.Read().CallMethod(listAdd, thisParam.Read().ReadField(item_field.Signature.SpecializeFromDeclaringType()) ) }.ToBlock(resultVar) )); }); var copyFromSgn = MethodSignature.Instance( "CopyFrom", myContainerSgn, Accessibility.APublic, returnType: TypeSignature.Void, new MethodParameter( myContainerSgn.SpecializeByItself(), "other" ) ); var copyFromDef = MethodDef.Create(copyFromSgn, (thisParam, otherParam) => { var field = item_field.Signature.SpecializeFromDeclaringType(); return(thisParam.Read().AssignField( field, otherParam.Read().ReadField(field) )); }); var myContainerDef = TypeDef.Empty(myContainerSgn) .AddMember(item_field, item_prop, toListDef, copyFromDef); cx.AddType(myContainerDef); check.CheckOutput(cx); }
/// <summary> /// Adds a property. /// </summary> /// <param name="propertyBuilder">The property builder.</param> /// <returns></returns> public ClassBuilder WithProperty(PropertyBuilder propertyBuilder) { PropertyBuilders.Add(propertyBuilder); return(this); }
/// <summary> /// Adds a property. /// </summary> /// <param name="name">The name.</param> /// <param name="type">The type.</param> /// <param name="readOnly">if set to <c>true</c> [read only].</param> /// <param name="attributes">The attributes.</param> /// <returns></returns> public ClassBuilder WithProperty(string name, Type type, bool readOnly, IEnumerable <Attribute> attributes) { PropertyBuilders.Add(new PropertyBuilder(name, type, attributes, readOnly)); return(this); }
/// <summary> /// Adds a property. /// </summary> /// <param name="name">The name.</param> /// <param name="type">The type.</param> /// <param name="readOnly">if set to <c>true</c> [read only].</param> /// <returns></returns> public ClassBuilder WithProperty(string name, Type type, bool readOnly) { PropertyBuilders.Add(new PropertyBuilder(name, type, readOnly: readOnly)); return(this); }