public static object GetConfig(Type type, XmlNode node) { XmlSerializer serializer = new XmlSerializer(type); XmlRootAttribute xmlRootAttribute = ChoType.GetAttribute <XmlRootAttribute>(type); if (xmlRootAttribute == null) { throw new NullReferenceException(String.Format("Missing XmlRootAttribute in {0} type.", type.FullName)); } if (String.IsNullOrEmpty(xmlRootAttribute.ElementName)) { throw new NullReferenceException(String.Format("Missing XmlRootAttribute(ElementName) in {0} type.", type.FullName)); } node = node.SelectSingleNode(String.Format("//{0}", xmlRootAttribute.ElementName)); object configObject = null; if (node != null) { configObject = serializer.Deserialize(new XmlNodeReader(node)); } else { configObject = ChoObjectManagementFactory.CreateInstance(type); } ChoObjectInitializer.Initialize(configObject); return(configObject); }
internal static object GetObject(Type type, bool beforeFieldInit) { if (type == null) { throw new ArgumentNullException("type"); } object instance; if (IsConstructing(type)) { instance = New(type, null); if (instance != null) { ChoObjectInitializer.Initialize(instance, beforeFieldInit); } } else { _globalObjectCache.TryGetValue(type, out instance); } return(instance); }
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; } } } } } }
internal static T CreateInstance <T>(Type objType, ChoObjectConstructionType defaultObjectConstructionType, bool beforeFieldInit, out Exception exception) { exception = null; ChoGuard.ArgumentNotNull(objType, "objType"); T instance = default(T); ChoObjectConstructionType objectConstructionType = defaultObjectConstructionType; if (IsConstructing(objType)) { instance = New <T>(objType, null); if (instance != null) { ChoObjectInitializer.Initialize(instance, beforeFieldInit); } } else { try { _globalObjectBuildStateCache[objType] = ObjectBuildState.Constructing; IChoCustomObjectFactory customObjectFactory = null; ChoObjectFactoryAttribute objectFactoryAttribute = ChoType.GetAttribute(objType, typeof(ChoObjectFactoryAttribute)) as ChoObjectFactoryAttribute; if (objectFactoryAttribute != null) { objectConstructionType = objectFactoryAttribute.ObjectConstructionType; customObjectFactory = objectFactoryAttribute.CustomObjectFactory; } switch (objectConstructionType) { case ChoObjectConstructionType.Singleton: //lock (_globalObjectCache.SyncRoot) //{ if (_globalObjectCache.ContainsKey(objType)) { return((T)_globalObjectCache[objType]); } else { instance = New <T>(objType, customObjectFactory); _globalObjectCache[objType] = instance; } //} break; default: instance = New <T>(objType, customObjectFactory); break; } if (instance != null) { try { ChoObjectInitializer.Initialize(instance, beforeFieldInit); } catch (TypeInitializationException) { throw; } catch (ChoFatalApplicationException) { throw; } catch (Exception ex) { exception = ex; } } } finally { _globalObjectBuildStateCache[objType] = ObjectBuildState.Constructed; } } return(instance); }