C# Xml与Model互转

public class XmlHelp
    {
        public class SerializerUtility<T>
        {
            private static object _obj = new object();

            public void SetExtraType(Type[] extraTypes)
            {
                _extraTypes = extraTypes;
            }

            private Type[] _extraTypes = null;

            /// <summary>
            /// Xml文件转实体
            /// </summary>
            /// <param name="fileName">文件名</param>
            /// <returns></returns>
            public T XMLToModel(string fileName)
            {
                lock (_obj)
                {
                    XmlSerializer xml;
                    if (_extraTypes == null)
                    {
                        xml = new XmlSerializer(typeof(T));
                    }
                    else
                    {
                        xml = new XmlSerializer(typeof(T), _extraTypes);
                    }
                    //对于文件的操作，有不可控制的异常，所以一定要捕获异常
                    try
                    {
                        if (string.IsNullOrEmpty(fileName) || !File.Exists(fileName))
                        {
                            return default(T);
                        }
                        //使用using在结束的时候关闭FileStream
                        //也可以使用Close()方法关闭
                        using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite))
                        {
                            //注意编码方式，如果不是中文环境，对中文会出现乱码
                            using (StreamReader sr = new StreamReader(fs, Encoding.UTF8))
                            {
                                object obj = xml.Deserialize(sr);
                                return (T)obj;
                            }
                        }
                    }
                    catch (Exception ex)
                    {
                        //记录日志
                        return default(T);
                    }
                }
            }
            /// <summary>
            /// 实体保存到xml文件
            /// </summary>
            /// <param name="cInfo"></param>
            /// <param name="fileName"></param>
            /// <returns></returns>
            public bool ModelToXml(T cInfo, string fileName)
            {
                lock (_obj)
                {
                    XmlSerializer xml;
                    if (_extraTypes == null)
                    {
                        xml = new XmlSerializer(typeof(T));
                    }
                    else
                    {
                        xml = new XmlSerializer(typeof(T), _extraTypes);
                    }
                    //对于文件的操作，有不可控制的异常，所以一定要捕获异常
                    try
                    {
                        if (string.IsNullOrEmpty(fileName)) return false;
                        //注意编码方式，如果不是中文环境，对中文会出现乱码
                        using (StreamWriter sw = new StreamWriter(fileName, false, Encoding.UTF8))
                        {
                            //将命名控件设置为空
                            XmlSerializerNamespaces xmlns = new XmlSerializerNamespaces();
                            xmlns.Add(String.Empty, String.Empty);

                            xml.Serialize(sw, cInfo, xmlns);
                        }
                        return true;
                    }
                    catch (Exception e)
                    {
                        //记录日志
                        return false;
                    }
                }
            }
            /// <summary>
            /// 实体转xml-实体与xml定义一致
            /// </summary>
            /// <param name="msgInfo"></param>
            /// <returns></returns>
            public string ConvertXml(T msgInfo)
            {
                try
                {
                    XmlSerializer mySerializer = new XmlSerializer(typeof(T));
                    StringBuilder sb = new StringBuilder(4 * 1024);
                    XmlSerializerNamespaces namespaces = new XmlSerializerNamespaces();
                    namespaces.Add(string.Empty, string.Empty);
                    XmlWriterSettings settings = new XmlWriterSettings();
                    settings.Encoding = Encoding.UTF8;
                    settings.OmitXmlDeclaration = false;
                    using (XmlWriter myWriter = XmlWriter.Create(sb, settings))
                    {
                        mySerializer.Serialize(myWriter, msgInfo, namespaces);
                    }
                    return sb.ToString();
                }
                catch (System.Exception ex)
                {
                    //记录日志
                    return null;
                }
            }

            /// <summary>
            /// 将xml字符串反序列化为实例-实体与xml定义不一致
            /// </summary>
            /// <param name="xml"></param>
            /// <param name="t"></param>
            /// <returns></returns>
            public  void SetInstanceValueByXMLString(string xml, T model)
            {
                try
                {
                    PropertyInfo[] fields = model.GetType().GetProperties();
                    foreach (PropertyInfo field in fields)
                    {
                        string regexText = string.Format(@"<{0}>([\s\S]*)</{0}>", field.Name);
                        Regex reg = new Regex(regexText);
                        Match match = reg.Match(xml);
                        if (match.Success)
                        {
                            string val = match.Value.Replace("<" + field.Name + ">", "").Replace("</" + field.Name + ">", "");
                            field.SetValue(model, val, null);
                        }
                    }
                }
                catch (Exception ex)
                {
                    //记录日志
                    throw ex;
                }
            }
            /// <summary>
            /// xml字符串转实体
            /// </summary>
            /// <param name="message"></param>
            /// <returns></returns>
            public T ConvertModel(string message)
            {
                try
                {
                    XmlSerializer serializer = new XmlSerializer(typeof(T));
                    using (XmlReader reader = new XmlTextReader(new StringReader(message)))
                    {
                        object obj = serializer.Deserialize(reader);
                        return (T)obj;
                    }

                }
                catch (System.Exception ex)
                {
                    //记录日志
                    return default(T);
                }
            }            

        }
    }