public ChoLoggableObject GetMe(Type type)
{
ChoGuard.ArgumentNotNull(type, "Type");
if (_singletonElement == null)
{
lock (SyncRoot)
{
if (_singletonElement == null)
{
_singletonElement = new ChoSingletonLoggableObject();
_singletonElement.LogDirectory = LogDirectory;
_singletonElement.LogFileName = LogFileName.IsNullOrEmpty() ? ChoPath.AddExtension(type.FullName, ChoReservedFileExt.Log) : LogFileName;
_singletonElement.LogCondition = LogCondition;
_singletonElement.LogTimeStampFormat = LogTimeStampFormat;
}
}
}
return(_singletonElement);
}
public override ChoBaseConfigurationElement GetMe(Type type)
{
ChoGuard.ArgumentNotNull(type, "Type");
if (_configurationElement == null)
{
lock (SyncRoot)
{
if (_configurationElement == null)
{
object customConfigurationSectionHandler = Activator.CreateInstance(_configurationSectionHandlerType) as IChoCustomConfigurationSectionHandler;
if (customConfigurationSectionHandler == null)
{
throw new ChoConfigurationConstructionException(String.Format("Missing {0} custom configuration section handler.", _configurationSectionHandlerType.FullName));
}
if (!(customConfigurationSectionHandler is IChoCustomConfigurationSectionHandler))
{
throw new ChoConfigurationConstructionException(String.Format("Mismatched {0} custom configuration section handler type specified.", _configurationSectionHandlerType.FullName));
}
_configurationElement = new ChoCustomConfigurationElement(customConfigurationSectionHandler as IChoCustomConfigurationSectionHandler,
_parameters);
_configurationElement.DefaultConfigSectionHandlerType = ConfigSectionHandlerType;
_configurationElement.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;
_configurationElement.MetaDataInfo = standardConfigurationMetaDataInfo;
LoadParameters(_configurationElement);
}
}
}
return(_configurationElement);
}
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);
}
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;
}
}
}
}
}
}
