示例#1
0
        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);
        }
示例#2
0
        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;
                            }
                        }
                    }
                }
            }
        }
示例#4
0
        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);
        }