IDeserializationCallback.OnDeserialization メソッド

.NET Framework クラス ライブラリ リファレンス

IDeserializationCallback.OnDeserialization メソッド

オブジェクト グラフ全体が逆シリアル化された時点で実行します。

名前空間: System.Runtime.Serialization
アセンブリ: mscorlib (mscorlib.dll 内)
構文

Visual Basic (宣言)

Sub OnDeserialization ( _
    sender As Object _
)

Visual Basic (使用法)

Dim instance As IDeserializationCallback
Dim sender As Object

instance.OnDeserialization(sender)

C#

void OnDeserialization (
    Object sender
)

C++

void OnDeserialization (
    Object^ sender
)

J#

void OnDeserialization (
    Object sender
)

JScript

function OnDeserialization (
    sender : Object
)

パラメータ

sender

コールバックを開始したオブジェクト。このパラメータの機能は、現在実装されていません。

使用例

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 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]
ref class Circle: public IDeserializationCallback
{
private:
   Double m_radius;

public:

   // 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]
   Double m_area;
   Circle( Double radius )
   {
      m_radius = radius;
      m_area = Math::PI * radius * radius;
   }

   virtual 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;
   }

   virtual String^ ToString() override
   {
      return String::Format( "radius= {0}, area= {1}",
 m_radius, m_area );
   }
};

void Serialize()
{
   Circle^ c = gcnew Circle( 10 );
   Console::WriteLine( "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 = gcnew FileStream( "DataFile.dat",FileMode::Create );

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

void Deserialize()
{
   // Declare the Circle reference.
   Circle^ c = nullptr;

   // Open the file containing the data that we want to deserialize.
   FileStream^ fs = gcnew FileStream( "DataFile.dat",FileMode::Open );
   try
   {
      BinaryFormatter^ formatter = gcnew 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( "Failed to deserialize. Reason: {0}", e->Message
 );
      throw;
   }
   finally
   {
      fs->Close();
   }

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

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

J#

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

開発プラットフォームの中には、.NET Framework によってサポートされていないバージョンがあります。サポートされているバージョンについては、「システム要件」を参照してください。

バージョン情報

.NET Framework
サポート対象 : 2.0、1.1、1.0

参照

関連項目
IDeserializationCallback インターフェイス
IDeserializationCallback メンバ
System.Runtime.Serialization 名前空間
その他の技術情報
イベントとデリゲート
XML シリアル化および SOAP シリアル化