Imports System
Imports System.Web
Imports System.IO
Imports System.Collections
Imports System.Runtime.Serialization.Formatters.Binary
Imports System.Runtime.Serialization
Imports System.Security.Permissions


' There should be only one instance of this type per AppDomain.
<Serializable()> _
Public NotInheritable Class Singleton
   Implements ISerializable

   ' This is the one instance of this type.
   Private Shared ReadOnly theOneObject As New Singleton

   ' Here are the instance fields.
   Public someString As String
   Public someNumber As Int32

   ' Private constructor allowing this type to construct the Singleton.
   Private Sub New()
      ' Do whatever is necessary to initialize the Singleton.
      someString = "This is a string field"
      someNumber = 123
   End Sub

   ' A method returning a reference to the Singleton.
   Public Shared Function GetSingleton() As Singleton
      Return theOneObject
   End Function

   ' A method called when serializing a Singleton.
   <SecurityPermissionAttribute(SecurityAction.LinkDemand, _
   Flags:=SecurityPermissionFlag.SerializationFormatter)> _
   Private Sub GetObjectData(ByVal info As SerializationInfo, _
      ByVal context As StreamingContext) _
      Implements ISerializable.GetObjectData

      ' Instead of serializing this object, we will  
      ' serialize a SingletonSerializationHelp instead.
      info.SetType(GetType(SingletonSerializationHelper))
      ' No other values need to be added.
   End Sub

   ' Note: ISerializable's special constructor is not necessary 
   ' because it is never called.
End Class


<Serializable()> _
Friend NotInheritable Class SingletonSerializationHelper
   Implements IObjectReference
   ' This object has no fields (although it could).

   ' GetRealObject is called after this object is deserialized.
   Public Function GetRealObject(ByVal context As StreamingContext) As Object Implements IObjectReference.GetRealObject
      ' When deserialiing this object, return a reference to 
      ' the Singleton object instead.
      Return Singleton.GetSingleton()
   End Function
End Class


Class App
   <STAThread()> Shared Sub Main()
        Run()
    End Sub

    Shared Sub Run()
        Dim fs As New FileStream("DataFile.dat", FileMode.Create)

        Try
            ' Construct a BinaryFormatter and use it 
            ' to serialize the data to the stream.
            Dim formatter As New BinaryFormatter

            ' Create an array with multiple elements refering to 
            ' the one Singleton object.
            Dim a1() As Singleton = {Singleton.GetSingleton(), Singleton.GetSingleton()}

            ' This displays "True".
            Console.WriteLine("Do both array elements refer to the same object? " & _
               Object.ReferenceEquals(a1(0), a1(1)))

            ' Serialize the array elements.
            formatter.Serialize(fs, a1)

            ' Deserialize the array elements.
            fs.Position = 0
            Dim a2() As Singleton = DirectCast(formatter.Deserialize(fs), Singleton())

            ' This displays "True".
            Console.WriteLine("Do both array elements refer to the same object? " & _
               Object.ReferenceEquals(a2(0), a2(1)))

            ' This displays "True".
            Console.WriteLine("Do all array elements refer to the same object? " & _
               Object.ReferenceEquals(a1(0), a2(0)))
        Catch e As SerializationException
            Console.WriteLine("Failed to serialize. Reason: " & e.Message)
            Throw
        Finally
            fs.Close()
        End Try

    End Sub
End Class

using System;
using System.Web;
using System.IO;
using System.Collections;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using System.Security.Permissions;


// There should be only one instance of this type per AppDomain.
[Serializable]
public sealed class Singleton : ISerializable 
{
    // This is the one instance of this type.
    private static readonly Singleton theOneObject = new Singleton();

    // Here are the instance fields.
    private string someString_value;
    private Int32 someNumber_value;

   public string SomeString
   {
       get{return someString_value;}
       set{someString_value = value;}
   }

   public Int32 SomeNumber
   {
       get{return someNumber_value;}
       set{someNumber_value = value;}
   }

    // Private constructor allowing this type to construct the Singleton.
    private Singleton() 
    { 
        // Do whatever is necessary to initialize the Singleton.
        someString_value = "This is a string field";
        someNumber_value = 123;
    }

    // A method returning a reference to the Singleton.
    public static Singleton GetSingleton() 
    { 
        return theOneObject; 
    }

    // A method called when serializing a Singleton.
    [SecurityPermissionAttribute(SecurityAction.LinkDemand, 
    Flags=SecurityPermissionFlag.SerializationFormatter)]
    void ISerializable.GetObjectData(
        SerializationInfo info, StreamingContext context) 
    {
        // Instead of serializing this object, 
        // serialize a SingletonSerializationHelp instead.
        info.SetType(typeof(SingletonSerializationHelper));
        // No other values need to be added.
    }

    // Note: ISerializable's special constructor is not necessary 
    // because it is never called.
}


[Serializable]
internal sealed class SingletonSerializationHelper : IObjectReference 
{
    // This object has no fields (although it could).

    // GetRealObject is called after this object is deserialized.
    public Object GetRealObject(StreamingContext context) 
    {
        // When deserialiing this object, return a reference to 
        // the Singleton object instead.
        return Singleton.GetSingleton();
    }
}


class App 
{
    [STAThread]
    static void Main() 
    {
        FileStream fs = new FileStream("DataFile.dat", FileMode.Create);

        try 
        {
            // Construct a BinaryFormatter and use it 
            // to serialize the data to the stream.
            BinaryFormatter formatter = new BinaryFormatter();

            // Create an array with multiple elements refering to 
            // the one Singleton object.
            Singleton[] a1 = { Singleton.GetSingleton(), Singleton.GetSingleton() };

            // This displays "True".
            Console.WriteLine(
                "Do both array elements refer to the same object? " + 
                (a1[0] == a1[1]));     

            // Serialize the array elements.
            formatter.Serialize(fs, a1);

            // Deserialize the array elements.
            fs.Position = 0;
            Singleton[] a2 = (Singleton[]) formatter.Deserialize(fs);

            // This displays "True".
            Console.WriteLine("Do both array elements refer to the same object? " 
                + (a2[0] == a2[1])); 

            // This displays "True".
            Console.WriteLine("Do all array elements refer to the same object? " 
                + (a1[0] == a2[0]));
        }   
        catch (SerializationException e) 
        {
            Console.WriteLine("Failed to serialize. Reason: " + e.Message);
            throw;
        }
        finally 
        {
            fs.Close();
        }
    }
}

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

ref class SingletonSerializationHelper;

// There should be only one instance of this type per AppDomain.

[Serializable]
public ref class Singleton sealed: public ISerializable
{
private:

   // This is the one instance of this type.
   static Singleton^ theOneObject = gcnew Singleton;

public:

   // Here are the instance fields.
   String^ someString;
   Int32 someNumber;

private:

   // Private constructor allowing this type to construct the singleton.
   Singleton()
   {

      // Do whatever is necessary to initialize the singleton.
      someString = "This is a String* field";
      someNumber = 123;
   }

public:

   // A method returning a reference to the singleton.
   static Singleton^ GetSingleton()
   {
      return theOneObject;
   }

   // A method called when serializing a Singleton.
   [System::Security::Permissions::SecurityPermissionAttribute
   (System::Security::Permissions::SecurityAction::LinkDemand, 
   Flags=System::Security::Permissions::SecurityPermissionFlag::SerializationFormatter)]
   virtual void GetObjectData( SerializationInfo^ info, StreamingContext context )
   {
      // Instead of serializing this Object*, we will  
      // serialize a SingletonSerializationHelp instead.
      info->SetType( SingletonSerializationHelper::typeid );

      // No other values need to be added.
   }

   // NOTE: ISerializable*'s special constructor is NOT necessary 
   // because it's never called
};

[Serializable]
private ref class SingletonSerializationHelper sealed: public IObjectReference
{
public:

   // This Object* has no fields (although it could).
   // GetRealObject is called after this Object* is deserialized
   virtual Object^ GetRealObject( StreamingContext context )
   {
      // When deserialiing this Object*, return a reference to 
      // the singleton Object* instead.
      return Singleton::GetSingleton();
   }
};

[STAThread]
int main()
{
   FileStream^ fs = gcnew FileStream( "DataFile.dat",FileMode::Create );
   try
   {
      // Construct a BinaryFormatter and use it 
      // to serialize the data to the stream.
      BinaryFormatter^ formatter = gcnew BinaryFormatter;

      // Create an array with multiple elements refering to 
      // the one Singleton Object*.
      array<Singleton^>^a1 = {Singleton::GetSingleton(),Singleton::GetSingleton()};

      // This displays S"True".
      Console::WriteLine( "Do both array elements refer to the same Object? {0}", (a1[ 0 ] == a1[ 1 ]) );

      // Serialize the array elements.
      formatter->Serialize( fs, a1 );

      // Deserialize the array elements.
      fs->Position = 0;
      array<Singleton^>^a2 = (array<Singleton^>^)formatter->Deserialize( fs );

      // This displays S"True".
      Console::WriteLine( "Do both array elements refer to the same Object? {0}", (a2[ 0 ] == a2[ 1 ]) );

      // This displays S"True".
      Console::WriteLine( "Do all  array elements refer to the same Object? {0}", (a1[ 0 ] == a2[ 0 ]) );
   }
   catch ( SerializationException^ e ) 
   {
      Console::WriteLine( "Failed to serialize. Reason: {0}", e->Message );
      throw;
   }
   finally
   {
      fs->Close();
   }

   return 0;
}

#using <mscorlib.dll>
#using <System.dll>
#using <System.Web.dll>

using namespace System;
using namespace System::Web;
using namespace System::IO;
using namespace System::Collections;
using namespace System::Runtime::Serialization::Formatters::Binary;
using namespace System::Runtime::Serialization;
using namespace System::Security::Permissions;


private __sealed __gc class SingletonSerializationHelper;

// There should be only one instance of this type per AppDomain.
[Serializable]
[AspNetHostingPermission(SecurityAction::LinkDemand, 
    Level=AspNetHostingPermissionLevel::Minimal)]
public __gc __sealed class Singleton : public ISerializable 
{
    // This is the one instance of this type.
private:
    static Singleton* theOneObject = new Singleton();

    // Here are the instance fields.
public:
    String* someString;
    Int32 someNumber;

    // Private constructor allowing this type to construct the singleton.
private:
    Singleton() 
    { 
        // Do whatever is necessary to initialize the singleton.
        someString = S"This is a String* field";
        someNumber = 123;
    }

    // A method returning a reference to the singleton.
public:
    static Singleton* GetSingleton() 
    { 
        return theOneObject; 
    }

    // A method called when serializing a Singleton.
    void GetObjectData(SerializationInfo* info, StreamingContext context) 
    {
        // Instead of serializing this Object*, we will  
        // serialize a SingletonSerializationHelp instead.
        info->SetType(__typeof(SingletonSerializationHelper));
        // No other values need to be added.
    }

    // NOTE: ISerializable*'s special constructor is NOT necessary 
    // because it's never called
};

[Serializable]
[AspNetHostingPermission(SecurityAction::LinkDemand, 
   Level=AspNetHostingPermissionLevel::Minimal)]
private __gc __sealed class SingletonSerializationHelper : public IObjectReference 
    {
        // This Object* has no fields (although it could).
        // GetRealObject is called after this Object* is deserialized
    public:
        Object* GetRealObject(StreamingContext context) 
        {
            // When deserialiing this Object*, return a reference to 
            // the singleton Object* instead.
            return Singleton::GetSingleton();
        }
    };

[STAThread]
int main() 
{
    FileStream* fs = new FileStream(S"DataFile.dat", FileMode::Create);

    try 
    {
        // Construct a BinaryFormatter and use it 
        // to serialize the data to the stream.
        BinaryFormatter* formatter = new BinaryFormatter();

        // Create an array with multiple elements refering to 
        // the one Singleton Object*.
        Singleton* a1[] = { Singleton::GetSingleton(), Singleton::GetSingleton() };

        // This displays S"True".
        Console::WriteLine(S"Do both array elements refer to the same Object? {0}", __box((a1->Item[0] == a1->Item[1])));

        // Serialize the array elements.
        formatter->Serialize(fs, a1);

        // Deserialize the array elements.
        fs->Position = 0;
        Singleton* a2[] = (Singleton* __gc[]) formatter->Deserialize(fs);

        // This displays S"True".
        Console::WriteLine(S"Do both array elements refer to the same Object? {0}", __box((a2->Item[0] == a2->Item[1]))); 

        // This displays S"True".
        Console::WriteLine(S"Do all  array elements refer to the same Object? {0}", __box((a1->Item[0] == a2->Item[0])));
    } 
    catch (SerializationException* e) 
    {
        Console::WriteLine(S"Failed to serialize. Reason: {0}", e->Message);
        throw;
    }
    __finally 
    {
        fs->Close();
    }
    return 0;
}