c#序列化详解示例

    // The value of this field is set and reset during and
    // after serialization.
    private string member2;

    // This field is not serialized. The OnDeserializedAttribute
    // is used to set the member value after serialization.
    [NonSerialized()]
    public string member3;

    // This field is set to null, but populated after deserialization.
    private string member4;

    // Constructor for the class.
    public TestSimpleObject()
    {
  member1 = 11;
  member2 = "Hello World!";
  member3 = "This is a nonserialized value";
  member4 = null;
    }

    public void Print()
    {
  Console.WriteLine("member1 = '{0}'", member1);
  Console.WriteLine("member2 = '{0}'", member2);
  Console.WriteLine("member3 = '{0}'", member3);
  Console.WriteLine("member4 = '{0}'", member4);
    }

    [OnSerializing()]
    internal void OnSerializingMethod(StreamingContext context)
    {
  member2 = "This value went into the data file during serialization.";
    }

    [OnSerialized()]
    internal void OnSerializedMethod(StreamingContext context)
    {
  member2 = "This value was reset after serialization.";
    }

    [OnDeserializing()]
    internal void OnDeserializingMethod(StreamingContext context)
    {
  member3 = "This value was set during deserialization";
    }

    [OnDeserialized()]
    internal void OnDeserializedMethod(StreamingContext context)
    {
  member4 = "This value was set after deserialization.";
    }   
}

  public MyObject()
  {
  }

  protected MyObject(SerializationInfo info, StreamingContext context)
  {
    n1 = info.GetInt32("i");
    n2 = info.GetInt32("j");
    str = info.GetString("k");
  }
[SecurityPermissionAttribute(SecurityAction.Demand,SerializationFormatter
=true)]
  public virtual void GetObjectData(SerializationInfo info, StreamingContext context)
  {
    info.AddValue("i", n1);
    info.AddValue("j", n2);
    info.AddValue("k", str);
  }
}

    // You must apply a DataContractAttribute or SerializableAttribute
    // to a class to have it serialized by the DataContractSerializer.
    [DataContract(Name = "Customer", Namespace = "http://www.contoso.com")]
    class Person : IExtensibleDataObject
    {
  [DataMember()]
  public string FirstName;
  [DataMember]
  public string LastName;
  [DataMember()]
  public int ID;

  public Person(string newfName, string newLName, int newID)
  {
FirstName = newfName;
LastName = newLName;
ID = newID;
  }

  private ExtensionDataObject extensionData_Value;

  public ExtensionDataObject ExtensionData
  {
get
{
    return extensionData_Value;
}
set
{
    extensionData_Value = value;
}
  }
    }

    public sealed class Test
    {
  private Test() { }

  public static void Main()
  {
try
{
    WriteObject("DataContractSerializerExample.xml");
    ReadObject("DataContractSerializerExample.xml");

}

catch (SerializationException serExc)
{
    Console.WriteLine("Serialization Failed");
    Console.WriteLine(serExc.Message);
}
catch (Exception exc)
{
    Console.WriteLine(
    "The serialization operation failed: {0} StackTrace: {1}",
    exc.Message, exc.StackTrace);
}

finally
{
    Console.WriteLine("Press <Enter> to exit....");
    Console.ReadLine();
}
  }

  public static void WriteObject(string fileName)
  {
Console.WriteLine(
    "Creating a Person object and serializing it.");
Person p1 = new Person("Zighetti", "Barbara", 101);
FileStream writer = new FileStream(fileName, FileMode.Create);
DataContractSerializer ser =
    new DataContractSerializer(typeof(Person));
ser.WriteObject(writer, p1);
writer.Close();
  }

  public static void ReadObject(string fileName)
  {
Console.WriteLine("Deserializing an instance of the object.");
FileStream fs = new FileStream(fileName,
FileMode.Open);
XmlDictionaryReader reader =
    XmlDictionaryReader.CreateTextReader(fs, new XmlDictionaryReaderQuotas());
DataContractSerializer ser = new DataContractSerializer(typeof(Person));

// Deserialize the data and read it from the instance.
Person deserializedPerson =
    (Person)ser.ReadObject(reader, true);
reader.Close();
fs.Close();
Console.WriteLine(String.Format("{0} {1}, ID: {2}",
deserializedPerson.FirstName, deserializedPerson.LastName,
deserializedPerson.ID));
  }
    }

