Correctness of a callback approach for managing WCF stateful services needing to dialogue with their hosting application

Question

I am writing a complex distributed application by taking advantage of WCF services.

Requirements

My requirements are the following:

There are many stations (PCs) having the same software running on them (the application I need to develop).
Every station will send messages to other stations (every station has a neighbourhood). The stations will route messages in order to reach the final destination for each message (it is a P2P context where local routing is necessary).
When a message is delivered by a station, that station has to be sure that message reaches the destination (another station somewhere in the world). For performance reasons I cannot create services that route my message using synchronous approaches (a service call would last too much time, polling has never been a good idea). For this reason a feedback messaging is considered: once the message reaches its destination, the destination will send a I-Received-The-Message message back to the sender.
With this approach, I need my stations to implement services in order to route feedback messages. Basically, everytime a message is delivered, a task table is filled with one record indicating that a message delivery needs to be confirmed. If no feedback message for that message reaches the sender station, the sender station will try to send the original message again.

What I cannot do

I know that for P2P scenarios there is a well provided service type, but I cannot use it for some reasons (I will not bother you with these reasons). Please, accept the requirements I listed above.

My solution

I adopted this solution:

Two service contracts define calls for sending (routing) normal messages and reply/delivery-confirm messages:

/* Routing routines */
[ServiceContract]
public interface IMessageRouting {
   /* When a client receives the message, in the MyMessage type 
      there are some fields that helps the current station to 
      decide which neighbour station the received packet will 
      be routed to */
   [OperationContract(IsOneWay = true)]
   void RouteMessage(MyMessage msg);
}

/* Delivery-Confirm messaging */
[ServiceContract]
public interface IDeliveryConfirmMessageRouting {
   /* When the final destination (THE FINAL DESTINATION 
      ONLY, not an intermediate hop station) obtains a 
      message, it will route back to the sender a reply message */
   [OperationContract(IsOneWay = true)]
   void RouteDeliveryConfirmMessage(MyDeliveryConfirmMessage dcmsg);
}

Here are the services implementations:

/* This service will be self-hosted by my application in order 
   to provide routing functionality to other stations */
[ServiceBehaviour(InstanceContextMode = InstanceContextMode.Single, 
 ConcurrencyMode = ConcurrencyMode.Single)]
public class StationMessagingService : IMessageRouting {
   /* Constructing the service */
   public StationMessagingService() { ... }
   // Implementation of serive operations
   public void RouteMessage(MyMessage msg) {
      ...
   }
}

And the delivery confirm service...

/* This service will be self-hosted by my application in order 
   to provide delivery confirm message routing functionality 
   to other stations */
[ServiceBehaviour(InstanceContextMode = InstanceContextMode.Single, 
 ConcurrencyMode = ConcurrencyMode.Single)]
public class StationDeliveryConfirmService : IDeliveryConfirmMessageRouting {
   /* This service is particular, I will discuss the following lines 
      before the constructors in the next paragraph after first 
      typing all the code */
   public delegate void DeliveryMessageReceivedEventHandler(
         object sender, String DeliveryMessageReceivedEventArgs);
   public event DeliveryMessageReceivedEventHandler DeliveryMessageReceived;
   /* Constructing the service */
   public StationDeliveryConfirmService() { ... }
   // Implementation of serive operations
   public void RouteDeliveryConfirmMessage(MyDeliveryConfirmMessage dcmsg) {
      ...
      /* In the end fire the event only if I am the destination 
         of this message, otherwise I must route this message */
      if (...) { /* Omitting condition for clarity */
         this.DeliveryMessageReceived(this, 
               "A delivery confirm message has arrived with this info: " + 
               dcmsg.Info()); /* Info contains string info */
      }
   }
}

At this point I am ready to host my services:

