XML文件数据操作

转载 于 2014-03-19 09:03:00 发布 · 79 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：http://www.cnblogs.com/elves/p/3610547.html

 

#region XML序列化文件和反序列化

        /// <summary>
        /// 通用类的保存函数，可以将已经声明过可序列化的类以文件方式保存起来。
        /// 保存格式分为 XML明文式和 二进制。
        /// 如果目标目录不存在，就自动创建目录。
        /// </summary>
        /// <typeparam name="T">要保存的类的类型</typeparam>
        /// <param name="tclass">要保存的类</param>
        /// <param name="sFilePath">要保存的文件完整路径，包括文件名。</param>
        /// <param name="bXmlOrBin">true=XML，false=Bin</param>
        /// <exception cref="System.Exception"></exception>
        public void Save<T>(T tclass, string sFilePath, bool bXmlOrBin)
        {
            //目录检查
            string sFolder = sFilePath.Substring(0, sFilePath.LastIndexOf("\\"));
            if (!Directory.Exists(sFolder)) Directory.CreateDirectory(sFolder);

            using (FileStream fs = new FileStream(sFilePath, FileMode.Create, FileAccess.Write))
            {
                if (bXmlOrBin)
                {
                    using (MemoryStream stream = Serialize<T>(tclass, bXmlOrBin))
                    {
                        stream.WriteTo(fs);
                        stream.Close();
                    }
                }
                else
                {
                    System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = null;
                    bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                    bf.Serialize(fs, bXmlOrBin);
                }
                fs.Close();
            }
        }

        /// <summary>
        /// 从文件加载保存的信息，然后反序列化并返回保存的信息。
        /// 如果要读取的文件不存在会引发异常。
        /// </summary>
        /// <typeparam name="T">类型</typeparam>
        /// <param name="tclass">要返回的类，失败返回默认</param>
        /// <param name="sFilePath">文件路径</param>
        /// <param name="bXmlOrBin">true=XML，false=Bin</param>
        /// <exception cref="System.Exception"></exception>
        /// <exception cref="System.IO.IOException">文件不存在</exception>
        public void Load<T>(out T tclass, string sFilePath, bool bXmlOrBin)
        {
            if (!File.Exists(sFilePath))
            {
                tclass = default(T);
                return;
                //throw new IOException("要访问的文件不存在。");
            }
            using (FileStream fs = new FileStream(sFilePath, FileMode.Open, FileAccess.Read))
            {
                tclass = Deserialize<T>(fs, bXmlOrBin);
                fs.Close();
            }
        }

        /// <summary>
        /// 将传入的某个模型序列化，并返回其数据量，用于保存到文件里面。
        /// 提供序列化到XML或二进制。
        /// </summary>
        /// <typeparam name="T">类的类型</typeparam>
        /// <param name="model">要序列化的模型</param>
        /// <param name="bXmlOrBin">true=xml序列化，false=二进制序列化</param>
        /// <returns></returns>
        /// <exception cref="System.Exception"></exception>
        public MemoryStream Serialize<T>(T model, bool bXmlOrBin = true)
        {
            MemoryStream stream = new MemoryStream();
            if (bXmlOrBin)
            {
                XmlSerializer serializer = new XmlSerializer(typeof(T));
                serializer.Serialize(stream, model);
            }
            else
            {
                var bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                bf.Serialize(stream, model);
            }
            stream.Position = 0;
            return stream;
        }

        /// <summary>
        /// 将传入的数据量进行反序列化。
        /// </summary>
        /// <typeparam name="T">类的类型</typeparam>
        /// <param name="stream">要反序列化的流</param>
        /// <param name="bXmlOrBin">true=xml序列化，false=二进制序列化</param>
        /// <returns></returns>
        public T Deserialize<T>(Stream stream, bool bXmlOrBin = true)
        {
            T model = default(T);
            using (var newstream = stream)
            {
                if (bXmlOrBin)
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(T));
                    //暂时没做什么处理，以后有日志文件，就直接添加进入
                    serializer.UnknownNode += new XmlNodeEventHandler(serializer_UnknownNode);
                    serializer.UnknownAttribute += new XmlAttributeEventHandler(serializer_UnknownAttribute);
                    model = (T)serializer.Deserialize(newstream);
                }
                else
                {
                    System.Runtime.Serialization.Formatters.Binary.BinaryFormatter bf = null;
                    bf = new System.Runtime.Serialization.Formatters.Binary.BinaryFormatter();
                    model = (T)bf.Deserialize(newstream);
                }
            }
            return model;
        }

        #region 反序列化中出错的问题
        private void serializer_UnknownNode(object sender, XmlNodeEventArgs e)
        {
            string aaaa = "Unknown Node:" + e.Name + "\t" + e.Text;
            string bb = string.Empty;
            //Console.WriteLine("Unknown Node:" + e.Name + "\t" + e.Text);
        }

        private void serializer_UnknownAttribute(object sender, XmlAttributeEventArgs e)
        {
            //System.Xml.XmlAttribute attr = e.Attr;
            //Console.WriteLine("Unknown attribute " +
            //attr.Name + "='" + attr.Value + "'");
            System.Xml.XmlAttribute attr = e.Attr;
            string aaaa = "Unknown attribute " + attr.Name + "='" + attr.Value + "'";
            string bb = string.Empty;
        }
        #endregion

        #endregion

 