namespace SerializerSample
{
    /// <summary>
    /// 序列化帮助类
    /// </summary>
    public sealed class SerializeHelper
    {
  #region DataContract序列化
  /// <summary>
  /// DataContract序列化
  /// </summary>
  /// <param name="value"></param>
  /// <param name="knownTypes"></param>
  /// <returns></returns>
  public static string SerializeDataContract(object value, List<Type> knownTypes = null)
  {
DataContractSerializer dataContractSerializer = new DataContractSerializer(value.GetType(), knownTypes);

using (MemoryStream ms = new MemoryStream())
{
    dataContractSerializer.WriteObject(ms, value);
    ms.Seek(0, SeekOrigin.Begin);
    using (StreamReader sr = new StreamReader(ms))
    {
  return sr.ReadToEnd();
    }
}
  }
  /// <summary>
  /// DataContract反序列化
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="xml"></param>
  /// <returns></returns>
  public static T DeserializeDataContract<T>(string xml)
  {
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(xml)))
{
    DataContractSerializer serializer = new DataContractSerializer(typeof(T));
    return (T)serializer.ReadObject(ms);
}
  }
  #endregion

  #region DataContractJson序列化
  /// <summary>
  ///  DataContractJson序列化
  /// </summary>
  /// <param name="value"></param>
  /// <returns></returns>
  public static string SerializeDataContractJson(object value)
  {
DataContractJsonSerializer dataContractSerializer = new DataContractJsonSerializer(value.GetType());
using (MemoryStream ms = new MemoryStream())
{   
    dataContractSerializer.WriteObject(ms, value);
    return Encoding.UTF8.GetString(ms.ToArray());
}
  }
  /// <summary>
  ///  DataContractJson反序列化
  /// </summary>
  /// <param name="type"></param>
  /// <param name="str"></param>
  /// <returns></returns>
  public static object DeserializeDataContractJson(Type type, string str)
  {
DataContractJsonSerializer dataContractSerializer = new DataContractJsonSerializer(type);
using (MemoryStream ms = new MemoryStream(System.Text.Encoding.UTF8.GetBytes(str)))
{
    return dataContractSerializer.ReadObject(ms);
}
  }
  /// <summary>
  /// DataContractJson反序列化
  /// </summary>
  /// <typeparam name="T"></typeparam>
  /// <param name="json"></param>
  /// <returns></returns>
  public T DeserializeDataContractJson<T>(string json)
  {
DataContractJsonSerializer dataContractSerializer = new DataContractJsonSerializer(typeof(T));
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(json)))
{
    return (T)dataContractSerializer.ReadObject(ms);
}
  }
  #endregion

  #region XmlSerializer序列化
  /// <summary>
  /// 将对象序列化到 XML 文档中和从 XML 文档中反序列化对象。XmlSerializer 使您得以控制如何将对象编码到 XML 中。
  /// </summary>
  /// <param name="value"></param>
  /// <returns></returns>
  public static string SerializeXml(object value)
  {
XmlSerializer serializer = new XmlSerializer(value.GetType());
using (MemoryStream ms = new MemoryStream())
{
    serializer.Serialize(ms, value);
    ms.Seek(0, SeekOrigin.Begin);
    using (StreamReader sr = new StreamReader(ms))
    {
  return sr.ReadToEnd();
    }
}
  }
  /// <summary>
  ///  XmlSerializer反序列化
  /// </summary>
  /// <param name="type"></param>
  /// <param name="str"></param>
  /// <returns></returns>
  public static object DeserializeXml(Type type, string str)
  {
XmlSerializer serializer = new XmlSerializer(type);
byte[] bytes = System.Text.Encoding.UTF8.GetBytes(str);
using (MemoryStream ms = new MemoryStream(bytes))
{
    return serializer.Deserialize(ms);
}
  }
  #endregion

  #region BinaryFormatter序列化
  /// <summary>
  /// BinaryFormatter序列化
  /// 必须类型必须标记为Serializable
  /// </summary>
  /// <param name="obj"></param>
  /// <returns></returns>
  public static string SerializeBinaryFormatter(object obj)
  {
BinaryFormatter formatter = new BinaryFormatter();
using (MemoryStream ms = new MemoryStream())
{
    formatter.Serialize(ms,obj);
    byte[] bytes = ms.ToArray();
    obj = formatter.Deserialize(new MemoryStream(bytes));
    //如果是UTF8格式，则反序列化报错。可以用Default格式，不过，建议还是传参为byte数组比较好
    return Encoding.Default.GetString(bytes);
}
  }

  /// <summary>
  /// BinaryFormatter反序列化
  /// 必须类型必须标记为Serializable
  /// </summary>
  /// <param name="serializedStr"></param>
  /// <returns></returns>
  public static T DeserializeBinaryFormatter<T>(string serializedStr)
  {
BinaryFormatter formatter = new BinaryFormatter();
byte[] bytes = Encoding.Default.GetBytes(serializedStr);
using (MemoryStream ms = new MemoryStream(bytes))
{
    return (T)formatter.Deserialize(ms);
}
  }
  #endregion

  #region SoapFormatter序列化
  /// <summary>
  /// SoapFormatter序列化
  /// 必须类型必须标记为Serializable
  /// </summary>
  /// <param name="obj"></param>
  /// <returns></returns>
  public static string SerializeSoapFormatter(object obj)
  {
SoapFormatter formatter = new SoapFormatter();
using (MemoryStream ms = new MemoryStream())
{
    formatter.Serialize(ms, obj);
    byte[] bytes = ms.ToArray();
    return Encoding.UTF8.GetString(bytes);
}
  }
  /// <summary>
  /// SoapFormatter反序列化
  /// 必须类型必须标记为Serializable
  /// </summary>
  /// <param name="serializedStr"></param>
  /// <returns></returns>
  public static T DeserializeSoapFormatter<T>(string serializedStr)
  {
SoapFormatter formatter = new SoapFormatter();
using (MemoryStream ms = new MemoryStream(Encoding.UTF8.GetBytes(serializedStr)))
{
    return (T)formatter.Deserialize(ms);
}
  }
  #endregion
    }
}