Serialization

While implementing a serialization mechanism in an object-oriented environment, we have to make a number of tradeoffs between ease of use and flexibility. The process can be automated to a large extent, provided you are given sufficient control over the process. For example, situations may arise where simple binary serialization is not sufficient, or there might be a specific reason to decide which fields in a class need to be serialized.

To create the serialization program to add data to file in binaryformat and SOAPformat and then by using deserialization we retrieve data from the same file.

1.     Declare Class hierarchy as [serializable]

2.     Include namespace System.Runtime.Serialization.Formatters.Binary or System.Runtime.Serialization.Formatters.Soap

3.     Create and intantiation of object.

4.     Create and Intantiation of FileStream Object

5.     Create and Instantiation of BinaryFormatter or SoapFormatter object

6.     For Serialization: use method serialize of class BanaryFormatter/Soap Formatter

7.     For DeSerialization: use method deserialize of class BanaryFormatter/Soap Formatter

using System;

using System.Collections.Generic;

using System.Text;

namespace SerializationSample

{

//    [Serializable] – To make class serializable

//    Each and every base class must be declared as Serializable to make child class serializable.

      [Serializable]

//    Defination of base class Person

public  class Person

      {

            private string _personName;

            public string PersonName

            {

                  get { return _personName; }

                  set { _personName = value; }

            }

            private int _age;

            public int Age

            {

                  get { return _age; }

                  set { _age = value; }

            }

            public Person(string name, int age)

            {

                  _personName = name;

                  _age = age;

            }

      }

}

using System;

using System.Collections.Generic;

using System.Text;

namespace SerializationSample

{   

//    Full Hierarchi must be declared as [Serializable]

[Serializable]

//    Defination of employee class begins .

//    Base class is Person

      public class employee:Person

      {

            private int _empid;

            public int EmpId

            {

                  get { return _empid; }

                  set { _empid = value; }

            }

            private decimal _basic;

            public decimal Basic

            {

                  get { return _basic; }

                  set { _basic = value; }

            }

      public employee(string _personName,int _age,int empid,decimal basic):base (_personName,_age)

      {

            _empid=empid;

            _basic=basic;

      }

      }

}

//    End of Defination of employee class

using System;

using System.Collections.Generic;

using System.ComponentModel;

using System.Data;

using System.Drawing;

using System.Text;

using System.Windows.Forms;

using System.IO;

//    namespace for Binary formatter

using System.Runtime.Serialization.Formatters.Binary;

//    namespace for Soap formatter

using System.Runtime.Serialization.Formatters.Soap;

//    Starting for windows application

namespace SerializationSample

{

      public partial class Form1 : Form

      {

            public Form1()

            {

                  InitializeComponent();

            }

            private void button1_Click(object sender, EventArgs e)

            {

FileStream fstream=null;

//Binary formatter object declaration

                  BinaryFormatter binaryformat=null;

                  try

                  {

                        //Person p = new Person(“scott”, 25);

                        employee lk = new employee(“deependra”, 23, 77619, 20000);

                        //Instantiation of FileStream Object

                        fstream = new FileStream(“Person.txt”, FileMode.Create, FileAccess.Write);

                        // Instantiation of BinaryFormatter Object

                        binaryformat = new BinaryFormatter();

                        //Serialize method is called –

                        // arguments are <FileStream Object> and <ClassName which going to be serialized> .

                        // It stores object in file.

                        binaryformat.Serialize(fstream, lk);

                        MessageBox.Show(“Employee object in binary FORMAT “);

                  }

                  catch (Exception k)

                  {

                        MessageBox.Show(k.Message);

                  }

                  finally

                  {

                        fstream.Close();

                  }

            }

            private void button2_Click(object sender, EventArgs e)

            {

                  BinaryFormatter binaryformat = null;

                  FileStream fstream = null;

                  try

                  {

                        fstream = new FileStream(“Person.txt”, FileMode.Open, FileAccess.Read);

                        binaryformat = new BinaryFormatter();

      //Deserialization of employee object

      //Input Parameters is FileStream object

      //Return type is an object

                        employee lk = binaryformat.Deserialize(fstream) as employee;

      // Showing the Data in Message Box Format

                        string message=string.Format(“Employee Name:{0}\nEmployee Age:{1} \nEmployee Id :{2}\nEmployee Basic:{3}”,lk.PersonName,lk.Age,lk.EmpId,lk.Basic);

                        MessageBox.Show(message);

                  }

                  catch(Exception ex)

                  {

                        MessageBox.Show(“ERROR:”,ex.Message);

                  }

                  finally

                  {

                        fstream.Close();

                  }

            }

