C# 序列化xml数据到class

public static class XmlClassData

    {

        /// <summary> 从XML读取数据 </summary>

        /// <typeparam name="C"> 读取的数据类型 </typeparam>

        /// <param name="fileInfo"> 包含数据的文件 FileInfo 信息 </param>

        /// <returns> 返回为 null 的时候读取失败 </returns>

        public static C ReadDataFromXml<C>(this FileInfo fileInfo) where C : class

        {

            return ReadDataFromXml<C>(fileInfo.FullName);

        }

        /// <summary> 从XML读取数据 </summary>

        /// <typeparam name="C"> 读取的数据类型 </typeparam>

        /// /// <param name="FullPath"> 包含数据的文件路径</param>

        /// <returns> Tpye = C ， 返回为null的时候读取失败 </returns>

        public static C ReadDataFromXml<C>(this string FullPath) where C : class

        {

            return XmlAction.Read(FullPath, typeof(C)) as C;

        }

        /// <summary> 从XML读取数据 </summary>

        /// <typeparam name="C">  读取的数据类型 </typeparam>

        /// <param name="stream">包含数据的数据流 </param>

        /// <returns> Tpye = C ， 返回为null的时候读取失败 </returns>

        public static C ReadDataFromXml<C>(this Stream stream) where C : class

        {

            return XmlAction.Read(stream, typeof(C)) as C;

        }

        /// <summary> 写入数据到 XML </summary>

        /// <typeparam name="C"> 读取的数据类型 </typeparam>

        /// <param name="obj"> 将要写入的数据</param>

        /// <param name="fullpath"> 写 =入的文件路径 </param>

        /// <returns> 返回为 null 的时候写入成功 </returns>

        public static string WriteDataToXml<C>(this C obj, string fullpath) where C : class

        {

            try

            {

                XmlAction.Save(obj, fullpath);

                return null;

            }

            catch (Exception ex)

            {

                return ex.Message;

            }

        }

        public static Stream WriteDataToStream<C>(this C obj) where C : class

        {

            try

            {

                

                return XmlAction.SaveStream(obj);

            }

            catch

            {

            }

            return null;

        }

    }

    /// <summary> struct 类型进行读取时，不确保一定成功 如果读取不成功会返回 default(S) </summary>

    public static class XmlStructData

    {

        /// <summary> 从XML读取数据 </summary>

        /// <typeparam name="S"> 读取的数据类型 </typeparam>

        /// <param name="fileInfo"> 包含数据的文件 FileInfo 信息 </param>

        /// <returns> 返回为默认值的时候读取失败 </returns>

        public static S ReadStructFromXml<S>(this FileInfo fileInfo) where S : struct

        {

            return ReadStructFromXml<S>(fileInfo.FullName);

        }

        /// <summary> 从XML读取数据 </summary>

        /// <typeparam name="S"> 读取的数据类型 </typeparam>

        /// <param name="fileInfo"> 包含数据的文件 FileInfo 信息 </param>

        /// <returns> 返回为默认值的时候读取失败 </returns>

        public static S ReadStructFromXml<S>(this string FullPath) where S : struct

        {

            var data = XmlAction.Read(FullPath, typeof(S));

            return data != null ? (S)data : default(S);

        }

        /// <summary> 从XML读取数据 ，返回为默认值的时候读取失败 </summary>

        /// <typeparam name="S"> 读取的数据类型 </typeparam> 

        /// <param name="FullPath"> 读取的路径 </param>

        /// <returns> 返回为默认值的时候读取失败 </returns>

        public static S ReadStructFromXml<S>(this Stream stream) where S : struct

        {

            var data = XmlAction.Read(stream, typeof(S));

            return data != null ? (S)data : default(S);

        }

        /// <summary> 写入数据到XML </summary>

        /// <typeparam name="S"> 写入的数据类型 </typeparam> 

        /// <param name="obj"></param>

        /// <param name="fullpath"> 写入的路径 </param>

        /// <returns> 返回为 null 的时候写入成功 </returns>

        public static string WriteStructToXml<S>(this S obj, string fullpath) where S : struct

        {

            try

            {

                XmlAction.Save(obj, fullpath);

                return null;

            }

            catch (Exception ex)

            {

                return ex.Message;

            }

        }

    }

    /// <summary> 封装对与Xml读写操作的类 </summary>

    internal static class XmlAction

    {

        internal static void Save(object obj, string filePath)

        {

            Save(obj, filePath, obj.GetType());

        }

        internal static void Save(object obj, string filePath, System.Type type)

        {

            try

            {

                using (StreamWriter writer = new StreamWriter(filePath))

                {

                    var xs = new XmlSerializer(type);

                    xs.Serialize(writer, obj);

                    writer.Close();

                }

            }

            catch { }

        }

        internal static Stream SaveStream(object obj)

        {

            MemoryStream stream = new MemoryStream();

            StreamWriter writer = new StreamWriter(stream);

            var xs = new XmlSerializer(obj.GetType());

            xs.Serialize(writer, obj);

            writer.Close();

            return stream as Stream;

        }

        internal static object Read(string filePath, System.Type type)

        {

            if (!System.IO.File.Exists(filePath))

            {

                return null;

            }

            try

            {

                using (StreamReader reader = new StreamReader(filePath))

                {

                    var xs = new XmlSerializer(type);

                    object obj = xs.Deserialize(reader);

                    reader.Close();

                    return obj;

                }

            }

            catch { }

            return null;

        }

        internal static object Read(Stream stream, System.Type type)

        {

            if (stream == null || stream.Length == 0)

            {

                return null;

            }

            try

            {

                var xs = new XmlSerializer(type);

                object obj = xs.Deserialize(stream);

                return obj;

            }

            catch { }

            return null;

        }

    }