Remoting and Web services

What is a application domain?
Previously “PROCESS” where used as security boundaries.One process has its own virtual memory and does not over lap the other process virtual memory , due to this one process can not crash the other process.So any problem or error in one process does not affect the other process.In .NET they went one step ahead introducing application domains.In application domains multiple application can run in same process without influencing each other.If one of the application domains throws error it does not affect the other application domains.To invoke method in a object running in different application domain .NET remoting is used.

(B) What is .NET Remoting ?
.NET remoting is replacement of DCOM.Using .NET remoting you can make remote object calls which lie in different Application Domains.As the remote objects run in different process client calling the remote object can not call it directly.So the client uses a proxy which looks like a real object. When client wants to make method call on the remote object it uses proxy for it.These method calls are called as “Messages”. Messages are serialized using “formatter” class and sent to client “channel”. Client Channel communicates with Server Channel.Server Channel uses as formatter to deserialize the message and sends to the remote object.

4. Remoting and Webservices 

(B) Which class does the remote object has to inherit ?
All remote object should inherit from System.MarshalbyRefObject.

(I) What are two different types of remote object creation mode in .NET ?
There are two different ways in which object can be created using Remoting :-
√ SAO (Server Activated Objects) also called as Well-Known call mode.
√ CAO (Client Activated Objects)
SAO has two modes “Single Call” and “Singleton”.With Single Call object the object is created with every method call thus making the object stateless.With Singleton the object is created only once and the object is shared with all clients.
CAO are stateful as compared to SAO. In CAO the creation request is sent from client side.

Client holds a proxy to the server object created on server.

(A) Describe in detail Basic of SAO architecture of Remoting?
For these type of questions interviewer expects small and sweet answers.He is basically looking at what you know about the specific subject.For these type of question this book will provide detail code which is not necessary to be said during interview.Only the basic steps
and overall brief are enough to convince that you have knowledge about the subject.Even though this question has detail code and answer say only what is needed in interview.

Remoting has atleast three sections :-
√ Common Interface which will be shared between them.
√ Server.
√ Client.

In CD “RemotingSample(SAO)” project is provided which gives a insight of remoting.Above is the figure which shows the three important project sections needed to implement remoting.

First important section is the common interface between Server and Client.”InterFaceRemoting” project has the interface code.For sample project interface is very simple with only two methods :- SetValue and GetValue.
Public Interface InterFaceRemoting
Sub SetValue(ByVal value As String)
Function GetValue() As String
End Interface
Second important section is the server.In this sample server is using HTTP channel and the server object is singleton.
Imports System
Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Channels.Http
Imports System.Runtime.Remoting.Channels
Imports InterFaceRemoting
Public Class RemotingServer
Inherits MarshalByRefObject

