Questo articolo è stato tradotto automaticamente. Per visualizzare l'articolo in inglese, selezionare la casella di controllo Inglese. È possibile anche visualizzare il testo inglese in una finestra popup posizionando il puntatore del mouse sopra il testo.
Traduzione
Inglese

Interfaccia ISerializable

 

Data di pubblicazione: ottobre 2016

Consente ad 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

NomeDescrizione
System_CAPS_pubmethodGetObjectData(SerializationInfo, StreamingContext)

Popola un oggetto SerializationInfo con i dati necessari per serializzare l'oggetto di destinazione.

Qualsiasi classe che può essere serializzato deve essere contrassegnato con il SerializableAttribute. Se una classe deve controllare il processo di serializzazione, è possibile implementare il ISerializable interfaccia. Il Formatter chiamate di GetObjectData in fase di serializzazione e popola l'oggetto specificato SerializationInfo con tutti i dati necessari per rappresentare l'oggetto. Il Formatter Crea un SerializationInfo con il tipo dell'oggetto nel grafico. Gli oggetti che devono inviare proxy per se stessi possono utilizzare il FullTypeName e AssemblyName metodi su SerializationInfo per modificare le informazioni trasmesse.

Nel caso di ereditarietà della classe, è possibile serializzare una classe che deriva da una classe base che implementa ISerializable. In questo caso, la classe derivata deve chiamare l'implementazione della classe base di GetObjectData all'interno dell'implementazione di GetObjectData. In caso contrario, i dati dalla classe di base non essere serializzati.

Il ISerializable interfaccia implica un costruttore con la firma constructor (SerializationInfo informazioni StreamingContext contesto). In fase di deserializzazione, il costruttore corrente viene chiamato solo dopo i dati di SerializationInfo è stato deserializzato dal formattatore. In generale, questo costruttore deve essere protetto se la classe non sealed.

L'ordine in cui gli oggetti sono deserializzati non può essere garantita. Ad esempio, se un tipo fa riferimento a un tipo che non è stato ancora deserializzato, si verifica un'eccezione. Se si creano tipi che dispongono di tali dipendenze, è possibile risolvere il problema mediante l'implementazione di IDeserializationCallback interfaccia e OnDeserialization metodo.

Architettura di serializzazione gestisce i tipi di oggetti che estendono MarshalByRefObject corrispondono a quelli che estendono Object. Questi tipi possono essere contrassegnati con il SerializableAttribute e implementare il ISerializable interfaccia come qualsiasi altro tipo di oggetto. Lo stato dell'oggetto verrà acquisito e resa persistente nel flusso.

Quando questi tipi vengono utilizzati tramite System.Runtime.Remoting, l'infrastruttura .NET remoting fornisce un surrogato che ha la precedenza sulla tipica serializzazione e serializza dapprima un proxy per il MarshalByRefObject. Un surrogato è un helper in grado di serializzare e deserializzare gli oggetti di un determinato tipo. Il proxy, invisibile all'utente nella maggior parte dei casi, sarà di tipo ObjRef.

Come un modello di progettazione generali, sarebbe insolito per una classe di essere contrassegnato con attributo serializzabile ed estendere MarshalByRefObject. Gli sviluppatori devono considerare con attenzione i possibili scenari di serializzazione e i servizi remoti quando si combinano queste due caratteristiche. Un esempio in cui potrebbe essere applicabile è con un MemoryStream. Quando la classe base di MemoryStream (Stream) si estende da MarshalByRefObject, è possibile acquisire lo stato di un MemoryStream e ripristinarlo quando necessario. Potrebbe pertanto essere significativo serializzare lo stato del flusso in un database e ripristinarlo in un secondo momento nel tempo. Tuttavia, quando utilizzato tramite i servizi remoti, un oggetto di questo tipo sarebbe elaborate dal proxy.

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

Note per gli implementatori:

Implementare questa interfaccia per consentire a un oggetto di partecipare alla propria serializzazione e deserializzazione.

Esempio di codice riportato di seguito viene illustrato l'utilizzo del ISerializable interfaccia per definire il comportamento di serializzazione personalizzata per una classe.

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
Disponibile da 1.1
Torna all'inizio
Mostra: