public override bool Equals(ChoBaseConfigurationMetaDataInfo obj)
{
if (object.ReferenceEquals(obj, null))
{
return(false);
}
if (!(obj is ChoStandardConfigurationMetaDataInfo))
{
return(false);
}
if (!base.Equals(obj))
{
return(false);
}
ChoStandardConfigurationMetaDataInfo other = obj as ChoStandardConfigurationMetaDataInfo;
if (other != null)
{
if (BindingMode != other.BindingMode)
{
return(false);
}
if (Defaultable != other.Defaultable)
{
return(false);
}
if (IgnoreCase != other.IgnoreCase)
{
return(false);
}
if (Silent != other.Silent)
{
return(false);
}
if (Parameters != other.Parameters)
{
return(false);
}
if (ConfigFilePath != other.ConfigFilePath)
{
return(false);
}
if (!ChoObject.Equals <ChoConfigurationMetaDataLogInfo>(ConfigurationMetaDataLogInfo, other.ConfigurationMetaDataLogInfo))
{
return(false);
}
}
return(true);
}
public override bool Equals(ChoDisposableObject obj)
{
if (Object.ReferenceEquals(obj, null))
{
return(false);
}
if (!(obj is ChoNameValueSection))
{
return(false);
}
ChoNameValueSection newSection = obj as ChoNameValueSection;
if (this.Count == 0 && newSection.Count == 0)
{
return(true);
}
if (this.Count != newSection.Count)
{
return(false);
}
if (Object.ReferenceEquals(Collection, newSection.Collection))
{
return(true);
}
if (Object.ReferenceEquals(Collection, null))
{
return(false);
}
if (Object.ReferenceEquals(newSection.Collection, null))
{
return(false);
}
//Is all keys are same
var diff = Collection.AllKeys.Except(newSection.Collection.AllKeys);
if (diff.Count() != 0)
{
return(false);
}
//Check the values are equal
foreach (string key in Collection.AllKeys)
{
if (!ChoObject.Equals(this[key], newSection[key]))
{
return(false);
}
}
return(true);
}
public static bool IsMetaDataModified(ChoPerformanceCounter pc)
{
if (pc == null)
{
return(false);
}
ChoPCMetaDataInfo newConfigurationMetaDataInfo = GetMetaDataSection(pc);
return(!ChoObject.Equals <ChoPCMetaDataInfo>(newConfigurationMetaDataInfo, pc.MetaDataInfo));
}
public bool IsMetaDataModified(T pc)
{
if (pc == null)
{
return(false);
}
TMetaDataInfo newConfigurationMetaDataInfo = GetMetaDataSection(pc);
return(!ChoObject.Equals <TMetaDataInfo>(newConfigurationMetaDataInfo, pc.MetaDataInfo));
}
internal static bool IsMetaDataModified(ChoBaseConfigurationElement configElement)
{
if (configElement == null)
{
return(false);
}
ChoBaseConfigurationMetaDataInfo newConfigurationMetaDataInfo = GetMetaDataSection(configElement);
return(!ChoObject.Equals <ChoBaseConfigurationMetaDataInfo>(newConfigurationMetaDataInfo, configElement.MetaDataInfo));
}
public static void SetMetaDataSection(ChoPerformanceCounter pc)
{
if (pc == null)
{
return;
}
if (ChoObject.Equals <ChoPCMetaDataInfo>(pc.MetaDataInfo, GetMetaDataSection(pc)))
{
return;
}
SaveMetaDataSection(pc);
}
public void SetMetaDataSection(T pc)
{
if (pc == null)
{
return;
}
TMetaDataInfo metaDataInfo = GetMetaDataSection(pc);
if (metaDataInfo != null && ChoObject.Equals <TMetaDataInfo>(pc.MetaDataInfo, metaDataInfo))
{
return;
}
SaveMetaDataSection(pc);
}
public static void SetMetaDataSection(ChoBaseConfigurationElement configElement)
{
if (configElement == null)
{
return;
}
if (ChoObject.Equals <ChoBaseConfigurationMetaDataInfo>(configElement.MetaDataInfo, GetMetaDataSection(configElement)))
{
return;
}
string configElementPath = configElement.ConfigElementPath;
ChoBaseConfigurationMetaDataInfo configurationMetaDataInfo = configElement.MetaDataInfo;
configurationMetaDataInfo = ChoObject.Merge <ChoBaseConfigurationMetaDataInfo>(configurationMetaDataInfo, GetDefaultMetaDataInfo(configElement));
if (configurationMetaDataInfo == null)
{
return;
}
using (ChoXmlDocument xmlDocument = new ChoXmlDocument(_metaDataFilepath))
{
if (configElementPath.IsNullOrEmpty())
{
return;
}
XmlNode node = xmlDocument.XmlDocument.SelectSingleNode(configElementPath);
if (node == null)
{
node = xmlDocument.XmlDocument.MakeXPath(configElementPath);
}
if (node != null)
{
ChoXmlDocument.SetOuterXml(node, configurationMetaDataInfo.ToXml());
xmlDocument.XmlDocument.InnerXml = ChoXmlDocument.AppendToInnerXml(node, GetPropertyInfos(configElement).ToXml());
xmlDocument.Save();
}
}
}
internal void Refresh(bool refresh)
{
if (_inLoadingProcess)
{
return;
}
lock (SyncRoot)
{
if (ConfigObject is IChoConfigurationParametersOverridable)
{
((IChoConfigurationParametersOverridable)ConfigObject).OverrideParameters(this);
}
_modifiedStateObject.ResetModified();
bool isDirty = false;
bool errorHandled = false;
bool canTraceOutput = true;
bool hasErrors = false;
this[ChoConfigurationConstants.FORCE_PERSIST] = false;
_inLoadingProcess = true;
ChoConfigSection prevConfigSection = ConfigSection;
if (ConfigSection != null)
{
ConfigSection.StopWatching();
}
try
{
if (ConfigObject != null)
{
//ChoConfigurationObjectErrorManagerService.ResetObjectErrors(ConfigObject);
if (ConfigObject is ChoInterceptableObject)
{
ChoInterceptableObject interceptableObject = ConfigObject as ChoInterceptableObject;
interceptableObject.SetDirty(false);
interceptableObject.SetSilent(false);
interceptableObject.SetInitialized(false);
interceptableObject.IsConfigObjectSilent = Silent;
}
}
GetConfig(ConfigObjectType, refresh);
}
catch (ConfigurationErrorsException configErrorsEx)
{
bool isModified = false;
errorHandled = SetNThrowException(configErrorsEx, ref isModified);
_modifiedStateObject.SetModified(isModified);
}
catch (TypeInitializationException typeEx)
{
bool isModified = false;
errorHandled = SetNThrowException(typeEx, ref isModified);
_modifiedStateObject.SetModified(isModified);
}
catch (ChoFatalApplicationException)
{
canTraceOutput = false;
throw;
}
catch (Exception ex)
{
bool isModified = false;
errorHandled = SetNThrowException(ex, ref isModified);
_modifiedStateObject.SetModified(isModified);
}
finally
{
if (ConfigSection != null && ConfigObject is ChoConfigurableObject)
{
//Call Notify Property Changed for all default values
CallNotifyPropertyChangedForAllDefaultableMembers();
ConfigSection.Initialize();
}
if (ConfigSection != null && ConfigSection.ConfigLoadException != null)
{
bool isModified = false;
errorHandled = SetNThrowException(ConfigSection.ConfigLoadException, ref isModified);
_modifiedStateObject.SetModified(isModified);
}
////Update configuration meta data information
//if (ConfigSection != null && ConfigSection.MetaDataInfo != null)
// ApplyConfigMetaData(ConfigSection.MetaDataInfo);
//Print the output to file
if (canTraceOutput)
{
//Set default trace output file name
if (LogFileName.IsNullOrEmpty())
{
LogFileName = ChoPath.AddExtension(ConfigObject.GetType().FullName, ChoReservedFileExt.Log);
}
//if (ConfigSection is IChoCustomConfigSection)
//{
// if (ConfigSection.ConfigData != null)
// ConfigSection.ConfigObject = ConfigSection.ConfigData as ChoConfigurableObject;
// ChoObjectManagementFactory.SetInstance(ConfigObject);
//}
if ((ConfigSection == null || ConfigSection.ConfigData == null) && !_defaultable /*&& !_persistable*/)
{
throw new ChoConfigurationConstructionException(String.Format("Failed to load '[{0}]' configuration section.", this._configElementPath));
}
else
{
if (prevConfigSection != null)
{
prevConfigSection.Dispose();
}
if (ConfigObject is ChoConfigurableObject)
{
((ChoConfigurableObject)ConfigObject).SetReadOnly(true);
}
bool hasConfigSectionDefined = ConfigSection != null ? ConfigSection.HasConfigSectionDefined : false;
try
{
if (!errorHandled)
{
if (!(ConfigSection is IChoCustomConfigSection))
{
if (hasConfigSectionDefined)
{
_modifiedStateObject.SetModified(ExtractNPopulateValues(ref hasErrors, ref isDirty));
}
else
{
_modifiedStateObject.SetModified(AssignToFallbackOrDefaultValues(ref isDirty));
}
}
else
{
if (hasConfigSectionDefined)
{
//isModfied = true;
if (ConfigSection == null)
{
_modifiedStateObject.SetModified(AssignToFallbackOrDefaultValues(ref isDirty));
}
else if (!ChoObject.Equals(ConfigSection, prevConfigSection))
{
_modifiedStateObject.SetModified(true);
}
else
{
_modifiedStateObject.SetModified(AssignToFallbackOrDefaultValues(ref isDirty));
}
}
else
{
_modifiedStateObject.SetModified(AssignToFallbackOrDefaultValues(ref isDirty));
}
}
}
if (!hasErrors)
{
hasErrors = ChoConfigurationObjectErrorManagerService.ContainsObjectError(ConfigObject);
}
ChoObjectInitializer.Initialize(ConfigObject, false, ConfigSection != null ? ConfigObject : null);
SetWatcher(false);
if (ConfigObject is ChoInterceptableObject)
{
ChoInterceptableObject interceptableObject = ConfigObject as ChoInterceptableObject;
if (interceptableObject.Dirty)
{
isDirty = interceptableObject.Dirty;
}
//if (interceptableObject.IsModified)
//{
// isModfied = interceptableObject.IsModified;
//}
interceptableObject.SetDirty(false);
//interceptableObject.SetSilent(false);
interceptableObject.SetInitialized(true);
}
if (ConfigObject is ChoConfigurableObject)
{
bool invokeObjectLoaded = /* isDirty || */ _firstTime || _modifiedStateObject.IsModified;
if (invokeObjectLoaded || hasErrors)
{
TraceOutput(false);
if (invokeObjectLoaded)
{
((ChoConfigurableObject)ConfigObject).RaiseAfterConfigurationObjectLoaded();
}
}
//if (isDirty)
//{
// TraceOutput(false);
// ((ChoConfigurableObject)ConfigObject).OnAfterConfigurationObjectLoaded();
//}
//else if (hasErrors)
// TraceOutput(false);
}
else
{
TraceOutput(false);
}
if (!isDirty && ConfigSection != null)
{
isDirty = ConfigSection.IsMetaDataDefinitionChanged;
}
}
finally
{
if (prevConfigSection != null)
{
prevConfigSection.Dispose();
prevConfigSection = null;
}
if (ConfigObject is ChoConfigurableObject)
{
((ChoConfigurableObject)ConfigObject).SetReadOnly(false);
}
if (!hasConfigSectionDefined || isDirty || hasErrors)
{
if (_defaultable)
{
Persist(false, null);
}
}
else if ((bool)this[ChoConfigurationConstants.FORCE_PERSIST])
{
Persist(false, null);
}
_inLoadingProcess = false;
if (_watchChange && ConfigSection != null)
{
ConfigSection.StartWatching();
}
ChoConfigurationObjectErrorManagerService.ResetObjectErrors(ConfigObject);
_firstTime = false;
}
}
}
}
}
}
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);
}
}
