c#正反序列化XML文件示例(xml序列化)

namespaceGlobalTimes.Framework
{
   ///<summary>
   ///XML文本通用解释器
   ///</summary>
   publicclassXmlHelper
   {
       privateconststringEncodePattern="<[^>]+?encoding=\"(?<enc>[^<>\\s]+)\"[^>]*?>";
       privatestaticreadonlyEncodingDefEncoding=Encoding.GetEncoding("gb2312");
       privatestaticreadonlyRegexRegRoot=newRegex("<(\\w+?)[>]",RegexOptions.Compiled);
       privatestaticreadonlyRegexRegEncode=newRegex(EncodePattern,
                                                           RegexOptions.Compiled|RegexOptions.IgnoreCase);
       privatestaticreadonlyDictionary<string,XmlSerializer>Parsers=newDictionary<string,XmlSerializer>();
       #region解析器

       staticEncodingGetEncoding(stringinput)
       {
           varmatch=RegEncode.Match(input);
           if(match.Success)
           {
               try
               {
                   returnEncoding.GetEncoding(match.Result("${enc}"));
               }
//ReSharperdisableEmptyGeneralCatchClause
               catch(Exception)
//ReSharperrestoreEmptyGeneralCatchClause
               {
               }
           }
           returnDefEncoding;
       }

       ///<summary>
       ///解析XML文件
       ///</summary>
       ///<typeparamname="T">类型</typeparam>
       ///<paramname="fileName">文件名</param>
       ///<returns>类的实例</returns>
       publicTParseFile<T>(stringfileName)whereT:class,new()
       {
           varinfo=newFileInfo(fileName);
           if(!info.Extension.Equals(".xml",StringComparison.CurrentCultureIgnoreCase)||!info.Exists)
           {
               thrownewArgumentException("输入的文件名有误！");
           }
           stringbody;
           vartempFileName=PathHelper.PathOf("temp",Guid.NewGuid().ToString().Replace("-","")+".xml");
           varfi=newFileInfo(tempFileName);
           vardi=fi.Directory;
           if(di!=null&&!di.Exists)
           {
               di.Create();
           }
           File.Copy(fileName,tempFileName);
           using(Streamstream=File.Open(tempFileName,FileMode.Open,FileAccess.Read))
           {
               using(TextReaderreader=newStreamReader(stream,DefEncoding))
               {
                   body=reader.ReadToEnd();
               }
           }
           File.Delete(tempFileName);
           varenc=GetEncoding(body);
           if(!Equals(enc,DefEncoding))
           {
               vardata=DefEncoding.GetBytes(body);
               vardest=Encoding.Convert(DefEncoding,enc,data);
               body=enc.GetString(dest);
           }
           returnParse<T>(body,enc);
       }

       ///<summary>
       ///将对象序列化为XML文件
       ///</summary>
       ///<paramname="fileName">文件名</param>
       ///<paramname="obj">对象</param>
       ///<returns></returns>
       ///<exceptioncref="ArgumentException">文件名错误异常</exception>
       publicboolSaveFile(stringfileName,objectobj)
       {
           returnSaveFile(fileName,obj,DefEncoding);
       }

       ///<summary>
       ///将对象序列化为XML文件
       ///</summary>
       ///<paramname="fileName">文件名</param>
       ///<paramname="obj">对象</param>
       ///<paramname="encoding"></param>
       ///<returns></returns>
       ///<exceptioncref="ArgumentException">文件名错误异常</exception>
       publicboolSaveFile(stringfileName,objectobj,Encodingencoding)
       {
           varinfo=newFileInfo(fileName);
           if(!info.Extension.Equals(".xml",StringComparison.CurrentCultureIgnoreCase))
           {
               thrownewArgumentException("输入的文件名有误！");
           }
           if(obj==null)returnfalse;
           vartype=obj.GetType();
           varserializer=GetSerializer(type);

           using(Streamstream=File.Open(fileName,FileMode.Create,FileAccess.Write))
           {
               using(TextWriterwriter=newStreamWriter(stream,encoding))
               {
                   serializer.Serialize(writer,obj);
               }
           }
           returntrue;
       }
       staticXmlSerializerGetSerializer(Typetype)
       {
           varkey=type.FullName;
           XmlSerializerserializer;
           varincl=Parsers.TryGetValue(key,outserializer);
           if(!incl||serializer==null)
           {
               varrootAttrs=newXmlAttributes{XmlRoot=newXmlRootAttribute(type.Name)};
               varattrOvrs=newXmlAttributeOverrides();
               attrOvrs.Add(type,rootAttrs);
               try
               {
                   serializer=newXmlSerializer(type,attrOvrs);
               }
               catch(Exceptione)
               {
                   thrownewException("类型声明错误！"+e);
               }
               Parsers[key]=serializer;
           }
           returnserializer;
       }
       ///<summary>
       ///解析文本
       ///</summary>
       ///<typeparamname="T">需要解析的类</typeparam>
       ///<paramname="body">待解析文本</param>
       ///<returns>类的实例</returns>
       publicTParse<T>(stringbody)whereT:class,new()
       {
           varencoding=GetEncoding(body);
           returnParse<T>(body,encoding);
       }

       ///<summary>
       ///解析文本
       ///</summary>
       ///<typeparamname="T">需要解析的类</typeparam>
       ///<paramname="body">待解析文本</param>
       ///<paramname="encoding"></param>
       ///<returns>类的实例</returns>
       publicTParse<T>(stringbody,Encodingencoding)whereT:class,new()
       {
           vartype=typeof(T);
           varrootTagName=GetRootElement(body);

           varkey=type.FullName;
           if(!key.Contains(rootTagName))
           {
               thrownewArgumentException("输入文本有误！key:"+key+"\t\troot:"+rootTagName);
           }

           varserializer=GetSerializer(type);
           objectobj;
           using(Streamstream=newMemoryStream(encoding.GetBytes(body)))
           {
               obj=serializer.Deserialize(stream);
           }
           if(obj==null)returnnull;
           try
           {
               varrsp=(T)obj;
               returnrsp;
           }
           catch(InvalidCastException)
           {
               varrsp=newT();
               varpisr=typeof(T).GetProperties();
               varpiso=obj.GetType().GetProperties();
               foreach(varinfoinpisr)
               {
                   varinfo1=info;
                   foreach(varvalueinfrompropertyInfoinpisowhereinfo1.Name.Equals(propertyInfo.Name)selectpropertyInfo.GetValue(obj,null))
                   {
                       info.SetValue(rsp,value,null);
                       break;
                   }
               }
               returnrsp;
           }
       }

       privatestaticXmlSerializerBuildSerializer(Typetype)
       {
           varrootAttrs=newXmlAttributes{XmlRoot=newXmlRootAttribute(type.Name)};
           varattrOvrs=newXmlAttributeOverrides();
           attrOvrs.Add(type,rootAttrs);
           try
           {
               returnnewXmlSerializer(type,attrOvrs);
           }
           catch(Exceptione)
           {
               thrownewException("类型声明错误！"+e);
           }
       }

       ///<summary>
       ///解析未知类型的XML内容
       ///</summary>
       ///<paramname="body">Xml文本</param>
       ///<paramname="encoding">字符编码</param>
       ///<returns></returns>
       publicobjectParseUnknown(stringbody,Encodingencoding)
       {
           varrootTagName=GetRootElement(body);
           vararray=AppDomain.CurrentDomain.GetAssemblies();
           Typetype=null;
           foreach(varassemblyinarray)
           {
               type=assembly.GetType(rootTagName,false,true);
               if(type!=null)break;
           }
           if(type==null)
           {
               Logger.GetInstance().Warn("加载{0}XML类型失败！",rootTagName);
               returnnull;
           }
           varserializer=GetSerializer(type);
           objectobj;
           using(Streamstream=newMemoryStream(encoding.GetBytes(body)))
           {
               obj=serializer.Deserialize(stream);
           }

           varrsp=obj;
           returnrsp;
       }
       ///<summary>
       ///用XML序列化对象
       ///</summary>
       ///<paramname="obj"></param>
       ///<returns></returns>
       publicstringSerialize(objectobj)
       {
           if(obj==null)returnstring.Empty;
           vartype=obj.GetType();
           varserializer=GetSerializer(type);
           varbuilder=newStringBuilder();
           using(TextWriterwriter=newStringWriter(builder))
           {
               serializer.Serialize(writer,obj);
           }
           returnbuilder.ToString();
       }
       #endregion

       ///<summary>
       ///获取XML响应的根节点名称
       ///</summary>
       privatestaticstringGetRootElement(stringbody)
       {
           varmatch=RegRoot.Match(body);
           if(match.Success)
           {
               returnmatch.Groups[1].ToString();
           }
           thrownewException("InvalidXMLformat!");
       }

   }
}