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);
}
}
}
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);
}
}
private string GetDefaultValueText(MemberInfo memberInfo)
{
string name = null;
string defaultValue = null;
bool isDefaultValueSpecified;
ChoCommandLineArgAttribute defaultCommandLineArgAttribute = null;
defaultCommandLineArgAttribute = (ChoCommandLineArgAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoCommandLineArgAttribute));
if (defaultCommandLineArgAttribute == null)
{
return(null);
}
name = ChoType.GetMemberName(memberInfo);
if (ChoType.GetMemberType(memberInfo) != typeof(bool))
{
isDefaultValueSpecified = ChoCmdLineArgMetaDataManager.TryGetDefaultValue(this, name, defaultCommandLineArgAttribute, out defaultValue);
if (isDefaultValueSpecified)
{
return(defaultValue);
}
}
return(null);
}
protected override void PostInvoke(ChoMemberInfo memberInfo)
{
object newValue = memberInfo.Value;
if (memberInfo.DirtyOperation)
{
string propertyName = ChoType.GetMemberName(memberInfo.Info);
if (memberInfo.Exception == null)
{
RaiseAfterConfigurationObjectMemberLoaded(memberInfo.Name, propertyName, newValue);
}
else
{
if (!RaiseConfigurationObjectMemberLoadError(memberInfo.Name, propertyName, newValue, memberInfo.Exception))
{
throw new ChoConfigurationObjectPostInvokeException("Error while loading configuration member load operation.", memberInfo.Exception);
}
else
{
memberInfo.ReturnMessage = new ReturnMessage(null, memberInfo.MethodCallMsg);
}
}
}
if (memberInfo.DirtyOperation && Dirty && !IsReadOnly() && Initialized)
{
ChoPropertyInfoAttribute memberInfoAttribute = ChoType.GetMemberAttribute(memberInfo.Info, typeof(ChoPropertyInfoAttribute)) as ChoPropertyInfoAttribute;
if (memberInfoAttribute == null || memberInfoAttribute.Persistable)
{
Persist();
}
SetDirty(false);
}
}
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);
}
private bool AssignToFallbackOrDefaultValues(ref bool isDirty)
{
bool isModfied = false;
object defaultValue = null;
object fallbackValue = null;
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;
}
name = ChoType.GetMemberName(memberInfo);
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute));
//if (memberInfoAttribute == null) continue;
defaultValue = null;
fallbackValue = null;
bool isDefaultValueSpecified = ChoConfigurationMetaDataManager.TryConfigDefaultValue(this, name, memberInfoAttribute, out defaultValue);
ChoConfigurationMetaDataManager.TryConfigFallbackValue(this, name, memberInfoAttribute, out fallbackValue);
if (fallbackValue == null)
{
if (!isDefaultValueSpecified)
{
continue;
}
}
bool hasError = !ChoConfigurationObjectErrorManagerService.GetObjectMemberError(ConfigObject, memberInfo.Name).IsNullOrEmpty();
if (hasError)
{
isModfied = true;
if (_firstTime)
{
AssignToFallbackOrDefaultValue(defaultValue, fallbackValue, memberInfo);
}
}
}
}
return(isModfied);
}
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 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(value, memberInfo, _instance);
// 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 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));
}
}
}
}
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)));
}
}
}
public void Validate()
{
if (RegistryKey.IsNullOrWhiteSpace())
{
throw new ChoConfigurationException("Missing registry key.");
}
if (ConfigObjectType == null)
{
throw new ChoConfigurationException("Missing configuration object type.");
}
//Load RegistryValueKinds
foreach (MemberInfo memberInfo in ChoType.GetMemberInfos(ConfigObjectType, typeof(ChoMemberRegistryInfoAttribute)))
{
ChoMemberRegistryInfoAttribute memberRegistryInfoAttribute = memberInfo.GetCustomAttribute <ChoMemberRegistryInfoAttribute>();
string memberName = ChoType.GetMemberName(memberInfo);
RegistryValueKindDict.Add(memberName, memberRegistryInfoAttribute.RegistryValueKind);
RegistryValueKindDictEx.Add(memberInfo.Name, memberRegistryInfoAttribute.RegistryValueKind);
RegistryKeyMap.Add(memberInfo.Name, memberName);
}
}
protected override void PostInvoke(ChoMemberInfo memberInfo)
{
object newValue = memberInfo.Value;
if (memberInfo.DirtyOperation)
{
string propertyName = ChoType.GetMemberName(memberInfo.Info);
if (memberInfo.Exception == null)
{
RaiseAfterConfigurationObjectMemberSet(memberInfo.Name, propertyName, newValue);
OnPropertyChanged(memberInfo.Name);
}
else
{
if (!RaiseConfigurationObjectMemberSetError(memberInfo.Name, propertyName, newValue, memberInfo.Exception))
{
memberInfo.Exception = new ChoConfigurationObjectPostInvokeException("Error while setting '{0}' configuration member value.".FormatString(memberInfo.Name), memberInfo.Exception);
}
else
{
memberInfo.Exception = null;
}
}
}
if (memberInfo.DirtyOperation /*&& Dirty */ && !IsReadOnly() && Initialized)
{
ChoPropertyInfoAttribute memberInfoAttribute = ChoType.GetMemberAttribute(memberInfo.Info, typeof(ChoPropertyInfoAttribute)) as ChoPropertyInfoAttribute;
if (memberInfoAttribute == null || memberInfoAttribute.Persistable)
{
Persist();
}
SetDirty(false);
}
}
public static object CreateInstanceAndDefaultToMembers(this Type type, IDictionary <string, ChoRecordFieldConfiguration> fcs)
{
var obj = ChoActivator.CreateInstance(type);
object defaultValue = null;
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties(type))
{
try
{
if (!fcs.ContainsKey(pd.Name) || !fcs[pd.Name].IsDefaultValueSpecified)
{
continue;
}
defaultValue = fcs[pd.Name].DefaultValue;
if (defaultValue != null)
{
ChoType.ConvertNSetPropertyValue(obj, pd.Name, defaultValue);
}
}
catch (Exception ex)
{
ChoETLFramework.WriteLog(ChoETLFramework.TraceSwitch.TraceError, "Error while assigning default value '{0}' to '{1}' member. {2}".FormatString(defaultValue, ChoType.GetMemberName(pd), ex.Message));
}
}
return(obj);
}
private static ChoPropertyInfos ConstructPropertyInfos(ChoCommandLineArgObject cmdLineArgObject)
{
if (cmdLineArgObject != null)
{
Dictionary <string, ChoPropertyInfos> propDict = _propDict;
string elementPath = cmdLineArgObject.GetType().Name;
if (elementPath.IsNullOrWhiteSpace())
{
return(ChoPropertyInfos.Default);
}
if (!propDict.ContainsKey(elementPath))
{
lock (_padLock)
{
if (!propDict.ContainsKey(elementPath))
{
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(cmdLineArgObject.GetType());
if (memberInfos != null && memberInfos.Length > 0)
{
//Set member values
List <ChoPropertyInfo> propertyInfoList = new List <ChoPropertyInfo>();
ChoDefaultCommandLineArgAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
memberInfoAttribute = (ChoDefaultCommandLineArgAttribute)ChoType.GetMemberAttributeByBaseType(memberInfo, typeof(ChoDefaultCommandLineArgAttribute));
if (memberInfoAttribute == null)
{
continue;
}
ChoPropertyInfo propInfo = new ChoPropertyInfo();
propInfo.Name = ChoType.GetMemberName(memberInfo);
if (ChoType.GetMemberType(memberInfo) != typeof(bool))
{
propInfo.DefaultValue = new ChoCDATA(memberInfoAttribute.DefaultValue);
propInfo.FallbackValue = new ChoCDATA(memberInfoAttribute.FallbackValue);
propInfo.IsDefaultValueSpecified = memberInfoAttribute.IsDefaultValueSpecified;
propInfo.IsFallbackValueSpecified = memberInfoAttribute.IsFallbackValueSpecified;
propertyInfoList.Add(propInfo);
}
}
if (propertyInfoList != null)
{
ChoPropertyInfos propertyInfos = new ChoPropertyInfos();
propertyInfos.PropertyInfoArr = propertyInfoList.ToArray();
SetMetaDataSection(cmdLineArgObject, propertyInfos);
return(propertyInfos);
}
}
}
}
}
}
return(ChoPropertyInfos.Default);
}
private void LoadDefaults(Type declaringType)
{
ChoIniFile iniFile = GetIniSection(declaringType, "DEFAULT_VALUE");
var dict = new Dictionary <string, object>();
object defaultValue = null;
string memberName = null;
foreach (PropertyDescriptor pd in TypeDescriptor.GetProperties(declaringType).AsTypedEnumerable <PropertyDescriptor>().Where(pd => !pd.Attributes.OfType <ChoIgnoreMemberAttribute>().Any()))
{
try
{
memberName = pd.Name;
if (_turnOnMetaDataCache)
{
defaultValue = iniFile.GetValue(pd.Name, ChoType.GetDefaultValue(pd), _isLockedCache[declaringType]);
}
else
{
defaultValue = ChoType.GetDefaultValue(pd);
}
if (defaultValue is string)
{
defaultValue = ((string)defaultValue).ExpandProperties();
}
defaultValue = ChoConvert.ConvertFrom(defaultValue, pd.PropertyType);
dict.Add(pd.Name, defaultValue);
}
catch (Exception ex)
{
ChoETLFramework.WriteLog(ChoETLFramework.Switch.TraceError, "Error while converting default value '{0}' to '{1}' member type. {2}".FormatString(defaultValue, ChoType.GetMemberName(pd), ex.Message));
}
}
foreach (FieldInfo memberInfo in ChoType.GetFields(declaringType))
{
try
{
memberName = memberInfo.Name;
if (_turnOnMetaDataCache)
{
defaultValue = iniFile.GetValue(memberInfo.Name, ChoType.GetDefaultValue(memberInfo), _isLockedCache[declaringType]);
}
else
{
defaultValue = ChoType.GetDefaultValue(memberInfo);
}
if (defaultValue is string)
{
defaultValue = ((string)defaultValue).ExpandProperties();
}
defaultValue = ChoConvert.ConvertFrom(defaultValue, memberInfo.FieldType);
dict.Add(memberInfo.Name, defaultValue);
}
catch (Exception ex)
{
ChoETLFramework.WriteLog(ChoETLFramework.Switch.TraceError, "Error while converting default value '{0}' to '{1}' member type. {2}".FormatString(defaultValue, ChoType.GetMemberName(memberInfo), ex.Message));
}
}
_defaultsCache.Add(declaringType, dict);
}
private void LoadIsRequireds(Type declaringType)
{
ChoIniFile iniFile = GetIniSection(declaringType, "REQUIRED");
var dict = new Dictionary <string, bool>();
bool isRequired = false;
ChoMemberAttribute memberAttribute = null;
foreach (MemberInfo memberInfo in ChoType.GetMembers(declaringType))
{
memberAttribute = ChoType.GetAttribute <ChoMemberAttribute>(memberInfo);
if (memberAttribute == null)
{
continue;
}
try
{
if (_turnOnMetaDataCache)
{
isRequired = iniFile.GetValue(memberInfo.Name, memberAttribute.IsRequired, _isLockedCache[declaringType]);
}
else
{
isRequired = memberAttribute.IsRequired;
}
dict.Add(memberInfo.Name, isRequired);
}
catch (Exception ex)
{
ChoETLFramework.WriteLog(ChoETLFramework.Switch.TraceError, "Incorrect IsRequired value specified for '{0}' member type in INI file. Defaulted to false. {1}".FormatString(ChoType.GetMemberName(memberInfo), ex.Message));
}
}
_isReqCache.Add(declaringType, dict);
}
private void LoadConverterParams(Type declaringType)
{
ChoIniFile iniFile = GetIniSection(declaringType, "FORMATTER");
var dict = new Dictionary <string, object[]>();
string parameters = null;
ChoMemberAttribute memberAttribute = null;
foreach (MemberInfo memberInfo in ChoType.GetMembers(declaringType))
{
memberAttribute = ChoType.GetAttribute <ChoMemberAttribute>(memberInfo);
if (memberAttribute == null)
{
continue;
}
try
{
if (_turnOnMetaDataCache)
{
parameters = iniFile.GetValue(memberInfo.Name);
}
List <object> p = new List <object>();
if (!parameters.IsNullOrWhiteSpace())
{
foreach (string kv in parameters.SplitNTrim(';'))
{
p.Add(kv.SplitNTrim(','));
}
}
dict.Add(memberInfo.Name, parameters.IsNullOrWhiteSpace() ? null : p.ToArray());
}
catch (Exception ex)
{
ChoETLFramework.WriteLog(ChoETLFramework.Switch.TraceError, "Failed to retrieve converter params for '{0}' member type from INI file. {1}".FormatString(ChoType.GetMemberName(memberInfo), ex.Message));
}
}
_converterParams.Add(declaringType, dict);
}
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 static void AssignToDefaultValues(ChoCommandLineArgObject commandLineArgObject)
//{
// object newCmdLineArgValue = null;
// string name = null;
// string defaultValue = null;
// bool isDefaultValueSpecified;
// MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(commandLineArgObject.GetType());
// if (memberInfos != null && memberInfos.Length > 0)
// {
// ChoCommandLineArgAttribute defaultCommandLineArgAttribute = null;
// foreach (MemberInfo memberInfo in memberInfos)
// {
// defaultCommandLineArgAttribute = (ChoCommandLineArgAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoCommandLineArgAttribute));
// if (defaultCommandLineArgAttribute == null) continue;
// name = ChoType.GetMemberName(memberInfo);
// defaultValue = null;
// if (ChoType.GetMemberType(memberInfo) == typeof(bool))
// continue;
// isDefaultValueSpecified = ChoCmdLineArgMetaDataManager.TryGetDefaultValue(commandLineArgObject, name, defaultCommandLineArgAttribute, out defaultValue);
// if (!isDefaultValueSpecified)
// continue;
// try
// {
// defaultValue = ChoString.ExpandPropertiesEx(defaultValue);
// object newConvertedValue = ChoConvert.ConvertFrom(defaultValue, memberInfo, commandLineArgObject);
// //object newConvertedValue = ChoConvert.ConvertFrom(commandLineArgObject, defaultValue, ChoType.GetMemberType(memberInfo),
// // ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
// ChoType.SetMemberValue(commandLineArgObject, memberInfo, newCmdLineArgValue);
// }
// catch //(Exception ex)
// {
// }
// }
// }
//}
private static Exception ExtractNPopulateValue(ChoCommandLineArgObject commandLineArgObject, MemberInfo memberInfo, ChoCommandLineArgParser commandLineArgParser)
{
ChoDefaultCommandLineArgAttribute defaultCommandLineArgAttribute = null;
ChoCommandLineArgAttribute commandLineArgumentAttribute = null;
ChoPositionalCommandLineArgAttribute posCommandLineArgAttribute = null;
if (ChoType.IsReadOnlyMember(memberInfo))
{
return(null);
}
commandLineArgumentAttribute = null;
posCommandLineArgAttribute = null;
defaultCommandLineArgAttribute = commandLineArgumentAttribute = (ChoCommandLineArgAttribute)memberInfo.GetCustomAttribute <ChoCommandLineArgAttribute>(true);
if (commandLineArgumentAttribute == null)
{
defaultCommandLineArgAttribute = posCommandLineArgAttribute = (ChoPositionalCommandLineArgAttribute)memberInfo.GetCustomAttribute <ChoPositionalCommandLineArgAttribute>(true);
if (posCommandLineArgAttribute == null)
{
return(null);
}
}
bool containsCmdLineArg = false;
string cmdLineArgValue = null;
object newCmdLineArgValue = null;
string defaultValue = null;
bool isDefaultValueSpecified = false;
bool isFallbackValueSpecified = false;
string name = null;
string fallbackValue = null;
object fallbackValueObj = null;
object defaultValueObj = null;
name = ChoType.GetMemberName(memberInfo);
try
{
if (posCommandLineArgAttribute != null)
{
if (!commandLineArgParser.IsSwitchSpecified(posCommandLineArgAttribute.Position))
{
commandLineArgObject.RaiseCommandLineArgNotFound(posCommandLineArgAttribute.Position.ToString(), ref cmdLineArgValue);
}
cmdLineArgValue = commandLineArgParser[posCommandLineArgAttribute.Position];
}
else if (commandLineArgumentAttribute != null)
{
if (!commandLineArgParser.IsSwitchSpecified(commandLineArgumentAttribute.CommandLineSwitch))
{
commandLineArgObject.RaiseCommandLineArgNotFound(commandLineArgumentAttribute.CommandLineSwitch, ref cmdLineArgValue);
}
if (ChoType.GetMemberType(memberInfo) == typeof(bool))
{
containsCmdLineArg = IsSwitchSpecified(commandLineArgParser, commandLineArgumentAttribute.CommandLineSwitch, commandLineArgumentAttribute.Aliases);
if (containsCmdLineArg)
{
cmdLineArgValue = "True";
//cmdLineArgValue = GetCmdLineArgValue(commandLineArgParser, commandLineArgumentAttribute.CommandLineSwitch, commandLineArgumentAttribute.Aliases);
//if (cmdLineArgValue.IsNullOrWhiteSpace())
// cmdLineArgValue = "True";
}
else
{
containsCmdLineArg = IsSwitchSpecified(commandLineArgParser, "{0}-".FormatString(commandLineArgumentAttribute.CommandLineSwitch), commandLineArgumentAttribute.Aliases);
if (containsCmdLineArg)
{
cmdLineArgValue = "False";
}
}
}
//else if (ChoType.GetMemberType(memberInfo).IsEnum)
//{
// containsCmdLineArg = IsSwitchSpecified(commandLineArgParser, Enum.GetNames(ChoType.GetMemberType(memberInfo)));
// if (containsCmdLineArg)
// cmdLineArgValue = GetCmdLineArgValue(commandLineArgParser, Enum.GetNames(ChoType.GetMemberType(memberInfo)));
// else
// cmdLineArgValue = GetCmdLineArgValue(commandLineArgParser, commandLineArgumentAttribute.CommandLineSwitch, commandLineArgumentAttribute.Aliases);
//}
else
{
cmdLineArgValue = GetCmdLineArgValue(commandLineArgParser, commandLineArgumentAttribute.CommandLineSwitch, commandLineArgumentAttribute.Aliases);
}
}
else
{
return(null);
}
//if (ChoType.GetMemberType(memberInfo) != typeof(bool))
//{
isDefaultValueSpecified = ChoCmdLineArgMetaDataManager.TryGetDefaultValue(commandLineArgObject, name, defaultCommandLineArgAttribute, out defaultValue);
isFallbackValueSpecified = ChoCmdLineArgMetaDataManager.TryGetFallbackValue(commandLineArgObject, name, defaultCommandLineArgAttribute, out fallbackValue);
//}
try
{
if (isFallbackValueSpecified)
{
// fallbackValueObj = ChoConvert.ConvertFrom(commandLineArgObject, ChoString.ExpandPropertiesEx(fallbackValue),
//ChoType.GetMemberType(memberInfo),
//ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
fallbackValueObj = ChoConvert.ConvertFrom(ChoString.ExpandPropertiesEx(fallbackValue), memberInfo, commandLineArgObject);
}
}
catch
{
}
try
{
if (isDefaultValueSpecified)
{
//defaultValueObj = ChoConvert.ConvertFrom(commandLineArgObject, ChoString.ExpandPropertiesEx(defaultValue), ChoType.GetMemberType(memberInfo),
// ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
defaultValueObj = ChoConvert.ConvertFrom(ChoString.ExpandPropertiesEx(defaultValue), memberInfo, commandLineArgObject);
}
}
catch
{
}
if (commandLineArgObject != null && !commandLineArgObject.RaiseBeforeCommandLineArgLoaded(memberInfo.Name, ref cmdLineArgValue, defaultValueObj, fallbackValueObj))
{
if (!cmdLineArgValue.IsNull())
{
newCmdLineArgValue = ChoConvert.ConvertFrom(ChoString.ExpandPropertiesEx(cmdLineArgValue), memberInfo, commandLineArgObject);
//newCmdLineArgValue = ChoConvert.ConvertFrom(commandLineArgObject, ChoString.ExpandPropertiesEx(cmdLineArgValue),
// ChoType.GetMemberType(memberInfo),
// ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
}
if (newCmdLineArgValue == null && defaultCommandLineArgAttribute.IsRequired)
{
if (ChoType.GetMemberType(memberInfo) != typeof(bool))
{
if (commandLineArgumentAttribute != null)
{
throw new ChoCommandLineArgException("Missing arg value for '{0}' required command line switch.".FormatString(
commandLineArgumentAttribute == null ? ChoCommandLineArgObject.DefaultCmdLineSwitch : commandLineArgumentAttribute.CommandLineSwitch),
commandLineArgObject.GetUsage());
}
else if (posCommandLineArgAttribute != null)
{
if (posCommandLineArgAttribute.ShortName.IsNull())
{
throw new ChoCommandLineArgException("Missing positional arg value at '{0}' position.".FormatString(
posCommandLineArgAttribute == null ? ChoCommandLineArgObject.DefaultCmdLineSwitch : posCommandLineArgAttribute.Position.ToString()), commandLineArgObject.GetUsage());
}
else
{
throw new ChoCommandLineArgException("Missing '{0}' argument.".FormatString(posCommandLineArgAttribute.ShortName), commandLineArgObject.GetUsage());
}
}
else
{
throw new ChoCommandLineArgException("Missing arg value at '{0}' position.".FormatString(ChoCommandLineArgObject.DefaultCmdLineSwitch), commandLineArgObject.GetUsage());
}
}
}
else
{
if (newCmdLineArgValue == null)
{
if (isDefaultValueSpecified)
{
//if (ChoType.GetMemberType(memberInfo) != typeof(bool))
newCmdLineArgValue = defaultValueObj;
//else
// newCmdLineArgValue = false;
}
}
ChoType.SetMemberValue(commandLineArgObject, memberInfo, newCmdLineArgValue);
if (commandLineArgObject != null)
{
commandLineArgObject.RaiseAfterCommandLineArgLoaded(memberInfo.Name, newCmdLineArgValue);
}
}
}
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
if (commandLineArgObject != null && commandLineArgObject.RaiseCommandLineArgLoadError(memberInfo.Name, cmdLineArgValue, ex))
{
}
else
{
if (defaultCommandLineArgAttribute.IsRequired)
{
return(ex);
}
if (fallbackValueObj != null)
{
ChoType.SetMemberValue(commandLineArgObject, memberInfo, fallbackValueObj);
}
else
{
return(ex);
}
}
}
return(null);
}
internal static Dictionary <string, object> ToPersistableDictionaryCollection(ChoBaseConfigurationElement configElement, Type itemType)
{
ChoGuard.ArgumentNotNull(configElement, "ConfigElement");
object target = configElement.ConfigObject;
ChoGuard.ArgumentNotNull(target, "Target");
Dictionary <string, object> dict = new Dictionary <string, object>();
//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(dict);
}
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));
name = ChoType.GetMemberName(memberInfo, memberInfoAttribute);
if (target is ChoConfigurableObject && ((ChoConfigurableObject)target).RaiseBeforeConfigurationObjectMemberPersist(memberInfo.Name, name, ref memberValue))
{
dict.Add(name, memberValue);
}
else
{
if (memberInfoAttribute != null && !memberInfoAttribute.Persistable)
{
continue;
}
memberValue = ChoType.GetMemberValue(target, memberInfo.Name);
Type memberType = ChoConfigurationMetaDataManager.GetSourceType(configElement, name, memberInfoAttribute);
if (memberType == null)
{
if (itemType == typeof(Object))
{
memberType = ChoType.GetMemberType(memberInfo);
}
else
{
memberType = itemType;
}
}
dict.Add(name, ChoConvert.ConvertTo(target, memberValue, memberType,
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo), null));
}
}
return(dict);
}
private static ChoPropertyInfos ConstructPropertyInfos(ChoBaseConfigurationElement configElement)
{
if (configElement != null && configElement.ConfigbObjectType != null)
{
Dictionary <string, ChoPropertyInfos> propDict = _propDict;
string configElementPath = configElement.ConfigElementPath;
if (configElementPath.IsNullOrWhiteSpace())
{
return(ChoPropertyInfos.Default);
}
if (!propDict.ContainsKey(configElementPath))
{
lock (_padLock)
{
if (!propDict.ContainsKey(configElementPath))
{
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(configElement.ConfigbObjectType);
if (memberInfos != null && memberInfos.Length > 0)
{
//Set member values
List <ChoPropertyInfo> propertyInfoList = new List <ChoPropertyInfo>();
ChoPropertyInfoAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null)
{
continue;
}
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute));
ChoPropertyInfo propInfo = new ChoPropertyInfo();
propInfo.Name = ChoType.GetMemberName(memberInfo);
if (memberInfoAttribute != null)
{
propInfo.DefaultValue = memberInfoAttribute.DefaultValue;
propInfo.FallbackValue = memberInfoAttribute.FallbackValue;
propInfo.SourceType = memberInfoAttribute.SourceType;
propInfo.IsDefaultValueSpecified = memberInfoAttribute.IsDefaultValueSpecified;
propInfo.IsFallbackValueSpecified = memberInfoAttribute.IsFallbackValueSpecified;
}
propertyInfoList.Add(propInfo);
}
if (propertyInfoList.Count > 0)
{
ChoPropertyInfos propertyInfos = new ChoPropertyInfos();
propertyInfos.PropertyInfoArr = propertyInfoList.ToArray();
return(propertyInfos);
}
}
}
}
}
}
return(ChoPropertyInfos.Default);
}
public static void Initialize(this object target)
{
if (target == null)
{
return;
}
object defaultValue = null;
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties <DefaultValueAttribute>(target.GetType()))
{
try
{
defaultValue = ChoTypeDescriptor.GetPropetyAttribute <DefaultValueAttribute>(pd).Value;
if (defaultValue != null)
{
ChoType.ConvertNSetPropertyValue(target, pd.Name, defaultValue);
}
}
catch (Exception ex)
{
ChoETLFramework.WriteLog(ChoETLFramework.TraceSwitch.TraceError, "Error while assigning default value '{0}' to '{1}' member. {2}".FormatString(defaultValue, ChoType.GetMemberName(pd), ex.Message));
}
}
foreach (PropertyDescriptor pd in ChoTypeDescriptor.GetProperties <ChoDefaultValueAttribute>(target.GetType()))
{
if (ChoTypeDescriptor.GetPropetyAttribute <ChoDefaultValueAttribute>(pd) == null)
{
continue;
}
try
{
defaultValue = ChoTypeDescriptor.GetPropetyAttribute <ChoDefaultValueAttribute>(pd).Value;
if (defaultValue != null)
{
ChoType.ConvertNSetPropertyValue(target, pd.Name, defaultValue);
}
}
catch (Exception ex)
{
ChoETLFramework.WriteLog(ChoETLFramework.TraceSwitch.TraceError, "Error while assigning default value '{0}' to '{1}' member. {2}".FormatString(defaultValue, ChoType.GetMemberName(pd), ex.Message));
}
}
//ChoETLFramework.InitializeObject(target);
if (target is IChoInitializable)
{
((IChoInitializable)target).Initialize();
}
}
private static void ExtractAndPopulateValues <T>(T target, IDataReader dr, ChoDataObjectAttribute objAttr)
{
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(target.GetType());
if (memberInfos != null && memberInfos.Length > 0)
{
string name;
string fallbackValue = null;
object memberValue = null;
object newValue = null;
object defaultValue = null;
object value = null;
ChoPropertyInfoAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
name = ChoType.GetMemberName(memberInfo);
memberValue = null;
newValue = null;
value = null;
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttributeByBaseType(memberInfo, typeof(ChoPropertyInfoAttribute));
try
{
if (dr.FieldExists(name))
{
value = dr[name];
}
try
{
defaultValue = memberInfo.GetDefaultValue();
//if (memberInfoAttribute != null)
//{
// if (!memberInfoAttribute.DefaultValue.IsNullOrWhiteSpace())
// defaultValue = ChoString.ExpandPropertiesEx(memberInfoAttribute.DefaultValue);
//}
}
catch
{
defaultValue = null;
}
try
{
if (memberInfoAttribute != null)
{
if (!memberInfoAttribute.FallbackValue.IsNullOrWhiteSpace())
{
fallbackValue = ChoString.ExpandPropertiesEx(memberInfoAttribute.FallbackValue);
}
}
}
catch
{
fallbackValue = null;
}
newValue = memberValue = value;
if (newValue.IsNullOrDbNull())
{
if (fallbackValue == null)
{
newValue = defaultValue;
}
else
{
newValue = fallbackValue;
}
}
newValue = ChoConvert.ConvertFrom(newValue, memberInfo, target);
// newValue = ChoConvert.ConvertFrom(target, newValue, ChoType.GetMemberType(memberInfo),
//ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
if (newValue == null)
{
}
else
{
ChoType.SetMemberValue(target, memberInfo, newValue);
}
}
catch (Exception)
{
if (objAttr == null || (objAttr != null && !objAttr.Silent))
{
throw;
}
}
}
}
}
