Crear el atributo serializable en C#

1. Utilice la clase SoapFormatter o SerializableAttribute para crear el atributo serializable en C#
2. Utilice el BinaryFormatter para crear el atributo serializable en C#
3. Utilice el XMLSerializer para crear el atributo serializable en C#

En este tutorial, aprenderá las tres formas principales de habilitar la serialización de un atributo para usarlos con precisión en C#. La serialización de atributos es un proceso basado en diferentes pasos para persistir un atributo u objeto desde la memoria a una secuencia de bits.

Cuando serializa una clase en C#, afecta automáticamente a todos sus elementos y solo los campos de atributos marcados no se serializan, lo que significa que puede guardar fácilmente una estructura de datos compleja simplemente serializando el objeto raíz.

Hibernate es un excelente ejemplo de arquitectura moderna de atributos serializables para almacenar un objeto o atributo (para la clase serializable) en tamaños de bytes y para transferir el objeto a otro sistema cuando sea necesario para deserializar.

Utilice la clase SoapFormatter o SerializableAttribute para crear el atributo serializable en C#

Todos los atributos, ya sean públicos o privados, marcados con SerializableAttribute se serializan automáticamente a menos que la interfaz Iserializable anule el proceso de serialización de atributos. Para excluir algunos atributos del proceso de serialización, el NonSerializedAttribute es extremadamente útil.

Marcar los atributos SerializableAttribute solo aplica cuando se usa el SoapFormatter o el BinaryFormatter y el XmlSerializer; DataContractSerializer y JaveScriptSerializer no lo admiten ni lo reconocen. La clase BinaryFormatter pertenece al espacio de nombres System.Runtime.Serialization.Formatters.Binary, y los atributos serializables utilizan Clipboard.SetData() para almacenarse en el portapapeles.

La serialización binaria de Attribute es más eficiente debido a su consumo optimizado de memoria y tiempo; sin embargo, no es legible por humanos. Por otro lado, la serialización SOAP no es eficiente ni está optimizada, pero hace que el código C# sea legible.

La serialización XML es ligeramente diferente ya que usa XmlIgnore en lugar de NonSerialized e ignora Serializable porque vive en el espacio de nombres System.Xml.Serialization. No puede serializar miembros de clases privadas.

// using `System.Runtime.Serialization` namespace is optional

using System;
using System.IO;
using System.Windows.Forms;

// required | essential namespace
using System.Runtime > Serialization.Formatters.Soap;

namespace serializable_attribute {
  public partial class Form1 : Form {
    [Serializable()]
    public class test_class {
      public int attribute_one;
      public string attribute_two;
      public string attribute_three;
      public double attribute_four;

      // the `attribute_five` as the fifth member is not serialized
      [NonSerialized()]
      public string attribute_five;

      public test_class() {
        attribute_one = 11;
        attribute_two = "the lord of the rings";
        attribute_three = "valerian steel";
        attribute_four = 3.14159265;
        attribute_five = "i am unserialized text!";
      }
      public void Print() {
        // MessageBox.Show(attribute_five.ToString()); remember, object reference is NULL

        string delimiter = " , ";
        string messageBoxContent = String.Join(delimiter, attribute_one, attribute_two,
                                               attribute_three, attribute_four, attribute_five);
        MessageBox.Show(messageBoxContent);
      }
    }
    public Form1() {
      InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e) {
      test_class obj = new test_class();

      Stream serialized_stream = File.Open(
          "data.xml", FileMode.Open);  // replace your `.xml` file location or let it be default
      // define a new `SoapFormatter` object
      SoapFormatter formatter_soap = new SoapFormatter();

      // serialize the object with the stream
      formatter_soap.Serialize(serialized_stream, obj);
      serialized_stream.Close();  // close the stream

      // obj = null; | optional
      serialized_stream = File.Open("data.xml", FileMode.Open);
      formatter_soap = new SoapFormatter();

      // deserialize the stream w.r.t the serializable object
      obj = (test_class)formatter_soap.Deserialize(serialized_stream);

      // close the stream
      serialized_stream.Close();

      // print the serialized object
      obj.Print();
    }
  }
}

Producción :

11, the lord of the rings, valerian steel, 3.14159265 ,

