c#序列化詳解示例。本站提示廣大學習愛好者：（c#序列化詳解示例）文章只能為提供參考，不一定能成為您想要的結果。以下是c#序列化詳解示例正文
幾種序列化技巧：
1）二進制序列化堅持類型保真度，這關於在運用法式的分歧挪用之間保存對象的狀況很有效。例如，經由過程將對象序列化到剪貼板，可在分歧的運用法式之間同享對象。您可以將對象序列化到流、磁盤、內存和收集等等。長途處置應用序列化“經由過程值”在盤算機或運用法式域之間傳遞對象。
2）XML 序列化僅序列化公共屬性和字段，且不堅持類型保真度。當您要供給或應用數據而不限制應用該數據的運用法式時，這一點是很有效的。因為 XML 是一個開放式尺度，是以，關於經由過程 Web 同享數據而言，這是一個很好的選擇。SOAP 異樣是一個開放式尺度，這使它同樣成為一個頗具吸引力的選擇。
3）應用供給的數據協議，將類型實例序列化和反序列化為 XML 流或文檔（或許JSON格局）。常運用於WCF通訊。
BinaryFormatter
序列化可被界說為將對象的狀況存儲到存儲序言中的進程。在此進程中，對象的公共字段和公有字段和類的稱號（包含包括該類的法式集）都被轉換為字撙節，然後寫入數據流。在今後反序列化該對象時，創立原始對象的准確復本。
1、使一個類可序列化的最簡略方法是按以下所示應用 Serializable 屬性標志。
2、有選擇的序列化
經由過程用 NonSerialized 屬性標志成員變量，可以避免它們被序列化
3、自界說序列化
1) 在序列化時代和以後運轉自界說辦法
最好做法也是最簡略的辦法（在 .Net Framework 2.0 版中引入），就是在序列化時代和以後將以下屬性運用於用於更負數據的辦法：
OnDeserializedAttribute
OnDeserializingAttribute
OnSerializedAttribute
OnSerializingAttribute
詳細事例以下：
// This is the object that will be serialized and deserialized.
[Serializable()]
public class TestSimpleObject
{
// This member is serialized and deserialized with no change.
public int member1;
// 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.";
}
}
2) 完成 ISerializable 接口
關於用 Serializable 屬性標志且在類級別上或其結構函數上具有聲明性或敕令性平安的類，不該應用默許序列化。相反，這些類應一直完成 ISerializable 接口。完成 ISerializable 觸及完成 GetObjectData 辦法和在反序列化對象時應用的特別結構函數。
詳細實例以下：
[Serializable]
public class MyObject : ISerializable
{
public int n1;
public int n2;
public String str;
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);
}
}
留意：
在反序列化一個對象時不挪用結構函數。出於機能方面的緣由對反序列化施加了該束縛。然則，這違背了運轉庫與對象編寫器之間的一些平日商定，開辟人員應確保他們在將對象標志為可序列化時懂得厥後果。
SoapFormatter
以 SOAP 格局將對象或全部銜接對象的圖形序列化和反序列化。根本用法相似於BinaryFormatter。SoapFormatter 和 BinaryFormatter 兩個類完成 IRemotingFormatter 接口以支撐長途進程挪用 (RPC)，完成 IFormatter 接口（由 IRemotingFormatter 繼續）以支撐對象圖形的序列化。SoapFormatter 類還支撐對 ISoapMessage 對象停止 RPC，而不用應用 IRemotingFormatter 功效。
XmlSerializer
將對象序列化到 XML 文檔中和從 XML 文檔中反序列化對象。XmlSerializer 使您得以掌握若何將對象編碼到 XML 中。
XML 序列化是將對象的公共屬性 (Property) 和字段轉換為序列格局（這裡是指 XML）以便存儲或傳輸的進程。反序列化則是從 XML 輸入中從新創立原始狀況的對象。是以，可以將序列化視為將對象的狀況保留到流或緩沖區的辦法。例如，ASP.NET 應用 XmlSerializer 類對 XML Web services 新聞停止編碼。
例子：
C#代碼
public class MyClass
{
public MyObject MyObjectProperty;
}
public class MyObject
{
public string ObjectName;
}
序列化後的XML
<MyClass>
<MyObjectProperty>
<ObjectName>My String</ObjectName>
</MyObjectProperty>
</MyClass>
還可以經由過程標志來掌握XML的輸入
1、默許值
DefaultValueAttribute
2、過濾某屬性或字段
XmlIgnoreAttribute
3、重寫默許序列化邏輯
4、將對象序列化為 SOAP 編碼的 XML 流
留意
XML 序列化不轉換辦法、索引器、公有字段或只讀屬性（只讀聚集除外）。要序列化對象的一切字段和屬性（公共的和公有的），請應用 BinaryFormatter，而不要應用 XML 序列化。
DataContractSerializer
應用供給的數據協議，將類型實例序列化和反序列化為 XML 流或文檔。 此類不克不及被繼續。
DataContractSerializer 用於序列化和反序列化在 Windows Communication Foundation (WCF) 新聞中發送的數據。 經由過程將 DataContractAttribute 屬性 (Attribute) 運用於類，而將 DataMemberAttribute 屬性 (Attribute) 運用於類成員，可以指定要序列化的屬性 (Property) 和字段。
應用步調：
1）DataContractSerializer 與 DataContractAttribute 和 DataMemberAttribute 類聯合應用。
要預備序列化某個類，請將 DataContractAttribute 運用於該類。 關於前往要序列化的數據的類的每一個成員，請運用 DataMemberAttribute。 您可以序列化字段和屬性，而不管其可拜訪性級別是甚麼：private、protected、internal、protected internal 或 public。
2）添加到已知類型的聚集中
在序列化或反序列化對象時，DataContractSerializer 必需“已知”該類型。 起首，創立一個完成 IEnumerable<T>（如 List<T>）的類實例，並將已知類型添加到聚集中。 然後，應用接收 IEnumerable<T>（例如，[M:System.Runtime.Serialization.DataContractSerializer.#ctor(System.Type,System.Collections.Generic.IEnumerable{System.Type}]）的重載之一創立 DataContractSerializer 的實例。
詳細實例：
namespace DataContractSerializerExample
{
using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.Serialization;
using System.Xml;
// 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));
}
}
DataContractJsonSerializer
將對象序列化為 JavaScript 對象表現法 (JSON)，並將 JSON 數據反序列化為對象。 此類不克不及被繼續。
詳細應用與DataContractSerializer相似。這裡不再贅述。
上面對這些辦法的應用做了匯總，願望能給年夜家帶來一些贊助。
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Json;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap;
using System.Xml.Serialization;
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
}
}
