Information
The topic you requested is included in another documentation set. For convenience, it's displayed below. Choose Switch to see the topic in its original location.

IDeserializationCallback Interface

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

For a list of all members of this type, see IDeserializationCallback Members.

[Visual Basic]
Public Interface IDeserializationCallback
[C#]
public interface IDeserializationCallback
[C++]
public __gc __interface IDeserializationCallback
[JScript]
public interface IDeserializationCallback

Classes that Implement IDeserializationCallback

Class Description
AssemblyName Describes an assembly's unique identity in full.
CompareInfo Implements a set of methods for culture-sensitive string comparisons.
Hashtable Represents a collection of key-and-value pairs that are organized based on the hash code of the key.
NameObjectCollectionBase Provides the abstract (MustInherit in Visual Basic) base class for a collection of associated String keys and Object values that can be accessed either with the key or with the index.
PermissionSet Represents a collection that can contain many different types of permissions.
TextInfo Defines properties and behaviors, such as casing, that are specific to a writing system.
WindowsIdentity Represents a Windows user.

Remarks

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.

Example

[Visual Basic] 
Imports System
Imports System.IO
Imports System.Collections
Imports System.Runtime.Serialization.Formatters.Binary
Imports 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
   Implements IDeserializationCallback
   Private m_radius As Double

   ' 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 m_area As Double

   Public Sub New(ByVal radius As Double)
      m_radius = radius
      m_area = Math.PI * radius * radius
   End Sub

   Private Sub OnDeserialization(ByVal sender As Object) _
      Implements IDeserializationCallback.OnDeserialization
      ' After being deserialized, initialize the m_area field 
      ' using the deserialized m_radius value.
      m_area = Math.PI * m_radius * m_radius
   End Sub

   Public Overrides Function ToString() As String
      Return String.Format("radius={0}, area={1}", m_radius, m_area)
   End Function
End Class


Class Class1
   <STAThread()> Shared Sub Main()
      Serialize()
      Deserialize()
   End Sub

   Shared Sub Serialize()
      Dim c As 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.
      Dim fs As New FileStream("DataFile.dat", FileMode.Create)

      ' Construct a BinaryFormatter and use it 
      ' to serialize the data to the stream.
      Dim formatter As New BinaryFormatter
      Try
         formatter.Serialize(fs, c)
      Catch e As SerializationException
         Console.WriteLine("Failed to serialize. Reason: " + e.Message)
         Throw
      Finally
         fs.Close()
      End Try
   End Sub


   Shared Sub Deserialize()
      ' Declare the Circle reference
      Dim c As Circle = Nothing

      ' Open the file containing the data that you want to deserialize.
      Dim fs As New FileStream("DataFile.dat", FileMode.Open)
      Try
         Dim formatter As New BinaryFormatter

         ' Deserialize the Circle from the file and 
         ' assign the reference to the local variable.
         c = CType(formatter.Deserialize(fs), Circle)
      Catch e As SerializationException
         Console.WriteLine("Failed to deserialize. Reason: " + e.Message)
         Throw
      Finally
         fs.Close()
      End Try

      ' To prove that the Circle deserialized correctly, display its area.
      Console.WriteLine("Object being deserialized: " + c.ToString())
   End Sub
End Class

[C#] 
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());
    }
}

[C++] 
#using <mscorlib.dll>

using namespace System;
using namespace System::IO;
using namespace System::Collections;
using namespace System::Runtime::Serialization::Formatters::Binary;
using namespace System::Runtime::Serialization;

// This class is serializable and will have its OnDeserialization method
// called after each instance of this class is deserialized.
[Serializable]
__gc class Circle : public 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.
public:
   [NonSerialized]
   Double m_area;

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

   void 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:
   String* ToString() 
   {
      return String::Format(S"radius= {0}, area= {1}", __box(m_radius), __box(m_area));
   }
};


void Serialize() 
{
   Circle* c = new Circle(10);
   Console::WriteLine(S"Object being serialized: {0}", c);

   // To serialize the Circle, you must first open a stream for 
   // writing. We will use a file stream here.
   FileStream* fs = new FileStream(S"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(S"Failed to serialize. Reason: {0}", e->Message);
      throw;
   }
   __finally 
   {
      fs->Close();
   }
}

void Deserialize() 
{
   // Declare the Circle reference.
   Circle* c = 0;

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

      // Deserialize the Circle from the file and 
      // assign the reference to our local variable.
      c = dynamic_cast<Circle*>(formatter->Deserialize(fs));
   } 
   catch (SerializationException* e) 
   {
      Console::WriteLine(S"Failed to deserialize. Reason: {0}", e->Message);
      throw;
   }
   __finally 
   {
      fs->Close();
   }

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

[STAThread]
int main() 
{
   Serialize();
   Deserialize();
}

[JScript] No example is available for JScript. To view a Visual Basic, C#, or C++ example, click the Language Filter button Language Filter in the upper-left corner of the page.

Requirements

Namespace: System.Runtime.Serialization

Platforms: Windows 98, Windows NT 4.0, Windows Millennium Edition, Windows 2000, Windows XP Home Edition, Windows XP Professional, Windows Server 2003 family

Assembly: Mscorlib (in Mscorlib.dll)

See Also

IDeserializationCallback Members | System.Runtime.Serialization Namespace | Events and Delegates | XML and SOAP Serialization

Was this page helpful?
(1500 characters remaining)
Thank you for your feedback
Show:
© 2014 Microsoft