Exportieren (0) Drucken
Alle erweitern

ISerializable-Schnittstelle

Aktualisiert: November 2007

Ermöglicht einem Objekt, die eigene Serialisierung und Deserialisierung zu überwachen.

Namespace:  System.Runtime.Serialization
Assembly:  mscorlib (in mscorlib.dll)

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

Alle Klassen, die möglicherweise serialisiert werden, müssen mit dem SerializableAttribute markiert werden. Wenn eine Klasse die eigene Serialisierung überwachen muss, kann diese die ISerializable-Schnittstelle implementieren. Der Formatter ruft während der Serialisierung GetObjectData auf und füllt die angegebene SerializationInfo mit allen zur Darstellung des Objekts erforderlichen Daten. Der Formatter erstellt eine SerializationInfo mit dem Typ des Objekts im Diagramm. Objekte, die Proxys senden müssen, können die übertragenen Informationen mithilfe der FullTypeName-Methode und der AssemblyName-Methode für die SerializationInfo ändern.

Im Fall der Klassenvererbung kann eine Klasse, die von einer Basisklasse abgeleitet ist, die ISerializable implementiert, serialisiert werden. In diesem Fall sollte die abgeleitete Klasse die Basisklassenimplementierung von GetObjectData in ihrer Implementierung von GetObjectData aufrufen. Andernfalls werden die Daten von der Basisklasse nicht serialisiert.

Die ISerializable-Schnittstelle impliziert einen Konstruktor mit der Signatur Konstruktor(SerializationInfo-Informationen, StreamingContext-Kontext). Während der Deserialisierung wird der aktuelle Konstruktor erst aufgerufen, nachdem die Daten in der SerializationInfo vom Formatierungsprogramm deserialisiert wurden. Dieser Konstruktor sollte i. d. R. geschützt sein, sofern die Klasse nicht versiegelt ist.

Die Reihenfolge, in der Objekte deserialisiert werden, kann nicht garantiert werden. Wenn beispielsweise ein Typ auf einen noch nicht deserialisierten Typ verweist, tritt eine Ausnahme auf. Beim Erstellen von Typen mit derartigen Abhängigkeiten umgehen Sie dieses Problem, indem Sie die IDeserializationCallback-Schnittstelle und die OnDeserialization-Methode implementieren.

Die Serialisierungsarchitektur behandelt Objekttypen, die MarshalByRefObject erweitern, wie Typen, die Object erweitern. Diese Typen können wie alle anderen Objekttypen mit dem SerializableAttribute markiert werden und die ISerializable-Schnittstelle implementieren. Der Objektzustand der Typen wird aufgezeichnet und im Stream gespeichert.

Wenn diese Typen über System.Runtime.Remoting verwendet werden, stellt die Remotinginfrastruktur einen Ersatz bereit, der Vorrang vor der normalen Serialisierung hat und stattdessen einen Proxy in das MarshalByRefObject serialisiert. Ein Ersatz ist eine Hilfsfunktion, die Objekte eines bestimmten Typs serialisieren und deserialisieren kann. Der Proxy, der den Benutzern i. d. R. nicht sichtbar ist, ist vom Typ ObjRef.

In allgemein üblichen Entwurfsmustern wird eine Klasse, die MarshalByRefObject erweitert, i. d. R. nicht mit dem serializable-Attribut markiert Entwickler sollten bei der Kombination dieser beiden Merkmale die möglichen Serialisierungs- und Remoteszenarien genau überdenken. Eine Anwendungsmöglichkeit ist z. B. ein MemoryStream. Obwohl die Basisklasse von MemoryStream (Stream) eine Erweiterung von MarshalByRefObject ist, kann der Zustand eines MemoryStream nach Belieben aufgezeichnet und wiederhergestellt werden. Es kann deshalb sinnvoll sein, den Zustand dieses Streams in eine Datenbank zu serialisieren und zu einem späteren Zeitpunkt wiederherzustellen. Objekte dieses Typs würden jedoch in einer Remotesituation über ein Proxy übermittelt werden.

Weitere Informationen über die Serialisierung von Klassen, die MarshalByRefObject erweitern, finden Sie unter RemotingSurrogateSelector. Weitere Informationen über das Implementieren von ISerializable finden Sie unter Benutzerdefinierte Serialisierung.

Hinweise zur Implementierung:

Implementieren Sie diese Schnittstelle, damit ein Objekt an der eigenen Serialisierung und Deserialisierung teilnehmen kann.

Im folgenden Codebeispiel wird die Definition eines benutzerdefinierten Serialisierungsverhaltens einer Klasse mithilfe der ISerializable-Schnittstelle veranschaulicht.

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

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0, 2.0, 1.1, 1.0

Community-Beiträge

HINZUFÜGEN
Anzeigen:
© 2015 Microsoft