/* My program */
public class Program {
   // Program's entry point
   static void Main(string[] args) {
      // Defining the delivery check table (I have a special type/class for this)
      DeliveryCheckTable DCT = new DeliveryCheckTable(...);
      // Creating services
      StationMessagingService SMS = new StationMessagingService();
      StationDeliveryConfirmService SDCS = new StationDeliveryConfirmService();
      // Event handlers registration (expalinations in the next paragraph)
      SDCS.DeliveryMessageReceived += Program.DeliveryMessageReceivedHandler;
      // Hosting
      Uri MyBaseAddress = new Uri("http://services.myapplication.com/Services/");
      using (ServiceHost hostMessagingSvc = new ServiceHost(SMS, MyBaseAddress),
             ServiceHost hostDeliveryConfirmSvc = new ServiceHost(SDCS, 
             MyBaseAddress)) {
         // Info on endpoints in config file
         // Running services
         hostMessagingSvc.Open();
         hostDeliveryConfirmSvc.Open();
         // ...
         // Application's other operations
         // For clarity and simplicity, just consider that the code 
         // here is some kind of infinite loop with actions in it 
         // where the GUI can commununicate with the user, somewhere 
         // in the application's code, there is a List where all 
         // sent messages are inserted and, when a delivery 
         // confirm arrives, the corresponding item in the list is cleared. 
         // The list is rendered as a table by the GUI.
         // ...
         /*** Arriving here somehow when my application needs to be shut down. ***/
         // Closing services
         hostMessagingSvc.Close();
         hostDeliveryConfirmSvc.Close();
      }
   }
   /* Event handlers for the delivery confirm messages 
      service (please be patient, these lines of code 
      will be discussed in short) */
   static void DeliveryMessageReceivedHandler(object sender, 
         string DeliveryMessageReceivedEventArgs) {
      /* Here I will perform actions on the List 
         deleting the row containing the ID of the 
         message sent whose confirm has arrived */
   }
} /* Program class */

Some explainations

As you can see by the code (a code that runs and works correctly), I managed to let my hosted service communicate with the hosting application via callbacks. So the typic flow is the following:

A neighbour of mine calls my application's void RouteMessage(... msg) service routine in order to send me a message.
In the service routine, I will check the message header and look for destination, if the destination is not me, I will route it to another neighbour of mine (closer to the destination), otherwise I will consume the message.
If I consume the message, then I'll have to send back the confirm.
I will call a neighbour of mine's void RouteDeliveryConfirmMessage(... msg) service routine in order to let it route that delivery confirm message.
Every station routes messages and, if a station finds out to be the destination, it consumes the message. but when the message is a confirm, and a station is the destination, that station will consume the confirm and will fire the DeliveryMessageReceived event causing the handler routine to start and deleting the corresponding table entry (so that the sender will have the ack knowing it is no more necessary to resend the message cause it was correctly received).

Application context

As you can see, I did not provide many details about my application, just the necessary in order to understand the code... This happens mainly for these reasons:

I do not want to bother you with my application design issues and targets.
There is much to say about why I chose some approaches, but that would be very context specific, and I would probably goig too deep in an unrelated topic.
Some may ask: "Why do you need to make a station route a message instead of providing direct messaging from the sender to the destination?", "What's the purpose of routing? Do not services let you call directly the destination station's service endpoint?". Well, I need to manage Peers in a network where peers have just a little knowledge of the entire network. New peers joins the existing one and they only have links to some station's endpoints. A peer does not need to have full knowledge of the network, it has a neighbourhood and it uses that. However, consider this as part of my requirements.

The question

OK, time for questioning. Just one question. What I described here is a solution I managed to develop in order to let a service communicate with its hosting application. This is a problem for which I did not find a correct pattern. So I found this way of coding it... Is it good? Is it a best practice? Is it a bad practice? Should that be bad practice, what's the correct pattern/way of doing this? How to solve communication issues betwen the service and its hosting application?

Thankyou

Correctness of a callback approach for managing WCF stateful services needing to dialogue with their hosting application

Answers (1)

WCF Discovery

Related Questions