|


|
| 
 

 


Understanding .NET Remoting
Implementing Server-Activated and Client-Activated
Objects
Transporting Messages Across Application Domains Using
Channels
Configuring and Securing .NET Remoting Objects
 3

 
 

u To enable communication between different applications reside

on the same computer or on different computers.
u These computers can be part of the same network or different
network.
u These computers can run the same or different operating
systems.

x
 0
 

  
 

u èhat does .Net remoting do?

activate objects
control the lifetime of objects
transport messages by using communication channels
u Communication channel are the objects that transport messages
between the remote objects
u Messages is encoded and decoded using native .NET
serialization formatters (binary and SOAP).
u There are two ways to encode all message: binary and XML
u To enable perform communication between different objects in
different application domains orusing different transportation
protocols
x
 0
 
 
 




|


 













|





|

|














 
x
 0
 ½



½


 
  



u The .NET Remoting system allows clients to call methods on

objects across remoting boundaries
u Remoting boundaries include application domains, processes,
and computers
u How do you access to object and call method?
Copy of the server object in the client application
The client can call a method on the local copy of the server object.
u Should you copy server object to the client process ?
objects do not contain a large number of methods and are not large
size
Copying an entire server object to the client process is a waste of client
resources, which include bandwidth, memory, and processing time
x
 0
 
 
 ½ 



 
  

 




x

    

x
 0

 
 
 



u èhat are different between Remotable and Noneremotable

object?
Nonremotable objects do not provide the remoting system with a
method to either copy them or use them in another application
domain
Remotable objects can either be accessed outside their application
domain or context using a proxy or copied and passed outside
their application domain or context
u There are two types of remotable objects
Marshal-by-value objects
Marshal-by-reference objects

x

0
 J



½

 |
 ½



u Understanding Remote Object Activation

u Server Activation
u Client Activation
u Remoting Tasks
u Using Lifetime Leases
u Initializing Lifetime Leases
u Renewing Lifetime Leases

x
 0
 
 
½ | 


u Marshal By Value Object

|
|
|

|
 

x
 0
 
 
½ | 


u Marshal By Reference Object

|
| |



|
 

x
  0
 3


 

½ 

u èhen you develop remoting object you need to track:

Create object
Initiate object

x
 0
 

½ 

u Objects are created on the server when you call a method in the server class
u There are two ways to create a server-activated object :
Singleton
SingleCall
public class SSNServer
{
public SSNServer()
{ RemotingConfiguration.ApplicationName = "testService"; Re
motingConfiguration.RegisterèellKnownServiceType(
typeof(testService), "MyUri",èellKnownObjectMode.Singleton);

}
}

x
  0
 
|

½ 

|
 

|

 

x
  0
 
 

½ 

|




|



x
  0
 

|


u èhat does Channels do?

To send messages to an application running in a different application
domain
Send and receive messages using various protocols, such as TCP and
HTTP.
HttpChannel
TcpChannel
ChannelServices.RegisterChannel
RemotingConfiguration.ApplicationName
RemotingConfiguration.RegisterèellKnownServiceType
RemotingConfiguration.RegisterèellKnownClientType
x
  0
 

|


RemotingConfiguration.RegisterèellKnownServiceType(RemoteTier,U
RI,ObjectMode)
RemotingConfiguration.RegisterèellKnownClientType(RemoteTier,URL)

x
 0
  


