internal void CallAfterConfigurationMemberPersist()
{
//if (!(ConfigObject is ChoConfigurableObject))
// return;
if (AfterConfigurationObjectMemberPersist != null)
{
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(GetType());
if (memberInfos == null || memberInfos.Length == 0)
{
return;
}
ChoPropertyInfoAttribute memberInfoAttribute = null;
string name = null;
foreach (MemberInfo memberInfo in memberInfos)
{
if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null)
{
continue;
}
object memberValue = ChoType.GetMemberValue(this, memberInfo.Name);
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute));
name = ChoType.GetMemberName(memberInfo, memberInfoAttribute);
RaiseAfterConfigurationObjectMemberPersist(memberInfo.Name, name, memberValue);
}
}
}
public static bool IsValidFor(this object @this, MemberInfo mi, out Exception aggEx)
{
aggEx = null;
ChoGuard.ArgumentNotNullOrEmpty(@this, "Target");
if (@this == null)
{
return(true);
}
var results = new List <ValidationResult>();
object surrObj = ChoMetadataObjectCache.Default.GetMetadataObject(@this);
if (surrObj is IChoValidatable)
{
((IChoValidatable)surrObj).TryValidateFor(@this, mi.Name, results);
}
else
{
var context = new ValidationContext(@this, null, null);
context.MemberName = mi.Name;
Validator.TryValidateValue(ChoType.GetMemberValue(@this, mi), context, results, ChoTypeDescriptor.GetPropetyAttributes <ValidationAttribute>(ChoTypeDescriptor.GetProperty <ValidationAttribute>(@this.GetType(), mi.Name)));
}
if (results.Count > 0)
{
aggEx = new ApplicationException("Failed to validate '{0}' member. {2}{1}".FormatString(mi.Name, ToString(results), Environment.NewLine));
return(false);
}
else
{
return(true);
}
}
protected override bool PreInvoke(ChoMemberInfo memberInfo)
{
object oldValue = ChoType.GetMemberValue(this, memberInfo.Info);
object newValue = memberInfo.Value;
bool isEqual = IsMemeberValueEqualInternal(memberInfo.Info, oldValue, newValue);
if (!isEqual)
{
if (memberInfo.DirtyOperation)
{
string propertyName = ChoType.GetMemberName(memberInfo.Info);
try
{
bool handled = RaiseBeforeConfigurationObjectMemberLoaded(memberInfo.Name, propertyName, oldValue, ref newValue);
memberInfo.Value = newValue;
return(!handled);
}
catch (Exception ex)
{
if (!RaiseConfigurationObjectMemberLoadError(memberInfo.Name, propertyName, newValue, ex))
{
throw;
}
}
}
return(true);
}
else
{
return(!isEqual);
}
}
public static object ConvertFrom(object target, MemberInfo memberInfo, CultureInfo culture)
{
ChoGuard.ArgumentNotNull(target, "Target");
ChoGuard.ArgumentNotNull(memberInfo, "MemberInfo");
Type objType = null;
if (target is Type)
{
objType = target as Type;
target = null;
}
else
{
objType = target.GetType();
}
if (target == null)
{
return(ChoConvert.ConvertFrom(target, ChoType.GetMemberValue(objType, memberInfo.Name), ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), culture));
}
else
{
return(ChoConvert.ConvertFrom(target, ChoType.GetMemberValue(target, memberInfo.Name), ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), culture));
}
}
private void WireNotifyPropertyChangedMembersForChanges(Type type)
{
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(type);
if (memberInfos != null && memberInfos.Length > 0)
{
//Set member values
INotifyPropertyChanged memberValue = null;
ChoPropertyInfoAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null)
{
continue;
}
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute));
memberValue = ChoType.GetMemberValue(this, memberInfo.Name) as INotifyPropertyChanged;
if (memberValue == null)
{
continue;
}
memberValue.PropertyChanged += MemberValuePropertyChanged;
WireNotifyPropertyChangedMembersForChanges(memberValue.GetType());
}
}
}
private static void DoPostTypeMemberConversion(Type type)
{
bool hasError = false;
foreach (MemberInfo memberInfo in ChoType.GetMemberInfos(type, typeof(ChoTypeConverterAttribute)))
{
object memberValue = null;
try
{
memberValue = ChoType.GetMemberValue(null, memberInfo.Name);
ChoType.SetMemberValue(null, memberInfo, ChoObject.ConvertValueToObjectMemberType(type, memberInfo, memberValue) /* ChoConvert.ChangeType(configObject, memberInfo) */);
}
catch (TargetInvocationException)
{
throw;
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
hasError = true;
ChoConfigurationObjectErrorManagerService.SetObjectMemberError(type, memberInfo.Name, String.Format("[Value: {0}] - {1}", ChoString.ToString(memberValue), ex.Message));
ChoType.SetMemberDefaultValue(null, memberInfo.Name);
}
}
if (hasError)
{
ChoConfigurationObjectErrorManagerService.SetObjectError(type, "Object has some validation errors.");
}
}
public object GetValue(object target)
{
if (MemberInfo != null)
{
return(ChoType.GetMemberValue(target, MemberInfo));
}
else if (target is IDictionary <string, object> ) ///ExpandoObject || target is ChoDynamicObject)
{
IDictionary <string, object> dict = target as IDictionary <string, object>;
if (dict.ContainsKey(MemberName))
{
return(((IDictionary <string, object>)target)[MemberName]);
}
else
{
if (target is ChoDynamicObject && ((ChoDynamicObject)target).DynamicObjectName == MemberName)
{
return(((ChoDynamicObject)target).GetText());
}
throw new ApplicationException("Can't find '{0}' member in dynamic object.".FormatString(MemberName));
}
}
else
{
return(ChoType.GetMemberValue(target, MemberName)); // ChoConvert.ConvertTo(ChoType.GetMemberValue(target, MemberName), ProperyType);
}
}
public override string ToString()
{
StringBuilder msg = new StringBuilder();
foreach (PropertyInfo pi in GetType().GetProperties(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
AppendToMsg(msg, ChoType.GetMemberValue(this, pi).ToNString());
}
return(msg.ToString());
}
public static IEnumerable <object> AsList(this object target, bool flattenhierarchy = false, bool expandCollection = false)
{
if (target != null)
{
Type type = target.GetType();
foreach (MemberInfo memberInfo in ChoTypeMembersCache.GetAllMemberInfos(type))
{
object memberValue = ChoType.GetMemberValue(target, memberInfo);
if (!flattenhierarchy)
{
yield return(memberValue);
}
else
{
Type memberType = ChoType.GetMemberType(memberInfo);
if (memberType.IsSimple())
{
yield return(memberValue);
}
else if (typeof(ICollection).IsAssignableFrom(memberType))
{
if (!expandCollection || memberValue == null)
{
yield return(memberValue);
}
else
{
if (((ICollection)memberValue).Count == 0)
{
yield return(null);
}
else
{
foreach (object value in (ICollection)memberValue)
{
yield return(value);
}
}
}
}
else
{
foreach (Tuple <string, object> subItem in AsDictionary(memberValue, flattenhierarchy))
{
yield return(subItem);
}
}
}
}
}
yield break;
}
public static void ConvertNSetMemberValue(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ref object fieldValue, CultureInfo culture)
{
if (fieldConfig.Converters.IsNullOrEmpty())
{
ChoType.ConvertNSetMemberValue(rec, fn, fieldValue, culture);
fieldValue = ChoType.GetMemberValue(rec, fn);
}
else
{
fieldValue = ChoConvert.ConvertFrom(fieldValue, ChoType.GetMemberType(rec.GetType(), fn), null, fieldConfig.Converters.ToArray(), null, culture);
ChoType.SetMemberValue(rec, fn, fieldValue);
}
}
public static int Compare(object obj1, object obj2)
{
if (System.Object.ReferenceEquals(obj1, obj2))
{
return(0);
}
if (obj1 == null)
{
return(-1);
}
if (obj2 == null)
{
return(1);
}
if (obj1.GetType().IsSimple())
{
return(((IComparable)obj1).CompareTo(obj2));
}
else
{
MemberInfo[] memberInfos = obj1.GetType().GetMembers(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly | BindingFlags.GetField | BindingFlags.GetProperty);
if (memberInfos == null || memberInfos.Length == 0)
{
return(0);
}
else
{
int retValue = 0;
foreach (MemberInfo memberInfo in memberInfos)
{
if (!ChoType.IsValidObjectMember(memberInfo))
{
continue;
}
if (ChoType.GetMemberAttribute(memberInfo, typeof(ChoIgnoreCompareAttribute)) != null)
{
continue;
}
retValue += Compare(ChoType.GetMemberValue(obj1, memberInfo), ChoType.GetMemberValue(obj2, memberInfo));
}
return(retValue);
}
}
}
internal static NameValueCollection ToPersistableNameValueCollection(object target)
{
ChoGuard.ArgumentNotNull(target, "Target");
NameValueCollection nameValues = new NameValueCollection();
//Dictionary<string, MemberInfo> configMemberInfos = ChoType.GetMembersDictionary(target.GetType(), typeof(ChoConfigurationPropertyAttribute));
//MemberInfo[] memberInfos = ChoType.GetMembers(target.GetType(), typeof(ChoConfigurationPropertyAttribute));
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(target.GetType());
if (memberInfos == null || memberInfos.Length == 0)
{
return(nameValues);
}
ChoPropertyInfoAttribute memberInfoAttribute = null;
string name = null;
foreach (MemberInfo memberInfo in memberInfos)
{
if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null)
{
continue;
}
object memberValue = ChoType.GetMemberValue(target, memberInfo.Name);
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute));
//if (memberInfoAttribute == null) continue;
name = ChoType.GetMemberName(memberInfo, memberInfoAttribute);
if (target is ChoConfigurableObject && ((ChoConfigurableObject)target).RaiseBeforeConfigurationObjectMemberPersist(memberInfo.Name, name, ref memberValue))
{
nameValues.Add(name, memberValue == null ? null : memberValue.ToString());
}
else
{
if (memberInfoAttribute != null && !memberInfoAttribute.Persistable)
{
continue;
}
memberValue = ChoType.GetMemberValue(target, memberInfo.Name);
nameValues.Add(name, ChoString.ToString(ChoConvert.ConvertTo(target, memberValue, typeof(string),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), null),
String.Empty, String.Empty));
}
}
return(nameValues);
}
public override bool TryGetMember(GetMemberBinder binder, out object result)
{
result = null;
MemberInfo memberInfo = ChoTypeMembersCache.GetMemberInfo(_type, binder.Name);
if (memberInfo != null)
{
result = ChoType.GetMemberValue(_instance, memberInfo);
return(true);
}
else
{
return(false);
}
}
public static object GetPersistableMemberValue(object target, MemberInfo memberInfo)
{
ChoGuard.ArgumentNotNull(target, "Target");
object memberValue = ChoType.GetMemberValue(target, memberInfo.Name);
object persistValue = memberValue;
string propertyName = ChoType.GetMemberName(memberInfo);
if (target is ChoConfigurableObject && ((ChoConfigurableObject)target).RaiseBeforeConfigurationObjectMemberPersist(memberInfo.Name, propertyName, ref persistValue))
{
return(persistValue);
}
return(memberValue);
}
public static object GetObjectMemberValue(object target, MemberInfo memberInfo)
{
ChoGuard.ArgumentNotNull(target, "Target");
object memberValue = ChoType.GetMemberValue(target, memberInfo);
if (memberValue == null)
{
ChoPropertyInfoAttribute memberInfoAttribute = ChoType.GetMemberAttribute <ChoPropertyInfoAttribute>(memberInfo);
if (memberInfoAttribute != null)
{
memberValue = memberInfoAttribute.DefaultValue;
}
}
return(memberValue);
}
// If the type of the value to convert is string, parses the string
// and returns the integer to set the value of the property to.
// This example first extends the integer array that supplies the
// standard values collection if the user-entered value is not
// already in the array.
public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{
value = ChoType.GetMemberValue(Target, DependentMemberName);
object convertedObject = null;
using (ChoBufferProfileEx outerProfile = new ChoBufferProfileEx(LogFileName, "Converting file to objects...."))
{
try
{
if (value.GetType() == typeof(string))
{
convertedObject = GetObject(value as string, outerProfile);
}
else if (value.GetType() == typeof(string[]))
{
Hashtable convertedObjects = new Hashtable();
foreach (string fileName in (string[])value)
{
object element = GetObject(fileName, outerProfile);
if (KeyName == InternalHashKey)
{
convertedObjects.Add(element.GetHashCode().ToString(), element);
}
else
{
convertedObjects.Add(ChoType.GetMemberValue(element, KeyName).ToString(), element);
}
}
convertedObject = convertedObjects;
}
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
outerProfile.Append(ex);
}
}
return(convertedObject);
}
private static string GetNFormatMemberValue(object target, MemberInfo memberInfo, bool collectErrMsgs, ChoMemberFormatterAttribute memberFormaterAttribute,
ChoMemberItemFormatterAttribute memberItemFormaterAttribute, BindingFlags bindingFlags)
{
try
{
string memberText = null;
object memberValue = ChoType.GetMemberValue(target, memberInfo);
if (memberValue == target)
{
return(null);
}
//if (memberFormaterAttribute == null)
//{
// object[] typeConverters = ChoTypeDescriptor.GetTypeConverters(memberInfo);
// if (typeConverters != null && typeConverters.Length > 0)
// {
// if (typeConverters.Length == 1 && typeConverters[0].GetType() == typeof(System.ComponentModel.TypeConverter))
// {
// }
// else
// {
// object convertedValue = ChoConvert.ConvertTo(target, memberInfo, typeof(string)); //, typeConverters, ChoTypeDescriptor.GetTypeConverterParams(memberInfo), null);
// return convertedValue == null ? String.Empty : convertedValue.ToString();
// //return memberText;
// }
// }
//}
memberText = ChoFormattableObject.ToString(memberValue, collectErrMsgs, memberFormaterAttribute, memberItemFormaterAttribute, bindingFlags);
if (memberText.ContainsMultiLines())
{
memberText = Environment.NewLine + memberText.Indent();
}
return(memberText);
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
throw new ChoApplicationException(memberInfo.Name, ex);
}
}
private static void DoValidate <T>(T target, ChoValidationResults validationResults)
{
bool validationRoutineFound = false;
bool canContinue = true;
foreach (MethodInfo methodInfo in GetValidationRoutines(target.GetType()))
{
canContinue = false;
validationRoutineFound = true;
canContinue = (bool)ChoType.InvokeMethod(target, methodInfo.Name, new object[] { validationResults });
if (!canContinue)
{
break;
}
}
//Do built-in attribute validations
if (!validationRoutineFound)
{
MemberInfo[] memberInfos = ChoType.GetMembers(target.GetType());
foreach (MemberInfo memberInfo in memberInfos)
{
IChoSurrogateValidator validator = ChoCompositeValidatorBuilder.GetValidator(memberInfo);
if (validator == null)
{
continue;
}
try
{
validator.Validate(memberInfo, ChoType.GetMemberValue(target, memberInfo.Name));
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
validationResults.AddResult(new ChoValidationResult(ex.Message));
}
}
}
}
public static void DoMemberLevelValidation(this object rec, string fn, ChoRecordFieldConfiguration fieldConfig, ChoObjectValidationMode vm)
{
if (rec is ExpandoObject)
{
((IDictionary <string, object>)rec).DoMemberLevelValidation(fn, fieldConfig, vm);
}
else
{
if ((vm & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
{
if (fieldConfig.Validators.IsNullOrEmpty())
{
ChoValidator.ValidateFor(rec, fn);
}
else
{
ChoValidator.ValidateFor(ChoType.GetMemberValue(rec, fn), fn, fieldConfig.Validators);
}
}
}
}
protected override bool PreInvoke(ChoMemberInfo memberInfo)
{
object oldValue = ChoType.GetMemberValue(this, memberInfo.Info);
object newValue = memberInfo.Value;
bool isEqual = IsMemeberValueEqualInternal(memberInfo.Info, oldValue, newValue);
if (!isEqual)
{
if (memberInfo.DirtyOperation)
{
string propertyName = ChoType.GetMemberName(memberInfo.Info);
try
{
bool cancel = RaiseBeforeConfigurationObjectMemberSet(memberInfo.Name, propertyName, oldValue, ref newValue);
//if (!cancel)
//{
// //memberInfo.Value = newValue;
// ChoType.SetMemberValue(this, memberInfo.Info, newValue);
// this.OnPropertyChanged(memberInfo.Name);
//}
return(!cancel);
}
catch (Exception ex)
{
if (!RaiseConfigurationObjectMemberSetError(memberInfo.Name, propertyName, newValue, ex))
{
throw new ChoConfigurationObjectPostInvokeException("Error while setting configuration member value.", memberInfo.Exception);
}
}
}
return(true);
}
else
{
return(!isEqual);
}
}
public IEnumerable <KeyValuePair <string, object> > AsDictionary()
{
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(GetType());
if (memberInfos != null && memberInfos.Length > 0)
{
//Set member values
string name;
ChoPropertyInfoAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null)
{
continue;
}
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute));
name = ChoType.GetMemberName(memberInfo);
yield return(new KeyValuePair <string, object>(name, ChoType.GetMemberValue(GetType(), memberInfo)));
}
}
}
// If the type of the value to convert is string, parses the string
// and returns the integer to set the value of the property to.
// This example first extends the integer array that supplies the
// standard values collection if the user-entered value is not
// already in the array.
public override object ConvertFrom(System.ComponentModel.ITypeDescriptorContext context, System.Globalization.CultureInfo culture, object value)
{
value = ChoType.GetMemberValue(Target, DependentMemberName);
object convertedObject = null;
using (ChoBufferProfileEx outerProfile = new ChoBufferProfileEx(LogFileName, "Converting file to objects...."))
{
try
{
if (value.GetType() == typeof(string))
{
convertedObject = GetObject(value as string, outerProfile);
}
else if (value.GetType() == typeof(string[]))
{
ChoNotNullableArrayList convertedObjects = new ChoNotNullableArrayList();
foreach (string fileName in (string[])value)
{
convertedObjects.Add(GetObject(fileName, outerProfile));
}
convertedObject = convertedObjects.ToArray(ObjElementType);
}
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
outerProfile.Append(ex);
}
}
return(convertedObject);
}
private static string GetNFormatMemberValue(object target, MemberInfo memberInfo, bool collectErrMsgs, ChoMemberFormatterAttribute memberFormaterAttribute,
ChoMemberItemFormatterAttribute memberItemFormaterAttribute, BindingFlags bindingFlags)
{
try
{
string memberText = null;
object memberValue = ChoType.GetMemberValue(target, memberInfo);
if (memberValue == target)
{
return(null);
}
if (memberFormaterAttribute == null)
{
object[] typeConverters = ChoTypeDescriptor.GetTypeConverters(memberInfo);
if (typeConverters != null && typeConverters.Length > 0)
{
memberText = (string)ChoConvert.ConvertTo(target, memberValue, typeof(string), typeConverters, ChoTypeDescriptor.GetTypeConverterParams(memberInfo), null);
return(memberText);
}
}
memberText = ChoFormattableObject.ToString(memberValue, collectErrMsgs, memberFormaterAttribute, memberItemFormaterAttribute, bindingFlags);
if (memberText.ContainsMultiLines())
{
memberText = Environment.NewLine + memberText.Indent();
}
return(memberText);
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
throw new ChoApplicationException(memberInfo.Name, ex);
}
}
public static bool IsValidFor(this object @this, MemberInfo mi, out Exception aggEx)
{
aggEx = null;
ChoGuard.ArgumentNotNullOrEmpty(@this, "Target");
if (@this == null)
{
return(true);
}
var results = new List <ValidationResult>();
if (@this is IChoValidatable)
{
((IChoValidatable)@this).TryValidateFor(mi.Name, results);
}
else
{
//if (ChoObjectMemberMetaDataCache.Default.IsRequired(mi) && ChoType.GetMemberValue(@this, mi) == null)
// results.Add(new ValidationResult("Null value found for {0} member.".FormatString(mi.Name)));
var context = new ValidationContext(@this, null, null);
context.MemberName = mi.Name;
Validator.TryValidateValue(ChoType.GetMemberValue(@this, mi), context, results, ChoType.GetAttributes <ValidationAttribute>(mi));
}
if (results.Count > 0)
{
aggEx = new ApplicationException("Failed to validate '{0}' member. {2}{1}".FormatString(mi.Name, ToString(results), Environment.NewLine));
return(false);
}
else
{
return(true);
}
}
private static void DoValidate(object target, ChoValidationResults validationResults)
{
bool canContinue = true;
foreach (MethodInfo methodInfo in GetValidationRoutines(target.GetType()))
{
canContinue = false;
canContinue = (bool)ChoType.InvokeMethod(target, methodInfo.Name, validationResults);
if (!canContinue)
{
break;
}
}
//Do built-in attribute validations
if (canContinue)
{
MemberInfo[] memberInfos = ChoType.GetMembers(target.GetType());
foreach (MemberInfo memberInfo in memberInfos)
{
foreach (ChoMemberAttribute memberAttribute in ChoType.GetMemberAttributesByBaseType(memberInfo,
typeof(ChoMemberAttribute)))
{
try
{
memberAttribute.Validate(ChoType.GetMemberValue(target, memberInfo.Name), false);
}
catch (Exception ex)
{
validationResults.AddResult(ex.Message);
}
}
}
}
}
public object GetValue(object target)
{
if (MemberInfo != null)
{
return(ChoType.GetMemberValue(target, MemberInfo));
}
else if (target is ExpandoObject)
{
IDictionary <string, object> dict = target as IDictionary <string, object>;
if (dict.ContainsKey(MemberName))
{
return(((IDictionary <string, object>)target)[MemberName]);
}
else
{
throw new ApplicationException("Can't find '{0}' member in dynamic object.".FormatString(MemberName));
}
}
else
{
return(ChoType.GetMemberValue(target, MemberName));
}
}
void ChoRegistrySectionInfo_PropertyChanged(object sender, System.ComponentModel.PropertyChangedEventArgs e)
{
if (RegistryValueKindDictEx.ContainsKey(e.PropertyName) && RegistryValueKindDictEx[e.PropertyName] == RegistryValueKind.ExpandString)
{
string expandedStringMemberName = e.PropertyName + EXPAND_KEY_POSTFIX;
MemberInfo memberInfo = ChoType.GetMemberInfo(sender.GetType(), expandedStringMemberName);
if (memberInfo != null)
{
object expandString = ChoType.GetMemberValue(sender, e.PropertyName);;
if (expandString != null && expandString is string)
{
ChoType.SetMemberValue(sender, expandedStringMemberName, Environment.ExpandEnvironmentVariables(expandString as string));
}
else
{
ChoType.SetMemberValue(sender, expandedStringMemberName, null);
}
}
//Console.WriteLine(sender.ToString());
}
}
private object GetPropertyValue(string propertyName)
{
object target = GetTargetState();
Match match = Regex.Match(propertyName, _matchString);
if (!match.Success)
{
return(propertyName);
}
string className = match.Groups["class"].ToString();
string memberName = match.Groups["member"].ToString();
string assemblyName = match.Groups["assembly"].ToString();
if (String.Compare(className, THIS, true) == 0)
{
if (className != THIS || target == null)
{
return(propertyName);
}
//Call the object member, return the value
return(ChoType.GetMemberValue(target.GetType(), target, memberName));
}
else
{
//Call the object shared member, return the value
Type objType = null;
string typeName = null;
try
{
if (String.IsNullOrEmpty(assemblyName))
{
typeName = className;
}
else
{
typeName = String.Format("{0}, {1}", className, assemblyName);
}
objType = ChoType.GetType(typeName);
if (objType == null)
{
string typeName1 = ChoTypeFactory.Me[typeName];
if (!String.IsNullOrEmpty(typeName1))
{
objType = ChoType.GetType(typeName1);
}
}
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
throw new ApplicationException(String.Format("Failed to load {0} type.", typeName), ex);
}
if (objType == null)
{
throw new ApplicationException(String.Format("Failed to load {0} type.", typeName));
}
return(ChoType.GetMemberValue(objType, null, memberName));
}
}
private bool FillRecord(object rec, Tuple <int, string> pair)
{
int lineNo;
string line;
lineNo = pair.Item1;
line = pair.Item2;
object fieldValue = null;
string[] fieldValues = (from x in line.Split(Configuration.Delimiter, Configuration.StringSplitOptions, Configuration.QuoteChar)
select x).ToArray();
if (Configuration.ColumnCountStrict)
{
if (fieldValues.Length != Configuration.RecordFieldConfigurations.Count)
{
throw new ChoParserException("Incorrect number of field values found at line [{2}]. Expected [{0}] field values. Found [{1}] field values.".FormatString(Configuration.RecordFieldConfigurations.Count, fieldValues.Length, pair.Item1));
}
}
Dictionary <string, string> _fieldNameValues = ToFieldNameValues(fieldValues);
ValidateLine(pair.Item1, fieldValues);
ChoCSVRecordFieldConfiguration fieldConfig = null;
foreach (KeyValuePair <string, ChoCSVRecordFieldConfiguration> kvp in Configuration.RecordFieldConfigurationsDict)
{
fieldConfig = kvp.Value;
if (Configuration.CSVFileHeaderConfiguration.HasHeaderRecord)
{
if (_fieldNameValues.ContainsKey(fieldConfig.FieldName))
{
fieldValue = _fieldNameValues[fieldConfig.FieldName];
}
else if (Configuration.ColumnCountStrict)
{
throw new ChoParserException("No matching '{0}' field header found.".FormatString(fieldConfig.FieldName));
}
}
else
{
if (fieldConfig.FieldPosition - 1 < fieldValues.Length)
{
fieldValue = fieldValues[fieldConfig.FieldPosition - 1];
}
else if (Configuration.ColumnCountStrict)
{
throw new ChoParserException("Missing field value for {0} [Position: {1}] field.".FormatString(fieldConfig.FieldName, fieldConfig.FieldPosition));
}
}
fieldValue = CleanFieldValue(fieldConfig, fieldValue as string);
if (!RaiseBeforeRecordFieldLoad(rec, pair.Item1, kvp.Key, ref fieldValue))
{
continue;
}
try
{
bool ignoreFieldValue = fieldConfig.IgnoreFieldValue(fieldValue);
if (!ignoreFieldValue)
{
if (rec is ExpandoObject)
{
if (fieldConfig.FieldType != typeof(string))
{
fieldValue = ChoConvert.ConvertTo(fieldValue, fieldConfig.FieldType, Configuration.Culture);
}
var x = rec as IDictionary <string, Object>;
x.Add(kvp.Key, fieldValue);
}
else
{
if (ChoType.HasProperty(rec.GetType(), kvp.Key))
{
ChoType.ConvertNSetMemberValue(rec, kvp.Key, fieldValue);
fieldValue = ChoType.GetMemberValue(rec, kvp.Key);
if ((Configuration.ObjectValidationMode & ChoObjectValidationMode.MemberLevel) == ChoObjectValidationMode.MemberLevel)
{
ChoValidator.ValididateFor(rec, kvp.Key);
}
}
else
{
throw new ChoMissingRecordFieldException("Missing '{0}' property in {1} type.".FormatString(kvp.Key, ChoType.GetTypeName(rec)));
}
}
}
if (!RaiseAfterRecordFieldLoad(rec, pair.Item1, kvp.Key, fieldValue))
{
return(false);
}
}
catch (ChoParserException)
{
throw;
}
catch (ChoMissingRecordFieldException)
{
if (Configuration.ThrowAndStopOnMissingField)
{
throw;
}
}
catch (Exception ex)
{
ChoETLFramework.HandleException(ex);
if (fieldConfig.ErrorMode == ChoErrorMode.ThrowAndStop)
{
throw;
}
try
{
ChoFallbackValueAttribute fbAttr = ChoTypeDescriptor.GetPropetyAttribute <ChoFallbackValueAttribute>(rec.GetType(), kvp.Key);
if (fbAttr != null)
{
if (!fbAttr.Value.IsNullOrDbNull())
{
ChoType.ConvertNSetMemberValue(rec, kvp.Key, fbAttr.Value);
}
}
else
{
throw;
}
}
catch
{
if (fieldConfig.ErrorMode == ChoErrorMode.IgnoreAndContinue)
{
continue;
}
else if (fieldConfig.ErrorMode == ChoErrorMode.ReportAndContinue)
{
if (!RaiseRecordFieldLoadError(rec, pair.Item1, kvp.Key, fieldValue, ex))
{
throw;
}
}
else
{
throw;
}
}
}
}
return(true);
}
private bool ExtractNPopulateValues(ref bool hasErrors, ref bool isDirty)
{
bool isModfied = false;
object oldValue = null;
object newValue = null;
object origValue = null;
object defaultValue = null;
object fallbackValue = null;
bool isConfigmemberDefined = false;
//MemberInfo[] memberInfos = ChoType.GetMembers(ConfigObject.GetType(), typeof(ChoConfigurationPropertyAttribute));
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(ConfigObject.GetType());
if (memberInfos != null && memberInfos.Length > 0)
{
//Set member values
string name;
ChoPropertyInfoAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null)
{
continue;
}
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute));
//if (memberInfoAttribute == null) continue;
oldValue = null;
newValue = null;
origValue = null;
defaultValue = null;
fallbackValue = null;
name = ChoType.GetMemberName(memberInfo);
isConfigmemberDefined = ConfigSection.HasConfigMemberDefined(name);
oldValue = ChoType.GetMemberValue(ConfigObject, memberInfo.Name);
object configFallbackValue = null;
object configDefaultValue = null;
bool isDefaultValueSpecified = ChoConfigurationMetaDataManager.TryConfigDefaultValue(this, name, memberInfoAttribute, out configDefaultValue);
ChoConfigurationMetaDataManager.TryConfigFallbackValue(this, name, memberInfoAttribute, out configFallbackValue);
if (configFallbackValue == null)
{
if (isDefaultValueSpecified)
{
defaultValue = origValue = newValue = configDefaultValue;
}
}
else
{
fallbackValue = origValue = newValue = configFallbackValue;
}
if (!isConfigmemberDefined)
{
if (!isDirty)
{
isDirty = memberInfoAttribute != null && memberInfoAttribute.Persistable ? true : false;
}
}
else
{
origValue = newValue = ConfigSection[name];
}
try
{
object newConvertedValue = ChoConvert.ConvertFrom(ConfigObject, newValue, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
newValue = newConvertedValue;
}
catch { }
ChoConfigurableObject configObject = ConfigObject as ChoConfigurableObject;
if (configObject != null)
{
if (!configObject.IsMemeberValueEqualInternal(memberInfo, oldValue, newValue))
{
if (!configObject.RaiseBeforeConfigurationObjectMemberLoaded(memberInfo.Name, name, origValue, ref newValue))
{
try
{
//ChoType.SetMemberValue(ConfigObject, memberInfo.Name, newValue != null ? ChoConvert.ConvertFrom(ConfigObject, newValue,
// ChoType.GetMemberType(memberInfo), ChoTypeConvertersCache.GetTypeConverters(memberInfo)) : null);
SetConfigPropertyValue(newValue, memberInfo);
if (!_firstTime)
{
isModfied = true;
}
configObject.RaiseAfterConfigurationObjectMemberLoaded(memberInfo.Name, name, newValue);
ChoConfigurationObjectErrorManagerService.ResetObjectMemberError(ConfigObject, memberInfo.Name);
}
catch (Exception innerEx)
{
if (!configObject.RaiseConfigurationObjectMemberLoadError(memberInfo.Name, name, origValue, innerEx))
{
if (Silent)
{
if (_firstTime)
{
AssignToFallbackOrDefaultValue(defaultValue, fallbackValue, memberInfo);
}
ChoConfigurationObjectErrorManagerService.SetObjectMemberError(ConfigObject, memberInfo.Name, String.Format(Resources.ConfigConstructMsg, ChoString.ToString(origValue), innerEx.Message));
}
else
{
throw new ChoConfigurationConstructionException(String.Format(Resources.ConfigConstructExceptionMsg, ChoString.ToString(origValue), ConfigObject.GetType().FullName,
memberInfo.Name), innerEx);
}
}
}
}
}
}
else
{
try
{
//ChoType.SetMemberValue(ConfigObject, memberInfo.Name, newValue != null ? ChoConvert.ConvertFrom(ConfigObject, newValue,
// ChoType.GetMemberType(memberInfo), ChoTypeConvertersCache.GetTypeConverters(memberInfo)) : null);
SetConfigPropertyValue(newValue, memberInfo);
if (!_firstTime)
{
isModfied = true;
}
ChoConfigurationObjectErrorManagerService.ResetObjectMemberError(ConfigObject, memberInfo.Name);
}
catch (Exception innerEx)
{
if (Silent)
{
if (_firstTime)
{
AssignToFallbackOrDefaultValue(defaultValue, fallbackValue, memberInfo);
}
ChoConfigurationObjectErrorManagerService.SetObjectMemberError(ConfigObject, memberInfo.Name, String.Format(Resources.ConfigConstructMsg, ChoString.ToString(origValue), innerEx.Message));
}
else
{
throw new ChoConfigurationConstructionException(String.Format(Resources.ConfigConstructExceptionMsg, ChoString.ToString(origValue), ConfigObject.GetType().FullName,
memberInfo.Name), innerEx);
}
}
}
}
}
return(isModfied);
}