XML解析序列化2

/// <summary>
    /// 实体转Xml，Xml转实体类
    /// </summary>
    /// <typeparam name="T"></typeparam>
    public class XmlHelper<T> where T : new()
    {
        #region 实体类转成Xml
        /// <summary>
        /// 对象实例转成xml
        /// </summary>
        /// <param name="item">对象实例</param>
        /// <returns></returns>
        public static string EntityToXml(T item)
        {
            IList<T> items = new List<T>();
            items.Add(item);
            return EntityToXml(items);
        }

        /// <summary>
        /// 对象实例集转成xml
        /// </summary>
        /// <param name="items">对象实例集</param>
        /// <returns></returns>
        public static string EntityToXml(IList<T> items)
        {
            //创建XmlDocument文档
            XmlDocument doc = new XmlDocument();
            //创建根元素
            XmlElement root = doc.CreateElement("s");//typeof(T).Name + 
            //添加根元素的子元素集
            foreach (T item in items)
            {
                EntityToXml(doc, root, item);
            }
            //向XmlDocument文档添加根元素
            doc.AppendChild(root);

            return doc.InnerXml;
        }

        private static void EntityToXml(XmlDocument doc, XmlElement root, T item)
        {
            //创建元素
            XmlElement xmlItem = doc.CreateElement("t");//typeof(T).Name
            //对象的属性集

            System.Reflection.PropertyInfo[] propertyInfo =
            typeof(T).GetProperties(System.Reflection.BindingFlags.Public |
            System.Reflection.BindingFlags.Instance);



            foreach (System.Reflection.PropertyInfo pinfo in propertyInfo)
            {
                if (pinfo != null)
                {
                    //对象属性名称
                    string name = pinfo.Name;
                    //对象属性值
                    string value = String.Empty;

                    if (pinfo.GetValue(item, null) != null)
                        value = pinfo.GetValue(item, null).ToString();//获取对象属性值
                    //设置元素的属性值
                    xmlItem.SetAttribute(name, value);
                }
            }
            //向根添加子元素
            root.AppendChild(xmlItem);
        }


        #endregion

        #region Xml转成实体类

        /// <summary>
        /// Xml转成对象实例
        /// </summary>
        /// <param name="xml">xml</param>
        /// <returns></returns>
        public static T XmlToEntity(string xml)
        {
            IList<T> items = XmlToEntityList(xml);
            if (items != null && items.Count > 0)
                return items[0];
            else return default(T);
        }

        /// <summary>
        /// Xml转成对象实例集
        /// </summary>
        /// <param name="xml">xml</param>
        /// <returns></returns>
        public static IList<T> XmlToEntityList(string xml)
        {
            XmlDocument doc = new XmlDocument();
            try
            {
                doc.Load(xml);//LoadXML
            }
            catch (Exception ex)
            {
                throw ex;
            }
            if (doc.ChildNodes.Count <= 1)
                return null;
            //if (doc.ChildNodes[0].Name.ToLower() != typeof(T).Name.ToLower() + "s")
            //    return null;

            XmlNode node = doc.ChildNodes[1];

            IList<T> items = new List<T>();

            foreach (XmlNode child in node.ChildNodes)
            {
                if (child.Name.ToLower() == typeof(T).Name.ToLower())
                    items.Add(XmlNodeToEntity(child));
            }

            return items;
        }

        private static T XmlNodeToEntity(XmlNode node)
        {
            T item = new T();

            if (node.NodeType == XmlNodeType.Element)
            {
                //XmlElement element = (XmlElement)node;

                System.Reflection.PropertyInfo[] propertyInfo =
            typeof(T).GetProperties(System.Reflection.BindingFlags.Public |
            System.Reflection.BindingFlags.Instance);

                foreach (XmlNode attr in node.ChildNodes)//XmlAttribute
                {
                    string attrName = attr.Name.ToLower();
                    string attrValue = attr.InnerXml.ToString();
                    foreach (System.Reflection.PropertyInfo pinfo in propertyInfo)
                    {
                        if (pinfo != null)
                        {
                            string name = pinfo.Name.ToLower();
                            Type dbType = pinfo.PropertyType;
                            if (name == attrName)
                            {
                                if (String.IsNullOrEmpty(attrValue))
                                    continue;
                                switch (dbType.ToString())
                                {
                                    case "System.Int32":
                                        pinfo.SetValue(item, Convert.ToInt32(attrValue), null);
                                        break;
                                    case "System.Boolean":
                                        pinfo.SetValue(item, Convert.ToBoolean(attrValue), null);
                                        break;
                                    case "System.DateTime":
                                        pinfo.SetValue(item, Convert.ToDateTime(attrValue), null);
                                        break;
                                    case "System.Decimal":
                                        pinfo.SetValue(item, Convert.ToDecimal(attrValue), null);
                                        break;
                                    case "System.Double":
                                        pinfo.SetValue(item, Convert.ToDouble(attrValue), null);
                                        break;
                                    default:
                                        pinfo.SetValue(item, attrValue, null);
                                        break;
                                }
                                continue;
                            }
                        }
                    }
                }
            }
            return item;
        }

        #endregion
    }

//IList<ds> listDS = new List<MainWeb.ds>();
//listDS = XmlHelper<ds>.XmlToEntityList("D:\\DownLoad\\数据\\2017-03.xml");

 

 

/// <summary>
        /// 根据节点读取xml指定节点内容
        /// </summary>
        /// <param name="spath">路径</param>
        /// <param name="nodeName">节点名字</param>
        /// <returns></returns>
        public static string getXMLNodeText(string spath, string nodeName)
        {
            try
            {
                string uri = System.Web.HttpContext.Current.Server.MapPath("~/" + spath);
                XmlDocument doc = new XmlDocument();
                doc.Load(uri);
                XmlElement eml = doc.SelectSingleNode("/" + nodeName) as XmlElement;
                string result = eml.InnerText;
                return result;
            }
            catch
            {
                return "";
            }
        }



string strNode = getXMLNodeText("Web层文件路径", "documentXML/ParentNode/ChildNode");

 

根据IP获取城市--有道接口

 string Uri = "http://www.yodao.com/smartresult-xml/search.s?type=ip&q=" + IP;

            //获取省份名称
            string CtryDisc = MyRegex.HttpWeb.getHtmlByUri(Uri, Encoding.GetEncoding("GB2312"));
            using (XmlReader read = XmlReader.Create(CtryDisc))//获取返回的xml格式文件内容
            {
                while (read.Read())
                {
                    switch (read.NodeType)
                    {
                        case XmlNodeType.Text://取xml格式文件当中的文本内容
                            if (string.Format("{0}", read.Value).ToString().Trim() != IP)//youdao返回的xml格式文件内容一个是IP，另一个是IP地址
                            {
                                CtryDisc = string.Format("{0}", read.Value).ToString().Trim();//赋值
                            }
                            break;
                        //other
                    }
                }
            }

 

config.xml

#region XML控制
        public XmlDocument xml = null;
        public string xmlpath = string.Empty;
        /// <summary>
        /// 以XML格式进行存储
        /// </summary>
        public bool Save(string id, string data, string nodes, string key, string value, bool isMsg)
        {
            if (!IsXml(isMsg)) return false;
            foreach (XmlNode xl in xml.SelectNodes(nodes))
            {
                if (xl.Attributes[key].Value == id)
                {
                    xl.Attributes[value].Value = data;
                    break;
                }
            }
            xml.Save(xmlpath);
            return true;
        }

        /// <summary>
        /// 获取数据
        /// </summary>
        public string GetData(string id, string nodes, string key, string value, bool isMsg)
        {
            if (!IsXml(isMsg)) return "";
            foreach (XmlNode xl in xml.SelectNodes(nodes))
            {
                if (xl.Attributes[key].Value == id)
                    return xl.Attributes[value].Value;
            }
            return "";
        }

        /// <summary>
        /// 判断XML文件是否存在
        /// </summary>
        /// <returns></returns>
        public bool IsXml(bool isMsg)
        {
            FileInfo file = new FileInfo(xmlpath);
            if (!file.Exists)
            {
                if (isMsg)
                    MessageBox.Show(string.Format("无法找到数据配置文件:{0}\n请联系管理员！", file.Name));
                return false;
            }
            file.IsReadOnly = false;
            xml = new XmlDocument();
            xml.Load(xmlpath);
            return true;
        }
        #endregion

xmlpath = string.Format(@"{0}config.xml", AppDomain.CurrentDomain.BaseDirectory);
                if (!File.Exists(xmlpath))
                {
                    MessageBox.Show("找不到config.xml配置文件请联系管理员！");
                    return;
                }


  /*             
                string _appStrPath = "/configuration/appSettings/add";
                string _depart = GetData("depart", _appStrPath, "key", "value", false);
*/

 

 

