using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using System.Xml;
using NewLife.Reflection;
namespace NewLife.Xml
{
/// <summary>Xml辅助类</summary>
public static class XmlHelper
{
#region 实体转Xml
/// <summary>序列化为Xml</summary>
/// <param name="obj">要序列化为Xml的对象</param>
/// <returns>Xml字符串</returns>
public static String ToXml(this Object obj)
{
// 去掉默认命名空间xmlns:xsd和xmlns:xsi
return obj.ToXml(null, "", "");
}
/// <summary>序列化为Xml字符串</summary>
/// <param name="obj">要序列化为Xml的对象</param>
/// <param name="encoding">编码</param>
/// <param name="prefix">前缀</param>
/// <param name="ns">命名空间,设为0长度字符串可去掉默认命名空间xmlns:xsd和xmlns:xsi</param>
/// <param name="includeDeclaration">是否包含Xml声明</param>
/// <param name="attachComment">是否附加注释,附加成员的Description和DisplayName注释</param>
/// <returns>Xml字符串</returns>
public static String ToXml(this Object obj, Encoding encoding = null, String prefix = null, String ns = null, Boolean includeDeclaration = false, Boolean attachComment = false)
{
if (obj == null) throw new ArgumentNullException("obj");
if (encoding == null) encoding = Encoding.UTF8;
// 删除字节序
encoding = encoding.TrimPreamble();
using (var stream = new MemoryStream())
{
ToXml(obj, stream, encoding, prefix, ns, includeDeclaration, attachComment);
return encoding.GetString(stream.ToArray());
}
}
/// <summary>序列化为Xml数据流</summary>
/// <param name="obj">要序列化为Xml的对象</param>
/// <param name="stream">目标数据流</param>
/// <param name="encoding">编码</param>
/// <param name="prefix">前缀</param>
/// <param name="ns">命名空间,设为0长度字符串可去掉默认命名空间xmlns:xsd和xmlns:xsi</param>
/// <param name="includeDeclaration">是否包含Xml声明 <?xml version="1.0" encoding="utf-8"?></param>
/// <param name="attachComment">是否附加注释,附加成员的Description和DisplayName注释</param>
/// <returns>Xml字符串</returns>
public static void ToXml(this Object obj, Stream stream, Encoding encoding = null, String prefix = null, String ns = null, Boolean includeDeclaration = false, Boolean attachComment = false)
{
if (obj == null) throw new ArgumentNullException("obj");
if (encoding == null) encoding = Encoding.UTF8;
// 删除字节序
encoding = encoding.TrimPreamble();
var xml = new NewLife.Serialization.Xml();
xml.Stream = stream;
xml.Encoding = encoding;
xml.UseAttribute = false;
xml.UseComment = attachComment;
xml.Write(obj);
//var type = obj.GetType();
//if (!type.IsPublic) throw new XException("类型{0}不是public,不能进行Xml序列化!", type.FullName);
//var serial = new XmlSerializer(type);
//var setting = new XmlWriterSettings();
////setting.Encoding = encoding.TrimPreamble();
//setting.Encoding = encoding;
//setting.Indent = true;
//// 去掉开头 <?xml version="1.0" encoding="utf-8"?>
//setting.OmitXmlDeclaration = !includeDeclaration;
//var p = stream.Position;
//using (var writer = XmlWriter.Create(stream, setting))
//{
// if (ns == null)
// serial.Serialize(writer, obj);
// else
// {
// var xsns = new XmlSerializerNamespaces();
// xsns.Add(prefix, ns);
// serial.Serialize(writer, obj, xsns);
// }
//}
//if (attachComment)
//{
// if (stream is FileStream) stream.SetLength(stream.Position);
// stream.Position = p;
// var doc = new XmlDocument();
// doc.Load(stream);
// doc.DocumentElement.AttachComment(type);
// stream.Position = p;
// //doc.Save(stream);
// using (var writer = XmlWriter.Create(stream, setting))
// {
// doc.Save(writer);
// }
//}
}
/// <summary>序列化为Xml文件</summary>
/// <param name="obj">要序列化为Xml的对象</param>
/// <param name="file">目标Xml文件</param>
/// <param name="encoding">编码</param>
/// <param name="prefix">前缀</param>
/// <param name="ns">命名空间,设为0长度字符串可去掉默认命名空间xmlns:xsd和xmlns:xsi</param>
/// <param name="includeDeclaration">是否包含Xml声明 <?xml version="1.0" encoding="utf-8"?></param>
/// <param name="attachComment">是否附加注释,附加成员的Description和DisplayName注释</param>
/// <returns>Xml字符串</returns>
public static void ToXmlFile(this Object obj, String file, Encoding encoding = null, String prefix = null, String ns = null, Boolean includeDeclaration = false, Boolean attachComment = true)
{
if (File.Exists(file)) File.Delete(file);
file.EnsureDirectory(true);
// 如果是字符串字典,直接写入文件,其它设置无效
if (obj is IDictionary<String, String>)
{
var xml = (obj as IDictionary<String, String>).ToXml(prefix);
File.WriteAllText(file, xml, encoding ?? Encoding.UTF8);
return;
}
using (var stream = new FileStream(file, FileMode.OpenOrCreate, FileAccess.ReadWrite))
{
obj.ToXml(stream, encoding, prefix, ns, includeDeclaration, attachComment);
// 必须通过设置文件流长度来实现截断,否则后面可能会多一截旧数据
stream.SetLength(stream.Position);
}
}
#endregion
#region Xml转实体
/// <summary>字符串转为Xml实体对象</summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="xml">Xml字符串</param>
/// <returns>Xml实体对象</returns>
public static TEntity ToXmlEntity<TEntity>(this String xml) where TEntity : class
{
return xml.ToXmlEntity(typeof(TEntity)) as TEntity;
}
/// <summary>字符串转为Xml实体对象</summary>
/// <param name="xml">Xml字符串</param>
/// <param name="type">实体类型</param>
/// <returns>Xml实体对象</returns>
public static Object ToXmlEntity(this String xml, Type type)
{
if (xml.IsNullOrWhiteSpace()) throw new ArgumentNullException("xml");
if (type == null) throw new ArgumentNullException("type");
var x = new NewLife.Serialization.Xml();
x.Stream = new MemoryStream(xml.GetBytes());
return x.Read(type);
//if (!type.IsPublic) throw new XException("类型{0}不是public,不能进行Xml序列化!", type.FullName);
//var serial = new XmlSerializer(type);
//using (var reader = new StringReader(xml))
//using (var xr = new XmlTextReader(reader))
//{
// // 必须关闭Normalization,否则字符串的\r\n会变为\n
// //xr.Normalization = true;
// return serial.Deserialize(xr);
//}
}
/// <summary>数据流转为Xml实体对象</summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="stream">数据流</param>
/// <param name="encoding">编码</param>
/// <returns>Xml实体对象</returns>
public static TEntity ToXmlEntity<TEntity>(this Stream stream, Encoding encoding = null) where TEntity : class
{
return stream.ToXmlEntity(typeof(TEntity), encoding) as TEntity;
}
/// <summary>数据流转为Xml实体对象</summary>
/// <param name="stream">数据流</param>
/// <param name="type">实体类型</param>
/// <param name="encoding">编码</param>
/// <returns>Xml实体对象</returns>
public static Object ToXmlEntity(this Stream stream, Type type, Encoding encoding = null)
{
if (stream == null) throw new ArgumentNullException("stream");
if (type == null) throw new ArgumentNullException("type");
if (encoding == null) encoding = Encoding.UTF8;
var x = new NewLife.Serialization.Xml();
x.Stream = stream;
x.Encoding = encoding;
return x.Read(type);
//if (!type.IsPublic) throw new XException("类型{0}不是public,不能进行Xml序列化!", type.FullName);
//var serial = new XmlSerializer(type);
//using (var reader = new StreamReader(stream, encoding))
//using (var xr = new XmlTextReader(reader))
//{
// // 必须关闭Normalization,否则字符串的\r\n会变为\n
// //xr.Normalization = true;
// return serial.Deserialize(xr);
//}
}
/// <summary>Xml文件转为Xml实体对象</summary>
/// <typeparam name="TEntity">实体类型</typeparam>
/// <param name="file">Xml文件</param>
/// <param name="encoding">编码</param>
/// <returns>Xml实体对象</returns>
public static TEntity ToXmlFileEntity<TEntity>(this String file, Encoding encoding = null) where TEntity : class
{
if (file.IsNullOrWhiteSpace()) throw new ArgumentNullException("file");
if (!File.Exists(file)) return null;
using (var stream = new FileStream(file, FileMode.Open, FileAccess.Read))
{
return stream.ToXmlEntity<TEntity>(encoding);
}
}
#endregion
#region Xml类型转换
/// <summary>删除字节序,硬编码支持utf-8、utf-32、Unicode三种</summary>
/// <param name="encoding">原始编码</param>
/// <returns>删除字节序后的编码</returns>
internal static Encoding TrimPreamble(this Encoding encoding)
{
if (encoding == null) return encoding;
var bts = encoding.GetPreamble();
if (bts == null || bts.Length < 1) return encoding;
if (encoding is UTF8Encoding) return _utf8Encoding ?? (_utf8Encoding = new UTF8Encoding(false));
if (encoding is UTF32Encoding) return _utf32Encoding ?? (_utf32Encoding = new UTF32Encoding(false, false));
if (encoding is UnicodeEncoding) return _unicodeEncoding ?? (_unicodeEncoding = new UnicodeEncoding(false, false));
return encoding;
}
private static Encoding _utf8Encoding;
private static Encoding _utf32Encoding;
private static Encoding _unicodeEncoding;
internal static Boolean CanXmlConvert(this Type type)
{
var code = Type.GetTypeCode(type);
if (code != TypeCode.Object) return true;
if (!type.IsValueType) return false;
if (type == typeof(Guid) || type == typeof(DateTimeOffset) || type == typeof(TimeSpan)) return true;
return false;
}
internal static String XmlConvertToString(Object value)
{
if (value == null) return null;
var type = value.GetType();
var code = Type.GetTypeCode(type);
if (code == TypeCode.String) return value.ToString();
if (code == TypeCode.DateTime) return XmlConvert.ToString((DateTime)value, XmlDateTimeSerializationMode.RoundtripKind);
//var method = Reflect.GetMethodEx(typeof(XmlConvert), "ToString", type);
var method = typeof(XmlConvert).GetMethodEx("ToString", type);
if (method == null) throw new XException("类型{0}不支持转为Xml字符串,请先用CanXmlConvert方法判断!", type);
return (String)"".Invoke(method, value);
}
internal static T XmlConvertFromString<T>(String xml) { return (T)XmlConvertFromString(typeof(T), xml); }
internal static Object XmlConvertFromString(Type type, String xml)
{
if (xml == null) return null;
var code = Type.GetTypeCode(type);
if (code == TypeCode.String) return xml;
if (code == TypeCode.DateTime) return XmlConvert.ToDateTime(xml, XmlDateTimeSerializationMode.RoundtripKind);
//var method = Reflect.GetMethodEx(typeof(XmlConvert), "To" + type.Name, typeof(String));
var method = typeof(XmlConvert).GetMethodEx("To" + type.Name, typeof(String));
if (method == null) throw new XException("类型{0}不支持从Xml字符串转换,请先用CanXmlConvert方法判断!", type);
return "".Invoke(method, xml);
}
#endregion
#region Xml注释
///// <summary>是否拥有注释</summary>
//private static Dictionary<Type, Boolean> typeHasCommit = new Dictionary<Type, Boolean>();
///// <summary>附加注释</summary>
///// <param name="node"></param>
///// <param name="type">类型</param>
///// <returns></returns>
//public static XmlNode AttachComment(this XmlNode node, Type type)
//{
// if (node == null || type == null) return node;
// if (node.ChildNodes == null || node.ChildNodes.Count < 1) return node;
// // 如果没有注释
// var rs = false;
// if (typeHasCommit.TryGetValue(type, out rs) && !rs) return node;
// rs = node.AttachCommentInternal(type);
// if (!typeHasCommit.ContainsKey(type))
// {
// lock (typeHasCommit)
// {
// if (!typeHasCommit.ContainsKey(type))
// {
// typeHasCommit.Add(type, rs);
// }
// }
// }
// return node;
//}
//static Boolean AttachCommentInternal(this XmlNode node, Type type)
//{
// if (node.ChildNodes == null || node.ChildNodes.Count < 1) return false;
// var rs = false;
// // 当前节点加注释
// if (!node.PreviousSibling.IsComment())
// {
// if (SetComment(node, type)) rs = true;
// }
// #region 特殊处理数组和列表
// Type elmType = null;
// if (type.HasElementType)
// elmType = type.GetElementType();
// else if (type.IsGenericType && type.GetGenericArguments().Length == 1 && type.As<IEnumerable>())
// elmType = type.GetGenericArguments()[0];
// if (elmType != null && elmType.Name.EqualIgnoreCase(node.ChildNodes[0].Name))
// {
// for (var i = 0; i < node.ChildNodes.Count; i++)
// {
// rs |= node.ChildNodes[i].AttachCommentInternal(elmType);
// }
// return rs;
// }
// #endregion
// for (var i = 0; i < node.ChildNodes.Count; i++)
// {
// var curNode = node.ChildNodes[i];
// // 如果当前是注释,跳过两个,下一个也不处理了
// if (curNode.IsComment()) { i++; continue; }
// // 找到对应的属性
// var name = curNode.Name;
// var pi = type.GetPropertyEx(name);
// // 如果前一个是注释,跳过
// if (i <= 0 || !node.ChildNodes[i - 1].IsComment())
// {
// if (pi != null && SetComment(curNode, pi)) { rs = true; i++; }
// }
// // 递归。因为必须依赖于Xml树,所以不用担心死循环
// if (pi != null && Type.GetTypeCode(pi.PropertyType) == TypeCode.Object) rs |= curNode.AttachCommentInternal(pi.PropertyType);
// }
// return rs;
//}
//private static Boolean SetComment(this XmlNode node, MemberInfo member)
//{
// if (node.IsComment() || node.PreviousSibling.IsComment()) return false;
// #region 从特性中获取注释
// var commit = String.Empty;
// var des = member.GetCustomAttribute<DescriptionAttribute>(true);
// var dis = member.GetCustomAttribute<DisplayNameAttribute>(true);
// if (des != null && dis == null)
// commit = des.Description;
// else if (des == null && dis != null)
// commit = dis.DisplayName;
// else if (des != null && dis != null)
// {
// // DisplayName。Description
// if (des.Description == null && !dis.DisplayName.IsNullOrWhiteSpace() || !des.Description.Contains(dis.DisplayName))
// {
// commit = dis.DisplayName;
// if (!commit.EndsWith(".") || commit.EndsWith("。")) commit += "。";
// }
// if (!des.Description.IsNullOrWhiteSpace()) commit += des.Description;
// }
// #endregion
// if (commit.IsNullOrWhiteSpace()) return false;
// var cm = node.OwnerDocument.CreateComment(commit);
// node.ParentNode.InsertBefore(cm, node);
// return true;
//}
//private static Boolean IsComment(this XmlNode node) { return node != null && node.NodeType == XmlNodeType.Comment; }
#endregion
#region Xml转字典
/// <summary>简单Xml转为字符串字典</summary>
/// <param name="xml"></param>
/// <returns></returns>
public static Dictionary<String, String> ToXmlDictionary(this String xml)
{
if (String.IsNullOrEmpty(xml)) return null;
var doc = new XmlDocument();
doc.LoadXml(xml);
var root = doc.DocumentElement;
var dic = new Dictionary<String, String>();
if (root.ChildNodes != null && root.ChildNodes.Count > 0)
{
foreach (XmlNode item in root.ChildNodes)
{
if (item.ChildNodes != null && (item.ChildNodes.Count > 1 ||
item.ChildNodes.Count == 1 && !(item.FirstChild is XmlText) && !(item.FirstChild is XmlCDataSection)))
{
dic[item.Name] = item.InnerXml;
}
else
{
dic[item.Name] = item.InnerText;
}
}
}
return dic;
}
/// <summary>字符串字典转为Xml</summary>
/// <param name="dic"></param>
/// <param name="rootName"></param>
/// <returns></returns>
public static String ToXml(this IDictionary<String, String> dic, String rootName = null)
{
if (String.IsNullOrEmpty(rootName)) rootName = "xml";
var doc = new XmlDocument();
var root = doc.CreateElement(rootName);
doc.AppendChild(root);
if (dic != null && dic.Count > 0)
{
foreach (var item in dic)
{
var elm = doc.CreateElement(item.Key);
elm.InnerText = item.Value;
root.AppendChild(elm);
}
}
return doc.OuterXml;
}
#endregion
}
}
|