Este artículo se tradujo automáticamente. Para ver el artículo en inglés, active la casilla Inglés. Además, puede mostrar el texto en inglés en una ventana emergente si mueve el puntero del mouse sobre el texto.
Traducción
Inglés

Interfaz ISerializable

 

Publicado: octubre de 2016

Permite que un objeto controle su propia serialización y deserialización.

Espacio de nombres:   System.Runtime.Serialization
Ensamblado:  mscorlib (en mscorlib.dll)

[ComVisibleAttribute(true)]
public interface ISerializable

NombreDescripción
System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Llena SerializationInfo con los datos necesarios para serializar el objeto de destino.

Cualquier clase que tenga posibilidades de serializarse debe marcarse con el SerializableAttribute. Si una clase necesita controlar su proceso de serialización, puede implementar la ISerializable interfaz. El Formatter llamadas el GetObjectData durante la serialización y llena proporcionado SerializationInfo con todos los datos necesarios para representar el objeto. El Formatter crea un SerializationInfo con el tipo del objeto en el gráfico. Los objetos que necesitan enviar proxies para ellos mismos pueden utilizar el FullTypeName y AssemblyName métodos en SerializationInfo para cambiar la información transmitida.

En el caso de herencia de clases, es posible serializar una clase que deriva de una clase base que implementa ISerializable. En este caso, la clase derivada debe llamar a la implementación de clase base GetObjectData dentro de su implementación de GetObjectData. De lo contrario, no se serializará los datos de la clase base.

El ISerializable interfaz implica un constructor con la firma constructor (SerializationInfo información, StreamingContext contexto). Durante la deserialización, se llama al constructor actual sólo después de los datos en el SerializationInfo se ha deserializado el formateador. En general, este constructor debe protegerse si la clase no está sellada.

No se puede garantizar el orden en el que se deserializan los objetos. Por ejemplo, si un tipo hace referencia a un tipo que no se ha deserializado todavía, se producirá una excepción. Si está creando tipos que tienen tales dependencias, puede solucionar el problema mediante la implementación de la IDeserializationCallback interfaz y la OnDeserialization (método).

La arquitectura de serialización controla tipos de objetos que extienden MarshalByRefObject igual que los tipos que extienden Object. Estos tipos se pueden marcar con el SerializableAttribute e implementar el ISerializable interfaz como cualquier otro tipo de objeto. Su estado de objeto se capturarán y persistirá en la secuencia.

Cuando estos tipos se utilizan a través de System.Runtime.Remoting, la infraestructura remota proporciona un suplente que anticipa la serialización típica y en su lugar, serializa un proxy para el MarshalByRefObject. Un suplente es una aplicación auxiliar que sabe cómo serializar y deserializar objetos de un tipo determinado. El proxy, invisible para el usuario en la mayoría de los casos, será de tipo ObjRef.

Como modelo de diseño general, sería poco habitual que una clase se marca con el atributo serializable y ampliar MarshalByRefObject. Los programadores deben pensar sobre los posibles escenarios de serialización y comunicación remota al combinar estas dos características. Es un ejemplo que esto sería aplicable con un MemoryStream. Mientras que la clase base de MemoryStream (Stream) se extiende desde MarshalByRefObject, es posible capturar el estado de un MemoryStream y restaurarlo como se desee. Podría, por lo tanto, ser significativo para serializar el estado de esta secuencia en una base de datos y restaurarla posteriormente en el tiempo. Sin embargo, cuando se utiliza a través de remoting, un objeto de este tipo sería procesado.

Para obtener más información acerca de la serialización de clases que extienden MarshalByRefObject, consulte RemotingSurrogateSelector. Para obtener más información acerca de cómo implementar ISerializable, consulte Serialización personalizada.

Notas para implementadores:

Implemente esta interfaz para permitir que un objeto participe en su propia serialización y deserialización.

En el ejemplo de código siguiente se muestra el uso de la ISerializable interfaz para definir el comportamiento de serialización personalizado para una clase.

using System;
using System.Text;
using System.IO;
// Add references to Soap and Binary formatters.
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization.Formatters.Soap ;
using System.Runtime.Serialization;


[Serializable]
public class MyItemType : ISerializable
{
    public MyItemType()
    {
        // Empty constructor required to compile.
    }

    // The value to serialize.
    private string myProperty_value;

    public string MyProperty
    {
        get { return myProperty_value; }
        set { myProperty_value = value; }
    }

    // Implement this method to serialize data. The method is called 
    // on serialization.
    public void GetObjectData(SerializationInfo info, StreamingContext context)
    {
        // Use the AddValue method to specify serialized values.
        info.AddValue("props", myProperty_value, typeof(string));

    }

    // The special constructor is used to deserialize values.
    public MyItemType(SerializationInfo info, StreamingContext context)
    {
        // Reset the property value using the GetValue method.
        myProperty_value = (string) info.GetValue("props", typeof(string));
    }
}

// This is a console application. 
public static class Test
{
    static void Main()
    {
        // This is the name of the file holding the data. You can use any file extension you like.
        string fileName = "dataStuff.myData";

        // Use a BinaryFormatter or SoapFormatter.
        IFormatter formatter = new BinaryFormatter();
        //IFormatter formatter = new SoapFormatter();

        Test.SerializeItem(fileName, formatter); // Serialize an instance of the class.
        Test.DeserializeItem(fileName, formatter); // Deserialize the instance.
        Console.WriteLine("Done");
        Console.ReadLine();
    }

    public static void SerializeItem(string fileName, IFormatter formatter)
    {
        // Create an instance of the type and serialize it.
        MyItemType t = new MyItemType();
        t.MyProperty = "Hello World";

        FileStream s = new FileStream(fileName , FileMode.Create);
        formatter.Serialize(s, t);            
        s.Close();
    }


    public static void DeserializeItem(string fileName, IFormatter formatter)
    {
        FileStream s = new FileStream(fileName, FileMode.Open);
        MyItemType t = (MyItemType)formatter.Deserialize(s);
        Console.WriteLine(t.MyProperty);            
    }       
}

.NET Framework
Disponible desde 1.1
Volver al principio
Mostrar: