UriSectionReader.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Net / System / Net / Configuration / UriSectionReader.cs / 1305376 / UriSectionReader.cs
                        
                        
                            using System; 
using System.Collections.Generic;
using System.Text;
using System.Net;
using System.Security.Permissions; 
using System.IO;
using System.Xml; 
using System.Security; 
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis; 

namespace System.Configuration
{
    // This class is used to read the  section from a config file directly, without using System.Configuration 
    internal class UriSectionReader
    { 
        private const string rootElementName = "configuration"; 

        private string configFilePath; 
        private XmlReader reader;

        // result data after parsing the configuration section
        private UriSectionData sectionData; 

        private UriSectionReader(string configFilePath, UriSectionData parentData) 
        { 
            Debug.Assert(configFilePath != null, "'configFilePath' must not be null");
 
            this.configFilePath = configFilePath;
            this.sectionData = new UriSectionData();

            if (parentData != null) 
            {
                sectionData.IriParsing = parentData.IriParsing; 
                sectionData.IdnScope = parentData.IdnScope; 

                foreach (KeyValuePair schemeSetting in parentData.SchemeSettings) 
                {
                    sectionData.SchemeSettings.Add(schemeSetting.Key, schemeSetting.Value);
                }
            } 
        }
 
        public static UriSectionData Read(string configFilePath) 
        {
            return Read(configFilePath, null); 
        }

        public static UriSectionData Read(string configFilePath, UriSectionData parentData)
        { 
            UriSectionReader reader = new UriSectionReader(configFilePath, parentData);
            return reader.GetSectionData(); 
        } 

        [SuppressMessage("Microsoft.Security","CA2106:SecureAsserts", Justification="Must Assert read permission for only this file")] 
        [SuppressMessage("Microsoft.Security","CA2103:ReviewImperativeSecurity", Justification="Must Assert read permission for only this file")]
        private UriSectionData GetSectionData()
        {
            // Assert read permission for only this file. 
            new FileIOPermission(FileIOPermissionAccess.Read, configFilePath).Assert();
            try 
            { 
                if (File.Exists(configFilePath))
                { 
                    using (FileStream configFile = new FileStream(configFilePath, FileMode.Open, FileAccess.Read))
                    {
                        XmlReaderSettings settings = new XmlReaderSettings();
                        settings.IgnoreComments = true; 
                        settings.IgnoreWhitespace = true;
                        settings.IgnoreProcessingInstructions = true; 
                        using (reader = XmlReader.Create(configFile, settings)) 
                        {
                            if (ReadConfiguration()) 
                            {
                                return sectionData;
                            }
                        } 
                    }
                } 
            } 
            catch (Exception)
            { 
                // In this case we really want to catch all exceptions: Uri never threw, therefore we can't
                // start throwing exceptions now when reading the configuration.
            }
            finally 
            {
                FileIOPermission.RevertAssert(); 
            } 

            return null; 
        }

        private bool ReadConfiguration()
        { 
            if (!ReadToUriSection())
            { 
                return false; 
            }
 
            while (reader.Read())
            {
                if (IsEndElement(CommonConfigurationStrings.UriSectionName))
                { 
                    return true;
                } 
 
                if (reader.NodeType != XmlNodeType.Element)
                { 
                    return false;
                }

                string currentElementName = reader.Name; 

                if (AreEqual(currentElementName, CommonConfigurationStrings.IriParsing)) 
                { 
                    if (ReadIriParsing())
                    { 
                        continue;
                    }
                }
                else if (AreEqual(currentElementName, CommonConfigurationStrings.Idn)) 
                {
                    if (ReadIdnScope()) 
                    { 
                        continue;
                    } 
                }
                else if (AreEqual(currentElementName, CommonConfigurationStrings.SchemeSettings))
                {
                    if (ReadSchemeSettings()) 
                    {
                        continue; 
                    } 
                }
 
                // we found an unknown element in  section.
                return false;
            }
 
            // we reached EOF, but the  node didn't have a final  node
            return false; 
        } 

        private bool ReadIriParsing() 
        {
            string attributeValue = reader.GetAttribute(CommonConfigurationStrings.Enabled);

            bool configIriParsingValue; 
            if (bool.TryParse(attributeValue, out configIriParsingValue))
            { 
                sectionData.IriParsing = configIriParsingValue; 
                return true;
            } 
            else
            {
                return false;
            } 
        }
 
