public static (VirtualProperty prop, IField field) AddAutoProperty(this VirtualType declaringType, string name, IType propertyType, Accessibility accessibility = Accessibility.Public, bool isReadOnly = true) { name = E.SymbolNamer.NameMember(declaringType, name, lowerCase: accessibility == Accessibility.Private); var field = new VirtualField(declaringType, Accessibility.Private, string.Format(AutoPropertyField, name), propertyType, isReadOnly: isReadOnly, isHidden: true); field.Attributes.Add(declaringType.Compilation.CompilerGeneratedAttribute()); var getter = new VirtualMethod(declaringType, accessibility, string.Format(PropertyGetter, name), Array.Empty <IParameter>(), propertyType, isHidden: true); getter.BodyFactory = () => CreateExpressionFunction(getter, new IL.LdObj(new IL.LdFlda(new IL.LdLoc(new IL.ILVariable(IL.VariableKind.Parameter, declaringType, -1)), field), propertyType) ); getter.Attributes.Add(declaringType.Compilation.CompilerGeneratedAttribute()); var setter = isReadOnly ? null : new VirtualMethod(declaringType, accessibility, string.Format(PropertySetter, name), new [] { new VirtualParameter(propertyType, "value") }, declaringType.Compilation.FindType(typeof(void)), isHidden: true); var prop = new VirtualProperty(declaringType, accessibility, name, getter, setter); declaringType.Methods.Add(getter); if (setter != null) { declaringType.Methods.Add(setter); } declaringType.Fields.Add(field); declaringType.Properties.Add(prop); return(prop, field); }
public static IProperty AddExplicitInterfaceProperty(this VirtualType declaringType, IProperty ifcProperty, IMember baseMember) { Debug.Assert(declaringType.Equals(baseMember.DeclaringType) || declaringType.GetAllBaseTypeDefinitions().Contains(baseMember.DeclaringType)); Debug.Assert(ifcProperty.DeclaringType.Kind == TypeKind.Interface); var getter = new VirtualMethod(declaringType, Accessibility.Private, "get_" + ifcProperty.FullName, new IParameter[0], ifcProperty.ReturnType, explicitImplementations: new [] { ifcProperty.Getter }, isHidden: true); getter.BodyFactory = () => { var thisParam = new IL.ILVariable(IL.VariableKind.Parameter, declaringType, -1); return(CreateExpressionFunction(getter, new IL.LdLoc(thisParam).AccessMember(baseMember))); }; var setter = ifcProperty.Setter == null ? null : new VirtualMethod(declaringType, Accessibility.Private, "get_" + ifcProperty.FullName, ifcProperty.Setter.Parameters, ifcProperty.Setter.ReturnType, explicitImplementations: new [] { ifcProperty.Setter }, isHidden: true); if (setter != null) { setter.BodyFactory = () => { var thisParam = new IL.ILVariable(IL.VariableKind.Parameter, declaringType, -1); var valueParam = new IL.ILVariable(IL.VariableKind.Parameter, declaringType, 0); return(CreateExpressionFunction(getter, new IL.LdLoc(thisParam).AssignMember(baseMember, new IL.LdLoc(valueParam)))); } } ; var prop = new VirtualProperty(declaringType, Accessibility.Private, ifcProperty.FullName, getter, setter, explicitImplementations: new [] { ifcProperty }); getter.ApplyAction(declaringType.Methods.Add); setter?.ApplyAction(declaringType.Methods.Add); prop.ApplyAction(declaringType.Properties.Add); return(prop); }
public static void AddPropertyAttributes(VirtualProperty property, string fieldName) { if (ToCamelCase(property.Name) == fieldName) { return; } property.Attributes.Add(GetJsonPropertyAttribute(property.Compilation, fieldName)); }
public static void GenerateExtraTypes <T>() { TweakableInfo <T> tweakableInfo = new TweakableInfo <T>(null, null, null, null, 0u, null, null); TweakableNamedToggleValue <T> tweakableNamedToggleValue = new TweakableNamedToggleValue <T>(null, default(T)); TweakableToggleValue <T> tweakableToggleValue = new TweakableToggleValue <T>(default(T)); BaseTweakable <T> baseTweakable = new BaseTweakable <T>((TweakableInfo <T>)null, (PropertyInfo)null, (WeakReference)null); VirtualField <T> virtualField = new VirtualField <T>(); VirtualProperty <T> virtualProperty = new VirtualProperty <T>(null, null); }
/// <summary> /// Resolves cache for current values /// </summary> private void Resolve() { if ((objectReference == null) || (objectReference.Target == null)) { return; } if (DatabaseProvider.IsValidType(objectReference.Target) == true) { propColumn = (DataColumn)DatabaseProvider.PropertyExists(objectReference.Target, PropertyName); } else if (VirtualObjectProvider.IsValidType(objectReference.Target) == true) { propVirtual = (objectReference.Target as IVirtualObject)[PropertyName]; } else { // Object is just a normal class propInfo = ConnectionProvider.ResolveMappingPropertyByType(objectReference.Target.GetType(), PropertyName, false); } }
/// <summary> /// Resolves cache for current values /// </summary> private void Resolve() { if ((objectReference == null) || (objectReference.Target == null)) return; if (DatabaseProvider.IsValidType(objectReference.Target) == true) { propColumn = (DataColumn) DatabaseProvider.PropertyExists (objectReference.Target, PropertyName); } else if (VirtualObjectProvider.IsValidType(objectReference.Target) == true) { propVirtual = (objectReference.Target as IVirtualObject)[PropertyName]; } else { // Object is just a normal class propInfo = ConnectionProvider.ResolveMappingPropertyByType (objectReference.Target.GetType(), PropertyName, false); } }
/// <summary> /// Clears all cached values /// </summary> public void Clear() { propColumn = null; propVirtual = null; propInfo = null; }
public static void OnPropChange(IVirtualObject a_Object, VirtualProperty a_Property) { Console.WriteLine("Changed value in (" + a_Object + "::" + a_Object.ObjectType.Name + ") on " + a_Property.Name); }
public static void OnPropChange (IVirtualObject a_Object, VirtualProperty a_Property) { Console.WriteLine ("Changed value in (" + a_Object + "::" + a_Object.ObjectType.Name + ") on " + a_Property.Name); }
public static IList <IDataObject> GetDataObjectsWithVirtualProperties(this IList <IDataObject> dataObjects, DataObject objectType) { //TODO Handle null _logger.DebugFormat("Adding virtual properties to object"); try { foreach (DataProperty dataPropertyDef in objectType.dataProperties.Where(x => x.isVirtual == true)) { IDataObject dataObject = null; for (int i = 0; i < dataObjects.Count; i++) { dataObject = dataObjects[i]; // check if property already exist or not // if (dataObject.GetPropertyValue(dataPropertyDef.propertyName) != null) // continue; VirtualProperty vp = ((VirtualProperty)dataPropertyDef); StringBuilder valueBuilder = new StringBuilder(); for (int j = 0; j < vp.virtualPropertyValues.Count; j++) { VirtualPropertyValue vpValue = vp.virtualPropertyValues[j]; if (vpValue.type == VirtualPropertyValueType.Constant) { valueBuilder.Append(vpValue.valueText); } else if (vpValue.type == VirtualPropertyValueType.Property) { string val = Convert.ToString(dataObject.GetPropertyValue(vpValue.propertyName.ToUpper())); if (vpValue.length == -1 || val.Length <= vpValue.length) { valueBuilder.Append(val); } else { valueBuilder.Append(val.Substring(0, vpValue.length)); } } if (j + 1 < vp.virtualPropertyValues.Count) { valueBuilder.Append(vp.delimiter); } } object value = valueBuilder.ToString(); if (typeof(SerializableDataObject).IsAssignableFrom(dataObject.GetType())) { ((SerializableDataObject)dataObject).Dictionary[dataPropertyDef.propertyName] = value; } else if (typeof(GenericDataObject).IsAssignableFrom(dataObject.GetType())) { ((GenericDataObject)dataObject).Dictionary[dataPropertyDef.propertyName] = value; } else if (typeof(GenericContentObject).IsAssignableFrom(dataObject.GetType())) { ((GenericContentObject)dataObject).Dictionary[dataPropertyDef.propertyName] = value; } else //create new GenericDataObject object from exiting IDataObject and then add the new properties { IDataObject dataObjectNew = GetNewObject(dataObject, objectType); ((GenericDataObject)dataObjectNew).Dictionary[dataPropertyDef.propertyName] = value; dataObjects[i] = dataObjectNew; } } } } catch (Exception e) { _logger.Error("Error in adding virtual proprties" + e.Message); throw e; } return(dataObjects); }