可实现自动重载配置文件读取类

在开发的过程中,我们可能会在网站的运行中对配置文件做一些修改,并且这些修改还要求实时反映出来。或许在 Web.config 中添加是一个不错的方案,但是如果配置太多的话,我想你也不想把它弄得太臃肿。那这个时候应该怎么办呢?或许我这这篇文章能够帮到你。

 

我现在遇到的问题是公司把网站拆分了,开发的时候每组就是每组的,但是正式线上可能还需要把其它组的配置写进去,最后因此导致的问题不胜枚举。无奈,就想到了把配置文件分开,每个组一个就不会出现这样的问题了。但是问题又来了,我怎么能在配置文件变动后,网站会自动重新提取最近的内容呢?后来从这篇文章《使用.NET FileSystemWatcher对象监控C#目录改变》得到些灵感,将这个东西做了出来。

 

现在,我将我的做法贡献出来,如果对你有用,请留下你的足迹;如果你觉得不好,也可以给我留言,我好进一步改进。我相信人民大众的力量是无限的,如果你对此有更好的改动,请你在下面贴出来或者回复我的邮件(Lenic@live.cn),我也相信你不会默默无闻的。

 

废话说了一堆,还是先看看这个类怎么用吧。

private static XmlParser xml = null;
static Default()
{
    var path = HttpContext.Current.Server.MapPath(".\\TestData.xml");
    xml = XmlParser.Load(path, new string[] { "orange" });
}
基本上是将配置文件的绝对路径当作参数传递进去就可以了,第二个参数是有额外用途的,这个一会儿再说。

 

我们需要读取这个 XML 文件的内容,预先看一下其内容:

   1:  <?xml version="1.0" encoding="utf-8"?>
   2:  <apple phone="true">
   3:    <items>
   4:      <orange id="1">
   5:        <name>橘子1</name>
   6:      </orange>
   7:      <orange id="o2">
   8:        <name>橘子2</name>
   9:      </orange>
  10:      <orange id="o3">
  11:        <name>橘子3</name>
  12:      </orange>
  13:      <orange id="o4">
  14:        <name>橘子4</name>
  15:      </orange>
  16:    </items>
  17:    <id>a1</id>
  18:    <name>苹果</name>
  19:  </apple>

 

在写配置的时候,我们一般是将其写入到节点的 Attribute 中的,比如文件中的 orange 节点的 id 和 apple 节点的 phone 两个配置信息。除此之外,对于哪些文本特别长的 Attribute ,会考虑将其作为子节点写入,比如文件中的 name 节点,分别就是 apple 和 orange 的配置信息。

 

如果通过我的 XmlParser 类读取,可以统一使用 GetString 方法读取,示例如下:

   1:  string a = xml.GetString("name");
   2:  string b = xml.GetString("phone");

当然,你可以通过重载获得更大的控制权。

 

另外一个问题,我想获取 orange 节点如何做到?回到 Load 方法,其第二个参数是一个字符串数组,我解释一下其作用:指定 apple 节点下逐级复杂节点的 Type 。在 Load 时会把这些 Type 作为递归 XmlParser 填充当前对象的 Items 属性下。这是正统的用法,如果你有意见,请先保留,下面会有说明。

 

我在这里举例说明:XML 配置文件中,apple 作为根节点,下面有个 items 包含了一组 orange ,在 Load 的时候我指定了 orange 作为第一级的复杂节点,使用的时候就可以通过下面的语句进行读取:

   1:  var c = xml.Items[0].GetString("name"); // name = 橘子1

到此,我相信你了解了第二个参数的作用。在不用递归子级的时候,可以设置第二个参数为 null 。

 

还有一些需求是不指定子级,在运行时动态分析。比如在 apple 节点下直接添加 orange 节点,此时如果想要获取 orange 的节点信息,你可以求助于

InnerParsers 属性,该属性包含了 apple 下的所有子节点,当然也就有这个非正统的 orange 节点。顺带提一句,Items 属性中只会包含在 items 子节点下的所有符合 orange 名称的节点。orange 通过 Load 方法第二个参数指定,逐级递归时依然有效。

 

罗嗦一句,EqualComparer 类的说明我正在写,稍等大概半小时就可以出来了,由此导致的不便还请您谅解。最后,贴上代码,毕竟代码在程序员的世界是最清楚明了的语言:

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Xml.Linq;
using Lenic.Core;
 
namespace Lenic
{
    /// <summary>
    /// 配置文件分析方式
    /// </summary>
    public enum XmlParserTypes
    {
        /// <summary>
        /// 【缺省值】自适应检索方式(分析顺序:Attriburtes、Children)
        /// </summary>
        Auto = 0,
        /// <summary>
        /// 从 Attributes 中检索
        /// </summary>
        Attribute = 1,
        /// <summary>
        /// 从 Children 中检索
        /// </summary>
        InnerElement = 2,
    }
 
    /// <summary>
    /// 尝试从字符串中解析 T 类型, 分析成功时返回 <c>true</c> , 分析结果在 result 中.
    /// </summary>
    /// <typeparam name="T">待分析的目标类型.</typeparam>
    /// <param name="obj">待分析的源字符串.</param>
    /// <param name="result">分析完成的结果.</param>
    /// <returns><c>true</c> 表示分析成功; 否则返回 <c>false</c> .</returns>
    public delegate bool TryParse<T>(string obj, out T result);
 
    /// <summary>
    /// 配置文件分析基类
    /// </summary>
    [DebuggerStepThrough]
    [DebuggerDisplay("Type = {Type}, ItemsCount = {Items.Length}")]
    public class XmlParser
    {
        #region Fields
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private string filePath = string.Empty;
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private WeakReference element = null;
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private Dictionary<string, string> attributes = null;
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private Dictionary<string, string> children = null;
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private XmlParser[] items = null;
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private string type = null;
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private string[] path = null;
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private XmlParser[] innerParsers = null;
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private FileSystemWatcher fsw = null;
        [DebuggerBrowsable(DebuggerBrowsableState.Never)]
        private string text = null;
        #endregion
 
        #region Properties
        private XElement Element
        {
            get
            {
                if (element.IsAlive)
                    return element.Target as XElement;
                else
                    throw new NullReferenceException("The current element is not effective.");
            }
        }
 
        /// <summary>
        /// 获取当前节点的类型.
        /// </summary>
        public string Type
        {
            get { return type; }
        }
 
        /// <summary>
        /// 获取当前节点的串连文本内容.
        /// </summary>
        public string Text
        {
            get
            {
                if (text == null)
                    text = Element.Value;
                return text;
            }
        }
 
        /// <summary>
        /// 获取包含的内层元素集合(items 节点).
        /// </summary>
        [DebuggerDisplay("Length = {Items.Length}")]
        public XmlParser[] Items
        {
            get
            {
                if (items == null)
                {
                    var currPath = path.Length > 0 ? path[0] : string.Empty;
                    var innerPath = path.Length > 0 ? path.Skip(1) : Enumerable.Empty<string>();
                    items = Element.Elements()
                        .Where(p => p.Name.LocalName.Equals("items", StringComparison.CurrentCultureIgnoreCase))
                        .Elements()
                        .Where(p => p.Name.LocalName.Equals(currPath, StringComparison.CurrentCultureIgnoreCase))
                        .Select(p => new XmlParser(new WeakReference(p, true), innerPath))
                        .ToArray();
 
                    WeakReference wr = new WeakReference(1, true);
                }
                return items;
            }
        }
 
        /// <summary>
        /// 获取当前节点的所有属性集合.
        /// </summary>
        [DebuggerDisplay("Count = {Attributes.Count}")]
        public Dictionary<string, string> Attributes
        {
            get
            {
                if (attributes == null)
                {
                    attributes = new Dictionary<string, string>(new EqualComparer<string>((x, y) =>
                        string.Compare(x, y, StringComparison.CurrentCultureIgnoreCase) == 0));
 
                    foreach (var item in Element.Attributes())
                    {
                        if (!attributes.ContainsKey(item.Name.LocalName))
                            attributes.Add(item.Name.LocalName, item.Value);
                    }
                }
                return attributes;
            }
        }
 
        /// <summary>
        /// 获取当前节点的所有内含元素集合(不包含 items 节点).
        /// </summary>
        [DebuggerDisplay("Count = {Children.Count}")]
        public Dictionary<string, string> Children
        {
            get
            {
                if (children == null)
                {
                    Func<string, bool> comparer = p => true;
                    if (path.Length > 0)
                    {
                        var currPath = path[0];
                        comparer = p => !p.Equals(currPath, StringComparison.CurrentCultureIgnoreCase);
                    }
 
                    children = new Dictionary<string, string>(new EqualComparer<string>((x, y) =>
                        string.Compare(x, y, StringComparison.CurrentCultureIgnoreCase) == 0));
 
                    foreach (var item in Element.Elements()
                                                .Where(p => !p.Name.LocalName.Equals("items", StringComparison.CurrentCultureIgnoreCase) &&
                                                            comparer(p.Name.LocalName)))
                    {
                        if (!children.ContainsKey(item.Name.LocalName))
                            children.Add(item.Name.LocalName, item.Value);
                    }
                }
                return children;
            }
        }
 