Implements InterFaceRemoting.InterFaceRemoting
Private strData As String
Public Function GetValue() As String Implements
InterFaceRemoting.InterFaceRemoting.GetValue
Return strData
End Function
Sub New()
strData = “testing..”
End Sub
Public Sub SetValue(ByVal value As String) Implements
InterFaceRemoting.InterFaceRemoting.SetValue
strData = value
End Sub
End Class
Module ModuleRemotingStartUp
Sub Main()
Dim objHttpChannel As HttpChannel
Console.WriteLine(“Server Started….”)
objHttpChannel = New HttpChannel(1234)
ChannelServices.RegisterChannel(objHttpChannel)
RemotingConfiguration.RegisterWellKnownServiceType(GetType(RemotingServer),
“RemoteObject”, WellKnownObjectMode.Singleton)
Console.WriteLine(“Server registered and listening waiting
for clients…”)
Console.ReadLine()
End Sub
End Module
Following is detail explanation :-
√ Channel object is created and registered.Following is the code.
Dim objHttpChannel As HttpChannel
Console.WriteLine(“Server Started….”)
objHttpChannel = New HttpChannel(1234)
ChannelServices.RegisterChannel(objHttpChannel)
√ Server then hosts the object so that client can connect to it.This is the time when we specify what mode the server object will be created i.e. Singleton or SingleCall.This is done by the following below given code.Note in sample we are hosting the server object in singleton mode that means that the same object will be shared between all clients.Also note the server object is implementing
“InterFaceRemoting” and inheriting from “MarshalByRefObject”.
RemotingConfiguration.RegisterWellKnownServiceType(GetType(RemotingServer),
“RemoteObject”, WellKnownObjectMode.Singleton)
Now comes the final section that is third section the client which will connect to this hosted remoting object.
Following is a detail explanation of client code :-
√ First we create the channel i.e. HTTP.Note whatever channel the server is
using same will be used by the client.
ChannelServices.RegisterChannel(objHttpChannel)
√ As said before the common interface i.e.“InterFaceRemoting” will be used
to communicate with client.
√ After that we can get the server object reference using following code
objRemoting = CType(Activator.GetObject(GetType(InterFaceRemoting.InterFaceRemoting),
“http://localhost:1234/RemoteObject”), InterFaceRemoting.InterFaceRemoting)
√ Then the client can make method call as if the object is local.But actually the
object is a proxy.
Console.WriteLine(“Value on server :- “ & objRemoting.GetValue.ToString())
Imports System
Imports System.Runtime.Remoting
Imports System.Runtime.Remoting.Channels.Http
Imports System.Runtime.Remoting.Channels
Imports InterFaceRemoting
Module ModuleStartClient
Sub Main()
Dim objHttpChannel As New HttpChannel
Dim objRemoting As InterFaceRemoting.InterFaceRemoting
ChannelServices.RegisterChannel(objHttpChannel)
objRemoting =
CType(Activator.GetObject(GetType(InterFaceRemoting.InterFaceRemoting),
“http://localhost:1234/RemoteObject”),
InterFaceRemoting.InterFaceRemoting)

Console.WriteLine(“Referenced the main object…. Now
displaying Data”)
Console.WriteLine(“Value on server :- “ &
objRemoting.GetValue.ToString())
Console.WriteLine(“Press enter to Terminate”)
Console.ReadLine()
End Sub
End Module
You an run the program and see the output.For running the program run the server program which is in server directory.Run “Server.exe” from BIN directory.

Now run “Client.exe” from client folder in BIN directory.Following will be the outputseen.This means that the client connected to the server program and displayed the data in the server object.In the server object we have initialized value “testing……” In constructor
of class “RemotingServer”.Same value is displayed at the client side as shown in figure below.

(A) What are the situations you will use singleton architecture in remoting ?
If all remoting clients have to share the same data singleton architecture will be used.

(A) What is fundamental of published or precreated objects in Remoting?
In scenarios of singleton or single call the objects are created dynamically.But in situations where you want to precreate object and publish it you will use published object scenarios.
Dim obj as new objRemote
obj.Initvalue = 100
RemotingServices.Marshal(obj,”RemoteObject”)
As shown in above sample following changes will be needed on server
side.RemotingConfiguration.RegisterWellKnownServiceType is replaced by
RemotingServices.Marshal(obj,”RemoteObject”) where “obj” is the precreated objected
on the server whose value is initialized to 100.
(A) What are the ways client can create object on server in CAO model ?
There are two ways by which you can create Client objects on remoting server :-
√ Activator.CreateInstance().
√ By Keyword “New”.

(A) Are CAO stateful in nature ?
Yes.In CAO remoting model client creates a instance on server and instance variable set by client on server can be retrieved again with correct value.

(A) In CAO model when we want client objects to be created by “NEW”
keyword is there any precautions to be taken ?
Remoting Clients and Remoting Server can communicate because they share a common contract by implementing Shared Interface or Base Class (As seen in previous examples). But according to OOP’s concept we can not create a object of interface or Base Classes
(Abstract Class). Shipping the server object to client is not a good design practice.In CAO model we can use SOAPSUDS utility to generate Metadata DLL from server which can be shipped to client , clients can then use this DLL for creating object on server.Run
the SOAPSUDS utility from visual studio command prompt for syntax see below :-
soapsuds -ia:RemotingServer -nowp -oa:ClientMetaData.dll
Where RemotingServer is your server class name.
ClientMetaData.dll is the DLL name by which you will want to create the metadll.
Server code will change as follows :-
ChannelServices.RegisterChannel(objHttpChannel)
RemotingConfiguration.ApplicationName = “RemoteObject”
RemotingConfiguration.RegisterActivatedServiceType(GetType(InterFaceRemoting.InterFaceRemoting))

Note :- We have to provide applicationname and register the object as ActivatedServiceType.
On client side we have to reference the generated ClientMetaData.dll from SOAPSUDS
utility.Below are changes which are needed to be incorporated at the Remoting Client :-
RemotingConfiguration.RegisterActivatedClientType(typeof(RemoteObject),“http://
localhost:1234/MyServer”)
Dim objRemoteObject as new RemoteObject().
RemoteObject is class which is obtained from ClientMetaData.dll which we created using
SOAPSUDS utility.Now you can reference the object as normal object.

(I) Is it a good design practice to distribute the implementation to Remoting Client ?
It’s never advisable to distribute complete implementation at client , due to following reasons :-
√ Any one can use ILDASM and decrypt your logic.
√ It’s a bad architecture move to have full implementation as client side as any changes in implementation on server side you have to redistribute it again.
So the best way is to have a interface or SOAPSUDS generated meta-data DLL at client side rather than having full implementation.

(A) What is LeaseTime,SponsorshipTime ,RenewonCallTime and LeaseManagerPollTime?
This is a very important question from practical implementation point of view.Companies who have specific requirement for Remoting project’s will expect this question to be answered. In normal .NET environment objects lifetime is managed by garbage collector.But in
remoting environment remote clients can access objects which is out of control of garbage collector.Garbage collector boundary is limited to a single PC on which framework is running , any remote client across physical PC is out of control of GC (Garbage Collector).
This constraint of garbage collector leads to a new way of handling lifetime for remoting objects , by using concept called as “LeaseTime”.Every server side object is assigned by default a “LeaseTime” of five minutes.This leasetime is decreased at certain intervals.Again for every method call a default of two minutes is assigned.When i say method call means
every call made from client.This is called as “RenewalOnCallTime”. Let’s put the whole thing in equation to make the concept more clear.
Total Remoting object life time = LeaseTime + (Number of method calls) X (RenewalTime).
If we take NumberOfMethodCalls as one.

Then default Remote Object Life Time = 5 + (1) X 2 = 10 minutes (Everything is in minutes)

When total object lifetime is reduced to zero , it queries the sponsor that should the object be destroyed.Sponsor is a object which decides should object Lifetime be renewed.So it queries any registered sponsors with the object , if does not find any then the object is marked for garbage collection.After this garbage collection has whole control on the object lifetime.If we do not foresee how long a object will be needed specify the “SponsorShipTimeOut” value. SponsorShipTimeOut is time unit a call to a sponsor is timed out.
“LeaseManagerPollTime” defines the time the sponsor has to return a leasetime extension.

(A) Which config file has all the supported channels/protocol ?
Machine.config file has all the supported channels and formatter supported by .NET remoting.Machine.config file can be found at
“C:\WINDOWS\Microsoft.NET\Framework\vXXXXX\CONFIG” path.Find element in the Machine.config file which has the channels
and the formatters.Below is a figure shown which can give a clear idea of how the file looks like.

Note :- Interviewer will not ask you to name all channels and formatters in machine.config
but will definitely like to know in which file are all the formatter and channels specified one sweet answer “Machine.config” can fetch you handsome job.

(A) How can you specify remoting parameters using Config files ?
Both remoting server and remoting client parameters can be provided through config files.Below is a sample of server config file which provides all remoting parameter values which we where providing through code.

Later this config file can be loaded using the following code.
RemotingConfiguration.Configure(AppDomain.CurrentDomain.SetupInformation.ApplicationBase
& “Server.config”)
Same way we also have client.config file for loading the client remoting parameters.
client remoting can then load the configuration file by using :-
Dim IobjCommon As CommonInterFace.Icommon
Dim StrData As String
Dim objServiceEntries As WellKnownClientTypeEntry()
RemotingConfiguration.Configure(AppDomain.CurrentDomain.SetupInformation.ApplicationBase
& “Client.config”)
objServiceEntries =
RemotingConfiguration.GetRegisteredWellKnownClientTypes()
IobjCommon = Activator.GetObject(GetType(Icommon),
objServiceEntries(0).ObjectUrl.ToString())
StrData = IobjCommon.GetValue()

Console.WriteLine(“ Serve side Data is “ & StrData)
Console.ReadLine()
Note :- Complete source is provided in CD in folder “RemotingObjectLifeTime”.If you run Server and Client following output can be seen.All source is compiled using VS2005
BETA1

(A) Can Non-Default constructors be used with Single Call SAO?
Twist :- What are the limitation of constructors for Single call SAO ?

Non-Default constructors can not be used with single call objects as object is created with every method call, there is no way to define Non-default constructors in method calls.
It’s possible to use Non-Default constructor with Client activated objects as both methods :-
“NEW” keyword and “Activator.CreateInstance” provide a way to specify Non-Default constructors.

(I) How can we call methods in remoting Asynchronously ?
All previous examples are synchronous method calls , that means client has to wait until the method completes the process.By using Delegates we can make Asynchronous method calls.

(A) What is Asynchronous One-Way Calls ?
One-way calls are a different from asynchronous calls from execution angle that the .NET Framework does not guarantee their execution. In addition, the methods used in this kind of call cannot have return values or out parameters.One-way calls are defined by using
[OneWay()] attribute in class.

(B) What is marshalling and what are different kinds of marshalling ?
Marshaling is used when an object is converted so that it can be sent across the network or across application domains.Unmarshaling creates an object from the marshaled data.There are two ways to do marshalling :-

√ Marshal-by-value (MBV) :- In this the object is serialized into the channel, and a copy of the object is created on the other side of the network. The object to marshal is stored into a stream, and the stream is used to build a copy of the object on the other side with the unmarshalling sequence.
√ Marshaling-by-reference (MBR):- Here it creates a proxy on the client that is used to communicate with the remote object. The marshaling sequence of a remote object creates an ObjRef instance that itself can be serialized across the network.
Objects that are derived from “MarshalByRefObject” are always marshaled by reference.All our previous samples have classes inherited from “MarshalByRefObject”
To marshal a remote object the static method RemotingServices.Marshal() is
used.RemotingServices.Marshal() has following overloaded versions:-
public static ObjRef Marshal(MarshalByRefObject obj)
public static ObjRef Marshal(MarshalByRefObject obj, string objUri)
public static ObjRef Marshal(MarshalByRefObject obj, string objUri,Type
requestedType)
The first argument obj specifies the object to marshal. The objUri is the path that is stored within the marshaled object reference; it can be used to access the remote object. The requestedType can be used to pass a different type of the object to the object reference. This is useful if the client using the remote object shouldn’t use the object class but an interface that the remote object class implements instead. In this scenario the interface is the requestedType that should be used for marshaling.

(A) What is ObjRef object in remoting ?
All Marshal() methods return ObjRef object.The ObjRef is serializable because it implements the interface ISerializable, and can be marshaled by value. The ObjRef knows about :-
√ location of the remote object
√ host name
√ port number
√ object name.

admin

Back to top