Export (0) Print
Expand All

IDeserializationCallback Interface

Indicates that a class is to be notified when deserialization of the entire object graph has been completed.

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

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

Notes to Implementers Implement the current interface as part of support for a method that is called when deserialization of the object graph is complete. If an object needs to execute code on its child objects, it can delay this action, implement IDeserializationCallback, and execute the code only when it is called back on this interface.

using System;
using System.IO;
using System.Collections;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;

// This class is serializable and will have its OnDeserialization method
// called after each instance of this class is deserialized.
[Serializable]
class Circle : IDeserializationCallback 
{
    Double m_radius;

    // To reduce the size of the serialization stream, the field below is 
    // not serialized. This field is calculated when an object is constructed
    // or after an instance of this class is deserialized.
    [NonSerialized] public Double m_area;

    public Circle(Double radius) 
    {
        m_radius = radius;
        m_area = Math.PI * radius * radius;
    }

    void IDeserializationCallback.OnDeserialization(Object sender) 
    {
        // After being deserialized, initialize the m_area field 
        // using the deserialized m_radius value.
        m_area = Math.PI * m_radius * m_radius;
    }

    public override String ToString() 
    {
        return String.Format("radius={0}, area={1}", m_radius, m_area);
    }
}


class Class1 
{
    [STAThread]
    static void Main(string[] args) 
    {
        Serialize();
        Deserialize();
    }

    static void Serialize() 
    {
        Circle c = new Circle(10);
        Console.WriteLine("Object being serialized: " + c.ToString());

        // To serialize the Circle, you must first open a stream for 
        // writing. Use a file stream here.
        FileStream fs = new FileStream("DataFile.dat", FileMode.Create);

        // Construct a BinaryFormatter and use it 
        // to serialize the data to the stream.
        BinaryFormatter formatter = new BinaryFormatter();
        try 
        {
            formatter.Serialize(fs, c);
        }
        catch (SerializationException e) 
        {
            Console.WriteLine("Failed to serialize. Reason: " + e.Message);
            throw;
        }
        finally 
        {
            fs.Close();
        }
    }

   
    static void Deserialize() 
    {
        // Declare the Circle reference.
        Circle c = null;

        // Open the file containing the data that you want to deserialize.
        FileStream fs = new FileStream("DataFile.dat", FileMode.Open);
        try 
        {
            BinaryFormatter formatter = new BinaryFormatter();

            // Deserialize the Circle from the file and 
            // assign the reference to the local variable.
            c = (Circle) formatter.Deserialize(fs);
        }
        catch (SerializationException e) 
        {
            Console.WriteLine("Failed to deserialize. Reason: " + e.Message);
            throw;
        }
        finally 
        {
            fs.Close();
        }

        // To prove that the Circle deserialized correctly, display its area.
        Console.WriteLine("Object being deserialized: " + c.ToString());
    }
}

import System.*;
import System.IO.*;
import System.Collections.*;
import System.Runtime.Serialization.Formatters.Binary.*;
import System.Runtime.Serialization.*;

// This class is serializable and will have its OnDeserialization method
// called after each instance of this class is deserialized.
/** @attribute Serializable()
 */
class Circle implements IDeserializationCallback
{
    private double mRadius;

    // To reduce the size of the serialization stream, the field below is 
    // not serialized. This field is calculated when an object is constructed
    // or after an instance of this class is deserialized.
    /** @attribute NonSerialized()
     */
    public double mArea;

    public Circle(double radius)
    {
        mRadius = radius;
        mArea = Math.PI * radius * radius;
    } //Circle

    public void OnDeserialization(Object sender)
    {
        // After being deserialized, initialize the mArea field 
        // using the deserialized mRadius value.
        mArea = Math.PI * mRadius * mRadius;
    } //IDeserializationCallback.OnDeserialization

    public String ToString()
    {
        return String.Format("radius={0}, area={1}",
            System.Convert.ToString(mRadius),System.Convert.ToString(mArea));
    } //ToString
} //Circle

class Class1
{
    /** @attribute STAThread()
     */
    public static void main(String[] args) throws SerializationException 
    {
        Serialize();
        try {
            Deserialize();
        }
        catch (SerializationException e) { 
        }
    } //main

    static void Serialize() throws SerializationException 
    {
        Circle c = new Circle(System.Convert.ToDouble(10));
        Console.WriteLine("Object being serialized: " + c.ToString());

        // To serialize the Circle, you must first open a stream for 
        // writing. Use a file stream here.
        FileStream fs = new FileStream("DataFile.dat", FileMode.Create);
        // Construct a BinaryFormatter and use it 
        // to serialize the data to the stream.
        BinaryFormatter formatter = new BinaryFormatter();

        try {
            formatter.Serialize(fs, c);
        }
        catch (SerializationException e) {
            Console.WriteLine("Failed to serialize. Reason: " 
                + e.get_Message());
            throw e;
        }
        finally {
            fs.Close();
        }
    } //Serialize

    static void Deserialize() throws SerializationException
    {
        // Declare the Circle reference.
        Circle c = null;

        // Open the file containing the data that you want to deserialize.
        FileStream fs = new FileStream("DataFile.dat", FileMode.Open);

        try {
            BinaryFormatter formatter = new BinaryFormatter();
            // Deserialize the Circle from the file and 
            // assign the reference to the local variable.
            c = (Circle)(formatter.Deserialize(fs));
        }
        catch (SerializationException e) {
            Console.WriteLine("Failed to deserialize. Reason: " 
                + e.get_Message());
            throw e;
        }
        finally {
            fs.Close();
        }
        // To prove that the Circle deserialized correctly, display its area.
        Console.WriteLine("Object being deserialized: " + c.ToString());
    } //Deserialize
} //Class1

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

The .NET Framework does not support all versions of every platform. For a list of the supported versions, see System Requirements.

.NET Framework

Supported in: 2.0, 1.1, 1.0

Community Additions

ADD
Show:
© 2014 Microsoft