Beispiel #1
0
        // must be called outside of lock
        private void RefreshAndValidateSections(IDictionary <string, string> localSectionsToRefresh, IDictionary <string, string> externalSectionsToRefresh, out ICollection <string> sectionsToNotify, out IDictionary <string, string> sectionsWithChangedConfigSource)
        {
            sectionsToNotify = new List <string>();
            sectionsWithChangedConfigSource = new Dictionary <string, string>();

            // refresh local sections and determine what to do.
            foreach (KeyValuePair <string, string> sectionMapping in localSectionsToRefresh)
            {
                SqlConfigurationManager.RefreshSection(sectionMapping.Key, this.data);
                ConfigurationSection section = SqlConfigurationManager.GetSection(sectionMapping.Key, this.data) as ConfigurationSection;
                string refreshedConfigSource = section != null ? section.SectionInformation.ConfigSource : NullConfigSource;
                if (!sectionMapping.Value.Equals(refreshedConfigSource))
                {
                    sectionsWithChangedConfigSource.Add(sectionMapping.Key, refreshedConfigSource);
                }

                // notify anyway, since it might have been updated.
                sectionsToNotify.Add(sectionMapping.Key);
            }

            // refresh external sections and determine what to do.
            foreach (KeyValuePair <string, string> sectionMapping in externalSectionsToRefresh)
            {
                SqlConfigurationManager.RefreshSection(sectionMapping.Key, this.data);
                ConfigurationSection section = SqlConfigurationManager.GetSection(sectionMapping.Key, this.data) as ConfigurationSection;
                string refreshedConfigSource = (section != null) ? section.SectionInformation.ConfigSource : NullConfigSource;
                if (!sectionMapping.Value.Equals(refreshedConfigSource))
                {
                    sectionsWithChangedConfigSource.Add(sectionMapping.Key, refreshedConfigSource);

                    // notify only if che config source changed
                    sectionsToNotify.Add(sectionMapping.Key);
                }
            }
        }
Beispiel #2
0
 private static void PrepareConfigSystem(SqlConfigurationData data)
 {
     if (SqlConfigurationManager.initState < SqlConfigurationManager.InitState.Usable)
     {
         SqlConfigurationManager.EnsureConfigurationSystem(data);
     }
 }
Beispiel #3
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="sectionName"></param>
 /// <param name="section"></param>
 /// <param name="data"></param>
 public static void SaveSection(string sectionName, SerializableConfigurationSection section, SqlConfigurationData data)
 {
     if (!string.IsNullOrEmpty(sectionName))
     {
         SqlConfigurationManager.PrepareConfigSystem(data);
         SqlConfigurationManager.configSystem.SaveSection(sectionName, section);
     }
 }
Beispiel #4
0
 /// <summary>
 ///
 /// </summary>
 /// <param name="sectionName"></param>
 /// <param name="data"></param>
 public static void RemoveSection(string sectionName, SqlConfigurationData data)
 {
     if (!string.IsNullOrEmpty(sectionName))
     {
         SqlConfigurationManager.PrepareConfigSystem(data);
         SqlConfigurationManager.configSystem.RemoveSection(sectionName);
     }
 }
Beispiel #5
0
 /// <summary>
 /// Retrieves a specified configuration section for the current application's configuration
 /// </summary>
 /// <param name="sectionName">The configuration section name.</param>
 /// <param name="data">The configuration data for this connection.</param>
 /// <returns>The specified System.Configuration.ConfigurationSection object, or null if the section does not exist.</returns>
 public static object GetSection(string sectionName, SqlConfigurationData data)
 {
     if (string.IsNullOrEmpty(sectionName))
     {
         return(null);
     }
     SqlConfigurationManager.PrepareConfigSystem(data);
     return(SqlConfigurationManager.configSystem.GetSection(sectionName));
 }
Beispiel #6
0
        /// <summary>
        /// Retrieves a section from SqlConfiguration, and starts watching for
        /// its changes if not watching already.
        /// </summary>
        /// <param name="sectionName">The section name.</param>
        /// <returns>The section, or null if it doesn't exist.</returns>
        public ConfigurationSection GetSection(string sectionName)
        {
            object section = SqlConfigurationManager.GetSection(sectionName, data);
            ConfigurationSection configurationSection = section as ConfigurationSection;

            if (configurationSection != null)
            {
                lock (lockMe)
                {
                    if (!IsWatchingSection(sectionName))                        // should only be true sporadically
                    {
                        SetWatcherForSection(sectionName, this.data.ConnectionString);
                    }
                }
            }

            return(configurationSection);
        }
Beispiel #7
0
        /// <summary>
        /// <exclude/>
        /// </summary>
        /// <param name="configSource">The name of the updated configuration source.</param>
        public void ExternalConfigSourceChanged(string configSource)
        {
            string[] sectionsToNotify;

            lock (lockMe)
            {
                ConfigurationSourceWatcher watcher = null;
                this.watchedConfigSourceMapping.TryGetValue(configSource, out watcher);
                sectionsToNotify = new string[watcher.WatchedSections.Count];
                watcher.WatchedSections.CopyTo(sectionsToNotify, 0);
            }

            foreach (string sectionName in sectionsToNotify)
            {
                SqlConfigurationManager.RefreshSection(sectionName, this.data);
            }

            NotifyUpdatedSections(sectionsToNotify);
        }
Beispiel #8
0
        /// <summary>
        ///
        /// </summary>
        /// <param name="sectionName"></param>
        public void RemoveSection(string sectionName)
        {
            if ((sectionName == null) || (sectionName.Trim().Equals(String.Empty)))
            {
                throw new ArgumentNullException(sectionName);
            }

            SqlConfigurationManager.RemoveSection(sectionName, data);

            lock (lockMe)
            {
                if (IsWatchingSection(sectionName))
                {
                    ConfigSourceChanged(sectionName);
                    ConfigurationSourceWatcher watcher = this.watchedSectionMapping[sectionName];
                    UnlinkWatcherForSection(watcher, sectionName);
                }
            }
        }
Beispiel #9
0
        /// <summary>
        /// Saves a section from SqlConfiguration, and starts watching for
        /// its changes if not watching already.
        /// </summary>
        /// <param name="sectionName">The section name.</param>
        /// <param name="section">The section.</param>
        /// <returns></returns>
        public void SaveSection(string sectionName, SerializableConfigurationSection section)
        {
            if (section == null)
            {
                throw new ArgumentNullException("section");
            }
            if ((sectionName == null) || (sectionName.Trim().Equals(String.Empty)))
            {
                throw new ArgumentNullException(sectionName);
            }

            SqlConfigurationManager.SaveSection(sectionName, section, data);

            lock (lockMe)
            {
                if (!IsWatchingSection(sectionName))
                {
                    SetWatcherForSection(sectionName, section.SectionInformation.ConfigSource);
                }
            }
        }