Questa documentazione è stata archiviata e non viene gestita.

Interfaccia ISerializable

Consente a un oggetto di controllare la propria serializzazione e deserializzazione.

Spazio dei nomi: System.Runtime.Serialization
Assembly: mscorlib (in mscorlib.dll)

[ComVisibleAttribute(true)] 
public interface ISerializable
/** @attribute ComVisibleAttribute(true) */ 
public interface ISerializable
ComVisibleAttribute(true) 
public interface ISerializable

Tutte le classi serializzabili devono essere contrassegnate con SerializableAttribute. Per controllare il proprio processo di serializzazione, una classe può implementare l'interfaccia ISerializable. L'oggetto Formatter chiama il metodo GetObjectData in fase di serializzazione e popola l'oggetto SerializationInfo specificato con tutti i dati necessari per rappresentare l'oggetto. L'oggetto Formatter crea un oggetto SerializationInfo caratterizzato dal tipo dell'oggetto nel grafico. Gli oggetti che devono inviare proxy per se stessi possono utilizzare i metodi FullTypeName e AssemblyName sull'oggetto SerializationInfo per modificare le informazioni trasmesse.

In caso di ereditarietà della classe, è possibile serializzare una classe che deriva da una classe base che implementa l'oggetto ISerializable. In tal caso, la classe derivata deve chiamare l'implementazione della classe base di GetObjectData all'interno della relativa implementazione di GetObjectData. In caso contrario, i dati provenienti dalla classe base non saranno serializzati.

L'interfaccia ISerializable implica un costruttore contenente la firma Constructor (informazioni SerializationInfo, contesto StreamingContext). In fase di deserializzazione il costruttore corrente viene chiamato solo dopo che il formattatore ha deserializzato i dati dell'oggetto SerializationInfo. In generale, è opportuno proteggere questo costruttore se la classe non è sealed.

L'ordine in cui gli oggetti sono deserializzati non può essere garantito. Se, ad esempio, un tipo fa riferimento a un tipo che non è stato ancora deserializzato, verrà generata un'eccezione. Se si intende creare tipi che presentano questi tipi di dipendenze, è possibile ovviare al problema implementando l'interfaccia IDeserializationCallback e il metodo OnDeserialization.

L'architettura di serializzazione gestisce i tipi di oggetto che estendono MarshalByRefObject come quelli che estendono Object. Questi tipi possono essere contrassegnati da SerializableAttribute e implementano l'interfaccia ISerializable come qualsiasi altro tipo di oggetto. Lo stato di tali oggetti verrà acquisito e rimarrà nel flusso.

Quando questi tipi vengono utilizzati tramite lo spazio dei nomi System.Runtime.Remoting, l'infrastruttura remota fornisce un surrogato che ha la precedenza sulla tipica serializzazione e serializza dapprima un proxy per MarshalByRefObject. Un surrogato è un oggetto di supporto in grado di serializzare e deserializzare oggetti di un tipo specifico. Il tipo del proxy, invisibile all'utente nella maggior parte dei casi, sarà ObjRef.

In un normale schema di progettazione è insolito che una classe venga contrassegnata con l'attributo serializzabile e allo stesso tempo estenda l'oggetto MarshalByRefObject. È opportuno che gli sviluppatori considerino con attenzione i possibili scenari di serializzazione e servizi remoti quando si intende utilizzare entrambe le caratteristiche. Un esempio di applicazione di questo scenario è dato da MemoryStream. Quando la classe base di MemoryStream (Stream) si estende da MarshalByRefObject, è possibile acquisire lo stato di un oggetto MemoryStream e ripristinarlo quando necessario. Può pertanto essere significativo serializzare lo stato del flusso in un database e ripristinarlo successivamente. Se utilizzato tramite i servizi remoti tuttavia un oggetto di questo tipo sarà sottoposto a operazioni proxy.

Per ulteriori informazioni sulla serializzazione di classi che estendono l'oggetto MarshalByRefObject, vedere RemotingSurrogateSelector. Per ulteriori informazioni sull'implementazione di ISerializable, vedere Serializzazione personalizzata.

Note per gli implementatori: Implementare questa interfaccia per consentire a un oggetto di intervenire nella propria serializzazione e deserializzazione.

Nel codice riportato di seguito viene illustrato l'uso dell'interfaccia ISerializable per definire il comportamento personalizzato della serializzazione per una classe.

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 Edition, Windows Server 2003, Windows XP Media Center Edition, Windows XP Professional x64 Edition, Windows XP SP2, Windows XP Starter Edition

.NET Framework non supporta tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema.

.NET Framework

Supportato in: 2.0 1.1 1.0
Mostra: