1.简单读写：
引入using System.Xml;命名空间
写操作
//创建XmlDocument对象 XmlDocument doc = new XmlDocument(); //载入(.load方法载入具体文件) doc.LoadXml("<Student type='regular' Section='B'><Name>xlh</Name></Student>");
//常用属性方法有SelectSingleNode，ChildNodes，GetAttribute，AppendChild等，处理逻辑为遍历查找，例如： XmlNodeList nodeList = xmlDoc.SelectSingleNode("bookstore").ChildNodes;//获取bookstore节点的所有子节点，对于指定名称节点可以通过 XmlNodeList lis = doc.GetElementsByTagName("Name") ，然后取值 String str = lis[0].InnerText 获得。
foreach (XmlNode xn in nodeList)//遍历所有子节点 { XmlElement xe = (XmlElement)xn;//将子节点类型转换为XmlElement类型 if (xe.GetAttribute("genre") == "李赞红")//如果genre属性值为“李赞红” { xe.SetAttribute("genre", "update李赞红");//则修改该属性为“update李赞红” XmlNodeList nls = xe.ChildNodes;//继续获取xe子节点的所有子节点 foreach (XmlNode xn1 in nls)//遍历 { XmlElement xe2 = (XmlElement)xn1;//转换类型 if (xe2.Name == "author")//如果找到 { xe2.InnerText = "亚胜";//则修改 break;//找到退出来就可以了 } } break; } }
也可以通过XmlWriter来进行写入
读操作
通过XmlReader读取器例如
using (XmlReader read = XmlReader.Create(xmUrl)) { while (read.Read()) { switch (read.NodeType) { case XmlNodeType.Element: break; case XmlNodeType.Text: xs += read.Value + "|"; break; } } }
将文本内容取出，或者 XmlNodeList lis = doc.GetElementsByTagName("Name") 遍历指定属性来获取。以上方法只适合简单少量的读取，对于规则性数据还要采用序列化的方式。
创建操作参见http://www.cnblogs.com/yukaizhao/archive/2011/07/19/csharp_xmldocument_access_xml.html
2.序列化使用：
系列化将数据封装在数据实体中，所以使用时先定义实体类
[XmlRoot("Root")] public class People { [XmlAttribute("NAME")] public string Name { set; get; } [XmlAttribute("AGE")] public int Age { set; get; } } [XmlRoot("Root")] public class Student : People { [XmlElement("CLASS")] public string Class { set; get; } [XmlElement("NUMBER")] public int Number { set; get; } }
定义特性直接表示了xml文档结构关系。处理单元中要处理的数据
Student stu = new Student() { Age = 10, Class = "Class One", Name = "Tom", Number = 1 };
序列化
XmlSerializer ser = new XmlSerializer(typeof(Student)); ser.Serialize(File.Create("C:\x.xml"), stu);
反序列化
XmlSerializer ser = new XmlSerializer(typeof(Student)); Student stu = ser.Deserialize(File.OpenRead("C:\x.xml")) as Stud
关于序列化操作找到一个封装好的操作类
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Xml.Serialization; using System.IO; using System.Xml; // 此处代码来源于博客【在.net中读写config文件的各种方法】的示例代码 // http://www.cnblogs.com/fish-li/archive/2011/12/18/2292037.html namespace MyMVC { public static class XmlHelper { /// <summary> /// 序列化操作以及流中换行处理 /// </summary> /// <param name="stream"></param> /// <param name="o"></param> /// <param name="encoding"></param> private static void XmlSerializeInternal(Stream stream, object o, Encoding encoding) { if (o == null) throw new ArgumentNullException("o"); if (encoding == null) throw new ArgumentNullException("encoding"); XmlSerializer serializer = new XmlSerializer(o.GetType()); XmlWriterSettings settings = new XmlWriterSettings(); settings.Indent = true; settings.NewLineChars = " "; settings.Encoding = encoding; settings.IndentChars = " "; //按照相关设置快速序列化对象 using (XmlWriter writer = XmlWriter.Create(stream, settings)) { serializer.Serialize(writer, o); writer.Close(); } } /// <summary> /// 将一个对象序列化为XML字符串 /// </summary> /// <param name="o">要序列化的对象</param> /// <param name="encoding">编码方式</param> /// <returns>序列化产生的XML字符串</returns> public static string XmlSerialize(object o, Encoding encoding) { using (MemoryStream stream = new MemoryStream()) { XmlSerializeInternal(stream, o, encoding); stream.Position = 0; using (StreamReader reader = new StreamReader(stream, encoding)) { return reader.ReadToEnd(); } } } /// <summary> /// 将一个对象按XML序列化的方式写入到一个文件 /// </summary> /// <param name="o">要序列化的对象</param> /// <param name="path">保存文件路径</param> /// <param name="encoding">编码方式</param> public static void XmlSerializeToFile(object o, string path, Encoding encoding) { if (string.IsNullOrEmpty(path)) throw new ArgumentNullException("path"); using (FileStream file = new FileStream(path, FileMode.Create, FileAccess.Write)) { XmlSerializeInternal(file, o, encoding); } } /// <summary> /// 从XML字符串中反序列化对象 /// </summary> /// <typeparam name="T">结果对象类型</typeparam> /// <param name="s">包含对象的XML字符串</param> /// <param name="encoding">编码方式</param> /// <returns>反序列化得到的对象</returns> public static T XmlDeserialize<T>(string s, Encoding encoding) { if (string.IsNullOrEmpty(s)) throw new ArgumentNullException("s"); if (encoding == null) throw new ArgumentNullException("encoding"); XmlSerializer mySerializer = new XmlSerializer(typeof(T)); using (MemoryStream ms = new MemoryStream(encoding.GetBytes(s))) { using (StreamReader sr = new StreamReader(ms, encoding)) { return (T)mySerializer.Deserialize(sr); } } } /// <summary> /// 读入一个文件，并按XML的方式反序列化对象。 /// </summary> /// <typeparam name="T">结果对象类型</typeparam> /// <param name="path">文件路径</param> /// <param name="encoding">编码方式</param> /// <returns>反序列化得到的对象</returns> public static T XmlDeserializeFromFile<T>(string path, Encoding encoding) { if (string.IsNullOrEmpty(path)) throw new ArgumentNullException("path"); if (encoding == null) throw new ArgumentNullException("encoding"); string xml = File.ReadAllText(path, encoding); return XmlDeserialize<T>(xml, encoding); } } }
一个使用xmlDocument的方法
/// <summary> /// 将xml字符串映射为实体类 /// </summary> /// <typeparam name="T">实体类类型</typeparam> /// <param name="xml">xml字符串</param> /// <returns>实体类</returns> public dynamic ChangeXmlToEntity<T>(string xml) { dynamic entity = Activator.CreateInstance<T>(); doc = new XmlDocument(); doc.LoadXml(xml); xe = doc.DocumentElement; foreach (PropertyInfo p in entity.GetType().GetProperties()) { Type toType = p.PropertyType; if (p.PropertyType == typeof(int?)) { toType = typeof(int); } else if (p.PropertyType == typeof(decimal?)) { toType = typeof(decimal); } else if (p.PropertyType == typeof(float?)) { toType = typeof(float); } else if (p.PropertyType == typeof(double?)) { toType = typeof(double); } else if (p.PropertyType == typeof(DateTime?)) { toType = typeof(DateTime); } else if (p.PropertyType == typeof(string)) { toType = typeof(string); } MethodInfo m = p.GetSetMethod(); m.Invoke(entity, parameters: new object[] { Convert.ChangeType(xe.GetElementsByTagName(p.Name)[0].InnerText, toType) }); } return entity; }
补充：关于序列化不光xml序列化，json数据也需要序列化
.net3.5以上可以通过DataContractJsonSerializer类和JavaScriptSerializer类序列化操作 （DataContractJsonSerializer在.NET Framework 3.5包含在System.ServiceModel.Web.dll中，需要添加对其的引用,在System.Runtime.Serialization.Json命名空间下；.NET Framework 4在System.Runtime.Serialization中）
还可以使用XmlSerializer(.net2.0)
命名空间:System.Xml.Serialization
程序集:System.Xml（在 system.xml.dll 中）
例如
//序列化
string r1 = jsonSerializer.Serialize(personnel); //反序列化 Personnel _Personnel = jsonSerializer.Deserialize<Personnel>(r1);
.net2.0可以使用第三方的Newtonsoft.Json.dll进行序列化，例如：
JsonSerializer jsser = new JsonSerializer(); //wInfo为事先定义好的实体类 wInfo = JsonConvert.DeserializeObject<IpInfo>(jsonData);
另一个更加强大的序列化操作类，出处：http://www.cnblogs.com/yank/p/3198082.html
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; using System.Runtime.Serialization; using System.Runtime.Serialization.Json; using System.Runtime.Serialization.Formatters.Binary; using System.Runtime.Serialization.Formatters.Soap; using System.Xml.Serialization; namespace SerializerSample { /// <summary> /// 序列化帮助类 /// </summary> public sealed class SerializeHelper { #region DataContract序列化 /// <summary> /// DataContract序列化 /// </summary> /// <param name="value"></param> /// <param name="knownTypes"></param> /// <returns></returns> public static string SerializeDataContract(object value, List<Type> knownTypes = null) { DataContractSerializer dataContractSerializer = new DataContractSerializer(value.GetType(), knownTypes); using (MemoryStream ms = new MemoryStream()) { dataContractSerializer.WriteObject(ms, value); ms.Seek(0, SeekOrigin.Begin); using (StreamReader sr = new StreamReader(ms)) { return sr.ReadToEnd(); } } } /// <summary> /// DataContract反序列化 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="xml"></param> /// <returns></returns> public static T DeserializeDataContract<T>(string xml) { using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(xml))) { DataContractSerializer serializer = new DataContractSerializer(typeof(T)); return (T)serializer.ReadObject(ms); } } #endregion #region DataContractJson序列化 /// <summary> /// DataContractJson序列化 /// </summary> /// <param name="value"></param> /// <returns></returns> public static string SerializeDataContractJson(object value) { DataContractJsonSerializer dataContractSerializer = new DataContractJsonSerializer(value.GetType()); using (MemoryStream ms = new MemoryStream()) { dataContractSerializer.WriteObject(ms, value); return Encoding.UTF8.GetString(ms.ToArray()); } } /// <summary> /// DataContractJson反序列化 /// </summary> /// <param name="type"></param> /// <param name="str"></param> /// <returns></returns> public static object DeserializeDataContractJson(Type type, string str) { DataContractJsonSerializer dataContractSerializer = new DataContractJsonSerializer(type); using (MemoryStream ms = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(str))) { return dataContractSerializer.ReadObject(ms); } } /// <summary> /// DataContractJson反序列化 /// </summary> /// <typeparam name="T"></typeparam> /// <param name="json"></param> /// <returns></returns> public T DeserializeDataContractJson<T>(string json) { DataContractJsonSerializer dataContractSerializer = new DataContractJsonSerializer(typeof(T)); using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(json))) { return (T)dataContractSerializer.ReadObject(ms); } } #endregion #region XmlSerializer序列化 /// <summary> /// 将对象序列化到 XML 文档中和从 XML 文档中反序列化对象。XmlSerializer 使您得以控制如何将对象编码到 XML 中。 /// </summary> /// <param name="value"></param> /// <returns></returns> public static string SerializeXml(object value) { XmlSerializer serializer = new XmlSerializer(value.GetType()); using (MemoryStream ms = new MemoryStream()) { serializer.Serialize(ms, value); ms.Seek(0, SeekOrigin.Begin); using (StreamReader sr = new StreamReader(ms)) { return sr.ReadToEnd(); } } } /// <summary> /// XmlSerializer反序列化 /// </summary> /// <param name="type"></param> /// <param name="str"></param> /// <returns></returns> public static object DeserializeXml(Type type, string str) { XmlSerializer serializer = new XmlSerializer(type); byte[] bytes = System.Text.Encoding.UTF8.GetBytes(str); using (MemoryStream ms = new MemoryStream(bytes)) { return serializer.Deserialize(ms); } } #endregion #region BinaryFormatter序列化 /// <summary> /// BinaryFormatter序列化 /// 必须类型必须标记为Serializable /// </summary> /// <param name="obj"></param> /// <returns></returns> public static string SerializeBinaryFormatter(object obj) { BinaryFormatter formatter = new BinaryFormatter(); using (MemoryStream ms = new MemoryStream()) { formatter.Serialize(ms,obj); byte[] bytes = ms.ToArray(); obj = formatter.Deserialize(new MemoryStream(bytes)); //如果是UTF8格式，则反序列化报错。可以用Default格式，不过，建议还是传参为byte数组比较好 return Encoding.Default.GetString(bytes); } } /// <summary> /// BinaryFormatter反序列化 /// 必须类型必须标记为Serializable /// </summary> /// <param name="serializedStr"></param> /// <returns></returns> public static T DeserializeBinaryFormatter<T>(string serializedStr) { BinaryFormatter formatter = new BinaryFormatter(); byte[] bytes = Encoding.Default.GetBytes(serializedStr); using (MemoryStream ms = new MemoryStream(bytes)) { return (T)formatter.Deserialize(ms); } } #endregion #region SoapFormatter序列化 /// <summary> /// SoapFormatter序列化 /// 必须类型必须标记为Serializable /// </summary> /// <param name="obj"></param> /// <returns></returns> public static string SerializeSoapFormatter(object obj) { SoapFormatter formatter = new SoapFormatter(); using (MemoryStream ms = new MemoryStream()) { formatter.Serialize(ms, obj); byte[] bytes = ms.ToArray(); return Encoding.UTF8.GetString(bytes); } } /// <summary> /// SoapFormatter反序列化 /// 必须类型必须标记为Serializable /// </summary> /// <param name="serializedStr"></param> /// <returns></returns> public static T DeserializeSoapFormatter<T>(string serializedStr) { SoapFormatter formatter = new SoapFormatter(); using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(serializedStr))) { return (T)formatter.Deserialize(ms); } } #endregion } }