        /// <summary>
        /// 获取当前节点的所有内含元素集合(所有节点).
        /// </summary>
        [DebuggerDisplay("Length = {InnerParsers.Length}")]
        public XmlParser[] InnerParsers
        {
            get
            {
                if (innerParsers == null)
                {
                    var innerPath = path.Skip(1).ToArray();
                    innerParsers = Element.Elements()
                                          .Select(p => new XmlParser(new WeakReference(p, true), innerPath))
                                          .ToArray();
                }
                return innerParsers;
            }
        }
        #endregion
 
        #region Entrance
        /// <summary>
        /// 初始化新建一个 <see cref="XmlParser"/> 类的实例对象.
        /// </summary>
        /// <param name="filePath">文件路径.</param>
        /// <param name="path">内层元素的路径.</param>
        /// <returns>一个 <see cref="XmlParser"/> 类的实例对象</returns>
        public static XmlParser Load(string filePath, IEnumerable<string> path)
        {
            return new XmlParser(filePath, path);
        }
 
        /// <summary>
        /// 初始化新建一个 <see cref="XmlParser"/> 类的实例对象.
        /// </summary>
        /// <param name="filePath">文件路径.</param>
        /// <param name="path">内层元素的路径.</param>
        public XmlParser(string filePath, IEnumerable<string> path)
        {
            this.filePath = Path.GetFullPath(filePath);
 
            InitInstance(new WeakReference(XDocument.Load(this.filePath).Root, true), path);
            InitFileSystemWatcher();
        }
 
        private XmlParser(WeakReference element, IEnumerable<string> path)
        {
            InitInstance(element, path);
        }
 
        private void InitInstance(WeakReference reference, IEnumerable<string> path)
        {
            this.element = reference;
            this.type = ((XElement)element.Target).Name.LocalName;
            this.path = path == null ? new string[] { } : path.ToArray();
 
            this.OnXmlFileChanged = () =>
            {
                if (items != null)
                {
                    foreach (var item in items)
                        item.XmlFileChanged();
                    items = null;
                }
 
                if (innerParsers != null)
                {
                    foreach (var item in innerParsers)
                        item.XmlFileChanged();
                    innerParsers = null;
                }
 
                element.Target = null;
                type = null;
                text = null;
                attributes = null;
                children = null;
                if (!string.IsNullOrEmpty(filePath))
                    InitInstance(new WeakReference(XDocument.Load(this.filePath).Root, true), path);
            };
        }
 
        private void InitFileSystemWatcher()
        {
            fsw = new FileSystemWatcher
            {
                Filter = Path.GetFileName(filePath),
                IncludeSubdirectories = false,
                NotifyFilter = NotifyFilters.LastWrite,
                Path = Path.GetDirectoryName(filePath),
            };
            fsw.Changed += (sender, e) => XmlFileChanged();
            fsw.EnableRaisingEvents = true;
        }
        #endregion
 
        #region Events
        /// <summary>
        /// 在原始 XML 文件内容发生改变的时候发生
        /// </summary>
        public event Action OnXmlFileChanged;
 
        /// <summary>
        /// 引发 OnXmlFileChanged 事件
        /// </summary>
        protected void XmlFileChanged()
        {
            if (OnXmlFileChanged != null)
                OnXmlFileChanged();
        }
        #endregion
 
        #region Parse Integer
        /// <summary>
        /// 根据指定的条件获取属性的值(自适应在 Attribute 和 InnerElement 中寻找,缺省值为 <c>int.MinValue</c> ,并且忽略大小写).
        /// </summary>
        /// <param name="name">属性名称.</param>
        /// <param name="ignoreCase">如果设置为 <c>true</c> 表示忽略名称大小写检索.</param>
        /// <returns>检索结果.</returns>
        public int GetInteger(string name)
        {
            return GetInteger(name, int.MinValue, XmlParserTypes.Auto);
        }
 
        /// <summary>
        /// 根据指定的条件获取属性的值(自适应在 Attribute 和 InnerElement 中寻找).
        /// </summary>
        /// <param name="name">属性名称.</param>
        /// <param name="defaultValue">未找到属性时返回的缺省值.</param>
        /// <returns>检索结果.</returns>
        public int GetInteger(string name, int defaultValue)
        {
            return GetInteger(name, defaultValue, XmlParserTypes.Auto);
        }
 
        /// <summary>
        /// 根据指定的条件获取属性的值.
        /// </summary>
        /// <param name="name">属性名称.</param>
        /// <param name="defaultValue">未找到属性时返回的缺省值.</param>
        /// <param name="type">属性值检索方式.</param>
        /// <returns>检索结果.</returns>
        public int GetInteger(string name, int defaultValue, XmlParserTypes type)
        {
            var value = GetString(name, null, type);
            if (string.IsNullOrEmpty(value))
                return defaultValue;
 
            int result = 0;
            if (int.TryParse(value, out result))
                return result;
 
            return defaultValue;
        }
        #endregion
 
