Configuration manager class.
コード例 #1
0
        /// <summary>
        /// Initializes Logger instance.
        /// </summary>
        /// <param name="configuration">Configuration for logger.</param>
        public Logger(SConfigManager configuration)
        {
            // Configuration passed from parent, who initialized this instance.
            _configuration = configuration;

            Console.WriteLine("Logs are saved to: " + _configuration.Settings["LogDirectory"]);

            _enabled = Convert.ToBoolean(_configuration.Settings["Enabled"]);
        }
コード例 #2
0
        /// <summary>
        /// Monitor initializes application by reading configuration, parsing it and initializing child-components.
        /// </summary>
        public MonitorAgent()
        {
            // Get path to the configuration file using settings in app.config.
            // Standard configuration is used only to get the path to our custom configuration.
            string configurationFilePath =
                System.Configuration.ConfigurationManager.AppSettings[CONFIGURATION_SETTING_KEY];

            // Throw exception if cannot get information about xml configuration file.
            if (String.IsNullOrEmpty(configurationFilePath)) {
                throw new ArgumentException("Could not find setting with path to ther configuration file. "
                    +"Please check your config file contains key \""+
                    CONFIGURATION_SETTING_KEY+"\" and that key is set properly");
            }

            Console.WriteLine("Initializing configuration at root level...");
            // Use static method of SConfigManager class to read configuration from the file.
            string configurationXml = SConfigManager.ReadConfigFromFile(configurationFilePath);

            // Initialize SConfigManager using configuration string.
            _configuration = new SConfigManager(configurationXml);
            Console.WriteLine("Initialized." + System.Environment.NewLine);

            Console.WriteLine("Initializing logger...");
            // Initialize logger by passing child of root configuration into its constructor.
            logger = new Logger(_configuration.Children["Logger"]);

            logger.Log("Logger initialised.");
            Console.WriteLine("Logger initialized." + System.Environment.NewLine);

            // DirectoryWatchers
            if (_configuration.Children.ContainsKey("Watchers"))
            {
                // Iterate Children of "Watchers" child of root configuration
                foreach (KeyValuePair<string, SConfigManager> element in _configuration.Children["Watchers"].Children)
                {
                    SConfigManager config = (SConfigManager)element.Value;

                    // Initialize new directoryWatcher by passing configuration into its constructor.
                    Console.WriteLine("Initializing DirectoryWatcher: "  +config.Name + "...");
                    DirectoryWatcher directoryWatcher = new DirectoryWatcher(config);
                    directoryWatcher.LogHandler += new LogEventHandler(OnAction);
                    Console.WriteLine("DirectoryWatcher initialized: " + config.Name + "..."
                        + System.Environment.NewLine);

                    // Add new directoryWatcher to the list of directoryWatchers
                    _directoryWatchers.Add(directoryWatcher);
                }
            }

            Console.WriteLine("Watchers are now listening for any changes in watched directories."+
                "Make any action, like create or rename a file in those directories to see its working."
                + System.Environment.NewLine);
        }
コード例 #3
0
        /// <summary>
        /// Initializes the DirectoryWatcher instance.
        /// </summary>
        /// <param name="configuration">Configuration object conatining all necessary configuration for 
        /// this class.</param>
        public DirectoryWatcher(SConfigManager configuration)
        {
            // Configuration passed from parent, who initialized this instance.
            _configuration = configuration;

            Console.WriteLine("Watched directory: : " + _configuration.Settings["Directory"]);

            _watcher = new FileSystemWatcher();
            _watcher.Path = _configuration.Settings["Directory"];
            _watcher.NotifyFilter = NotifyFilters.FileName | NotifyFilters.LastWrite;
            _watcher.Filter = _configuration.Settings["Filter"];
            _watcher.Created += new FileSystemEventHandler(OnCreated);
            _watcher.Renamed += new RenamedEventHandler(OnRenamed);
            _watcher.Deleted += new FileSystemEventHandler(OnDeleted);
            _watcher.EnableRaisingEvents = true;
        }
コード例 #4
0
        /// <summary>
        /// Initializes a new instance of the <see cref="TimConfigurationManager.ConfigurationManager"/> class. 
        /// It parses given configuration which have to be in proper XML format.
        /// </summary>
        /// <example>  
        /// This sample shows how to call the initialize the <see cref="TimConfigurationManager.ConfigurationManager"/> class.
        /// <code> 
        /// class TestClass  
        /// { 
        ///     static int Main()  
        ///     { 
        ///         // Prepare path to file with configuration
        ///         string pathToFile = "path/to/file.txt";
        /// 
        ///         // Call static method to read content of a configuration file
        ///         string configString = ConfigurationManager.ReadConfigFromFile(pathToFile);
        /// 
        ///         // Initialize new Configuration Manager class by passing string with configuration
        ///         ConfigurationManager configurationManager = new ConfigurationManager(configString);
        ///         
        ///         //...
        ///     } 
        /// } 
        /// </code> 
        /// </example> 
        /// <param name="configuration">String containing configuration (in XML format) to be parsed into object.</param>
        /// <exception cref="System.Exception"></exception>
        public SConfigManager(string configuration)
        {
            this._configXml = configuration;
            XmlDocument configXml = null;

            // Initializing XmlDocument
            try
            {
                configXml = new XmlDocument();
                configXml.LoadXml(configuration);
            }
            catch (Exception e)
            {
                Exception exception = new Exception("Cannot parse XML file", e);
                throw exception;
            }

            // Read Name of the configuration section
            try
            {
                Name = configXml.DocumentElement.Attributes["name"].Value;

                if (Name == "")
                {
                    throw new Exception();
                }
            }
            catch (Exception)
            {
                ArgumentException exception = new ArgumentException("Argument cannot null nor empty", "name");
                throw exception;
            }

            try
            {
                // parse settings
                Settings = new Dictionary<string, string>();

                XmlNodeList xnList = configXml.SelectNodes("/configuration/settings//setting");

                foreach (XmlNode xn in xnList)
                {
                    string key = xn.Attributes["key"].Value;
                    string value = xn.Attributes["value"].Value;
                    Settings.Add(key, value);
                }

                // get custom xml
                xnList = configXml.SelectNodes("/configuration/custom");

                if (xnList.Count > 0)
                {
                    CustomXml = xnList[0].InnerXml.ToString();
                }

                // get children
                Children = new Dictionary<string, SConfigManager>();

                xnList = configXml.SelectNodes("/configuration/children/configuration");

                if (xnList.Count > 0)
                {
                    foreach (XmlNode xmlNode in xnList)
                    {
                        SConfigManager childConfig = new SConfigManager(xmlNode.OuterXml.ToString());

                        Children.Add(childConfig.Name, childConfig);
                    }
                }
            }
            catch (Exception ex)
            {
                Exception exception = new Exception("Error while processing XML", ex);
                throw exception;
            }
        }