/// <summary>    /// 实体转Xml，Xml转实体类    /// </summary>    /// <typeparam name="T"></typeparam>    public class XmlHelper<T> where T : new()    {        #region 实体类转成Xml        /// <summary>        /// 对象实例转成xml        /// </summary>        /// <param name="item">对象实例</param>        /// <returns></returns>        public static string EntityToXml(T item)        {            IList<T> items = new List<T>();            items.Add(item);            return EntityToXml(items);        }
        /// <summary>        /// 对象实例集转成xml        /// </summary>        /// <param name="items">对象实例集</param>        /// <returns></returns>        public static string EntityToXml(IList<T> items)        {            //创建XmlDocument文档            XmlDocument doc = new XmlDocument();            //创建根元素            XmlElement root = doc.CreateElement("s");//typeof(T).Name +             //添加根元素的子元素集            foreach (T item in items)            {                EntityToXml(doc, root, item);            }            //向XmlDocument文档添加根元素            doc.AppendChild(root);
            return doc.InnerXml;        }
        private static void EntityToXml(XmlDocument doc, XmlElement root, T item)        {            //创建元素            XmlElement xmlItem = doc.CreateElement("t");//typeof(T).Name            //对象的属性集
            System.Reflection.PropertyInfo[] propertyInfo =            typeof(T).GetProperties(System.Reflection.BindingFlags.Public |            System.Reflection.BindingFlags.Instance);


            foreach (System.Reflection.PropertyInfo pinfo in propertyInfo)            {                if (pinfo != null)                {                    //对象属性名称                    string name = pinfo.Name;                    //对象属性值                    string value = String.Empty;
                    if (pinfo.GetValue(item, null) != null)                        value = pinfo.GetValue(item, null).ToString();//获取对象属性值                    //设置元素的属性值                    xmlItem.SetAttribute(name, value);                }            }            //向根添加子元素            root.AppendChild(xmlItem);        }

        #endregion
        #region Xml转成实体类
        /// <summary>        /// Xml转成对象实例        /// </summary>        /// <param name="xml">xml</param>        /// <returns></returns>        public static T XmlToEntity(string xml)        {            IList<T> items = XmlToEntityList(xml);            if (items != null && items.Count > 0)                return items[0];            else return default(T);        }
        /// <summary>        /// Xml转成对象实例集        /// </summary>        /// <param name="xml">xml</param>        /// <returns></returns>        public static IList<T> XmlToEntityList(string xml)        {            XmlDocument doc = new XmlDocument();            try            {                doc.Load(xml);//LoadXML            }            catch (Exception ex)            {                throw ex;            }            if (doc.ChildNodes.Count <= 1)                return null;            //if (doc.ChildNodes[0].Name.ToLower() != typeof(T).Name.ToLower() + "s")            //    return null;
            XmlNode node = doc.ChildNodes[1];
            IList<T> items = new List<T>();
            foreach (XmlNode child in node.ChildNodes)            {                if (child.Name.ToLower() == typeof(T).Name.ToLower())                    items.Add(XmlNodeToEntity(child));            }
            return items;        }
        private static T XmlNodeToEntity(XmlNode node)        {            T item = new T();
            if (node.NodeType == XmlNodeType.Element)            {                //XmlElement element = (XmlElement)node;
                System.Reflection.PropertyInfo[] propertyInfo =            typeof(T).GetProperties(System.Reflection.BindingFlags.Public |            System.Reflection.BindingFlags.Instance);
                foreach (XmlNode attr in node.ChildNodes)//XmlAttribute                {                    string attrName = attr.Name.ToLower();                    string attrValue = attr.InnerXml.ToString();                    foreach (System.Reflection.PropertyInfo pinfo in propertyInfo)                    {                        if (pinfo != null)                        {                            string name = pinfo.Name.ToLower();                            Type dbType = pinfo.PropertyType;                            if (name == attrName)                            {                                if (String.IsNullOrEmpty(attrValue))                                    continue;                                switch (dbType.ToString())                                {                                    case "System.Int32":                                        pinfo.SetValue(item, Convert.ToInt32(attrValue), null);                                        break;                                    case "System.Boolean":                                        pinfo.SetValue(item, Convert.ToBoolean(attrValue), null);                                        break;                                    case "System.DateTime":                                        pinfo.SetValue(item, Convert.ToDateTime(attrValue), null);                                        break;                                    case "System.Decimal":                                        pinfo.SetValue(item, Convert.ToDecimal(attrValue), null);                                        break;                                    case "System.Double":                                        pinfo.SetValue(item, Convert.ToDouble(attrValue), null);                                        break;                                    default:                                        pinfo.SetValue(item, attrValue, null);                                        break;                                }                                continue;                            }                        }                    }                }            }            return item;        }
        #endregion    }

转载于:https://www.cnblogs.com/elves/p/3610547.html

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值