¿Que entendemos por Serializacion?

La serialización es un tema muy utilizado pero muy desconocido por todos los desarrolladores de software en general porque esta presente en casí todos los eventos de programación en los cuales trabajamos, por ejemplo "copy y paste", servicios web, objeto sesión de ASP.NET, etc.

El Mecanismo por Defecto
En el mecanismo por defecto implica el uso de del mecanismo estándar de serialización que utiliza .NET. La contraparte de la serialización es la deserialización. Para volver un objeto serializable se debe marcar la clase con el atributo Serializable; tal y como se ve en el siguiente código.

//Importante! debe incluir Serializable
[Serializable]
    class Program
    {
       static Int64 codigoCarreraBuscar;
       static void Main string[] args)
        {
            // Serializando, lo que creará un archivo en la carpeta de ejecucion con el nombre "Carreras.dat"
            Carrera _carrera = new Carrera(1, "Ingeniería en Informática");
            FileStream _fs = new FileStream("Carreras.dat", FileMode.Create);
            BinaryFormatter _bf = new BinaryFormatter();
            _bf.Serialize(_fs, _carrera);
            _fs.Close();

            // Deserializar, AL tener el programa serializado necesitamos deserializarlo para saber el contenido de ese archivo que hemos serializado
            FileStream _fs2 = new FileStream("Carreras.dat", FileMode.Open);
            BinaryFormatter _bf2 = new BinaryFormatter();
            Carrera _carreraDeserializada = _bf2.Deserialize(_fs2) as Carrera;
            Console.WriteLine("Carrera serializada individualmente");
            Console.WriteLine("Id: {0}, Nombre: {1}",
                _carreraDeserializada.Id,
                _carreraDeserializada.Nombre);
            
            // Serializando colecciones.
            EjemploLista();
        }

Serializando una coleccion usando la misma clase
  static void EjemploLista()
        {
          //FileStream en donde especificaremos el nombre del archivo serializado
            FileStream _fs = new FileStream("ListaCarreras.dat", FileMode.Create);
            BinaryFormatter _bf = new BinaryFormatter();
            List<Carrera> _carreras = new List<Carrera>();     //Creando una lista "Carrera" como nueva instancia
            //Agregando la linea Carreras
            Carrera _carrera1 = new Carrera(1, "Ingeniería en Informática");
            Carrera _carrera2 = new Carrera(2, "Ingeniería Civil");
            _carrera1.Egresados.Add(new Egresado(1, "Juan", "Flores"));
            _carrera1.Egresados.Add(new Egresado(2, "Carlos", "Linares"));
            _carrera2.Egresados.Add(new Egresado(3, "Edgardo", "Moreno"));
            //Agregando Usuarios a las carreras especificadas en la linea Carreras
            _carreras.Add(_carrera1);
            _carreras.Add(_carrera2);
            _carreras.Add(_carrera3);
             //Serializando el contenido que hemos agregado en la lista
            _bf.Serialize(_fs, _carreras);
            _fs.Close();
            //Deserializando el contenido que serializamos al inicio del metodo
            FileStream _fs2 = new FileStream("ListaCarreras.dat", FileMode.Open);
            BinaryFormatter _bf2 = new BinaryFormatter();
            List<Carrera> _listaCarrera = _bf2.Deserialize(_fs2) as List<Carrera>;
            _fs2.Close();
            Console.WriteLine("Carreras serializadas en lista");
            foreach (Carrera _car in _listaCarrera)//Ciclo que nos mostrará una lista con las carreras y las personas que contiene cada una de ellas
            {
                Console.WriteLine("Id: {0}, Nombre: {1}", _car.Id, _car.Nombre);
                Console.WriteLine("*********************************************");
                foreach (Egresado _egresado in _car.Egresados)
                {
                    Console.WriteLine("Id: {0}, Nombre: {1},Apellido: {2}", _egresado.Id, _egresado.Nombre, _egresado.Apellido);
                }
                Console.WriteLine("");
            }

/*El resto del trabajo lo hace el framework.
Por defecto existen dos tipos de serialización en .NET:
1.   Serialización Binaria: Preserva la fidelidad de los tipos lo cuál es útil para preservar el estado del objeto durante invocaciones diferentes de una aplicación. Un ejemplo de esta serialización es el uso del clipboard - copy paste. Un objeto se puede serializar a un stream, a un disco, a memoria, por la red, etc.
2.   Serialización XML: Serializa solamente las propiedades públicas y los campos y no preserva la fidelidad del tipo.Dado que XML es un estándar abierto es una opción atractiva para compartir datos en la Web.
Para llevar cabo la serialización y la deserialización .NET utiliza lo que se conoce como los Formatters - formateadores.
*/

/*Atte.Gerardo
Prueben este ejercicio y pregunten por cualquier duda, si les ha funcionado escelente y si necesecitan que siga incluyendo otro ejemplo, comenten...*/
/*SI NECESITAN MAS INFORMACION CON GUSTO LES SUBIRE MAS, por ahora les dejo este ej. para ver que les parece, comenten que tal les ha parecido y si les ha servido */[/size]

En otra ocasion les publicaré como serializar utilizando XML!