public object NormalizeValue(string name, object value, Type targetType = null)
{
var m1 = ChoType.GetMembers(GetType()).Where(m => !ChoType.IsReadOnlyMember(m) &&
(m.GetCustomAttribute <ChoPropertyAttribute>() != null && m.GetCustomAttribute <ChoPropertyAttribute>().Name == name) || m.Name == name).FirstOrDefault();
if (m1 == null)
{
return(value);
}
value = ChoConvert.ConvertTo(value, m1, targetType == null ? typeof(string) : targetType);
var attr = ChoType.GetMemberAttribute <ChoPropertyAttribute>(m1);
if (value != null && value is string)
{
string mv = value as string;
if (attr != null)
{
switch (attr.TrimOption)
{
case ChoPropertyValueTrimOption.Trim:
mv = mv.Trim();
break;
case ChoPropertyValueTrimOption.TrimEnd:
mv = mv.TrimEnd();
break;
case ChoPropertyValueTrimOption.TrimStart:
mv = mv.TrimStart();
break;
}
}
return(mv);
}
return(value);
}
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 override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
{
var crs = Writer.ContractResolverState;
if (crs == null)
{
var t = serializer.SerializeToJToken(value);
t.WriteTo(writer);
//serializer.Serialize(writer, value);
return;
}
var fc = crs.FieldConfig;
crs.Name = _fc == null?_mi.GetFullName() : crs.Name;
var rec = ChoType.GetMemberObjectMatchingType(crs.Name, crs.Record);
var name = ChoType.GetFieldName(crs.Name);
var st = ChoType.GetMemberAttribute(_mi, typeof(ChoSourceTypeAttribute)) as ChoSourceTypeAttribute;
if (st != null && st.Type != null)
{
_objType = st.Type;
}
if (_fc != null && _fc.SourceType != null)
{
_objType = _fc.SourceType;
}
if (RaiseBeforeRecordFieldWrite(rec, crs.Index, name, ref value))
{
if (_fc != null)
{
if (value != null && _objType != null)
{
value = ChoConvert.ConvertTo(value, _objType, null, _fc.PropConverters, _fc.PropConverterParams, _culture);
}
if (_fc.CustomSerializer == null)
{
if (_fc.ValueConverter == null)
{
var t = serializer.SerializeToJToken(value);
t.WriteTo(writer);
}
else
{
object retValue = _fc.ValueConverter(value);
ValidateOnWrite(ref retValue);
//ChoETLRecordHelper.DoMemberLevelValidation(retValue, _fc.Name, _fc, _validationMode);
JToken t = JToken.FromObject(retValue, serializer);
t.WriteTo(writer);
}
}
else
{
object retValue = _fc.CustomSerializer(writer);
ValidateOnWrite(ref retValue);
JToken t = JToken.FromObject(retValue, serializer);
t.WriteTo(writer);
}
}
else
{
if (value != null && _objType != null)
{
value = ChoConvert.ConvertTo(value, _objType, null, ChoTypeDescriptor.GetTypeConverters(_mi), ChoTypeDescriptor.GetTypeConverterParams(_mi), _culture);
}
if (ValidateOnWrite(ref value))
{
var t = serializer.SerializeToJToken(value);
t.WriteTo(writer);
}
else
{
JToken t = JToken.FromObject(null, serializer);
t.WriteTo(writer);
}
}
RaiseAfterRecordFieldWrite(rec, crs.Index, name, value);
}
else
{
JToken t = JToken.FromObject(null, serializer);
t.WriteTo(writer);
}
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
object retValue = null;
var crs = Reader.ContractResolverState;
if (crs == null)
{
return(serializer.Deserialize(reader, objectType));
}
var fc = crs.FieldConfig;
crs.Name = _fc == null?_mi.GetFullName() : crs.Name;
var rec = ChoType.GetMemberObjectMatchingType(crs.Name, crs.Record);
var name = ChoType.GetFieldName(crs.Name);
var st = ChoType.GetMemberAttribute(_mi, typeof(ChoSourceTypeAttribute)) as ChoSourceTypeAttribute;
if (st != null && st.Type != null)
{
_objType = st.Type;
}
if (_fc != null && _fc.SourceType != null)
{
_objType = _fc.SourceType;
}
retValue = reader;
if (!RaiseBeforeRecordFieldLoad(rec, crs.Index, name, ref retValue))
{
if (_fc != null)
{
if (_fc.CustomSerializer == null)
{
if (_fc.ValueConverter == null)
{
retValue = serializer.Deserialize(reader, objectType);
}
else
{
retValue = _fc.ValueConverter(serializer.Deserialize(reader, typeof(string)));
}
}
else
{
retValue = _fc.CustomSerializer(reader);
}
ValidateORead(ref retValue);
//ChoETLRecordHelper.DoMemberLevelValidation(retValue, _fc.Name, _fc, _validationMode);
if (retValue != null)
{
retValue = ChoConvert.ConvertFrom(retValue, objectType, null, _fc.PropConverters, _fc.PropConverterParams, _culture);
}
}
else
{
retValue = serializer.Deserialize(reader, objectType);
ValidateORead(ref retValue);
if (retValue != null)
{
retValue = ChoConvert.ConvertFrom(retValue, objectType, null, ChoTypeDescriptor.GetTypeConverters(_mi), ChoTypeDescriptor.GetTypeConverterParams(_mi), _culture);
}
}
}
if (!RaiseAfterRecordFieldLoad(rec, crs.Index, name, retValue))
{
return(null);
}
return(retValue == reader?serializer.Deserialize(reader, objectType) : retValue);
}
private void Initialize()
{
try
{
if (!Monitor.TryEnter(_padLock, 1 * 1000))
{
return;
}
IDictionary <string, object> kvpDict = null;
if (_func != null)
{
kvpDict = _func();
}
else
{
kvpDict = Seed();
}
if (kvpDict == null)
{
return;
}
IDictionary <string, object> mkvpDict = _kvpDict;
bool hasDiff = mkvpDict == null || kvpDict.Except(mkvpDict).Concat(mkvpDict.Except(kvpDict)).Any();
if (!hasDiff)
{
return;
}
_kvpDict = kvpDict;
ChoPropertyAttribute attr = null;
object memberValue = null;
string propName = null;
//scan through members and load them
foreach (var prop in ChoType.GetMembers(GetType()).Where(m => m.GetCustomAttribute <ChoIgnoreMemberAttribute>() != null && !ChoType.IsReadOnlyMember(m)))
{
attr = ChoType.GetMemberAttribute <ChoPropertyAttribute>(prop);
try
{
SetDefaultValue(prop, true);
propName = attr != null && !attr.Name.IsNullOrWhiteSpace() ? attr.Name : prop.Name;
if (kvpDict.ContainsKey(propName))
{
memberValue = AfterKVPLoaded(prop.Name, kvpDict[propName]);
}
else
{
memberValue = AfterKVPLoaded(prop.Name, null);
}
if (memberValue != null && memberValue is string)
{
string mv = memberValue as string;
if (attr != null)
{
switch (attr.TrimOption)
{
case ChoPropertyValueTrimOption.Trim:
mv = mv.Trim();
break;
case ChoPropertyValueTrimOption.TrimEnd:
mv = mv.TrimEnd();
break;
case ChoPropertyValueTrimOption.TrimStart:
mv = mv.TrimStart();
break;
}
}
memberValue = mv;
}
if (ChoType.GetMemberType(prop) == typeof(string))
{
if (!((string)memberValue).IsNullOrEmpty())
{
ChoType.ConvertNSetMemberValue(this, prop, memberValue);
}
}
else
{
if (memberValue != null)
{
ChoType.ConvertNSetMemberValue(this, prop, memberValue);
}
}
ChoValidator.ValidateFor(this, prop);
}
catch (Exception ex)
{
//ChoLog.Error("{0}: Error loading '{1}' property. {2}".FormatString(NName, prop.Name, ex.Message));
SetDefaultValue(prop, false);
}
}
}
catch (Exception outerEx)
{
//ChoLog.Error("{0}: Error loading options. {1}".FormatString(NName, outerEx.Message));
}
finally
{
Monitor.Exit(_padLock);
}
}
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 string ToString(object target, bool collectErrMsgs, ChoMemberFormatterAttribute memberFormaterAttribute1,
ChoMemberItemFormatterAttribute memberItemFormaterAttribute1, BindingFlags bindingFlags)
{
if (target == null)
{
return(String.Empty);
}
if (memberFormaterAttribute1 != null && memberFormaterAttribute1.CanFormat())
{
if (target.GetType().IsSimple())
{
return(memberFormaterAttribute1.FormatObject(target));
}
else
{
ChoStringMsgBuilder msg = new ChoStringMsgBuilder();
//msg.AppendLineIfNoNL(memberFormaterAttribute1.FormatObject(target));
msg.Append(memberFormaterAttribute1.FormatObject(target));
//msg.AppendNewLine();
if (collectErrMsgs)
{
GetErrorMsgs(target, msg);
}
return(msg.ToString());
}
}
else if (target.GetType().IsSimple() || target.GetType().IsMethodImplemented("ToString"))
{
return(target.ToString());
}
else if (target is Delegate)
{
return(String.Format("{0}.{1}", ((Delegate)target).Target == null ? "[Static]" : ((Delegate)target).Target.GetType().FullName, ((Delegate)target).Method.Name));
}
else if (target is IEnumerable)
{
StringBuilder arrMsg = new StringBuilder();
int count = 0;
foreach (object item in (IEnumerable)target)
{
count++;
arrMsg.AppendFormat("{0}{1}", ToString(item, collectErrMsgs, memberItemFormaterAttribute1, null, bindingFlags), Environment.NewLine);
}
return("[Count: {0}]{1}{2}".FormatString(count, Environment.NewLine, arrMsg.ToString()));
}
else
{
bool foundMatchingFormatter = false;
string retValue = ChoObject.Format(target, null, out foundMatchingFormatter);
if (foundMatchingFormatter)
{
if (target.GetType().IsSimple())
{
return(retValue);
}
else
{
ChoStringMsgBuilder msg = new ChoStringMsgBuilder();
msg.AppendFormat(retValue);
msg.AppendNewLine();
if (collectErrMsgs)
{
GetErrorMsgs(target, msg);
}
return(msg.ToString());
}
}
else
{
ChoInterceptableObject interceptableObject = null;
try
{
if (ChoType.IsRealProxyObject(target.GetType()))
{
interceptableObject = ChoInterceptableObject.Silentable(target as ChoInterceptableObject);
}
ChoTypeFormatterAttribute objectFormatter = ChoType.GetAttribute(target.GetType(), typeof(ChoTypeFormatterAttribute)) as ChoTypeFormatterAttribute;
if (objectFormatter == null)
{
ChoStringMsgBuilder msg = new ChoStringMsgBuilder(memberFormaterAttribute1 == null ? String.Format("{0} State", target.GetType().FullName)
: memberFormaterAttribute1.Name);
//MemberInfo[] memberInfos = target.GetType().GetMembers(bindingFlags /*BindingFlags.Public | BindingFlags.Instance /*| BindingFlags.DeclaredOnly*/ /*| BindingFlags.GetField | BindingFlags.GetProperty*/);
IEnumerable <MemberInfo> memberInfos = ChoType.GetGetFieldsNProperties(target.GetType(), bindingFlags);
if (memberInfos == null || memberInfos.Count() == 0)
{
msg.AppendFormatLine(ChoStringMsgBuilder.Empty);
}
else
{
foreach (MemberInfo memberInfo in memberInfos)
{
if (!ChoType.IsValidObjectMember(memberInfo))
{
continue;
}
ChoIgnoreMemberFormatterAttribute memberFormatterIgnoreAttribute = ChoType.GetMemberAttribute(memberInfo, typeof(ChoIgnoreMemberFormatterAttribute)) as ChoIgnoreMemberFormatterAttribute;
if (memberFormatterIgnoreAttribute != null)
{
continue;
}
string memberText = GetNFormatMemberValue(target, memberInfo, collectErrMsgs, null, null, bindingFlags);
int count = 0;
if (GetCountFromMsg(ref memberText, ref count))
{
msg.AppendFormatLine("{0} [Length: {2}]: {1}", memberInfo.Name, memberText, count);
}
else if (!memberText.ContainsHeader())
{
msg.AppendFormatLine("{0}: {1}", memberInfo.Name, memberText);
}
else
{
msg.AppendFormatLine("{0}: {1}", memberInfo.Name, memberText);
}
}
}
msg.AppendNewLine();
if (collectErrMsgs)
{
GetErrorMsgs(target, msg);
}
return(msg.ToString());
}
else
{
ChoStringMsgBuilder msg = new ChoStringMsgBuilder(ChoString.ExpandProperties(target, objectFormatter.Header));;
if (objectFormatter.HasFormatSpecified)
{
msg.AppendFormat(objectFormatter.FormatObject(target));
}
else
{
//MemberInfo[] memberInfos = target.GetType().GetMembers(bindingFlags /*BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance /*| BindingFlags.DeclaredOnly*/ /*| BindingFlags.GetField | BindingFlags.GetProperty*/);
IEnumerable <MemberInfo> memberInfos = ChoType.GetGetFieldsNProperties(target.GetType(), bindingFlags);
if (memberInfos == null || memberInfos.Count() == 0)
{
msg.AppendFormatLine(ChoStringMsgBuilder.Empty);
}
else
{
bool isPublicMember = true;
foreach (MemberInfo memberInfo in memberInfos)
{
if (!ChoType.IsValidObjectMember(memberInfo))
{
continue;
}
isPublicMember = true;
ChoIgnoreMemberFormatterAttribute memberFormatterIgnoreAttribute = ChoType.GetMemberAttribute(memberInfo, typeof(ChoIgnoreMemberFormatterAttribute)) as ChoIgnoreMemberFormatterAttribute;
if (memberFormatterIgnoreAttribute != null)
{
continue;
}
ChoMemberFormatterAttribute memberFormaterAttribute = ChoType.GetMemberAttribute(memberInfo, typeof(ChoMemberFormatterAttribute)) as ChoMemberFormatterAttribute;
ChoMemberItemFormatterAttribute memberItemFormaterAttribute = ChoType.GetMemberAttribute(memberInfo, typeof(ChoMemberItemFormatterAttribute)) as ChoMemberItemFormatterAttribute;
if (memberInfo is PropertyInfo)
{
MethodInfo getMethod = ((PropertyInfo)memberInfo).GetGetMethod(true);
isPublicMember = getMethod != null && getMethod.IsPublic;
}
else if (memberInfo is FieldInfo)
{
isPublicMember = ((FieldInfo)memberInfo).IsPublic;
}
else
{
continue;
}
if (isPublicMember || (!isPublicMember && memberFormaterAttribute != null))
{
object memberValue = ChoType.GetMemberValue(target, memberInfo);
if (memberValue == target)
{
return(null);
}
string memberText = GetNFormatMemberValue(target, memberInfo, collectErrMsgs, memberFormaterAttribute, memberItemFormaterAttribute, bindingFlags);
string memberName = memberFormaterAttribute == null || memberFormaterAttribute.Name.IsNullOrEmpty() ? memberInfo.Name : ChoPropertyManager.ExpandProperties(target, memberFormaterAttribute.Name);
if (memberFormaterAttribute == null || !memberFormaterAttribute.CanFormat())
{
int count = 0;
if (GetCountFromMsg(ref memberText, ref count))
{
msg.AppendFormatLine("{0} [Length: {2}]: {1}", memberName, memberText, count);
}
else if (memberText.ContainsHeader())
{
msg.AppendFormatLine("{0}: {1}", memberName, memberText);
}
else
{
msg.AppendFormatLine("{0}: {1}", memberName, memberText);
}
}
else if (memberFormaterAttribute.Name == ChoNull.NullString)
{
msg.Append(memberFormaterAttribute.PostFormat(memberName, memberText));
}
else
{
msg.AppendFormat(memberFormaterAttribute.PostFormat(memberName, memberText));
}
}
}
}
}
//msg.AppendNewLine();
if (collectErrMsgs)
{
GetErrorMsgs(target, msg);
}
return(msg.ToString());
}
}
finally
{
if (interceptableObject != null)
{
interceptableObject.Dispose();
}
}
}
}
}
private void Register(Type type)
{
if (type == null)
{
return;
}
if (_cache.ContainsKey(type))
{
return;
}
lock (_padLock)
{
if (_cache.ContainsKey(type))
{
return;
}
Dictionary <string, HashSet <string> > dependsOnCache = new Dictionary <string, HashSet <string> >(StringComparer.InvariantCultureIgnoreCase);
_cache.Add(type, dependsOnCache);
string memberName = null;
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(type);
if (memberInfos != null && memberInfos.Length > 0)
{
ChoPropertyDependsOnAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
memberName = memberInfo.Name;
memberInfoAttribute = (ChoPropertyDependsOnAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyDependsOnAttribute));
if (memberInfoAttribute == null)
{
continue;
}
string[] dependsOn = memberInfoAttribute.DependsOn;
if (dependsOn.IsNullOrEmpty())
{
continue;
}
foreach (string item in dependsOn)
{
if (item.IsNullOrWhiteSpace())
{
continue;
}
if (!dependsOnCache.ContainsKey(item))
{
dependsOnCache.Add(item, new HashSet <string>(StringComparer.InvariantCultureIgnoreCase));
}
if (dependsOnCache[item].Contains(memberName))
{
continue;
}
dependsOnCache[item].Add(memberName);
}
}
}
}
}
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 void LoadConfig(bool refresh)
{
object configObject = _configObject;
//Set default trace output file name
_traceOutputFileName = configObject.GetType().Name;
MemberInfo[] memberInfos = ChoType.GetMembers(configObject.GetType(), typeof(ChoMemberInfoAttribute));
if (memberInfos == null || memberInfos.Length == 0)
{
return;
}
_configSection = GetConfig();
if (_configSection == null)
{
throw new ChoConfigurationConstructionException("Missing configuration section.");
}
if (!refresh)
{
//Hookup the configuration watch job
ChoConfigurationChangeWatcherManager.SetWatcherForConfigSource(_configSection.ConfigurationChangeWatcher);
ChoConfigurationChangeWatcherManager.ConfigurationChanged += new ChoConfigurationChangedEventHandler(ChoConfigurationChangeWatcherManager_ConfigurationChanged);
}
else
{
_configSection.ConfigurationChangeWatcher.StopWatching();
}
ErrMsg = _configSection.ErrMsg;
if (!IgnoreError && ErrMsg != null)
{
throw new ApplicationException(ErrMsg);
}
Hashtable hashTable = _configSection.ToHashtable();
//Set member values
string name;
ChoMemberInfoAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
memberInfoAttribute = (ChoMemberInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoMemberInfoAttribute));
if (memberInfoAttribute == null)
{
continue;
}
name = memberInfoAttribute.Name;
try
{
//Set the config values
if (hashTable[name] != null)
{
ChoType.SetMemberValue(configObject, memberInfo.Name, hashTable[name]);
}
//Set default values
else if (memberInfoAttribute.DefaultValue != null)
{
ChoType.SetMemberValue(configObject, memberInfo.Name, memberInfoAttribute.DefaultValue);
}
}
catch (Exception ex)
{
if (IgnoreError)
{
SetMemberError(configObject, memberInfo.Name, String.Format(Resources.ConfigConstructMsg, ChoString.ToString(hashTable[name]), ex.Message));
}
else
{
throw new ChoConfigurationConstructionException(String.Format(Resources.ConfigConstructExceptionMsg, ChoString.ToString(hashTable[name]), configObject.GetType().Name,
memberInfo.Name), ex);
}
}
//try
//{
// //Validate the member with associated attributes
// foreach (IChoMemberValidator memberValidator in ChoType.GetMemberAttributesByBaseInterface(memberInfo, typeof(IChoMemberValidator)))
// {
// memberValidator.Validate(configObject, memberInfo);
// }
// foreach (ChoConfigurationValidatorAttribute memberValidator in ChoType.GetMemberAttributesByBaseInterface(memberInfo, typeof(ChoConfigurationValidatorAttribute)))
// {
// if (memberValidator.ValidatorInstance.CanValidate(ChoType.GetMemberType(memberInfo)))
// memberValidator.ValidatorInstance.Validate(ChoType.GetMemberValue(configObject, memberInfo.Name));
// }
//}
//catch (Exception ex)
//{
// if (IgnoreError)
// SetMemberError(configObject, memberInfo.Name, String.Format(Resources.ConfigConstructValidationMsg, ChoString.ToString(ChoType.GetMemberValue(configObject, memberInfo.Name)),
// ex.Message));
// else
// throw new ChoConfigurationConstructionException(String.Format(Resources.ConfigConstructValidationExceptionMsg, ChoString.ToString(ChoType.GetMemberValue(configObject, memberInfo.Name))), ex);
//}
}
_configSection.ConfigurationChangeWatcher.StartWatching();
//Print the output to file
TraceOutput(configObject);
}
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);
}
