[ComVisible(false)]
 public class SynchronizedCollection<T> : IList<T>, ICollection<T>, IEnumerable<T>, IList, ICollection, IEnumerable
 {
 /// <summary>
 /// 初始化 <see cref="T:System.Collections.Generic.SynchronizedCollection`1"/> 類(lèi)的新實(shí)例。
 /// </summary>
 public SynchronizedCollection();
 /// <summary>
 /// 通過(guò)用于對(duì)線程安全集合的訪問(wèn)進(jìn)行同步的對(duì)象來(lái)初始化 <see cref="T:System.Collections.Generic.SynchronizedCollection`1"/> 類(lèi)的新實(shí)例。
 /// </summary>
 /// <param name="syncRoot">用于對(duì)線程安全集合的訪問(wèn)進(jìn)行同步的對(duì)象。</param><exception cref="T:System.ArgumentNullException"><paramref name="syncRoot"/> 為 null。</exception>
 public SynchronizedCollection(object syncRoot);
 /// <summary>
 /// 使用指定的可枚舉元素列表和用于對(duì)線程安全集合的訪問(wèn)進(jìn)行同步的對(duì)象來(lái)初始化 <see cref="T:System.Collections.Generic.SynchronizedCollection`1"/> 類(lèi)的新實(shí)例。
 /// </summary>
 /// <param name="syncRoot">用于對(duì)線程安全集合的訪問(wèn)進(jìn)行同步的對(duì)象。</param><param name="list">用于初始化線程安全集合的元素的 <see cref="T:System.Collections.Generic.IEnumerable`1"/> 集合。</param><exception cref="T:System.ArgumentNullException"><paramref name="syncRoot"/> 或 <paramref name="list"/> 為 null。</exception>
 public SynchronizedCollection(object syncRoot, IEnumerable<T> list);
 /// <summary>
 /// 使用指定的元素?cái)?shù)組和用于對(duì)線程安全集合的訪問(wèn)進(jìn)行同步的對(duì)象來(lái)初始化 <see cref="T:System.Collections.Generic.SynchronizedCollection`1"/> 類(lèi)的新實(shí)例。
 /// </summary>
 /// <param name="syncRoot">用于對(duì)線程安全集合的訪問(wèn)進(jìn)行同步的對(duì)象。</param><param name="list">用于初始化線程安全集合的 <paramref name="T"/> 類(lèi)型元素的 <see cref="T:System.Array"/>。</param><exception cref="T:System.ArgumentNullException"><paramref name="syncRoot"/> 或 <paramref name="list"/> 為 null。</exception>
 public SynchronizedCollection(object syncRoot, params T[] list);
 /// <summary>
 /// 將項(xiàng)添加到線程安全只讀集合中。
 /// </summary>
 /// <param name="item">要添加到集合的元素。</param><exception cref="T:System.ArgumentException">設(shè)置的值為 null，或者不是集合的正確泛型類(lèi)型 <paramref name="T"/>。</exception>
 public void Add(T item);
 /// <summary>
 /// 從集合中移除所有項(xiàng)。
 /// </summary>
 public void Clear();
 /// <summary>
 /// 從特定索引處開(kāi)始，將集合中的元素復(fù)制到指定的數(shù)組。
 /// </summary>
 /// <param name="array">從集合中復(fù)制的 <paramref name="T "/>類(lèi)型元素的目標(biāo) <see cref="T:System.Array"/>。</param><param name="index">復(fù)制開(kāi)始時(shí)所在的數(shù)組中的從零開(kāi)始的索引。</param>
 public void CopyTo(T[] array, int index);
 /// <summary>
 /// 確定集合是否包含具有特定值的元素。
 /// </summary>
 /// 
 /// <returns>
 /// 如果在集合中找到元素值，則為 true；否則為 false。
 /// </returns>
 /// <param name="item">要在集合中定位的對(duì)象。</param><exception cref="T:System.ArgumentException">設(shè)置的值為 null，或者不是集合的正確泛型類(lèi)型 <paramref name="T"/>。</exception>
 public bool Contains(T item);
 /// <summary>
 /// 返回一個(gè)循環(huán)訪問(wèn)同步集合的枚舉數(shù)。
 /// </summary>
 /// 
 /// <returns>
 /// 一個(gè) <see cref="T:System.Collections.Generic.IEnumerator`1"/>，用于訪問(wèn)集合中存儲(chǔ)的類(lèi)型的對(duì)象。
 /// </returns>
 public IEnumerator<T> GetEnumerator();
 /// <summary>
 /// 返回某個(gè)值在集合中的第一個(gè)匹配項(xiàng)的索引。
 /// </summary>
 /// 
 /// <returns>
 /// 該值在集合中的第一個(gè)匹配項(xiàng)的從零開(kāi)始的索引。
 /// </returns>
 /// <param name="item">從集合中移除所有項(xiàng)。</param><exception cref="T:System.ArgumentException">設(shè)置的值為 null，或者不是集合的正確泛型類(lèi)型 <paramref name="T"/>。</exception>
 public int IndexOf(T item);
 /// <summary>
 /// 將一項(xiàng)插入集合中的指定索引處。
 /// </summary>
 /// <param name="index">要從集合中檢索的元素的從零開(kāi)始的索引。</param><param name="item">要作為元素插入到集合中的對(duì)象。</param><exception cref="T:System.ArgumentOutOfRangeException">指定的 <paramref name="index"/> 小于零或大于集合中的項(xiàng)數(shù)。</exception><exception cref="T:System.ArgumentException">設(shè)置的值為 null，或者不是集合的正確泛型類(lèi)型 <paramref name="T"/>。</exception>
 public void Insert(int index, T item);
 /// <summary>
 /// 從集合中移除指定項(xiàng)的第一個(gè)匹配項(xiàng)。
 /// </summary>
 /// 
 /// <returns>
 /// 如果從集合中成功移除了項(xiàng)，則為 true；否則為 false。
 /// </returns>
 /// <param name="item">要從集合中移除的對(duì)象。</param>
 public bool Remove(T item);
 /// <summary>
 /// 從集合中移除指定索引處的項(xiàng)。
 /// </summary>
 /// <param name="index">要從集合中檢索的元素的從零開(kāi)始的索引。</param><exception cref="T:System.ArgumentOutOfRangeException">指定的 <paramref name="index"/> 小于零或大于集合中的項(xiàng)數(shù)。</exception>
 public void RemoveAt(int index);
 /// <summary>
 /// 從集合中移除所有項(xiàng)。
 /// </summary>
 protected virtual void ClearItems();
 /// <summary>
 /// 將一項(xiàng)插入集合中的指定索引處。
 /// </summary>
 /// <param name="index">集合中從零開(kāi)始的索引，在此處插入對(duì)象。</param><param name="item">要插入到集合中的對(duì)象。</param><exception cref="T:System.ArgumentOutOfRangeException">指定的 <paramref name="index"/> 小于零或大于集合中的項(xiàng)數(shù)。</exception><exception cref="T:System.ArgumentException">設(shè)置的值為 null，或者不是集合的正確泛型類(lèi)型 <paramref name="T"/>。</exception>
 protected virtual void InsertItem(int index, T item);
 /// <summary>
 /// 從集合中移除指定 <paramref name="index"/> 處的項(xiàng)。
 /// </summary>
 /// <param name="index">要從集合中檢索的元素的從零開(kāi)始的索引。</param><exception cref="T:System.ArgumentOutOfRangeException">指定的 <paramref name="index"/> 小于零或大于集合中的項(xiàng)數(shù)。</exception>
 protected virtual void RemoveItem(int index);
 /// <summary>
 /// 使用另一項(xiàng)替換指定索引處的項(xiàng)。
 /// </summary>
 /// <param name="index">要替換的對(duì)象的從零開(kāi)始的索引。</param><param name="item">要替換的對(duì)象。</param><exception cref="T:System.ArgumentOutOfRangeException">指定的 <paramref name="index"/> 小于零或大于集合中的項(xiàng)數(shù)。</exception>
 protected virtual void SetItem(int index, T item);
 /// <summary>
 /// 返回一個(gè)循環(huán)訪問(wèn)同步集合的枚舉數(shù)。
 /// </summary>
 /// 
 /// <returns>
 /// 一個(gè) <see cref="T:System.Collections.Generic.IEnumerator`1"/>，用于訪問(wèn)集合中存儲(chǔ)的類(lèi)型的對(duì)象。
 /// </returns>
 IEnumerator IEnumerable.GetEnumerator();
 /// <summary>
 /// 從特定索引處開(kāi)始，將集合中的元素復(fù)制到指定的數(shù)組。
 /// </summary>
 /// <param name="array">從集合中復(fù)制的 <paramref name="T"/> 類(lèi)型元素的目標(biāo) <see cref="T:System.Array"/>。</param><param name="index">復(fù)制開(kāi)始時(shí)所在的數(shù)組中的從零開(kāi)始的索引。</param>
 void ICollection.CopyTo(Array array, int index);
 /// <summary>
 /// 向集合中添加一個(gè)元素。
 /// </summary>
 /// 
 /// <returns>
 /// 新元素的插入位置。
 /// </returns>
 /// <param name="value">要添加到集合中的對(duì)象。</param>
 int IList.Add(object value);
 /// <summary>
 /// 確定集合是否包含具有特定值的元素。
 /// </summary>
 /// 
 /// <returns>
 /// 如果在集合中找到元素 <paramref name="value"/>，則為 true；否則為 false。
 /// </returns>
 /// <param name="value">要在集合中定位的對(duì)象。</param><exception cref="T:System.ArgumentException"><paramref name="value"/> 不是集合所含類(lèi)型的對(duì)象。</exception>
 bool IList.Contains(object value);
 /// <summary>
 /// 確定集合中某個(gè)元素的從零開(kāi)始的索引。
 /// </summary>
 /// 
 /// <returns>
 /// 如果在集合中找到，則為 <paramref name="value"/> 的索引；否則為 -1。
 /// </returns>
 /// <param name="value">集合中要確定其索引的元素。</param>
 int IList.IndexOf(object value);
 /// <summary>
 /// 將某個(gè)對(duì)象插入到集合中的指定索引處。
 /// </summary>
 /// <param name="index">從零開(kāi)始的索引，將在該位置插入 <paramref name="value"/>。</param><param name="value">要在集合中插入的對(duì)象。</param><exception cref="T:System.ArgumentOutOfRangeException">指定的 <paramref name="index"/> 小于零或大于集合中的項(xiàng)數(shù)。</exception><exception cref="T:System.ArgumentException">設(shè)置的 <paramref name="value"/> 為 null，或者不是集合的正確泛型類(lèi)型 <paramref name="T"/>。</exception>
 void IList.Insert(int index, object value);
 /// <summary>
 /// 從集合中移除作為元素的指定對(duì)象的第一個(gè)匹配項(xiàng)。
 /// </summary>
 /// <param name="value">要從集合中移除的對(duì)象。</param>
 void IList.Remove(object value);
 }

 [__DynamicallyInvokable]
 public class KeyedByTypeCollection<TItem> : KeyedCollection<Type, TItem>
 {
 /// <summary>
 /// 初始化 <see cref="T:System.Collections.Generic.KeyedByTypeCollection`1"/> 類(lèi)的新實(shí)例。
 /// </summary>
 public KeyedByTypeCollection();
 /// <summary>
 /// 根據(jù)指定的對(duì)象枚舉初始化 <see cref="T:System.Collections.Generic.KeyedByTypeCollection`1"/> 類(lèi)的新實(shí)例。
 /// </summary>
 /// <param name="items">泛型類(lèi)型 <see cref="T:System.Object"/> 的 <see cref="T:System.Collections.Generic.IEnumerable`1"/>，用于初始化集合。</param><exception cref="T:System.ArgumentNullException"><paramref name="items"/> 為 null。</exception>
 public KeyedByTypeCollection(IEnumerable<TItem> items);
 /// <summary>
 /// 返回集合中第一個(gè)具有指定類(lèi)型的項(xiàng)。
 /// </summary>
 /// 
 /// <returns>
 /// 如果為引用類(lèi)型，則返回類(lèi)型 <paramref name="T"/> 的對(duì)象；如果為值類(lèi)型，則返回類(lèi)型 <paramref name="T"/> 的值。 如果集合中不包含類(lèi)型 <paramref name="T"/> 的對(duì)象，則返回類(lèi)型的默認(rèn)值：如果是引用類(lèi)型，默認(rèn)值為 null；如果是值類(lèi)型，默認(rèn)值為 0。
 /// </returns>
 /// <typeparam name="T">要在集合中查找的項(xiàng)的類(lèi)型。</typeparam>
 [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
 public T Find<T>();
 /// <summary>
 /// 從集合中移除具有指定類(lèi)型的對(duì)象。
 /// </summary>
 /// 
 /// <returns>
 /// 從集合中移除的對(duì)象。
 /// </returns>
 /// <typeparam name="T">要從集合中移除的項(xiàng)的類(lèi)型。</typeparam>
 [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
 public T Remove<T>();
 /// <summary>
 /// 返回 <see cref="T:System.Collections.Generic.KeyedByTypeCollection`1"/> 中包含的類(lèi)型 <paramref name="T"/> 的對(duì)象的集合。
 /// </summary>
 /// 
 /// <returns>
 /// 一個(gè)類(lèi)型 <paramref name="T"/> 的 <see cref="T:System.Collections.ObjectModel.Collection`1"/>，包含來(lái)自原始集合的類(lèi)型 <paramref name="T"/> 的對(duì)象。
 /// </returns>
 /// <typeparam name="T">要在集合中查找的項(xiàng)的類(lèi)型。</typeparam>
 [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
 public Collection<T> FindAll<T>();
 /// <summary>
 /// 從集合中移除所有具有指定類(lèi)型的元素。
 /// </summary>
 /// 
 /// <returns>
 /// <see cref="T:System.Collections.ObjectModel.Collection`1"/>，包含來(lái)自原始集合的類(lèi)型 <paramref name="T"/> 的對(duì)象。
 /// </returns>
 /// <typeparam name="T">要從集合中移除的項(xiàng)的類(lèi)型。</typeparam>
 [TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
 public Collection<T> RemoveAll<T>();
 /// <summary>
 /// 獲取集合中包含的某個(gè)項(xiàng)的類(lèi)型。
 /// </summary>
 /// 
 /// <returns>
 /// 集合中指定的 <paramref name="item"/> 的類(lèi)型。
 /// </returns>
 /// <param name="item">集合中要檢索其類(lèi)型的項(xiàng)。</param><exception cref="T:System.ArgumentNullException"><paramref name="item"/> 為 null。</exception>
 [__DynamicallyInvokable]
 protected override Type GetKeyForItem(TItem item);
 /// <summary>
 /// 在集合中的特定位置插入一個(gè)元素。
 /// </summary>
 /// <param name="index">從零開(kāi)始的索引，應(yīng)在該位置插入 <paramref name="item"/>。</param><param name="item">要在集合中插入的對(duì)象。</param><exception cref="T:System.ArgumentNullException"><paramref name="item"/> 為 null。</exception>
 [__DynamicallyInvokable]
 protected override void InsertItem(int index, TItem item);
 /// <summary>
 /// 使用一個(gè)新對(duì)象替換指定索引處的項(xiàng)。
 /// </summary>
 /// <param name="index">要替換的 <paramref name="item"/> 的從零開(kāi)始的索引。</param><param name="item">要添加到集合中的對(duì)象。</param><exception cref="T:System.ArgumentNullException"><paramref name="item"/> 為 null。</exception>
 [__DynamicallyInvokable]
 protected override void SetItem(int index, TItem item);
 }

 [ComVisible(true)]
 [Guid("496B0ABE-CDEE-11d3-88E8-00902754C43A")]
 [__DynamicallyInvokable]
 public interface IEnumerable
 {
 /// <summary>
 /// 返回一個(gè)循環(huán)訪問(wèn)集合的枚舉數(shù)。
 /// </summary>
 /// 
 /// <returns>
 /// 一個(gè)可用于循環(huán)訪問(wèn)集合的 <see cref="T:System.Collections.IEnumerator"/> 對(duì)象。
 /// </returns>
 /// <filterpriority>2</filterpriority>
 [DispId(-4)]
 [__DynamicallyInvokable]
 IEnumerator GetEnumerator();
 }

 List<TOutput> ConverAll<TOutput>(Conver<T,TOutput> conv)

List<TOutput>：返回類(lèi)型（一個(gè)泛型列表）。

ConverAll：方法名。

<TOutput>：類(lèi)型參數(shù)。

Conver<T,TOutput>：參數(shù)類(lèi)型（泛型委托）。

conv：參數(shù)名。

 /// <summary>
 /// 封裝一個(gè)方法，該方法具有四個(gè)參數(shù)并且不返回值。
 /// </summary>
 /// <param name="arg1">此委托封裝的方法的第一個(gè)參數(shù)。</param><param name="arg2">此委托封裝的方法的第二個(gè)參數(shù)。</param><param name="arg3">此委托封裝的方法的第三個(gè)參數(shù)。</param><param name="arg4">此委托封裝的方法的第四個(gè)參數(shù)。</param><typeparam name="T1">此委托封裝的方法的第一個(gè)參數(shù)類(lèi)型。</typeparam><typeparam name="T2">此委托封裝的方法的第二個(gè)參數(shù)類(lèi)型。</typeparam><typeparam name="T3">此委托封裝的方法的第三個(gè)參數(shù)類(lèi)型。</typeparam><typeparam name="T4">此委托封裝的方法的第四個(gè)參數(shù)類(lèi)型。</typeparam><filterpriority>2</filterpriority>
 [TypeForwardedFrom("System.Core, Version=3.5.0.0, Culture=Neutral, PublicKeyToken=b77a5c561934e089")]
 [__DynamicallyInvokable]
 public delegate void Action<in T1, in T2, in T3, in T4>(T1 arg1, T2 arg2, T3 arg3, T4 arg4);

 /// <summary>
 /// 表示比較同一類(lèi)型的兩個(gè)對(duì)象的方法。
 /// </summary>
 /// 
 /// <returns>
 /// 一個(gè)有符號(hào)整數(shù)，指示 <paramref name="x"/> 與 <paramref name="y"/> 的相對(duì)值，如下表所示。 值 含義 小于 0 <paramref name="x"/> 小于 <paramref name="y"/>。 0 <paramref name="x"/> 等于 <paramref name="y"/>。 大于 0 <paramref name="x"/> 大于 <paramref name="y"/>。
 /// </returns>
 /// <param name="x">要比較的第一個(gè)對(duì)象。</param><param name="y">要比較的第二個(gè)對(duì)象。</param><typeparam name="T">要比較的對(duì)象的類(lèi)型。</typeparam><filterpriority>1</filterpriority>
 [__DynamicallyInvokable]
 public delegate int Comparison<in T>(T x, T y);

 /// <summary>
 /// 泛型方法：編譯器能夠根據(jù)傳入的方法參數(shù)推斷類(lèi)型參數(shù)；它無(wú)法僅從約束或返回值推斷類(lèi)型參數(shù)
 /// </summary>
 public class ObjectXmlSerializer
 {
 /// <summary>
 /// 文件的反序列化
 /// </summary>
 /// <typeparam name="T">返回值類(lèi)型</typeparam>
 /// <param name="fileName"></param>
 /// <returns>
 /// 如果日志啟用，則發(fā)生異常時(shí)，異常寫(xiě)入日志，若日志沒(méi)有開(kāi)啟，則直接拋出異常信息
 /// loggingEnabled==true: Null is returned if any error occurs.
 /// loggingEnabled==false: throw exception
 /// </returns>
 public static T LoadFromXml<T>(string fileName) where T : class
 {
  return LoadFromXml<T>(fileName, true);
 }
 /// <summary>
 /// 文件反序列化，若發(fā)生異常，異常信息寫(xiě)入日志
 /// </summary>
 /// <typeparam name="T">加載類(lèi)的類(lèi)型</typeparam>
 /// <param name="fileName">文件名字</param>
 /// <param name="loggingEnabled">啟用日志記錄</param>
 /// <returns></returns>
 public static T LoadFromXml<T>(string fileName, bool loggingEnabled) where T : class
 {
  FileStream fs = null;
  try
  {
  var serializer = new XmlSerializer(typeof(T));
  fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);
  //反序列化對(duì)象
  return (T)serializer.Deserialize(fs);
  }
  catch (Exception e)
  {
  if (loggingEnabled)
  {
   //文件異常，寫(xiě)入日志
   LogLoadFileException(fileName, e);
   return null;
  }
  else
  {
   throw new Exception(e.Message);
  }
  }
  finally
  {
  if (fs != null) fs.Close();
  }
 }
 /// <summary>
 /// 序列化一個(gè)對(duì)象到文件中.
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="fileName">文件名</param>
 /// <param name="data">待序列化的數(shù)據(jù)</param>
 /// <returns>
 /// 如果日志啟用，則發(fā)生異常時(shí)，異常寫(xiě)入日志，若日志沒(méi)有開(kāi)啟，則直接拋出異常信息
 /// loggingEnabled==true: log exception
 /// loggingEnabled==false: throw exception
 /// </returns>
 public static void SaveToXml<T>(string fileName, T data) where T : class
 {
  SaveToXml(fileName, data, true);
 }
 /// <summary>
 /// 文件反序列化，若發(fā)生異常，異常信息寫(xiě)入日志
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="fileName">文件名</param>
 /// <param name="data">發(fā)序列化對(duì)象</param>
 /// <param name="loggingEnabled">是否啟用日志</param>
 public static void SaveToXml<T>(string fileName, T data, bool loggingEnabled) where T : class
 {
  FileStream fs = null;
  try
  {
  var serializer = new XmlSerializer(typeof(T));
  fs = new FileStream(fileName, FileMode.Create, FileAccess.Write);
  //序列化對(duì)象
  serializer.Serialize(fs, data);
  }
  catch (Exception e)
  {
  if (loggingEnabled) LogSaveFileException(fileName, e);
  else
  {
   throw new Exception(e.Message);
  }
  }
  finally
  {
  if (fs != null) fs.Close();
  }
 }
 /// <summary>
 /// 序列化
 /// XML & Datacontract Serialize & Deserialize Helper
 /// </summary>
 /// <typeparam name="T">T指定必須為class類(lèi)型</typeparam>
 /// <param name="serialObject"></param>
 /// <returns></returns>
 public static string XmlSerializer<T>(T serialObject) where T : class
 {
  var ser = new XmlSerializer(typeof(T));
  //MemoryStream實(shí)現(xiàn)對(duì)內(nèi)存的讀寫(xiě)，而不是對(duì)持久性存儲(chǔ)器進(jìn)行讀寫(xiě)
  //MemoryStream封裝以無(wú)符號(hào)字節(jié)數(shù)組形式存儲(chǔ)的數(shù)據(jù)，該數(shù)組在創(chuàng)建MemoryStream對(duì)象時(shí)被初始化，
  //或者該數(shù)組可創(chuàng)建為空數(shù)組。可在內(nèi)存中直接訪問(wèn)這些封裝的數(shù)據(jù)。
  //內(nèi)存流可降低應(yīng)用程序中對(duì)臨時(shí)緩沖區(qū)和臨時(shí)文件的需要。
  var mem = new MemoryStream();
  var writer = new XmlTextWriter(mem, UTF8);
  ser.Serialize(writer, serialObject);
  writer.Close();
  return UTF8.GetString(mem.ToArray());
 }
 /// <summary>
 /// 反序列化
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="str"></param>
 /// <returns></returns>
 public static T XmlDeserialize<T>(string str) where T : class
 {
  var mySerializer = new XmlSerializer(typeof(T));
  var mem2 = new StreamReader(new MemoryStream(UTF8.GetBytes(str)), UTF8);
  return (T)mySerializer.Deserialize(mem2);
 }
 /// <summary>
 /// 
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="xmlData"></param>
 /// <returns>返回值類(lèi)型為傳入的類(lèi)型</returns>
 public static T DataContractDeserializer<T>(string xmlData) where T : class
 {
  var stream = new MemoryStream(UTF8.GetBytes(xmlData));
  var reader = XmlDictionaryReader.CreateTextReader(stream, new XmlDictionaryReaderQuotas());
  var ser = new DataContractSerializer(typeof(T));
  var deserializedPerson = (T)ser.ReadObject(reader, true);
  reader.Close();
  stream.Close();
  return deserializedPerson;
 }
 /// <summary>
 /// 
 /// </summary>
 /// <typeparam name="T"></typeparam>
 /// <param name="myObject"></param>
 /// <returns></returns>
 public static string DataContractSerializer<T>(T myObject) where T : class
 {
  var stream = new MemoryStream();
  var ser = new DataContractSerializer(typeof(T));
  ser.WriteObject(stream, myObject);
  stream.Close();
  return UTF8.GetString(stream.ToArray());
 }
 /// <summary>
 /// 序列化時(shí)異常日志
 /// </summary>
 /// <param name="fileName">文件名</param>
 /// <param name="ex">異常</param>
 [Conditional("TRACE")]
 private static void LogLoadFileException(string fileName, Exception ex)
 {
  var sb = new StringBuilder();
  sb.Append("Fail to load xml file: ");
  sb.Append(fileName + Environment.NewLine);
  sb.Append(ex);
  //寫(xiě)入日志記錄中方法
  // Logger.LogEvent(LogCategory, LogEventLoadFileException, sb.ToString());
 }
 /// <summary>
 /// 反序列化時(shí)異常日志
 /// </summary>
 /// <param name="fileName">文件名</param>
 /// <param name="ex">異常</param>
 [Conditional("TRACE")]
 private static void LogSaveFileException(string fileName, Exception ex)
 {
  var sb = new StringBuilder();
  sb.Append("Fail to save xml file: ");
  sb.Append(fileName + Environment.NewLine);
  sb.Append(ex);
 }
 /// <summary>
 /// 將xml字符串序列化為數(shù)據(jù)流（數(shù)據(jù)流編碼為ASCII,UTF8）
 /// </summary>
 /// <returns>字符串轉(zhuǎn)換到流</returns>
 public static MemoryStream StringXmlToStream(string strXml,Encoding encod)
 {
  MemoryStream memoryStream = null;
  try
  {
  Encoding encoding;
  if (Equals(encod, ASCII))
  {
   encoding = new ASCIIEncoding();
  }
  else
  {
   encoding = new UTF8Encoding(); 
  }
  var byteArray = encoding.GetBytes(strXml);
  memoryStream = new MemoryStream(byteArray);
  memoryStream.Seek(0, SeekOrigin.Begin);
  return memoryStream;
  }
  catch (IOException ex)
  {
  throw new IOException(ex.Message);
  }
  finally
  {
  if (memoryStream != null) memoryStream.Close();
  }
 }
 }