Exportar (0) Imprimir
Expandir todo

ISerializable (Interfaz)

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
/** @attribute ComVisibleAttribute(true) */ 
public interface ISerializable
ComVisibleAttribute(true) 
public interface ISerializable

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

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

La interfaz ISerializable implica un constructor con la firma constructor (información SerializationInfo, contexto StreamingContext). En el momento de la deserialización, se llama al constructor actual sólo después de que el formateador haya deserializado los datos de SerializationInfo. En general, este constructor debe protegerse si la clase no es de tipo sealed.

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

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

Cuando estos tipos se utilizan a través de System.Runtime.Remoting, la infraestructura de entorno remoto proporciona un suplente que anticipa la serialización típica y, en su lugar, serializa un proxy para MarshalByRefObject. Un suplente es un elemento auxiliar que sabe cómo serializar y deserializar objetos de un tipo concreto. 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 marcase con el atributo "serializable" y extendiese MarshalByRefObject. Los programadores deben detenerse a pensar sobre los posibles escenarios de serialización y entorno remoto al combinar estas dos características. Un caso en el que esto sería aplicable se da con MemoryStream. Mientras que la clase base de MemoryStream (Stream) se extiende desde MarshalByRefObject, es posible capturar el estado de un objeto MemoryStream y restaurarlo como se desee. Por tanto, podría tener sentido serializar el estado de esta secuencia en una base de datos y restaurarla más adelante. No obstante, si se utiliza un objeto de este tipo a través de un entorno remoto, se utilizaría un proxy.

Para obtener más información sobre la serialización de clases que extienden MarshalByRefObject, vea RemotingSurrogateSelector. Para obtener más información sobre la implementación de ISerializable, vea Serialización personalizada.

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

En el siguiente ejemplo de código, se muestra cómo utilizar la interfaz ISerializable con el objeto de definir un comportamiento de serialización personalizado para una clase.

using System;
using System.Web;
using System.IO;
using System.Collections;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using System.Security.Permissions;


// There should be only one instance of this type per AppDomain.
[Serializable]
public sealed class Singleton : ISerializable 
{
    // This is the one instance of this type.
    private static readonly Singleton theOneObject = new Singleton();

    // Here are the instance fields.
    private string someString_value;
    private Int32 someNumber_value;

   public string SomeString
   {
       get{return someString_value;}
       set{someString_value = value;}
   }

   public Int32 SomeNumber
   {
       get{return someNumber_value;}
       set{someNumber_value = value;}
   }

    // Private constructor allowing this type to construct the Singleton.
    private Singleton() 
    { 
        // Do whatever is necessary to initialize the Singleton.
        someString_value = "This is a string field";
        someNumber_value = 123;
    }

    // A method returning a reference to the Singleton.
    public static Singleton GetSingleton() 
    { 
        return theOneObject; 
    }

    // A method called when serializing a Singleton.
    [SecurityPermissionAttribute(SecurityAction.LinkDemand, 
    Flags=SecurityPermissionFlag.SerializationFormatter)]
    void ISerializable.GetObjectData(
        SerializationInfo info, StreamingContext context) 
    {
        // Instead of serializing this object, 
        // serialize a SingletonSerializationHelp instead.
        info.SetType(typeof(SingletonSerializationHelper));
        // No other values need to be added.
    }

    // Note: ISerializable's special constructor is not necessary 
    // because it is never called.
}


[Serializable]
internal sealed class SingletonSerializationHelper : IObjectReference 
{
    // This object has no fields (although it could).

    // GetRealObject is called after this object is deserialized.
    public Object GetRealObject(StreamingContext context) 
    {
        // When deserialiing this object, return a reference to 
        // the Singleton object instead.
        return Singleton.GetSingleton();
    }
}


class App 
{
    [STAThread]
    static void Main() 
    {
        FileStream fs = new FileStream("DataFile.dat", FileMode.Create);

        try 
        {
            // Construct a BinaryFormatter and use it 
            // to serialize the data to the stream.
            BinaryFormatter formatter = new BinaryFormatter();

            // Create an array with multiple elements refering to 
            // the one Singleton object.
            Singleton[] a1 = { Singleton.GetSingleton(), Singleton.GetSingleton() };

            // This displays "True".
            Console.WriteLine(
                "Do both array elements refer to the same object? " + 
                (a1[0] == a1[1]));     

            // Serialize the array elements.
            formatter.Serialize(fs, a1);

            // Deserialize the array elements.
            fs.Position = 0;
            Singleton[] a2 = (Singleton[]) formatter.Deserialize(fs);

            // This displays "True".
            Console.WriteLine("Do both array elements refer to the same object? " 
                + (a2[0] == a2[1])); 

            // This displays "True".
            Console.WriteLine("Do all array elements refer to the same object? " 
                + (a1[0] == a2[0]));
        }   
        catch (SerializationException e) 
        {
            Console.WriteLine("Failed to serialize. Reason: " + e.Message);
            throw;
        }
        finally 
        {
            fs.Close();
        }
    }
}

Windows 98, Windows 2000 SP4, Windows Millennium, Windows Server 2003, Windows XP Media Center, Windows XP Professional x64, Windows XP SP2, Windows XP Starter Edition

.NET Framework no admite todas las versiones de cada plataforma. Para obtener una lista de las versiones admitidas, vea Requisitos del sistema.

.NET Framework

Compatible con: 2.0, 1.1, 1.0

Adiciones de comunidad

AGREGAR
Mostrar:
© 2014 Microsoft