private void InitializeConfigElement(ChoBaseConfigurationElement configElement, Type type)
{
if (configElement == null)
{
return;
}
configElement.DefaultConfigSectionHandlerType = ConfigSectionHandlerType;
configElement.ConfigFilePath = ConfigFilePath;
ChoStandardConfigurationMetaDataInfo standardConfigurationMetaDataInfo = new ChoStandardConfigurationMetaDataInfo();
standardConfigurationMetaDataInfo.BindingMode = BindingMode;
if (ConfigStorageType != null)
{
standardConfigurationMetaDataInfo.ConfigStorageType = ConfigStorageType.AssemblyQualifiedName;
}
standardConfigurationMetaDataInfo.ConfigurationMetaDataLogInfo = new ChoConfigurationMetaDataLogInfo();
standardConfigurationMetaDataInfo.ConfigurationMetaDataLogInfo.LogCondition = LogCondition;
standardConfigurationMetaDataInfo.ConfigurationMetaDataLogInfo.LogTimeStampFormat = LogTimeStampFormat;
standardConfigurationMetaDataInfo.ConfigurationMetaDataLogInfo.LogDirectory = LogDirectory;
standardConfigurationMetaDataInfo.ConfigurationMetaDataLogInfo.LogFileName = LogFileName.IsNullOrEmpty() ? ChoPath.AddExtension(type.FullName, ChoReservedFileExt.Log) : LogFileName;
standardConfigurationMetaDataInfo.Defaultable = Defaultable;
standardConfigurationMetaDataInfo.IgnoreCase = IgnoreCase;
standardConfigurationMetaDataInfo.Silent = Silent;
configElement.MetaDataInfo = standardConfigurationMetaDataInfo;
LoadParameters(configElement);
ChoConfigurationMetaDataManager.SetDefaultMetaDataInfo(configElement);
}
private void SetWatcher(bool refresh)
{
ChoConfigurationMetaDataManager.SetWatcher(this);
if (ConfigSection != null)
{
if (!refresh)
{
//Hookup the configuration watch job
if (_watchChange)
{
ConfigSection.SetWatcher(new ChoConfigurationChangedEventHandler(OnConfigurationChanged));
}
}
else
{
ConfigSection.StopWatching();
if (ConfigObject is ChoInterceptableObject)
{
ChoInterceptableObject interceptableObject = ConfigObject as ChoInterceptableObject;
//((ChoInterceptableObject)ConfigObject).SetInitialized(false);
}
}
}
}
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 void SetWatcher(ChoBaseConfigurationElement configElement)
{
if (configElement == null)
{
return;
}
//if (configElement.WatchChange)
//{
ConfigurationChangeWatcher.SetConfigurationChangedEventHandler("{0}_MetaData_WatcherHandler".FormatString(configElement.ConfigElementPath),
(sender, e) =>
{
if (ChoConfigurationMetaDataManager.IsMetaDataModified(configElement))
{
configElement.Refresh();
}
});
//}
}
private ChoBaseConfigurationMetaDataInfo InitDefaultMetaDataInfo(ChoBaseConfigurationElement configElement)
{
ChoBaseConfigurationMetaDataInfo defaultMetaDataInfo = ChoConfigurationMetaDataManager.GetDefaultMetaDataInfo(configElement);
if (defaultMetaDataInfo.ConfigStorageType.IsNullOrEmpty())
{
if (DefaultConfigStorage != null)
{
defaultMetaDataInfo.ConfigStorageType = DefaultConfigStorage.GetType().AssemblyQualifiedName;
}
else
{
IChoConfigStorage configStorage = ChoConfigStorageManagerSettings.Me.GetDefaultConfigStorage();
if (configStorage != null)
{
defaultMetaDataInfo.ConfigStorageType = configStorage.GetType().AssemblyQualifiedName;
}
}
}
return(defaultMetaDataInfo);
}
private void Reset()
{
if (ConfigObject == null)
{
return;
}
ChoConfigurationObjectErrorManagerService.ResetObjectErrors(ConfigObject);
//MemberInfo[] memberInfos = ChoType.GetMembers(ConfigObject.GetType(), typeof(ChoConfigurationPropertyAttribute));
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(ConfigObject.GetType());
if (memberInfos != null && memberInfos.Length > 0)
{
ChoPropertyInfoAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute));
string name = ChoType.GetMemberName(memberInfo);
object defaultValue = null;
bool isDefaultValueSpecified = ChoConfigurationMetaDataManager.TryConfigDefaultValue(this, name, memberInfoAttribute, out defaultValue);
if (memberInfoAttribute == null || !isDefaultValueSpecified)
{
continue;
}
try
{
//object newConvertedValue = memberInfoAttribute.DefaultValue;
object newConvertedValue = ChoConvert.ConvertFrom(ConfigObject, defaultValue, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
SetConfigPropertyValue(newConvertedValue, memberInfo);
//ChoType.SetMemberValue(ConfigObject, memberInfo, newConvertedValue);
}
catch (Exception innerEx)
{
ChoConfigurationObjectErrorManagerService.SetObjectMemberError(ConfigObject, memberInfo.Name, String.Format("Failed to assign `{0}` default value. {1}", ChoString.ToString(defaultValue), innerEx.Message));
}
}
}
}
internal void Persist(bool traceOutput, ChoDictionaryService <string, object> stateInfo)
{
lock (SyncRoot)
{
if (ConfigSection == null || ConfigSection.ConfigData == null)
{
if (_firstTime && _defaultable)
{
PersistInternal(traceOutput, stateInfo);
}
else
{
ChoConfigurationMetaDataManager.SetMetaDataSection(this);
}
}
else if (_persistable)
{
PersistInternal(traceOutput, stateInfo);
}
/*
* if (_bindingMode == ChoConfigurationBindingMode.OneTime)
* {
* if (_firstTime)
* PersistInternal(traceOutput, stateInfo);
* }
* else if (!_persistable || (ConfigSection == null || ConfigSection.ConfigData == null))
* {
* ChoConfigurationMetaDataManager.SetMetaDataSection(this);
* }
* else
* {
* PersistInternal(traceOutput, stateInfo);
* }
* */
}
}
public override void Persist(object data, ChoDictionaryService <string, object> stateInfo)
{
if (!(data is NameValueCollection))
{
throw new ChoConfigurationException("Data object is not NameValueCollection object.");
}
try
{
//Write meta-data info
ChoConfigurationMetaDataManager.SetMetaDataSection(ConfigElement);
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
ConfigElement.Log(ex.ToString());
}
NameValueCollection nameValueCollection = ((NameValueCollection)data);
foreach (string key1 in nameValueCollection.Keys)
{
if (_configuration.AppSettings.Settings.AllKeys.Contains(key1))
{
_configuration.AppSettings.Settings[key1].Value = nameValueCollection[key1];
}
else
{
_configuration.AppSettings.Settings.Add(new KeyValueConfigurationElement(key1, nameValueCollection[key1]));
}
}
_configuration.Save(ConfigurationSaveMode.Modified);
}
public override void Persist(object data, ChoDictionaryService <string, object> stateInfo)
{
ChoXmlDocument.CreateXmlFileIfEmpty(ConfigFilePath);
string backupConfigFilePath = String.Format("{0}.{1}", ConfigFilePath, ChoReservedFileExt.Cho);
try
{
//Write meta-data info
ChoConfigurationMetaDataManager.SetMetaDataSection(ConfigElement);
if (!IsAppConfigFile)
{
if (File.Exists(backupConfigFilePath))
{
File.SetAttributes(backupConfigFilePath, FileAttributes.Archive);
}
File.Copy(ConfigFilePath, backupConfigFilePath, true);
if (File.Exists(backupConfigFilePath))
{
File.SetAttributes(backupConfigFilePath, FileAttributes.Hidden);
}
}
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
ConfigElement.Log(ex.ToString());
}
try
{
//if seperate config file maintained, make a link in the application configuration
if (IsConfigReferenceDataChanged(stateInfo))
{
using (ChoXmlDocument xmlDocument = new ChoXmlDocument(ChoGlobalApplicationSettings.Me.ApplicationConfigFilePath))
{
XmlNode configNode = xmlDocument.XmlDocument.MakeXPath(ConfigElement.ConfigElementPath);
if (configNode != null)
{
if (!IsAppConfigFile)
{
string configXml = @"<{0} {1}=""{2}"" {3}=""{4}"" />".FormatString(ConfigSectionName, ChoConfigurationManager.PathToken, UnderlyingConfigFilePath, ChoXmlDocument.CinchoNSToken, ChoXmlDocument.CinchooNSURI);
ChoXmlDocument.SetNamespaceAwareOuterXml(configNode, configXml, ChoXmlDocument.CinchooNSURI);
}
}
}
}
PersistConfigData(data, stateInfo);
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
ConfigElement.Log(ex.ToString());
if (!IsAppConfigFile)
{
File.Copy(backupConfigFilePath, ConfigFilePath, true);
}
}
}
private bool ExtractNPopulateValues(ref bool hasErrors, ref bool isDirty)
{
bool isModfied = false;
object oldValue = null;
object newValue = null;
object origValue = null;
object defaultValue = null;
object fallbackValue = null;
bool isConfigmemberDefined = false;
//MemberInfo[] memberInfos = ChoType.GetMembers(ConfigObject.GetType(), typeof(ChoConfigurationPropertyAttribute));
MemberInfo[] memberInfos = ChoTypeMembersCache.GetAllMemberInfos(ConfigObject.GetType());
if (memberInfos != null && memberInfos.Length > 0)
{
//Set member values
string name;
ChoPropertyInfoAttribute memberInfoAttribute = null;
foreach (MemberInfo memberInfo in memberInfos)
{
if (memberInfo.GetCustomAttribute <ChoIgnorePropertyAttribute>() != null)
{
continue;
}
memberInfoAttribute = (ChoPropertyInfoAttribute)ChoType.GetMemberAttribute(memberInfo, typeof(ChoPropertyInfoAttribute));
//if (memberInfoAttribute == null) continue;
oldValue = null;
newValue = null;
origValue = null;
defaultValue = null;
fallbackValue = null;
name = ChoType.GetMemberName(memberInfo);
isConfigmemberDefined = ConfigSection.HasConfigMemberDefined(name);
oldValue = ChoType.GetMemberValue(ConfigObject, memberInfo.Name);
object configFallbackValue = null;
object configDefaultValue = null;
bool isDefaultValueSpecified = ChoConfigurationMetaDataManager.TryConfigDefaultValue(this, name, memberInfoAttribute, out configDefaultValue);
ChoConfigurationMetaDataManager.TryConfigFallbackValue(this, name, memberInfoAttribute, out configFallbackValue);
if (configFallbackValue == null)
{
if (isDefaultValueSpecified)
{
defaultValue = origValue = newValue = configDefaultValue;
}
}
else
{
fallbackValue = origValue = newValue = configFallbackValue;
}
if (!isConfigmemberDefined)
{
if (!isDirty)
{
isDirty = memberInfoAttribute != null && memberInfoAttribute.Persistable ? true : false;
}
}
else
{
origValue = newValue = ConfigSection[name];
}
try
{
object newConvertedValue = ChoConvert.ConvertFrom(ConfigObject, newValue, ChoType.GetMemberType(memberInfo),
ChoTypeDescriptor.GetTypeConverters(memberInfo), ChoTypeDescriptor.GetTypeConverterParams(memberInfo));
newValue = newConvertedValue;
}
catch { }
ChoConfigurableObject configObject = ConfigObject as ChoConfigurableObject;
if (configObject != null)
{
if (!configObject.IsMemeberValueEqualInternal(memberInfo, oldValue, newValue))
{
if (!configObject.RaiseBeforeConfigurationObjectMemberLoaded(memberInfo.Name, name, origValue, ref newValue))
{
try
{
//ChoType.SetMemberValue(ConfigObject, memberInfo.Name, newValue != null ? ChoConvert.ConvertFrom(ConfigObject, newValue,
// ChoType.GetMemberType(memberInfo), ChoTypeConvertersCache.GetTypeConverters(memberInfo)) : null);
SetConfigPropertyValue(newValue, memberInfo);
if (!_firstTime)
{
isModfied = true;
}
configObject.RaiseAfterConfigurationObjectMemberLoaded(memberInfo.Name, name, newValue);
ChoConfigurationObjectErrorManagerService.ResetObjectMemberError(ConfigObject, memberInfo.Name);
}
catch (Exception innerEx)
{
if (!configObject.RaiseConfigurationObjectMemberLoadError(memberInfo.Name, name, origValue, innerEx))
{
if (Silent)
{
if (_firstTime)
{
AssignToFallbackOrDefaultValue(defaultValue, fallbackValue, memberInfo);
}
ChoConfigurationObjectErrorManagerService.SetObjectMemberError(ConfigObject, memberInfo.Name, String.Format(Resources.ConfigConstructMsg, ChoString.ToString(origValue), innerEx.Message));
}
else
{
throw new ChoConfigurationConstructionException(String.Format(Resources.ConfigConstructExceptionMsg, ChoString.ToString(origValue), ConfigObject.GetType().FullName,
memberInfo.Name), innerEx);
}
}
}
}
}
}
else
{
try
{
//ChoType.SetMemberValue(ConfigObject, memberInfo.Name, newValue != null ? ChoConvert.ConvertFrom(ConfigObject, newValue,
// ChoType.GetMemberType(memberInfo), ChoTypeConvertersCache.GetTypeConverters(memberInfo)) : null);
SetConfigPropertyValue(newValue, memberInfo);
if (!_firstTime)
{
isModfied = true;
}
ChoConfigurationObjectErrorManagerService.ResetObjectMemberError(ConfigObject, memberInfo.Name);
}
catch (Exception innerEx)
{
if (Silent)
{
if (_firstTime)
{
AssignToFallbackOrDefaultValue(defaultValue, fallbackValue, memberInfo);
}
ChoConfigurationObjectErrorManagerService.SetObjectMemberError(ConfigObject, memberInfo.Name, String.Format(Resources.ConfigConstructMsg, ChoString.ToString(origValue), innerEx.Message));
}
else
{
throw new ChoConfigurationConstructionException(String.Format(Resources.ConfigConstructExceptionMsg, ChoString.ToString(origValue), ConfigObject.GetType().FullName,
memberInfo.Name), innerEx);
}
}
}
}
}
return(isModfied);
}
public override void Persist(object data, ChoDictionaryService <string, object> stateInfo)
{
if (!(data is NameValueCollection))
{
throw new ChoConfigurationException("Data object is not NameValueCollection object.");
}
try
{
//Write meta-data info
ChoConfigurationMetaDataManager.SetMetaDataSection(ConfigElement);
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
ConfigElement.Log(ex.ToString());
}
bool saveMainConfig = false;
string appSettingsFilePath = this.GetAppSettingsFilePathIfAnySpecified();
if (!appSettingsFilePath.IsNullOrWhiteSpace())
{
if (ChoConfigurationManager.GetFullPath(ChoConfigurationManager.ApplicationConfiguration.AppSettings.File) != ChoConfigurationManager.GetFullPath(appSettingsFilePath))
{
saveMainConfig = true;
ChoConfigurationManager.ApplicationConfiguration.AppSettings.File = appSettingsFilePath;
}
}
NameValueCollection nameValueCollection = ((NameValueCollection)data);
if (ChoConfigurationManager.ApplicationConfiguration.AppSettings.File.IsNullOrWhiteSpace())
{
foreach (string key1 in nameValueCollection.Keys)
{
if (ChoConfigurationManager.ApplicationConfiguration.AppSettings.Settings.AllKeys.Contains(key1))
{
ChoConfigurationManager.ApplicationConfiguration.AppSettings.Settings[key1].Value = nameValueCollection[key1];
}
else
{
ChoConfigurationManager.ApplicationConfiguration.AppSettings.Settings.Add(new KeyValueConfigurationElement(key1, nameValueCollection[key1]));
}
}
ChoConfigurationManager.ApplicationConfiguration.Save(ConfigurationSaveMode.Modified);
}
else
{
if (saveMainConfig)
{
ChoConfigurationManager.ApplicationConfiguration.Save(ConfigurationSaveMode.Modified);
}
File.WriteAllText(ChoConfigurationManager.GetFullPath(ChoConfigurationManager.ApplicationConfiguration.AppSettings.File), GetAppSettingsText(nameValueCollection));
}
//ConfigurationManager.RefreshSection(APP_SETTINGS_SECTION_NAME);
ChoConfigurationManager.Refresh();
}
public ChoConfigSection(Type configObjectType, XmlNode node, XmlNode[] contextNodes, ChoBaseConfigurationElement configElement)
: this()
{
_configElement = configElement;
if (configElement != null)
{
//Get and Set MetaDataFileName
configElement.ConfigurationMetaDataType = ConfigurationMetaDataType;
IChoConfigStorage attrDefinedConfigStorage = configElement.MetaDataInfo != null ? configElement.MetaDataInfo.ConfigStorage : null;
ChoBaseConfigurationMetaDataInfo defaultMetaDataInfo = InitDefaultMetaDataInfo(configElement);
configElement.MetaDataInfo = ChoObject.Merge <ChoBaseConfigurationMetaDataInfo>(ChoConfigurationMetaDataManager.GetMetaDataSection(configElement), defaultMetaDataInfo);
ConfigStorage = configElement.MetaDataInfo != null && configElement.MetaDataInfo.ConfigStorage != null ?
configElement.MetaDataInfo.ConfigStorage : attrDefinedConfigStorage;
if (ConfigStorage == null)
{
configElement.Log("Missing configuration storage, assigning to configSection default storage.");
ConfigStorage = DefaultConfigStorage;
if (ConfigStorage == null)
{
configElement.Log("Missing configuration storage, assigning to system default storage.");
ConfigStorage = ChoConfigStorageManagerSettings.Me.GetDefaultConfigStorage();
}
}
if (ConfigStorage != null)
{
try
{
CheckValidConfigStoragePassed(ConfigStorage);
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
if (configElement.Silent)
{
ConfigElement.Log(ex.Message);
ConfigStorage = ChoConfigStorageManagerSettings.Me.GetDefaultConfigStorage();
if (ConfigStorage != null)
{
ConfigElement.Log("Using default [{0}] config storage.".FormatString(ConfigStorage.GetType().FullName));
}
}
else
{
throw;
}
}
}
if (ConfigStorage == null)
{
throw new ChoConfigurationException("Missing configuration storage.");
}
IsMetaDataDefinitionChanged = !ChoObject.Equals <ChoBaseConfigurationMetaDataInfo>(ChoConfigurationMetaDataManager.GetMetaDataSection(configElement), defaultMetaDataInfo);
configElement.MetaDataInfo.ConfigStorage = ConfigStorage;
try
{
ConfigData = ConfigStorage.Load(_configElement, node);
}
catch (ChoFatalApplicationException)
{
throw;
}
catch (Exception ex)
{
_configLoadExceptions.Add(ex);
}
}
//if (ConfigStorage == null)
//{
// try
// {
// ConfigStorage = DefaultConfigStorage;
// if (ConfigStorage == null)
// ConfigStorage = ChoConfigStorageManagerSettings.Me.GetDefaultConfigStorage();
// }
// catch (Exception ex)
// {
// _configLoadExceptions.Add(ex);
// }
//}
try
{
ConfigurationChangeWatcher = ConfigStorage.ConfigurationChangeWatcher;
if (ConfigurationChangeWatcher != null)
{
ConfigurationChangeWatcher.StartWatching();
}
}
catch (Exception ex)
{
_configLoadExceptions.Add(ex);
}
}