            private void Form1_Load(object sender, EventArgs e)

            {

            }

      //DeSerialization using SoapFormatter

      //Steps and Methods are same as Binary Formatter     

private void button4_Click(object sender, EventArgs e)

            {

                  SoapFormatter soapformat = null;

                  FileStream fstream = null;

                  try

                  {

                        fstream = new FileStream(“PersonSOAP.txt”, FileMode.Open, FileAccess.Read);

                        soapformat = new SoapFormatter();

                        Person p = soapformat.Deserialize(fstream) as Person;

                        string message = string.Format(“Person Name:{0}\nPerson Age:{1}”, p.PersonName, p.Age);

                        MessageBox.Show(message);

                  }

                  catch (Exception ex)

                  {

                        MessageBox.Show(“ERROR:”, ex.Message);

                  }

                  finally

                  {

                        fstream.Close();

                  }

            }

//Serialization using SoapFormatter

      //Steps and Methods are same as Binary Formatter

            private void button3_Click(object sender, EventArgs e)

            {

                  FileStream fstream = null;

                  SoapFormatter soapformat = null;

                  try

                  {

                        Person p = new Person(“scott”, 25);

                        fstream = new FileStream(“PersonSOAP.txt”, FileMode.Create, FileAccess.Write);

                        soapformat = new SoapFormatter();

                        soapformat.Serialize(fstream, p);

                        MessageBox.Show(“Person object in SOAP FORMAT”);

                  }

                  catch (Exception k)

                  {

                        MessageBox.Show(k.Message);

                  }

                  finally

                  {

                        fstream.Close();

                  }

            }

      }

}

     Data shown here is store in Binary Format

   ÿÿÿÿ      JSerializationSample, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null   SerializationSample.Person  
_personName

Data shown here is store in SOAP Format

<SOAP-ENV:Envelope xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance” xmlns:xsd=”http://www.w3.org/2001/XMLSchema” xmlns:SOAP-ENC=”http://schemas.xmlsoap.org/soap/encoding/” xmlns:SOAP-ENV=”http://schemas.xmlsoap.org/soap/envelope/” xmlns:clr=”http://schemas.microsoft.com/soap/encoding/clr/1.0″ SOAP-ENV:encodingStyle=”http://schemas.xmlsoap.org/soap/encoding/”>

<SOAP-ENV:Body>

<a1:Person id=”ref-1″ xmlns:a1=”http://schemas.microsoft.com/clr/nsassem/SerializationSample/SerializationSample%2C%20Version%3D1.0.0.0%2C%20Culture%3Dneutral%2C%20PublicKeyToken%3Dnull”>

<_personName id=”ref-3″>scott</_personName>

<_age>25</_age>

</a1:Person>

</SOAP-ENV:Body>

</SOAP-ENV:Envelope>

 Establishing communication between objects that run in different processes, whether on the same computer or on different computers.

.NET Remoting enables client applications to use objects in other processes on the same computer or on any other computer available on its network.

Communicating across processes is still a complex task, but much of it is now handled by the .NET Framework.

To use .NET remoting to build an application in which two components communicate directly across an application domain boundary, you need to build only the following:

• A remotable object.
• A host application domain to listen for requests for that object.
• A client application domain that makes requests for that object.

Remote Objects:

There are three types of objects that can be configured to serve as .NET remote objects.

They are:  1) Single Call Objects

              2) Singleton Objects

              3) Client Activated Objects (CAO)

Code:

RemoteComponet Library:

//remote component library

using System;

using System.Collections.Generic;

using System.Text;

using System.ComponentModel;

using System.Data;

using System.Drawing;

namespace RemoteComponentLib

{

    public class RemoteComponent:MarshalByRefObject     //MarshalByRefObject ensures that the only reference of the object sent not the cpoy of the object

    {

        public string Greet(string name)

        {

            Debug(name);

            return “Hello” + name + “from satyam”;

            //Expected output is

            //#3448748-user1 -at server side

            //hello user from satyam -sent to client

        }

        //for tracing

        private void Debug(string name)

