Remoting Technology: Distributed Computing

namespace Rem_GeneralLib
{
    public interface ICustManager
    {
        Customer getCust(int id);
    }
}

You now need to define the customer that will hold the customer data. This class must be serialized because its object needs to be passed as a copy. Here, we are declaring the Name, and address, and calculating the present age as in the following.

using System;

namespace Rem_GeneralLib
{
    [Serializable]
    public class Customer
    {
        public string Name;
        public int Age;
        public string Address;
        public DateTime dt;

        public Customer()
        {
            Console.WriteLine("Customer Object Created......");
        }

        public int getAge()
        {
            Console.WriteLine("-----Customer Data-----");
            Console.WriteLine(Name);
            Console.WriteLine(dt.ToShortDateString());
            Console.WriteLine(Address);

            TimeSpan ts = DateTime.Today.Subtract(dt);
            return ts.Days / 365;
        }
    }
}

Finally, compile this class library project, and its corresponding Rem_GeneralLib.dll file is created in the Bin folder that will be referenced in the Remoting Server project later.

Remoting Server Implementation

The Remoting server application would be a console-based application. On the server, you need to provide an implementation of ICustManager that will allow you to load a customer from a fictitious database. This implementation will only fill in the Customer object with static data.

To implement the server application, first, add the reference of Rem_GeneralLib.dll and System.Runtime.Remoting.dll files. Now add the following lines to the declaration as in the following.

using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;

Thereafter, you will need to implement an ICustManager in an object derived from MarshalByRefObject. The method getCust() will just return a dummy Customer object. Finally, register an HTTP channel that listens on port 7861. This channel is registered in the Remoting system that will allow incoming requests to be forwarded to the corresponding object as in the following.

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using Rem_GeneralLib;

namespace Rem_Server
{
    public class CustomerManager : MarshalByRefObject, ICustManager
    {
        public CustomerManager()
        {
            Console.WriteLine("Customer Manager Object Created......");
        }
        public Customer getCust(int id)
        {
            Customer cst = new Customer();
            cst.Name = "Ajay Yadav";
            cst.dt = new DateTime(1982, 10, 9);
            cst.Address = "India";
            return cst;
        }
    }
    class RemServer
    {
        static void Main(string[] args)
        {
            HttpChannel chn = new HttpChannel(7861);
            ChannelServices.RegisterChannel(chn, false);

            RemotingConfiguration.RegisterWellKnownServiceType(
                                                   typeof(CustomerManager),
                                                   "RemotingServer",
                                                   WellKnownObjectMode.Singleton);
            Console.ReadLine();
        }
    }
}

The class CustomerManager is registered as a WellKnownServiceType, which allows the client to remotely call its methods. The URL will be “RemotingServer”. The object mode is set to singleton to ensure that only one instance will exist at any given time.

Service Consuming (Client Implementation)

The Remoting client project will connect the server and ask for a Customer object. For the Client project, you also need to add a reference of System.Runtime.Remoting.dll and compile the Gen_Remoting.dll file again.

Therefore, you must register the channel, you don't need to specify the port number because client-side ports are assigned automatically. Then create a proxy class that will support the ICustManager that will be passed in the Activator class as a parameter and specify the URL to the server type. Finally, call the Customer class method in order to populate the Customer class data.

using System;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Channels;
using System.Runtime.Remoting.Channels.Http;
using Rem_GeneralLib;
namespace Remoting_Client
{
    class ClientStartup
    {
        static void Main(string[] args)
        {
            HttpChannel chn = new HttpChannel();
            ChannelServices.RegisterChannel(chn, false);

            ICustManager mgr = (ICustManager)Activator.GetObject(
                typeof(ICustManager),
                "http://localhost:7861/RemotingServer");
            Console.WriteLine("Connecting to Server.....\n\n");

            Customer cust = mgr.getCust(101);
            int age = cust.getAge();

            Console.WriteLine(age);
            Console.ReadLine();
        }
    }
}

After finishing with the coding, compile the client project. Remember one thing, first, run the server project console application that will listen on port 7861 then start the client console application that will produce the following output.

Note. The system firewall echoes an alert because initially, it won't allow any communication on port 7861 for security reasons. So allow an ad-hoc communication on port 7861.

Notice at the server console, it will notify that the CustomerManager constructor has been called, right after displaying the output in the client project as in the following.

We can also confirm whether or not the socket is created on port 7861 by encountering the netstat command as in the following.

Summary

This article provided an introduction to .NET Remoting, one of the Distributed Computing technologies. We are now familiar with the various aspects in which .NET Remoting fits in and is applied. We dug deeper into remoting concepts and their advantages in detail. We also came to understand with a live example of remoting technology by creating three assemblies that encapsulated a general assembly, server program, and client application.