Lo que es más importante, el tiempo de ejecución de serialización se asocia con cada clase serializable o atribuye un número de versión (para deserializar después de la verificación). La deserialización solo ocurrirá cuando el número de versión de un atributo serializable sea correcto.

Un buen programador siempre debe declarar el número de versión explícitamente debido a su cálculo altamente sensible que depende de las implementaciones del compilador, lo que puede generar un error durante la deserialización.

Los atributos serializables se pueden almacenar o escribir en archivos; si entiendes el polimorfismo, esto puede tener mucho sentido. Puede serializar un atributo o guardar su estado convirtiéndolo en un flujo de bytes para almacenarlo en la memoria, una base de datos o un archivo.

La serialización de atributos es esencial para enviarlos a una aplicación remota por parte del servidor web, pasarlos de un dominio a otro, pasarlos a través de un firewall como una cadena JSON o XML, o mantener la seguridad o la información específica del usuario en todas las aplicaciones.

Utilice el BinaryFormatter para crear el atributo serializable en C#

El proceso de serialización es importante para decorar cada clase, interfaz o estructura con el atributo Serializable en C#. Crear un objeto FileStream con un nombre válido y legible es importante para serializar un atributo.

Se puede crear un método Serialize() con la ayuda de un objeto BinaryFormatter. El método BinaryFormatter.Deserialize() devuelve un objeto que debe convertirse al tipo apropiado.

Para aprender completamente el proceso de serialización de objetos o atributos, debe comprender el proceso de deserialización.

El proceso de deserialización de los atributos serializables comienza estableciendo la referencia en “nulo” y creando una matriz completamente nueva desde cero para albergar la matriz deserializada de objetos de prueba. Aprenderá esto en el siguiente programa ejecutable de C#, y también aprenderá los métodos SerializeNow() y DeSerializeNow(), respectivamente.

En general, la serialización de atributos consiste en crear una instancia de la ubicación del objeto serializado, crear una secuencia desde el objeto de archivo, crear una instancia de BinaryFormatter y finalmente llamar al método Serialize().

using System;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Windows.Forms;

namespace serializable_attribute {
  public partial class Form1 : Form {
    [Serializable()]
    public class test_class {
      public int attribute_one;
      public string attribute_two;
      public string attribute_three;
      public double attribute_four;

      // the `attribute_five` as the fifth member is not serialized
      [NonSerialized()]
      public string attribute_five;

      public test_class() {
        attribute_one = 11;
        attribute_two = "the lord of the rings";
        attribute_three = "valerian steel";
        attribute_four = 3.14159265;
        attribute_five = "i am unserialized text!";
      }
      public void Print() {
        // MessageBox.Show(attribute_five.ToString()); remember, object reference is NULL

        string delimiter = " , ";
        string messageBoxContent = String.Join(delimiter, attribute_one, attribute_two,
                                               attribute_three, attribute_four, attribute_five);
        MessageBox.Show(messageBoxContent);
      }
    }
    public Form1() {
      InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e) {
      test_class obj = new test_class();

      Stream serialized_stream = File.Open("data.xml", FileMode.Create);

      BinaryFormatter formatter_binary = new BinaryFormatter();
      formatter_binary.Serialize(serialized_stream, obj);
      serialized_stream.Close();

      // obj = null;
      serialized_stream = File.Open("data.xml", FileMode.Open);
      formatter_binary = new BinaryFormatter();

      obj = (test_class)formatter_binary.Deserialize(serialized_stream);
      serialized_stream.Close();

      obj.Print();
    }
  }
}

Producción :

11, the lord of the rings, valerian steel, 3.14159265 ,

Las clases para serialización y deserialización binaria o XML pertenecen al espacio de nombres System.Runtime.Serialization, lo que lo convierte en una parte/componente esencial del proceso de serialización. Tanto las serializaciones XML como las binarias pueden ofrecer beneficios separados.

La serialización binaria de atributos utiliza flujos de red basados en sockets y todos sus miembros son de solo lectura, lo que puede mejorar su rendimiento. Por otro lado, la serialización XML utiliza un flujo XML que se ajusta a un documento de lenguaje de definición de esquemas XML (XSD) en particular, lo que da como resultado atributos fuertemente tipados con propiedades públicas.