        {

            Console.WriteLine(“#{0}-{1}”, this.GetHashCode(),name);

        }

    }

}

Remote Client Console type:

//remote client program console type

using System;

using System.Collections.Generic;

using System.Text;

using System.Runtime.Remoting;  //provides classes and interfaces that allow developers to create and configure distributed applications.

using RemoteComponentLib;   //connects to library

namespace RemoteClient 

{

    class Program

    {

        static void Main(string[] args)

        {

            RemotingConfiguration.RegisterWellKnownClientType(typeof(RemoteComponent),“tcp://localhost:9999/RemoteUri”);

            RemoteComponent obj = new RemoteComponent();//the created obj refers as proxy

            Console.WriteLine(“Enter a string”);

            string str = Console.ReadLine();

            Console.WriteLine(obj.Greet(str));

            Console.ReadLine();

        }

    }

}

Remote Host:

//program for the RemoteHost

//remote client program console type

using System;

using System.Collections.Generic;

using System.Text;

using System.Runtime.Remoting;  //provides classes and interfaces that allow developers to create and configure distributed applications.

using RemoteComponentLib;   //connects to library

namespace RemoteClient 

{

    class Program

    {

        static void Main(string[] args)

        {

            RemotingConfiguration.RegisterWellKnownClientType(typeof(RemoteComponent),“tcp://localhost:9999/RemoteUri”);

            RemoteComponent obj = new RemoteComponent();//the created obj refers as proxy

            Console.WriteLine(“Enter a string”);

            string str = Console.ReadLine();

            Console.WriteLine(obj.Greet(str));

            Console.ReadLine();

        }

    }

}

Remote Client windwos type:

//for Remote client in windows form

OutPut:

Different Windows for the following

1.  Singleton –console Application

2.  Singlecall –console Application

3.  SingleCall –Windows Application

4.  SingleTon –Windows Application

Aslo:the code can be modified to use over different machines using IP address

An Interface is a reference type and it contains only abstract members. Interface‘s members can be Events, Methods, Properties .But the interface contains only declaration for its members. Any implementation must be placed in class that realizes them. The interface can’t contain constants, data fields, constructors, destructors and static members. All the member declarations inside interface are implicitly public.

Interfaces in C# are provided as a replacement of multiple inheritance. Because C# does not support multiple inheritance, it was necessary to incorporate some other method so that the class can inherit the behavior of more than one class, avoiding the problem of name ambiguity that is found in C++. With name ambiguity, the object of a class does not know which method to call if the two base classes of that class object contain the same named method.

A very important point to be remembered about c# interfaces is, if some interface is inherited, the program must implement all its declared members. Otherwise the c# compiler throws an error

Objective:

To create an interface and implement it in different classes

Steps to follow;

·       Create an interface iflight and define one method fly()

·       Create three classes bird,aeroplane and superman and implement

the method fly() in these classes

·       Create a main class and create an interface array of instances of the above three classes.

·       Run a loop and call the fly() method of different objects

Code:

//this is an interface with a method called fly();

    public interface IFlight

    {

        //definition of a method fly()

        void Fly();

    }

    //implementing the interface in class bird

    class Bird:IFlight

    {

        #region IFlight Members

        //implementing the abstract method fly() of the interface

        public void Fly()

        {

            Console.WriteLine(“Up Up High Sky”);

        }

        #endregion

    }

    //implementing the interface in class aeroplane

    class Aeroplane:IFlight

    {

        #region IFlight Members

        //implementing the abstract method fly() of the interface

        public void Fly()

        {

            Console.WriteLine(“aeroplane is flying”);

        }

        #endregion

    }

    //implementing the interface in class superman

    class SuperMan:IFlight

    {

        #region IFlight Members

        //implementing the abstract method fly() of the interface

        public void Fly()

        {

            Console.WriteLine(“Look that’s spiderman no its superman”);

        }

        #endregion

    }

//Main class

    class Program

    {

        static void Main(string[] args)

        {

            //creating an array of instances

            IFlight[] flyobjects ={ new Bird(), new Aeroplane(),new SuperMan() };

            //looping through the array

            foreach (IFlight obj in flyobjects)

            {

                obj.Fly();  //calling the fly method

            }

            Console.ReadLine();

        }

    }

Output :

Up Up High Sky

Aeroplane is flying

Look that’s spiderman no its superman