IDeserializationCallbackとは何？わかりやすく解説 Weblio辞書

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

索引トップ用語の索引ランキング

IDeserializationCallback インターフェイス

オブジェクトグラフ全体の逆シリアル化が完了した時点でクラスに通知することを示します。

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

Visual Basic (宣言)

<ComVisibleAttribute(True)> _
Public Interface IDeserializationCallback

Visual Basic (使用法)

Dim instance As IDeserializationCallback

[ComVisibleAttribute(true)] 
public interface IDeserializationCallback

C++

[ComVisibleAttribute(true)] 
public interface class IDeserializationCallback

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

JScript

ComVisibleAttribute(true) 
public interface IDeserializationCallback

解説

実装時の注意 オブジェクトグラフの逆シリアル化が完了すると呼び出されるメソッドに対するサポートの一部として、現在のインターフェイスを実装します。オブジェクトがその子オブジェクトでコードを実行する必要がある場合は、このアクションを延期し、IDeserializationCallback を実装して、このインターフェイスでコールバックされたときにだけコードを実行できます。

使用例

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

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();
}

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