La serializzazione è l'operazione di generazione di uno stream (MemoryStream) contenente un clone in bytes della classe serializzata. Lo stream può essere utilizzato successivamente per la scrittura di un file fisico o per la trasmissione in rete. La Deserializzazione è l'operazione contraria, partendo da un backup della classe serializzata si ottiene uno stream contenente il clone della classe e da questo la classe stessa. La classe da serializzare deve essere decorata con l'attributo "Serializable"

Ecco un esempio pratico di serializzazione deserializzazione di una classe in c#:

namespace Ollie10.Serializer
{
    #region

    using System;
    using System.Drawing;
    using System.IO;
    using System.Runtime.Serialization.Formatters.Binary;

    #endregion

    /// <summary>
	/// Esempio di serializzazione 
	/// Definizione una classe "Serializer" 
	/// Si decora la classe l'attributo [Serializable] (obbligatorio per i nostri scopi)
	/// </summary>
	[Serializable]
	public class Serializer
	{
		// definizione membri privati
		private int mIntero;
		private string mTesto;
		private DateTime mDataOra;
		private decimal mDecimale;
		private bool mBooleano;
		private Image mImmagine;

	    #region Proprietà
		public int Intero
		{
			get 
			{
				return mIntero;
			}
			set
			{
				mIntero = value;
			}
		}
		public string Testo
		{
			get
			{
				return mTesto;
			}
			set
			{
				mTesto = value;
			}
		}
		public DateTime DataOra
		{
			get
			{
				return mDataOra;
			}
			set
			{
				mDataOra = value;
			}
		}
		public decimal Decimale
		{
			get
			{
				return mDecimale;
			}
			set
			{
				mDecimale = value;
			}
		}
		public bool Booleano
		{
			get
			{
				return mBooleano;
			}
			set
			{
				mBooleano = value;
			}
		}
		public Image Immagine
		{
			get
			{
				return mImmagine;
			}
			set
			{
				mImmagine = value;
			}
		}
		#endregion
		#region Metodi serializzazione
		/// <summary>
		/// Serialize della classe Serializer
		/// </summary>
		/// <param name="serData">Classe da serializzare</param>
		/// <param name="NomeFile">Nome del file da generare</param>
		/// <returns>Operazione Eseguita/Non eseguita</returns>
		public bool Serialize(Serializer serData,string NomeFile)
		{
			bool RetValue = true;
			MemoryStream ms = new MemoryStream();
			BinaryFormatter br = new BinaryFormatter();
			using (FileStream fs = new FileStream(NomeFile, FileMode.OpenOrCreate))
			{
				try
				{
					// il metodo Serialize di BinaryFormatter
					// restituisce nella variabile ms (MemoryStream) 
					// la classe serializzata
					br.Serialize(ms,serData);
					// scriviamo sul file (FileStream fs) 
					ms.WriteTo(fs);
				}
				catch (Exception ex)
				{
					System.Diagnostics.Debug.WriteLine(ex.Message);
					System.Diagnostics.Debug.WriteLine(ex.StackTrace);
					RetValue = false;
				}
				finally
				{
					fs.Close();
				}
				
			}
			return RetValue;
		}
		/// <summary>
		/// Deserializzazione per la classe Serializer
		/// </summary>
		/// <param name="NomeFile"></param>
		/// <returns></returns>
		public Serializer DeSerialize(string NomeFile)
		{
			using (FileStream fs = new FileStream(NomeFile, FileMode.Open))
			{
				BinaryFormatter bf = new BinaryFormatter();
				try
				{
					fs.Seek(0, SeekOrigin.Begin);
					return (Serializer) bf.Deserialize(fs);
				}
				catch
				{
					return null;
				}
				finally
				{
					fs.Close();
				}
			}
		}
		#endregion
	}
}

In questo piccolo tutorial vediamo come serializzare un oggetto con SOAP, ricordiamoci come prima cosa di referenziare l'assembly System.Runtime.Serialization.Formatters.Soap.dll e creare una classe con l'attributo [Serializable].

Questa è la nostra classe di esempio:

[Serializable]
class Note
{
    private string _title;
    public string Title
    {
        get { return _title; }
        set { _title = value; }
    }

    private string  _body;
    public string  Body
    {
        get { return _body; }
        set { _body = value; }
    }

    private int _version;
    public int Version
    {
        get { return _version; }
        set { _version = value; }
    }
}

Ed ora vediamo il codice che permette di serializzare la classe su stream (FileStream nel caso del nostro esempio)

Note note = new Note();
private const string FILENAME = "noteserialized.xml";

private void Deserialize()
{
	if (File.Exists(FILENAME) == true)
	{
		System.Runtime.Serialization.Formatters.Soap.SoapFormatter sf = new System.Runtime.Serialization.Formatters.Soap.SoapFormatter();
		using (Stream strm = File.Open(FILENAME, FileMode.Open))
		{
			if (strm.Length > 0)
			{
				try
					{
						note = (Note)sf.Deserialize(strm);
					}
					catch (System.Xml.XmlException ex)
					{
						// NOSTRO CODICE DI ERRORE
					}
			}
		}
	}
}

private void Serialize()
{
	System.Runtime.Serialization.Formatters.Soap.SoapFormatter sf = new System.Runtime.Serialization.Formatters.Soap.SoapFormatter();
	using (Stream strm = File.Open(FILENAME, FileMode.Create, FileAccess.Write))
	{
		sf.Serialize(strm, note);
	}
}