Además, también puede usar el SerializableAttribute para un atributo serializable a un tipo para indicar su capacidad de serializar o no. Es una buena práctica no serializar atributos que contengan un identificador, un puntero o alguna otra estructura de datos relacionada o conectada a una condición o entorno en particular.

Utilice el XMLSerializer para crear el atributo serializable en C#

Habilita la persistencia del estado del objeto en el disco en formato XML. Para usar el XMLSerializer en C#, debe importar los espacios de nombres System.Xml y System.Xml.Serialization.

El objeto StreamWriter puede habilitar la serialización de un objeto. Lo más importante, la creación de los métodos Serialize() y Deserialize() son los mismos que los anteriores, pero en lugar de usar el BinaryFormatter, usará el XMLSerializer.

Puede encontrar el archivo .xml de los atributos serializados en la carpeta bin o debug de su programa C#; puede observar el estado persistente de la clase de prueba en la codificación XML. El Xsd.exe es un excelente programa ejecutable o una herramienta que funciona como la herramienta de definición de esquema XML para crear clases basadas en el documento XSD (definición de esquema XML) existente.

using System;
using System.IO;
using System.Xml.Serialization;
using System.Windows.Forms;

namespace serializable_attribute {
  [Serializable]
  public class XMLSerialize {
    public XMLSerialize() {}
    public XMLSerialize(string rank, string sol_name) {
      this._rank = rank;
      this._name = sol_name;
    }
    public string _rank { get; set; }
    public string _name { get; set; }
    public override string ToString() {
      return (_rank + " " + _name);
    }
  }
  public partial class Form1 : Form {
    public Form1() {
      InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e) {
      XMLSerialize[] ser_obj = new XMLSerialize[3];
      ser_obj[0] = new XMLSerialize("Captain", "Floyyd");
      ser_obj[1] = new XMLSerialize("Major", "Gerizmann");
      ser_obj[2] = new XMLSerialize("Sec. Lef.", "Angel");

      TextWriter obj_txtWriter = null;
      obj_txtWriter = new StreamWriter("test.xml");

      XmlSerializer obj_xmlSerl = new XmlSerializer(typeof(XMLSerialize[]));
      obj_xmlSerl.Serialize(obj_txtWriter, ser_obj);

      string delimiter = " , ";
      string messageBoxContent = String.Join(delimiter, ser_obj[0], ser_obj[1], ser_obj[2]);
      MessageBox.Show(messageBoxContent);

      obj_txtWriter.Close();
      obj_txtWriter = null;
    }
  }
}

Producción :

Captain Floyyd, Major Gerizmann, Sec. Lef. Angel

En C#, la serialización de atributos puede ser de dos tipos: serialización básica y personalizada. La serialización básica de atributos es fácil porque usa .NET para auto-serializar los atributos, y su único requisito es que una clase tenga aplicado el atributo SerializableAttribute.

La serialización personalizada le permite marcar qué objetos serializar. La clase debe estar marcada como SerializableAttribute y usar la interfaz ISerializable, y también se puede deserializar de manera personalizada usando el constructor personalizado.

La serialización de atributos del diseñador es la forma más rara de serialización de atributos que implica una persistencia de atributo especial asociada con la herramienta de desarrollo. Es un proceso de conversión de gráficos en un archivo fuente para recuperarlo, y los gráficos pueden contener marcas o código C#, incluso información de tablas SQL.

La mayoría de los atributos serializables son instancias técnicas .custom; sin embargo, el SerializableAttribute se asigna a un indicador .class de la interfaz de línea de comando (serializable). El System.SerializableAttribute especifica la capacidad del atributo para serializar.

Es importante recordar que no es necesario usar el NonSerializedAttribute si el tipo dado implementa la interfaz System.Runtime.Serialization.ISerializable, lo que indica que una clase proporciona sus propios métodos de serialización y deserialización. Esto puede ser algo como:

public sealed class SerializableAttribute : Attribute {public method SerializableAttribute();}

En este tutorial, ha aprendido todas las formas posibles de serializar atributos y modificar la serialización y deserialización de atributos en C#.