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