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);
}
private void AssignToFallbackOrDefaultValue(object defaultValue, object fallbackValue, MemberInfo memberInfo)
{
try
{
object convertedFallbackValue = ChoConvert.ConvertFrom(ConfigObject, fallbackValue, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
SetConfigPropertyValue(convertedFallbackValue, memberInfo);
}
catch
{
try
{
object convertedDefaultValue = ChoConvert.ConvertFrom(ConfigObject, defaultValue, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
SetConfigPropertyValue(convertedDefaultValue, memberInfo);
}
catch { }
}
}
private void Reset()
{
if (ConfigObject == null)
{
return;
}
ChoConfigurationObjectErrorManagerService.ResetObjectErrors(ConfigObject);
//MemberInfo[] memberInfos = ChoType.GetMembers(ConfigObject.GetType(), typeof(ChoConfigurationPropertyAttribute));
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(ConfigObject.GetType());
if (memberInfos != null && memberInfos.Length > 0)
{
ChoPropertyInfoAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute));
string name = ChoType.GetMemberName(memberInfo);
object defaultValue = null;
bool isDefaultValueSpecified = ChoConfigurationMetaDataManager.TryConfigDefaultValue(this, name, memberInfoAttribute, out defaultValue);
if (memberInfoAttribute == null || !isDefaultValueSpecified)
{
continue;
}
try
{
//object newConvertedValue = memberInfoAttribute.DefaultValue;
object newConvertedValue = ChoConvert.ConvertFrom(ConfigObject, defaultValue, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
SetConfigPropertyValue(newConvertedValue, memberInfo);
//ChoType.SetMemberValue(ConfigObject, memberInfo, newConvertedValue);
}
catch (Exception innerEx)
{
ChoConfigurationObjectErrorManagerService.SetObjectMemberError(ConfigObject, memberInfo.Name, String.Format("Failed to assign `{0}` default value. {1}", ChoString.ToString(defaultValue), innerEx.Message));
}
}
}
}
internal ChoMemberInfo(object target, Type type, IMethodMessage methodCallMsg)
{
_methodMsg = methodCallMsg;
_target = target;
MethodCallMsg = _methodMsg as MethodCallMessageWrapper;
if (_methodMsg.MethodName == "FieldSetter" || (_methodMsg.MethodName.StartsWith("set_") &&
_methodMsg.MethodName != "set_Dirty"))
{
_dirtyOperation = true;
}
if (_methodMsg.MethodName == "FieldSetter" || _methodMsg.MethodName == "FieldGetter")
{
_name = _methodMsg.Args[1] as string;
_memberType = MemberTypes.Field;
}
else if (_methodMsg.MethodName.StartsWith("get_"))
{
_name = _methodMsg.MethodName.Replace("get_", String.Empty);
_memberType = MemberTypes.Property;
}
else if (_methodMsg.MethodName.StartsWith("set_"))
{
_name = _methodMsg.MethodName.Replace("set_", String.Empty);
_memberType = MemberTypes.Property;
}
else
{
_name = _methodMsg.MethodName;
}
//_memberInfo = ChoType.GetMember(_target.GetType(), Name);
_memberInfo = ChoType.GetMemberInfo(type, Name);
if (_dirtyOperation)
{
//Set Converted value
Value = ChoConvert.ConvertFrom(_target, Value, ChoType.GetMemberType(_memberInfo),
ChoTypeDescriptor.GetTypeConverters(_memberInfo), ChoTypeDescriptor.GetTypeConverterParams(_memberInfo));
//Value = ChoConvert.ConvertFrom(_target, Value, ChoType.GetMemberType(_target.GetType(), _name),
// ChoType.GetTypeConverters(ChoType.GetMember(_target.GetType(), _name), typeof(ChoTypeConverterAttribute)));
}
}
public virtual void Validate()
{
string propName = null;
object propValue = null;
string propValueText = null;
var results = new List <ValidationResult>();
foreach (PropertyInfo pi in ChoType.GetProperties(GetType()))
{
propName = pi.Name;
results.Clear();
try
{
propValue = ChoType.GetPropertyValue(this, pi);
}
catch (Exception ex)
{
throw new ChoHL7Exception("Failed to validate '{0}' member.".FormatString(pi.FullName()), ex);
}
if (propValue is Array)
{
Array arr = (Array)propValue;
if (arr.Length == 0 && ChoTypeDescriptor.GetPropetyAttributes <RequiredAttribute>(ChoTypeDescriptor.GetProperty <RequiredAttribute>(GetType(), pi.Name)).Any())
{
throw new ChoHL7Exception("'{0}' member is required.".FormatString(pi.FullName()));
}
var maxCountAttr = ChoTypeDescriptor.GetPropetyAttributes <ChoHL7MaxCountAttribute>(ChoTypeDescriptor.GetProperty <ChoHL7MaxCountAttribute>(GetType(), pi.Name)).FirstOrDefault();
if (maxCountAttr != null)
{
if (arr.Length > maxCountAttr.Count)
{
throw new ChoHL7Exception("Incorrect number of elements found in '{0}' member. [Expected: {1}, Found: {2}]".FormatString(pi.FullName(), maxCountAttr.Count, arr.Length));
}
}
foreach (ChoHL7AbstractField arrValue in arr)
{
try
{
propValueText = arrValue.ToNString();
}
catch (Exception ex)
{
throw new ChoHL7Exception("Failed to validate '{0}' member.".FormatString(pi.FullName()), ex);
}
pi.CheckRequired(propValueText);
if (Configuration != null && !Configuration.DisableEnumChecks)
{
pi.CheckForValidEnumValue(propValueText);
}
var context = new ValidationContext(propValueText, null, null);
context.MemberName = pi.Name;
Validator.TryValidateValue(propValueText, context, results, ChoTypeDescriptor.GetPropetyAttributes <ValidationAttribute>(ChoTypeDescriptor.GetProperty <ValidationAttribute>(GetType(), pi.Name)));
if (results.Count > 0)
{
throw new ChoHL7Exception("Failed to validate '{0}' member. {2}{1}".FormatString(pi.FullName(), ChoHL7Helper.ToString(results), Environment.NewLine));
}
try
{
if (arrValue is ChoHL7AbstractField)
{
((ChoHL7AbstractField)arrValue).Validate();
}
}
catch (Exception ex)
{
throw new ChoHL7Exception("Failed to validate '{0}' member.".FormatString(pi.FullName()), ex);
}
}
}
else
{
try
{
propValueText = propValue.ToNString();
}
catch (Exception ex)
{
throw new ChoHL7Exception("Failed to validate '{0}' member.".FormatString(pi.FullName()), ex);
}
pi.CheckRequired(propValueText);
if (Configuration != null && !Configuration.DisableEnumChecks)
{
pi.CheckForValidEnumValue(propValueText);
}
var context = new ValidationContext(propValueText, null, null);
context.MemberName = pi.Name;
Validator.TryValidateValue(propValueText, context, results, ChoTypeDescriptor.GetPropetyAttributes <ValidationAttribute>(ChoTypeDescriptor.GetProperty <ValidationAttribute>(GetType(), pi.Name)));
if (results.Count > 0)
{
if (Configuration.DisableValueInErrorMessage)
{
throw new ChoHL7Exception("Failed to validate '{0}' member. {2}{1}".FormatString(pi.FullName(), ChoHL7Helper.ToString(results), Environment.NewLine));
}
else
{
throw new ChoHL7Exception("Failed to validate '{0}' member [Value: {3}]. {2}{1}".FormatString(pi.FullName(), ChoHL7Helper.ToString(results), Environment.NewLine, propValueText));
}
}
try
{
if (propValue is ChoHL7AbstractField)
{
((ChoHL7AbstractField)propValue).Validate();
}
}
catch (Exception ex)
{
throw new ChoHL7Exception("Failed to validate '{0}' member.".FormatString(pi.FullName()), ex);
}
}
}
}
public static void CheckForValidEnumValue(this PropertyInfo pi, string propValueText)
{
if (propValueText.IsNullOrEmpty())
{
return;
}
ChoHL7EnumTypeAttribute enumAttribute = ChoTypeDescriptor.GetPropetyAttributes <ChoHL7EnumTypeAttribute>(ChoTypeDescriptor.GetProperty(pi.DeclaringType, pi.Name)).FirstOrDefault();
if (enumAttribute != null)
{
Type enumType = enumAttribute.EnumType;
if (!enumType.IsEnum)
{
throw new ChoHL7Exception("'{0}' is not an enum type defined in '{1}' member.".FormatString(enumType.FullName, pi.FullName()));
}
if (!propValueText.IsNullOrWhiteSpace())
{
string[] enumTxts = GetEnumValues(enumType);
string[] splEnumTxts = GetSplEnumValues(enumType);
if (enumTxts.Length > 0 && !enumTxts.Contains(propValueText, StringComparer.CurrentCultureIgnoreCase))
{
if (splEnumTxts.Length > 0)
{
bool found = false;
foreach (var splEnumTxt in splEnumTxts)
{
if (propValueText.StartsWith(splEnumTxt))
{
found = true;
break;
}
}
if (!found)
{
throw new ChoHL7Exception("Incorrect '{0}' value found for '{1}' member.".FormatString(propValueText, pi.FullName()));
}
}
else
{
//char enumChar = propValueText[0];
//if (!Enum.IsDefined(enumType, (int)enumChar))
throw new ChoHL7Exception("Incorrect '{0}' value found for '{1}' member.".FormatString(propValueText, pi.FullName()));
}
}
}
}
}
public static void CheckRequired(this PropertyInfo pi, object propValue)
{
if (propValue is string && ((string)propValue).IsNullOrEmpty() && ChoTypeDescriptor.GetPropetyAttributes <RequiredAttribute>(ChoTypeDescriptor.GetProperty <RequiredAttribute>(pi.DeclaringType, pi.Name)).Any())
{
throw new ChoHL7Exception("'{0}' member is required.".FormatString(pi.FullName()));
}
else if (propValue == null && ChoTypeDescriptor.GetPropetyAttributes <RequiredAttribute>(ChoTypeDescriptor.GetProperty <RequiredAttribute>(pi.DeclaringType, pi.Name)).Any())
{
throw new ChoHL7Exception("'{0}' member is required.".FormatString(pi.FullName()));
}
}
public static object GetConvertedDefaultValue(this MemberInfo memberInfo)
{
ChoPropertyInfoAttribute memberInfoAttribute = ChoType.GetMemberAttribute <ChoPropertyInfoAttribute>(memberInfo);
if (memberInfoAttribute != null)
{
return(ChoConvert.ConvertFrom(null, memberInfoAttribute.DefaultValue, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo)));
}
else
{
return(null);
}
}
public static object GetConvertedValue(this MemberInfo memberInfo, object value)
{
return(ChoConvert.ConvertFrom(null, value, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo)));
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
MemberInfo memberInfo = ChoTypeMembersCache.GetMemberInfo(_type, binder.Name);
if (memberInfo == null)
{
return(false);
}
string propertyName = ChoType.GetMemberName(memberInfo);
object newConvertedValue = null;
try
{
newConvertedValue = ChoConvert.ConvertFrom(_instance, value, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
ChoType.SetMemberValue(_instance, memberInfo, newConvertedValue);
}
catch (ChoConfigurationObjectPostInvokeException)
{
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
if (_instance.RaiseConfigurationObjectMemberLoadError(binder.Name, propertyName, value, ex))
{
_instance.OnPropertyChanged(binder.Name);
return(true);
}
else
{
return(false);
}
}
_instance.OnPropertyChanged(binder.Name);
return(true);
}
private static Exception ExtractNPopulateValue(object target, MemberInfo memberInfo, string switchString, ChoCommandLineArgParser commandLineArgParser,
ChoCommandLineArgObject commandLineArgObject, bool isSwitchSpecified)
{
ChoCommandLineArgAttribute commandLineArgumentAttribute = null;
ChoDefaultCommandLineArgAttribute defaultCommandLineArgAttribute = null;
if (memberInfo == null)
{
if (commandLineArgObject != null)
{
commandLineArgObject.OnCommandLineArgMemberNotFound(switchString, commandLineArgParser[switchString]);
}
}
else
{
//if (ChoType.IsReadOnlyMember(memberInfo))
// return null;
commandLineArgumentAttribute = null;
defaultCommandLineArgAttribute = null;
commandLineArgumentAttribute = (ChoCommandLineArgAttribute)memberInfo.GetCustomAttribute <ChoCommandLineArgAttribute>(true);
if (commandLineArgumentAttribute == null)
{
defaultCommandLineArgAttribute = (ChoDefaultCommandLineArgAttribute)memberInfo.GetCustomAttribute <ChoDefaultCommandLineArgAttribute>(true);
if (defaultCommandLineArgAttribute == null)
{
return(null);
}
}
string cmdLineArgValue = null;
object newCmdLineArgValue = null;
try
{
if (defaultCommandLineArgAttribute != null)
{
cmdLineArgValue = commandLineArgParser.DefaultArgs.Length > 0 ? commandLineArgParser.DefaultArgs[0] : null;
}
else if (commandLineArgumentAttribute != null)
{
cmdLineArgValue = commandLineArgParser[commandLineArgumentAttribute.CommandLineSwitch];
defaultCommandLineArgAttribute = commandLineArgumentAttribute;
}
else
{
return(null);
}
object defaultCmdLineArgValue = defaultCommandLineArgAttribute.DefaultValue;
if (isSwitchSpecified && cmdLineArgValue == null && defaultCommandLineArgAttribute.FallbackValue != null)
{
defaultCmdLineArgValue = defaultCommandLineArgAttribute.FallbackValue;
}
if (commandLineArgObject == null || !commandLineArgObject.OnBeforeCommandLineArgLoaded(memberInfo.Name, cmdLineArgValue, defaultCommandLineArgAttribute.DefaultValue, defaultCommandLineArgAttribute.FallbackValue))
{
if (!cmdLineArgValue.IsNullOrWhiteSpace())
{
newCmdLineArgValue = ChoConvert.ConvertFrom(target, ChoString.ExpandPropertiesEx(cmdLineArgValue),
ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
}
else if (defaultCmdLineArgValue != null)
{
if (defaultCmdLineArgValue is string)
{
newCmdLineArgValue = ChoConvert.ConvertFrom(target, ChoString.ExpandPropertiesEx(defaultCmdLineArgValue as string),
ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
}
else
{
newCmdLineArgValue = ChoConvert.ConvertFrom(target, defaultCmdLineArgValue, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
}
}
if (newCmdLineArgValue != null)
{
ChoType.SetMemberValue(target, memberInfo, newCmdLineArgValue);
if (commandLineArgObject != null)
{
commandLineArgObject.OnAfterCommandLineArgLoaded(memberInfo.Name, newCmdLineArgValue);
}
}
else if (defaultCommandLineArgAttribute.IsRequired)
{
throw new ChoCommandLineArgException("Missing arg value for '{0}' required command line switch.".FormatString(
commandLineArgumentAttribute == null ? DefaultCmdLineSwitch : commandLineArgumentAttribute.CommandLineSwitch));
}
}
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
if (commandLineArgObject != null && commandLineArgObject.OnCommandLineArgLoadError(memberInfo.Name, cmdLineArgValue, ex))
{
}
else
{
return(ex);
}
}
}
return(null);
}
public override bool TrySetMember(SetMemberBinder binder, object value)
{
MemberInfo memberInfo = ChoTypeMembersCache.GetMemberInfo(_type, binder.Name);
if (memberInfo == null)
{
return(false);
}
try
{
object newConvertedValue = ChoConvert.ConvertFrom(_instance, value, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
ChoType.SetMemberValue(_instance, memberInfo, newConvertedValue);
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
Trace.TraceError(ex.ToString());
return(false);
}
if (!(_instance is INotifyPropertyChanged))
{
PropertyChangedEventHandler propertyChanged = PropertyChanged;
if (propertyChanged != null)
{
propertyChanged(this, new PropertyChangedEventArgs(binder.Name));
}
}
return(true);
}
