XML序列化与反序列化工具类

 /// <summary>
 /// XML序列化与反序列化工具类
 /// </summary>
 public static class XmlSerializerHelper
 {
     /// <summary>
     /// 将对象序列化为XML字符串
     /// </summary>
     /// <typeparam name="T">对象类型</typeparam>
     /// <param name="obj">要序列化的对象</param>
     /// <param name="xmlRootName">自定义XML根节点名称（可选）</param>
     /// <returns>序列化后的XML字符串</returns>
     public static string SerializeToXml<T>(T obj, string xmlRootName = null)
     {
         if (obj == null)
         {
             throw new ArgumentNullException(nameof(obj), "序列化对象不能为null");
         }

         try
         {
             using (StringWriter sw = new StringWriter())
             {
                 XmlSerializer serializer = CreateXmlSerializer(typeof(T), xmlRootName);
                 serializer.Serialize(sw, obj);
                 return sw.ToString();
             }
         }
         catch (Exception ex)
         {
             throw new InvalidOperationException("对象序列化为XML字符串失败", ex);
         }
     }

     /// <summary>
     /// 将XML字符串反序列化为对象
     /// </summary>
     /// <typeparam name="T">目标对象类型</typeparam>
     /// <param name="xml">XML字符串</param>
     /// <param name="xmlRootName">自定义XML根节点名称（可选）</param>
     /// <returns>反序列化后的对象</returns>
     public static T DeserializeFromXml<T>(string xml, string xmlRootName = null)
     {
         if (string.IsNullOrWhiteSpace(xml))
         {
             throw new ArgumentNullException(nameof(xml), "XML字符串不能为空");
         }

         try
         {
             using (StringReader sr = new StringReader(xml))
             {
                 XmlSerializer serializer = CreateXmlSerializer(typeof(T), xmlRootName);
                 return (T)serializer.Deserialize(sr);
             }
         }
         catch (Exception ex)
         {
             throw new InvalidOperationException("XML字符串反序列化为对象失败", ex);
         }
     }

     /// <summary>
     /// 将对象序列化到XML文件
     /// </summary>
     /// <typeparam name="T">对象类型</typeparam>
     /// <param name="obj">要序列化的对象</param>
     /// <param name="filePath">XML文件完整路径</param>
     /// <param name="xmlRootName">自定义XML根节点名称（可选）</param>
     public static void SerializeToFile<T>(T obj, string filePath, string xmlRootName = null)
     {
         if (obj == null)
         {
             throw new ArgumentNullException(nameof(obj), "序列化对象不能为null");
         }
         if (string.IsNullOrWhiteSpace(filePath))
         {
             throw new ArgumentNullException(nameof(filePath), "文件路径不能为空");
         }

         // 确保目录存在
         string directory = Path.GetDirectoryName(filePath);
         if (!string.IsNullOrEmpty(directory) && !Directory.Exists(directory))
         {
             Directory.CreateDirectory(directory);
         }

         try
         {
             using (StreamWriter writer = new StreamWriter(filePath))
             {
                 XmlSerializer serializer = CreateXmlSerializer(typeof(T), xmlRootName);
                 serializer.Serialize(writer, obj);
             }
         }
         catch (Exception ex)
         {
             throw new InvalidOperationException($"序列化对象到文件失败: {filePath}", ex);
         }
     }

     /// <summary>
     /// 从XML文件反序列化为对象
     /// </summary>
     /// <typeparam name="T">目标对象类型</typeparam>
     /// <param name="filePath">XML文件完整路径</param>
     /// <param name="xmlRootName">自定义XML根节点名称（可选）</param>
     /// <returns>反序列化后的对象</returns>
     public static T DeserializeFromFile<T>(string filePath, string xmlRootName = null)
     {
         if (string.IsNullOrWhiteSpace(filePath))
         {
             throw new ArgumentNullException(nameof(filePath), "文件路径不能为空");
         }
         if (!File.Exists(filePath))
         {
             throw new FileNotFoundException($"XML文件不存在: {filePath}");
         }

         try
         {
             using (StreamReader reader = new StreamReader(filePath))
             {
                 XmlSerializer serializer = CreateXmlSerializer(typeof(T), xmlRootName);
                 return (T)serializer.Deserialize(reader);
             }
         }
         catch (Exception ex)
         {
             throw new InvalidOperationException($"从文件反序列化对象失败: {filePath}", ex);
         }
     }

     /// <summary>
     /// 创建XmlSerializer实例，支持自定义根节点名称
     /// </summary>
     private static XmlSerializer CreateXmlSerializer(Type type, string xmlRootName)
     {
         if (string.IsNullOrWhiteSpace(xmlRootName))
         {
             return new XmlSerializer(type);
         }
         else
         {
             return new XmlSerializer(type, new XmlRootAttribute(xmlRootName));
         }
     }
 }