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);
}
/// <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 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);
}