TcpServerChannel channel;
channel = new TcpServerChannel(port)
ChannelServices.RegisterChannel(channel, false)
RemotingConfiguration.ApplicationName = _
³Option"
RemotingConfiguration.RegisterèellKnownServiceType( _
typeOf(RemoteTier.ClassRemote), _
³URI", èellKnownObjectMode.Singleton)

x

0
  |


TcpClientChannel channel;
ChannelServices.RegisterChannel(channel, false)
RemotingConfiguration.RegisterèellKnownClientType( _
typeOf(RemoteTier.ClassRemote), _
"TCP://IPAddress:8066/URI")

x
  0
 |   

u èe¶ve been hard-coding configuration

Changes require recompile
Dynamic
Easy to deploy
u Use File Configuration
XML
Easy to read
Easy to modify
No need to recompile

x
  0
 

|   





 








|


 

x
 0
 å
| 



 






    ½


 


 

x
 0
 | 


u Application
Thu;c tính: Name
u Service
u èellknown
Thu;c tính:
mode="Singleton"
objectUri=³URI"
type="RemoteTier.clsRemote, clsRemote"
u Channels
u Channel
Thu;c tính: ref, port, displayName

x
 0
 | 


iconfiguration>
isystem.runtime.remoting>
iapplication name="RemoteName">
iservice>
iwellknown mode="Singleton" objectUri=³URI"
type="RemoteTier.clsRemote, clsRemote"/>
i/service>
ichannels>
ichannel ref="http" port="8081"
displayName=³Http Channel " />
i/channels>
i/application>
i/system.runtime.remoting>
i/configuration>

x
 0
RemotingConfiguration.Configure(³FileNameServer.exe.config")

x
 0
 |
|   



|








|


 

x
 0
 å
| |



 




 

    ½


 


 

x
 0
 | |

u Application
Thu;c tính: Name
u Service
u èellknown
Thu;c tính:
mode="Singleton"
URL=³URL"
type="RemoteTier.clsRemote, clsRemote"
u Channels
u Channel
Thu;c tính: ref, port, displayName

x

0
 | |

iconfiguration>
isystem.runtime.remoting>
iapplication>
iclient>
iwellknown mode="Singleton"
url="http://localhost:8080/RemoteName/URI" type="RemoteTier.clsRemote,
clsRemote"/>
i/client>
ichannels>
ichannel ref="http" displayName="HTTP Channel " />
ichannel ref="tcp" displayName="TCP Channel " />
i/channels>
i/application>
i/system.runtime.remoting>
i/configuration>
x
 0
RemotingConfiguration.Configure(³FileNameClient.exe.config")

x
 0
 3
!

!





u The lifetime of a marshal-by-reference object is the duration for

which the object resides in memory
u The .NET Remoting system deletes an object only when it is
marked as ready for garbage collection
u Each application domain contains a lease manager that
administers the leases in its domain .

x
 0
 J"!

!





u To initialize a lifetime lease, you override the InitializeLifetimeService function of the MarshalByRefObject class
using System;
using System.Runtime;
using System.Runtime.Remoting;
using System.Runtime.Remoting.Lifetime;
public class MyLifetimeControlObject: MarshalByRefObject
{
public override object InitializeLifetimeService()
{
ILease lease = (ILease)base.InitializeLifetimeService();
if (lease.CurrentState == LeaseState.Initial)
{
lease.InitialLeaseTime = TimeSpan.FromMinutes(2);
lease.SponsorshipTimeout = TimeSpan.FromMinutes(3);
lease.RenewOnCallTime = TimeSpan.FromSeconds(3);
}
return lease;
}
}

x
 0
 

!

!





u The CurrentLeaseTime property returns the amount of time

remaining on the lease.
u These are the two ways to renew a lease :
A client application calls the ILease.Renew method.
A sponsor renews the lease.
RemoteType obj = new RemoteType();
ILease lease = (ILease)RemotingServices.GetLifetimeService(obj);
TimeSpan expireTime = lease.Renew(TimeSpan.FromSeconds(30));

x
 0
  
 # 

u The .NET Remoting system exposes the functionality of server

objects to client applications assuming that the objects are
contained locally in the client application.
u Scope of Publication :
Static members
Instance fields and accessors
Private members
Delegates
Overriding methods on an object

x
 0
 
 $



½

½ 
 
3
|


u Understanding Channels
u Channel Interfaces
u Registering a Channel
u Selecting Channels for Remoting
u HTTP Channels
u TCP Channels

x
 0
 3

|



u èhat does Channels do?

To send messages to an application running in a different application domain
Send and receive messages using various protocols, such as TCP and HTTP.

x
 0
 |
J


u The .NET Framework provides the

System.Runtime.Remoting.Channels name-space
u List Channel Interface:
IChannel
IChannelReceiver
IChannelSender
D
 



   
D

x
 0
 


|


u To register channels with the remoting infrastructure, you use the

ChannelServices class.

— 

 
 
 
— 

 
 
 

  
 
 
!"


x

0
 

|

 
 

u $ou should apply the following rules when selecting channels for
remote objects:
Register a server channel:TcpServerChannel or HttpServerChannel,
before registering a remote object
Register a server channel on the client computer
Channel names within an application domain cannot be the same
Two channels registered with the remoting system on a computer cannot
listen on the same port.

x
 0
 A#|



u The System.Runtime.Remoting.Channels.Http namespace

provides channel classes that use the HTTP protocol to transport
messages between remote objects .
u System.Runtime.Remoting.Channels.Http namespace provides
classes, such as HttpClientChannel, HttpServerChannel, and
HttpChannel
u To create an HttpClientChannel object and register it with the
remoting system :
ChannelServices.RegisterChannel(New HttpClientChannel())

x
 0
 A#|

%  &

u How to create and register an HttpServerChannel object to listen

at port 8080.
HttpServerChannel channel = New HttpServerChannel(8080)
ChannelServices.RegisterChannel(channel,false)
u How to create and register an HttpChannel object to listen at port
8010.
HttpChannel channel = New HttpChannel(8010)
ChannelServices.RegisterChannel(channel,false)


#——  

    $%&'$%(

x
 0
 |#|



u TCP Channel is the same HTTP Channel. $ou can see page
238-239.

x
 0
 J



 



u Understanding Events and Delegates

u Implementing Events and Delegates in Remoting Applications

x
 0
3







u èhat is Delegate?
u A delegate is a class that holds a reference to the method that is called when an event is
fired .
u To declare Delegates:
public delegate void RetirementHandler(object sender, RetireEventArgs e);
u To define define method to which the event delegate points
public class Action
{
public void RetireEvent (object sender, RetireEventArgs e)
{}
}
u To create an instance of the delegate and store the address of the method whose
reference the delegate holds.
Action a = new Action();
NewEventHandler handler = new RetirementHandler(a.RetireEvent);

x
 0
 J








 
  ½ 

u èhen you implement events and delegates in remoting
applications, you should ensure that:
The delegates you pass to the server for callback functions are
delegates to instance members because you cannot call static
members remotely.
$ou register a channel to listen for the callback function.

x
 0
 J








 
  ½ 
% &
u $ou must perform the following tasks to enable delegates to
listen for events in the remoting application:
Define an event and the extension to the EventArgs class that the event
passes to a delegate.
Define a delegate that wraps an event-handler method of the signature
required by the event.
Define a method that handles the event.
Initialize a delegate that wraps the event-handler method.
Add the delegate to the event.

x
 0
 |  
   
 



iconfiguration>
isystem.runtime.remoting>
iapplication>
iservice>
iwellknown mode = "SingleCall" type = "MyRemoteClass,RemoteAssembly"
objectUri = "MyApp.rem" />
iactivated type="ClientActivatedType, TypeAssembly" />
i/service>
i/application>
i/system.runtime.remoting>
i/configuration>

x
 0