        private bool ReadIdnScope() 
        {
            string attributeValue = reader.GetAttribute(CommonConfigurationStrings.Enabled); 

            try
            {
                sectionData.IdnScope = (UriIdnScope)Enum.Parse(typeof(UriIdnScope), attributeValue, true); 
                return true;
            } 
            catch (ArgumentException) 
            {
                return false; 
            }
        }

        private bool ReadSchemeSettings() 
        {
            while (reader.Read()) 
            { 
                if (IsEndElement(CommonConfigurationStrings.SchemeSettings))
                { 
                    return true;
                }

                if (reader.NodeType != XmlNodeType.Element) 
                {
                    return false; 
                } 

                string currentElementName = reader.Name; 

                if (AreEqual(currentElementName, SchemeSettingElementCollection.AddItemName))
                {
                    if (ReadAddSchemeSetting()) 
                    {
                        continue; 
                    } 
                }
                else if (AreEqual(currentElementName, SchemeSettingElementCollection.RemoveItemName)) 
                {
                    if (ReadRemoveSchemeSetting())
                    {
                        continue; 
                    }
                } 
                else if (AreEqual(currentElementName, SchemeSettingElementCollection.ClearItemsName)) 
                {
                    ClearSchemeSetting(); 
                    continue;
                }

                // unknown element found, e.g. if  is missing, reading  will end up here. 
                return false;
            } 
 
            // reached EOF without hitting 
            return false; 
        }

        private static bool AreEqual(string value1, string value2)
        { 
            return string.Compare(value1, value2, StringComparison.OrdinalIgnoreCase) == 0;
        } 
 
        private bool ReadAddSchemeSetting()
        { 
            string schemeValue = reader.GetAttribute(CommonConfigurationStrings.SchemeName);
            string genericUriParserOptionsValue = reader.GetAttribute(
                CommonConfigurationStrings.GenericUriParserOptions);
 
            if (string.IsNullOrEmpty(schemeValue) || string.IsNullOrEmpty(genericUriParserOptionsValue))
            { 
                return false; 
            }
 
            try
            {
                GenericUriParserOptions genericUriParserOptions = (GenericUriParserOptions)Enum.Parse(
                    typeof(GenericUriParserOptions), genericUriParserOptionsValue); 

                SchemeSettingInternal schemeSetting = new SchemeSettingInternal(schemeValue, 
                    genericUriParserOptions); 

                sectionData.SchemeSettings[schemeSetting.Name] = schemeSetting; 
                return true;
            }
            catch (ArgumentException)
            { 
                return false;
            } 
        } 

        private bool ReadRemoveSchemeSetting() 
        {
            string scheme = reader.GetAttribute(CommonConfigurationStrings.SchemeName);

            if (string.IsNullOrEmpty(scheme)) 
            {
                return false; 
            } 

            // ignore result value. It's ok if the scheme is not in the collection. 
            sectionData.SchemeSettings.Remove(scheme);
            return true;
        }
 
        private void ClearSchemeSetting()
        { 
            // no attributes to read, just clear collection 
            sectionData.SchemeSettings.Clear();
        } 

        private bool IsEndElement(string elementName)
        {
            return (reader.NodeType == XmlNodeType.EndElement) && 
                string.Compare(reader.Name, elementName, StringComparison.OrdinalIgnoreCase) == 0;
        } 
 
        private bool ReadToUriSection()
        { 
            if (!reader.ReadToFollowing(rootElementName))
            {
                return false;
            } 

            if (reader.Depth != 0) 
            { 
                // 'configuration' must be the root element. If not, this is not a valid config file.
                return false; 
            }

            // To be entirely correct, we should not look for  section, but we should look for the name
            // specified in the / node for type 'System.Configuration.Uri'. 
            // An admin/user can decide to rename the uri section to whatever he wants. However, since
            // all NCL (and some other) configuration implementations look for the hard-coded string, 
            // we don't change the current behavior. 
            do
            { 
                // 'uri' must be at depth 1, otherwise it is not our  section, but a custom one.
                if (!reader.ReadToFollowing(CommonConfigurationStrings.UriSectionName))
                {
                    return false; 
                }
 
            } while (reader.Depth != 1); 

            return true; 
        }
    }
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
UriSectionReader.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
