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

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

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