        #region Parse T
        /// <summary>
        /// 根据指定的条件获取属性的值(自适应在 Attribute 和 InnerElement 中寻找,缺省值为 <c>default(T)</c> ,并且忽略大小写).
        /// </summary>
        /// <typeparam name="T">待分析的类型.</typeparam>
        /// <param name="name">属性名称.</param>
        /// <param name="tryParse">字符串尝试分析委托.</param>
        /// <returns>检索结果.</returns>
        public T GetValue<T>(string name, TryParse<T> tryParse)
        {
            return GetValue<T>(name, tryParse, default(T), XmlParserTypes.Auto);
        }
 
        /// <summary>
        /// 根据指定的条件获取属性的值(自适应在 Attribute 和 InnerElement 中寻找).
        /// </summary>
        /// <typeparam name="T">待分析的类型.</typeparam>
        /// <param name="name">属性名称.</param>
        /// <param name="tryParse">字符串尝试分析委托.</param>
        /// <param name="defaultValue">未找到属性时返回的缺省值.</param>
        /// <returns>检索结果.</returns>
        public T GetValue<T>(string name, TryParse<T> tryParse, T defaultValue)
        {
            return GetValue<T>(name, tryParse, defaultValue, XmlParserTypes.Auto);
        }
 
        /// <summary>
        /// 根据指定的条件获取属性的值.
        /// </summary>
        /// <typeparam name="T">待分析的类型.</typeparam>
        /// <param name="name">属性名称.</param>
        /// <param name="tryParse">字符串尝试分析委托.</param>
        /// <param name="defaultValue">未找到属性时返回的缺省值.</param>
        /// <param name="type">属性值检索方式.</param>
        /// <returns>检索结果.</returns>
        public T GetValue<T>(string name, TryParse<T> tryParse, T defaultValue, XmlParserTypes type)
        {
            var value = GetString(name, null, type);
            if (string.IsNullOrEmpty(value))
                return defaultValue;
 
            T result = default(T);
            if (tryParse(value, out result))
                return result;
 
            return defaultValue;
        }
        #endregion
 
        #region Parse String
        /// <summary>
        /// 根据指定的条件获取属性的值(自适应在 Attribute 和 InnerElement 中寻找,缺省值为 <c>null</c> ,并且忽略大小写).
        /// </summary>
        /// <param name="name">属性名称.</param>
        /// <param name="ignoreCase">如果设置为 <c>true</c> 表示忽略名称大小写检索.</param>
        /// <returns>检索结果.</returns>
        public string GetString(string name)
        {
            return GetString(name, null, XmlParserTypes.Auto);
        }
 
        /// <summary>
        /// 根据指定的条件获取属性的值(自适应在 Attribute 和 InnerElement 中寻找).
        /// </summary>
        /// <param name="name">属性名称.</param>
        /// <param name="defaultValue">未找到属性时返回的缺省值.</param>
        /// <returns>检索结果.</returns>
        public string GetString(string name, string defaultValue)
        {
            return GetString(name, defaultValue, XmlParserTypes.Auto);
        }
 
        /// <summary>
        /// 根据指定的条件获取属性的值.
        /// </summary>
        /// <param name="name">属性名称.</param>
        /// <param name="defaultValue">未找到属性时返回的缺省值.</param>
        /// <param name="type">属性值检索方式.</param>
        /// <returns>检索结果.</returns>
        public string GetString(string name, string defaultValue, XmlParserTypes type)
        {
            var target = string.Empty;
 
            if (type == XmlParserTypes.Attribute)
                Attributes.TryGetValue(name, out target);
            else if (type == XmlParserTypes.InnerElement)
                Children.TryGetValue(name, out target);
            else if (type == XmlParserTypes.Auto)
            {
                if (Attributes.TryGetValue(name, out target))
                    return target;
                else if (Children.TryGetValue(name, out target))
                    return target;
            }
            else
                throw new NotSupportedException("error enum");
 
            return target;
        }
        #endregion
    }
}

 

代码中还有一些属性和方法我没做解释,但只要你看完代码后会了解的。这里提一个要求,如果您需要转载的话,请注明出处,费不了一分钟的,谢谢了!

转载于:https://www.cnblogs.com/lenic/archive/2011/12/04/2275361.html

  • 0
    点赞
  • 0
    评论
  • 0
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

表情包
插入表情
评论将由博主筛选后显示,对所有人可见 | 还能输入1000个字符
©️2021 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值