System.Runtime.Serialization.ISerializable Interface

Summary

Allows an object to control its own serialization and deserialization.

C# Syntax:

public interface ISerializable

Any class that might be serialized must be marked with the SerializableAttribute. If a class needs to control its serialization process, it can implement the ISerializable interface. The Formatter calls the ISerializable.GetObjectData at serialization time and populates the supplied SerializationInfo with all the data required to represent the object. The Formatter creates a SerializationInfo with the type of the object in the graph. Objects that need to send proxies for themselves can use the SerializationInfo.FullTypeName and SerializationInfo.AssemblyName methods on SerializationInfo to change the transmitted information.

If a parent class of the serialized class implements ISerializable, call the implementation of ISerializable.GetObjectData for your base class.

The ISerializable interface implies a constructor with the signature Constructor( SerializationInfo info, StreamingContext context). At deserialization time, the current constructor is called only after the data in the SerializationInfo has been deserialized by the formatter. In general this constructor should be protected if the class is not sealed.

The serialization architecture handles object types that extend MarshalByRefObject the same as types that extend Object. These types can be marked with the SerializableAttribute and implement the ISerializable interface as any other object type. Their object state will be captured and persisted onto the stream.

When these types are being used through System.Runtime.Remoting, the remoting infrastructure provides a surrogate that preempts normal serialization and instead serializes a proxy to the MarshalByRefObject. A surrogate is a helper that knows how to serialize and deserialize objects of a particular type. The proxy, invisible to the user in most cases, will be of type ObjRef.

As a general design pattern, it would be unusual for a class to be both marked with the serializable attribute and extend MarshalByRefObject. Developers should think carefully about the possible serialization and remoting scenarios when combining these two characteristics. One example where this might be applicable is with a MemoryStream. While the base class of MemoryStream ( Stream) extends from MarshalByRefObject, it is possible to capture the state of a MemoryStream and restore it at will. It might, therefore, be meaningful to serialize the state of this stream into a database and restore it at some later point in time. However, when used through remoting, an object of this type would be proxied.

For more details about serialization of classes that extend MarshalByRefObject see RemotingSurrogateSelector.

Notes to implementors: Implement this interface to allow an object to take part in its own serialization and deserialization.

The following code example demonstrates the use of the ISerializable interface to define custom serialization behavior for a class.

 using System;
 using System.IO;
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters.Binary;
 
 namespace Testing 
 {
    public class Test {
       public static void Main(String[] args) {
       // Creates a new MyClass1 object.
          MyClass1 f = new MyClass1();
    
          // Opens a file and serializes the object into it in binary format.
          Stream stream = File.Open("MyClass1MyClass2.bin", FileMode.Create);
          BinaryFormatter bformatter = new BinaryFormatter();
 
          bformatter.Serialize(stream, f);
          stream.Close();
    
          //Empties f.
          f = null;
    
          //Opens file "MyClass1MyClass2.bin" and deserializes the MyClass1 object from it.
          stream = File.Open("MyClass1MyClass2.bin", FileMode.Open);
          bformatter = new BinaryFormatter();
          f = (MyClass1)bformatter.Deserialize(stream);
          stream.Close();
       }
    }
 

    [Serializable()] 
    public class MyClass1: ISerializable {

       public MyClass2 someObject;
       public int size;
       public String shape;

       //Default constructor
       public MyClass1() {
          someObject = new MyClass2();
       }
 
       //Deserialization constructor.
       public MyClass1 (SerializationInfo info, StreamingContext context) {
          size = (int)info.GetValue("size", typeof(int));
          shape = (String)info.GetValue("shape", typeof(string));

          //Allows MyClass2 to deserialize itself
          someObject = new MyClass2(info, context);
       }
 
       //Serialization function.
       public void GetObjectData(SerializationInfo info, StreamingContext context){
          info.AddValue("size", size);
          info.AddValue("shape", shape);

          //Allows MyClass2 to serialize itself
          someObject.GetObjectData(info, context);
       }
    }
 
    public class MyClass2 {
 
       public double value = 3.14159265;

       public MyClass2() {
       }

       public MyClass2(SerializationInfo info, StreamingContext context) {
           value = (double)info.GetValue("MyClass2_value", typeof(double));
       }

 
       public void GetObjectData(SerializationInfo info, StreamingContext context) {
          info.AddValue("MyClass2_value", value);
       }

    }
 }

    

System.Runtime.Serialization Namespace See also:
MSDN: serialization | RemotingSurrogateSelector

System.Runtime.Serialization.ISerializable Member List:

Public Methods

GetObjectData

Populates a SerializationInfo with the data needed to serialize the target object.

System.Runtime.Serialization.ISerializable Member Details

Summary

Populates a SerializationInfo with the data needed to serialize the target object.

C# Syntax:

void GetObjectData(    SerializationInfo info,    StreamingContext context );

info

The SerializationInfo to populate with data.

context

The destination (see StreamingContext) for this serialization.

Any objects included in the SerializationInfo are automatically tracked and serialized by the formatter.

Return to top

Top of page