I am in the process of deciding which technology to use for our new application.

Does .NET Remoting TCP or HTTP channel support bidirectional communication?

I am going to use Singleton SAO which is stateful.

Hi,

actually you only need to declare one single channel.
A TCPServerChannel is for the service, and TCPClientChannel for the client (as their names imply).
Both the SAO and the CAO can be used on the same channel.

Personally I'd advise you use a configuration file if you can.
This will allow you to change channel settings without having to redeploy.
So, this might be extra interesting if you have many clients!
Also, itwill require only one line of code:RemotingConfiguration.Configure("MyApp.exe.config");
The config file should contain the node <system.runtime.remoting> and subnodes.
You can find more info about this in MSDN.
(maybe http://msdn.microsoft.com/en-us/library/ms973907.aspxcan help you, I haven't read it myself though)

If you want to speed up the client registration, you could store the client registrations in a Dictionary.
Then, if you're searching for a specific client, you canuse its key to search for it.
e.g. Client A wants to say something to client B, client A will say to the server (the SAO): "will you say 'something'to the client with ID x for me?"
Server can search for ID x in its dictionary, by simply calling _myClients[x]
The dictionary returns the CAO, and then you can call its method.
Of course, this would require client A to know the ID for client B.
But an ID could be a GUID or integer, whichis a value type and as such isfreely distributable across all clients.

If the server needs to communicate to ALL clients, you shoulduse .GetEnumerator

Kind regards,
Stefan

Hi,

OK, I think I'll have to explain the basic workings of .NET remoting here.
if you create a remote object,then there are actually 2 'objects' that are created.
The actual object is always stored server side.
Then, another object is created, called the proxy, which is kept client side.
This is always true, for both SAO and CAO objects.
This proxy is actually nothing more than a gateway to the real object, the one kept server side.
The proxy behaves as if it were the real thing.

Now, the difference between a SAO singleton and a CAO is that, if a method is executed on the object, a SAO method executes server-side, and a CAO method executes client side (on the proxy).


So, if you write the following line of code (suppose MyClient is a CAO remotable type):

MyClient mc = new MyClient();

Remember that 2 objects are created; the actual object and the proxy.
Note that this line of code is executed client side.
The mc variable is now the proxy, you see?

if the server now calls a method, that method is executed on the mc variable client side.

So, if you understand this you should see that the service is always the server, and therefore you should create a Server channel.
Same goes for client and Client channel.

By the way, I'm quite sure this way is possible because I'm using this technique myself ;-)

I can't agree wrt what you said about the difference between a CAO and a SAO.

Both CAO and SAO are executed on the server side and are initated by the client side through the client proxies like WCF Services and Web Services. The difference is that in case of SAO, server controls the life time of the created object which could be either singleton or singlecall and in the case of CAO, client initiates and controls the life time of the object which is created on the server side (behaves like a Session in WCF). Have a look at this sample.

"if the server now calls a method, that method is executed on the mc variable client side."

How server can call a CAO method of the client machine?! unless the server side acts as a client, e.g. via introducing TCPClientChannel, it can't initiate sending any message to the client machine, or I can't imagine how it does so...

Do you have any source code about what you mean?

Thanks,

using System;
namespace Library
{
public interface ICAO
{
void CallCAO();
}
}

using System;
namespace Library
{
public interface ISAO
{
int AmountOfClients { get; }

void RegisterCAO(ICAO cao);
}
}

6) In the Client project, Add 2 files: CAO.cs and app.config

using System;
using Library;
namespace Client
{
public class CAO : MarshalByRefObject, ICAO
{
public void CallCAO()
{
Console.WriteLine("Notifying CAO");
}
}
}

<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.runtime.remoting>
<application>
<client url="tcp://localhost:9000">
<activated type="Library.CAO, Library" />
<wellknown type="Library.ISAO, Library" url="tcp://localhost:9000/SAO.rem" />
</client>
<channels>
<channel ref="tcp" port="0" >
<clientProviders>
<formatter ref="binary"/>
</clientProviders>
<serverProviders>
<formatter ref="binary" typeFilterLevel="Full"/>
</serverProviders>
</channel>
</channels>
</application>
</system.runtime.remoting>
</configuration>

7) Alter the Program.cs from the Client project

using System;
using System.Runtime.Remoting;
using Library;
namespace Client
{
class Program
{
static void Main(string[] args)
{
RemotingConfiguration.Configure("Client.exe.config", false);

Console.WriteLine("This is the client\r\n");

System.Threading.Thread.Sleep(500);

ISAO sao = (ISAO)Activator.GetObject(typeof(ISAO), "tcp://localhost:9000/SAO.rem");

CAO cao = new CAO();
sao.RegisterCAO(cao);

Console.WriteLine("CAO has been added to SAO\r\n");

Console.ReadLine();
}
}
}

8) In the SERVICE project, add 2 files: SAO.cs and app.config

using System;
using System.Collections.Generic;
using System.Text;

using Library;

namespace Service
{
public class SAO : MarshalByRefObject, ISAO
{
private List<ICAO> _clients;

public int AmountOfClients { get { return _clients.Count; } }

public SAO()
{
_clients = new List<ICAO>();
}

public void RegisterCAO(ICAO cao)
{
_clients.Add(cao);
}

public void NotifySAO()
{
Console.WriteLine("Notifying SAO");
}

public void NotifyCAO()
{
foreach (ICAO cao in _clients)
cao.CallCAO();
}
}
}


<?xml version="1.0" encoding="utf-8" ?>
<configuration>
<system.runtime.remoting>
<application>
<service>
<activated type="Library.ICAO, Library" />
<wellknown mode="Singleton" type="Service.SAO, Library" objectUri="SAO.rem" />
</service>
<channels>
<channel ref="tcp" port="9000" >
<serverProviders>
<formatter ref="binary" typeFilterLevel="Full" />
</serverProviders>
</channel>
</channels>
</application>
</system.runtime.remoting>
</configuration>

9) In the Service project, alter the Program.cs

using System;
using System.Runtime.Remoting;
using Library;

namespace Service
{
class Program
{
static void Main(string[] args)
{
RemotingConfiguration.Configure("Service.exe.config", false);

Console.WriteLine("This is the service\r\n");

SAO sao = new SAO();
RemotingServices.Marshal(sao, "SAO.rem", typeof(SAO));

Console.WriteLine("There are " + sao.AmountOfClients + " clients registered.");
System.Threading.Thread.Sleep(1000);
Console.WriteLine("There are " + sao.AmountOfClients + " clients registered.\r\n");

// Notice where the string 'Notifying SAO' pops up
sao.NotifySAO();

// Notice where the string 'Notifying CAO' pops up
sao.NotifyCAO();

Console.ReadLine();
}
}
}

10) Now right click solution -properties -check Multiple start-up projects
11) Set 'Start' for Client and Service
12) Run the program

13) Notice that, even though the SERVICE calls sao.NotifyCAO(); theactual Console.WriteLineis executed on the CLIENT window !

Et voila, you just created service-to-client communication.

Hope this helps,
Stefan