eneter.net

SImple Request-Response Communication using TCP

2012-01-29T16:20:00.000+01:00

Summary: Very simple example showing how to implement request-response communication using TCP.

Introduction
The example bellow implements a request-response communication scenario using TCP. The client application sends a simple text message to the service. When the service receives the text message, it responses back to the client with the text message too.
The whole implementation is very simple and requires only few lines of code.

The example can be downloaded from http://eneter.net/Downloads/Examples/SimpleTcp.zip.
To run the example, first execute the service application and then the client application. You can run multiple client applications.

The example bellow uses Eneter Messaging Framework that provides functionality for various communication scenarios.
(The framework is free for non-commercial use (License) and can be downloaded from http://www.eneter.net.
More detailed technical info can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.)

Client Application
The client is a simple application containg a button to send a text message. When it receives the response message, it displayes it in the text box.

The implementation is very simple.

using System;
using System.Windows.Forms;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace HelloWorldTcpClient
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            OpenConnection();
        }

        private void OpenConnection()
        {
            // Create message sender.
            // It sends string and as a response receives also string.
            IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
            myMessageSender = aTypedMessagesFactory.CreateDuplexTypedMessageSender<string, string>();

            // Subscribe to receive response messages.
            myMessageSender.ResponseReceived += OnResponseReceived;

            // Create TCP messaging.
            IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
            IDuplexOutputChannel anOutputChannel = aMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8055/");

            // Attach the output channel to the message sender and be able
            // send messages and receive responses.
            myMessageSender.AttachDuplexOutputChannel(anOutputChannel);
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Detach output channel and stop listening to response messages.
            myMessageSender.DetachDuplexOutputChannel();
        }

        private void SendMessageBtn_Click(object sender, EventArgs e)
        {
            // Send message.
            myMessageSender.SendRequestMessage(MessageTextBox.Text);
        }

        private void OnResponseReceived(object sender, TypedResponseReceivedEventArgs<string> e)
        {
            // Display received response.
            // Note: This response does not come in the UI thread.
            //       Therefore, we ninvoke it in the UI thread.
            InvokeInUIThread(() => ReceivedResponseTextBox.Text = e.ResponseMessage);
        }

        // Helper method to invoke some functionality in UI thread.
        private void InvokeInUIThread(Action uiMethod)
        {
            // If we are not in the UI thread then we must synchronize via the invoke mechanism.
            if (InvokeRequired)
            {
                Invoke(uiMethod);
            }
            else
            {
                uiMethod();
            }
        }

        private IDuplexTypedMessageSender<string, string> myMessageSender;
    }
}

Service Application
The service is a simple console application listening via TCP to messages. When it receives a message, it sends back the text message.

Here is the whole service implementation:

using System;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace HelloWorldTcpService
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create message receiver.
            // It receives string and responses also string.
            IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
            IDuplexTypedMessageReceiver<string, string> aMessageReceiver
                = aTypedMessagesFactory.CreateDuplexTypedMessageReceiver<string, string>();

            // Subscribe to receive messages.
            aMessageReceiver.MessageReceived += OnMessageReceived;

            // Create input channel that will listen messages via TCP.
            IMessagingSystemFactory aTcpMessaging = new TcpMessagingSystemFactory();
            IDuplexInputChannel anInputChannel = aTcpMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:8055/");

            // Attach the input channel to the message receiver and start listening.
            aMessageReceiver.AttachDuplexInputChannel(anInputChannel);

            Console.WriteLine("TCP service is running. To stop press ENTER.");
            Console.ReadLine();

            // Detach the input channel and stop listening.
            aMessageReceiver.DetachDuplexInputChannel();
        }

        private static void OnMessageReceived(object sender, TypedRequestReceivedEventArgs<string> e)
        {
            // Display receive message.
            Console.WriteLine("Received message: " + e.RequestMessage);

            // Send back simple response.
            string aResponseMessage = "Thanks for " + e.RequestMessage;
            IDuplexTypedMessageReceiver<string, string> aReceiver
                = (IDuplexTypedMessageReceiver<string, string>)sender;
            aReceiver.SendResponseMessage(e.ResponseReceiverId, aResponseMessage);
        }
    }
}

And here are communicating applications.

How to Implement Load Balancing to Distribute Workload

2012-01-22T21:12:00.001+01:00

Summary: Simple example showing how to implement the load balancing if you need to increase the performance by distributing the workload across multiple services.

Introduction
The example demonstrates a communication scenario where the capacity of one running service is not enough and you want to increase the performance by distributing the workload across multiple services.
To simulate the scenario, the example below implements a client application using a service to calculate π (PI) number. The calculation is split into many small intervals (400 in our example).
Therefore, the service gets overloaded and the performance drops down.

The solution for such scenarios could be using of load balancer. The load balancer is a component maintaining a farm of services (typically same services but running on different machines) and is exposed to receive messages instead of the real service. The client does not know about this setup and thinks it communicates directly with the service. When the client sends a request, the load balancer receives this message and forwards it to the service picked from the farm. The service processes the message and sends back the response that is routed via the load balancer back to the client.

The example can be downloaded from http://eneter.net/Downloads/Examples/LoadBalancing.zip.
To run the example applications must be executed in the following order:
1. PiCalculator up to 3 instances.
2. LoadBalancer
3. Client

The example bellow uses Eneter Messaging Framework that provides functionality for various communication scenarios.
(The framework is free for non-commercial use (License) and can be downloaded from http://www.eneter.net.
More detailed technical info can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.)

Client
The client is a simple application containing a button sending the request to the service to calculate π (PI) number. The calculation is split into many small intervals. Therefore, the client sends about 400 messages each containing a small interval for the calculation.
Then it collects all responses and summarizes them together to get the final result, the PI number.

using System;
using System.Windows.Forms;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace Client
{
    public partial class Form1 : Form
    {
        // Requested calculation range.
        public class Range
        {
            public double From;
            public double To;
        }

        public Form1()
        {
            InitializeComponent();
            OpenConnection();
        }

        public void OpenConnection()
        {
            // Create TCP messaging for the communication.
            // Note: Requests are sent to the balancer that will forward them
            //       to available services.
            IMessagingSystemFactory myMessaging = new TcpMessagingSystemFactory();
            IDuplexOutputChannel anOutputChannel = myMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8060/");

            // Create sender to send requests.
            IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory();
            mySender = aSenderFactory.CreateDuplexTypedMessageSender<double, Range>();

            // Subscribe to receive response messages.
            mySender.ResponseReceived += OnResponseReceived;

            // Attach the output channel and be able to send messages and receive responses.
            mySender.AttachDuplexOutputChannel(anOutputChannel);
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Detach the output channel and stop listening for responses.
            mySender.DetachDuplexOutputChannel();
        }

        private void CalculatePiBtn_Click(object sender, EventArgs e)
        {
            myCalculatedPi = 0.0;

            // Split calculation of PI to 400 ranges and sends them for the calculation.
            for (double i = -1.0; i <= 1.0; i += 0.005)
            {
                Range anInterval = new Range() { From = i, To = i + 0.005 };
                mySender.SendRequestMessage(anInterval);
            }
        }

        private void OnResponseReceived(object sender, TypedResponseReceivedEventArgs<double> e)
        {
            // Receive responses (calculations for ranges) and calculate PI.
            myCalculatedPi += e.ResponseMessage;

            // Display the number.
            // Note: The UI control can be used only from the UI thread.
            InvokeInUIThread(() => ResultTextBox.Text = myCalculatedPi.ToString());
        }

        // Helper method to invoke some functionality in UI thread.
        private void InvokeInUIThread(Action uiMethod)
        {
            // If we are not in the UI thread then we must synchronize via the invoke mechanism.
            if (InvokeRequired)
            {
                Invoke(uiMethod);
            }
            else
            {
                uiMethod();
            }
        }

        private IDuplexTypedMessageSender<double, Range> mySender;
        private double myCalculatedPi;
    }
}

Load Balancer
The load balancer is a simple console application acting as a real service. In this example it has a farm of three services. (To keep things simple, all three services run on the same computer. They listens to different ports.)
When a user presses the button in the client application, the load balancer receives about 400 request messages and distributes them to its three services from the farm.
To decide which service is picked from the farm, the load balancer uses Round-Robin algorithm. Therefore, all services are chosen evenly.
(The Round-Robin algorithm is suitable for load balancing if processing of requests takes approximately same time.)

The code is very simple. The whole implementation is here:

using System;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.Nodes.LoadBalancer;

namespace LoadBalancer
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create TCP messaging for the communication with the client
            // and with services performing requests.
            IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();

            // Create load balancer.
            // It receives requests from the client and forwards them to available services
            // to balance the workload.
            ILoadBalancerFactory aLoadBalancerFactory = new RoundRobinBalancerFactory(aMessaging);
            ILoadBalancer aLoadBalancer = aLoadBalancerFactory.CreateLoadBalancer();

            // Addresses of available services.
            string[] anAvailableServices = {
                       "tcp://127.0.0.1:8071/", "tcp://127.0.0.1:8072/", "tcp://127.0.0.1:8073/" };

            // Add IP addresses of services to the load balancer.
            foreach (string anIpAddress in anAvailableServices)
            {
                aLoadBalancer.AddDuplexOutputChannel(anIpAddress);
            }

            // Create input channel that will listen to requests from clients.
            IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:8060/");

            // Attach the input channel to the load balancer and start listening.
            aLoadBalancer.AttachDuplexInputChannel(anInputChannel);

            Console.WriteLine("Load Balancer is running.\r\nPress ENTER to stop.");
            Console.ReadLine();

            // Stop lisening.
            aLoadBalancer.DetachDuplexInputChannel();
        }
    }
}

PI Calculator
The calculator is a simple service (console application). It receives requests to perform calculations for specific intervals. When the calculation is done, it sends back the calculation result.

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.NetworkInformation;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace PiCalculator
{
    // Requested calculation range.
    public class Range
    {
        public double From;
        public double To;
    }

    class Program
    {
        static void Main(string[] args)
        {
            string aServiceAddress = GetMyAddress();
            if (aServiceAddress == "")
            {
                Console.WriteLine("The service could not start because all possible ports are occupied.");
                return;
            }

            // Create TCP messaging for receiving requests.
            IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
            IDuplexInputChannel anInputChannel = aMessaging.CreateDuplexInputChannel(aServiceAddress);

            // Create typed message receiver to receive requests.
            // It receives request messages of type Range and sends back
            // response messages of type double.
            IDuplexTypedMessagesFactory aReceiverFactory = new DuplexTypedMessagesFactory();
            IDuplexTypedMessageReceiver<double, Range> aReceiver
                = aReceiverFactory.CreateDuplexTypedMessageReceiver<double, Range>();

            // Subscribre to messages.
            aReceiver.MessageReceived += OnMessageReceived;

            // Attach the input channel and start listening.
            aReceiver.AttachDuplexInputChannel(anInputChannel);

            Console.WriteLine("Root Square Calculator listening to " + aServiceAddress +
                " is running.\r\n Press ENTER to stop.");
            Console.ReadLine();

            // Detach the input channel and stop listening.
            aReceiver.DetachDuplexInputChannel();
        }

        private static void OnMessageReceived(object sender, TypedRequestReceivedEventArgs<Range> e)
        {
            Console.WriteLine("Calculate From: {0} To: {1}", e.RequestMessage.From, e.RequestMessage.To);

            // Calculate requested range.
            double aResult = 0.0;
            double aDx = 0.000000001;
            for (double x = e.RequestMessage.From; x < e.RequestMessage.To; x += aDx)
            {
                aResult += 2 * Math.Sqrt(1 - x * x) * aDx;
            }

            // Response back the result.
            IDuplexTypedMessageReceiver<double, Range> aReceiver
                = (IDuplexTypedMessageReceiver<double, Range>)sender;
            aReceiver.SendResponseMessage(e.ResponseReceiverId, aResult);
        }

        // Helper method to get the address.
        // Note: Since our example services are running on the same machine,
        //       we must ensure they do not try to listen to the same IP address.
        private static string GetMyAddress()
        {
            List<int> aPossiblePorts = new List<int>(new int[]{ 8071, 8072, 8073 });

            // When we execute this service three time we want to get three instances
            // listening to different port.
            IPGlobalProperties anIpGlobalProperties = IPGlobalProperties.GetIPGlobalProperties();
            IPEndPoint[] aTcpListeners = anIpGlobalProperties.GetActiveTcpListeners();

            // Remove from the possible ports those which are used.
            foreach (IPEndPoint aListener in aTcpListeners)
            {
                aPossiblePorts.Remove(aListener.Port);
            }

            // Get the first available port.
            if (aPossiblePorts.Count > 0)
            {
                return "tcp://127.0.0.1:" + aPossiblePorts[0] + "/";
            }

            // All three instances are used.
            return "";
        }

    }
}

And here are all applications communicating together.

Silverlight: Notification Messages from Desktop Application

2011-10-23T21:38:00.004+02:00

Summary: A simple example showing how a Silverlight application can subscribe for notification messages from a desktop application.

Introduction
The example bellow shows a scenario where the Silverlight application needs to observe desired events from a desktop application.
(E.g. some data got updated and your Silverlight client needs to react accordingly.)

The example consists of the Silverlight application and the standalone desktop application.
The desktop application calculates given numbers and notifies the result via the broker.
The Silverlight client subscribes in the broker to be notified whenever a calculation is performed.
Silverlight and desktop communicates via TCP.

The example is based on the Eneter Messaging Framework that provides components for various communication scenarios.
(The framework is free for non-commercial use (License) and can be downloaded from http://www.eneter.net.
The online help for developers can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.)

Desktop Application
The desktop application is responsible for counting two numbers and notifying the result to subscribed clients.
As you can see on the picture, the desktop application contains three communication components:

TCP Policy Server
Broker
Duplex Dispatcher.

TCP Policy Server
The TCP communication between Silverlight and a desktop application requires the policy server. The policy server is the special service listening to the port 943. When a Silverlight application tries to open the TCP connection the Silverlight framework internally sends the request to the port 943 and waits for the response. The policy server receives the request and responses with the policy file.
If the policy file allows the communication, Silverlight opens the connection and the communication can start.

Broker
The Broker is the component providing the publish-subscribe communication. In our case, the Silverlight client uses BrokerClient to subscribe for desired notification messages.
The desktop application uses BrokerClient to send notification messages to the broker.
Then when Broker receives the notification message, it forwards it to all subscribed clients.

Duplex Dispatcher
The Duplex Dispatcher allows Broker communicating via TCP and the local Synchronous messaging at the same time.
The reason is, the Silverlight client communicates via TCP, but the internal BrokerClient communicates via Synchronous messaging (because it would not be effective to communicate inside one process via TCP).
Therefore, the Dispatcher component is used. The Dispatcher component receives messages on attached input ports and forwards them to all attached output ports.
In our case the Dispatcher receives messages via TCP and Synchronous Messaging and forwards them to the Broker.

The implementation is here:

using System;
using System.Windows.Forms;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.SynchronousMessagingSystem;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.Nodes.Broker;
using Eneter.Messaging.Nodes.Dispatcher;

namespace DesktopCalculator
{
    public partial class Form1 : Form
    {
        private TcpPolicyServer myPolicyServer;
        private IDuplexBrokerClient myBrokerClient;
        private IDuplexDispatcher myDispatcher;

        public Form1()
        {
            InitializeComponent();

            // Start the policy server.
            // Note: Silverlight requires the policy server to start the communication.
            //       The policy server tells the silverlight if the communication is permitted.
            myPolicyServer = new TcpPolicyServer();
            myPolicyServer.StartPolicyServer();


            // Local messaging connecting the Dispatcher and the Broker.
            IMessagingSystemFactory aLocalMessaging = new SynchronousMessagingSystemFactory();

            // Create the broker forwarding notifications to subscribed clients.
            IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory();
            IDuplexBroker aBroker = aBrokerFactory.CreateBroker();

            // Attach the input channel to the broker.
            // Note: The broker will receive via this channel messages from the Dispatcher.
            IDuplexInputChannel aBrokerInputChannel =
                aLocalMessaging.CreateDuplexInputChannel("MyBrokerChannelId");
            aBroker.AttachDuplexInputChannel(aBrokerInputChannel);

            // Create the dispatcher.
            // The dispatcher will receive TCP messages and also local messages and forward them
            // to the broker.
            // (I.e. broker can get messages from local messaging and from TCP at the same time.)
            IDuplexDispatcherFactory aDispatcherFactory = new DuplexDispatcherFactory(aLocalMessaging);
            myDispatcher = aDispatcherFactory.CreateDuplexDispatcher();

            // Add the broker channel to the dispatcher.
            myDispatcher.AddDuplexOutputChannel("MyBrokerChannelId");

            // Attach the input channel receiving messages from the broker client.
            // Note: The channel id is same as the broker client has.
            IDuplexInputChannel aDispatcherLocalInputChannel =
                aLocalMessaging.CreateDuplexInputChannel("MyLocalBrokerClientId");
            myDispatcher.AttachDuplexInputChannel(aDispatcherLocalInputChannel);


            // Create the broker client notifying calculated results to the broker.
            myBrokerClient = aBrokerFactory.CreateBrokerClient();

            // Attach the output channel to the broker.
            // Note: The broker client will use this channel to send messages to the dispatcher.
            IDuplexOutputChannel aBrokerClientOutputChannel =
                aLocalMessaging.CreateDuplexOutputChannel("MyLocalBrokerClientId");
            myBrokerClient.AttachDuplexOutputChannel(aBrokerClientOutputChannel);


            // TCP messaging for the communication with the Silverlight client.
            IMessagingSystemFactory aTcpMessaging = new TcpMessagingSystemFactory();

            // Note: Silverlight can communicate only on ports: 4502-4532
            IDuplexInputChannel aTcpInputChannel =
                aTcpMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:4510");

            // Finaly attach the TCP input channel to the dispatcher and start listening
            // to Silverlight clients.
            myDispatcher.AttachDuplexInputChannel(aTcpInputChannel);
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Detach input channels from the dispatcher and stop the listening.
            myDispatcher.DetachDuplexInputChannel();

            // Stop the policy server.
            myPolicyServer.StopPolicyServer();
        }

        private void CalculateBtn_Click(object sender, EventArgs e)
        {
            // Calculate numbers.
            int aResult = int.Parse(Number1TextBox.Text) + int.Parse(Number2TextBox.Text);

            // Show the result in the text box.
            ResultTextBox.Text = aResult.ToString();

            // Notify the result to the broker.
            myBrokerClient.SendMessage("MyResultMessageId", ResultTextBox.Text);
        }
    }
}

Silverlight Client Application
The Silverlight client is responsible for subscribing to receive notifications from the desktop application - whenewer two numbers are calculated.
To subscribe for messages, the Silverlight application uses BrokerClient communicating via the TCP channel with the desktop application.

The implementation of the client is here:

using System.Windows;
using System.Windows.Controls;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.Nodes.Broker;

namespace SilverlightObserver
{
    public partial class MainPage : UserControl
    {
        private IDuplexBrokerClient myBrokerClient;
        private bool myIsSubscribedFlag;

        public MainPage()
        {
            InitializeComponent();

            // Create the BrokerClient to subscribe and receive notifications.
            IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory();
            myBrokerClient = aBrokerFactory.CreateBrokerClient();

            // Handle received notifications.
            myBrokerClient.BrokerMessageReceived += OnBrokerMessageReceived;


            // TCP messaging for the communication with the desktop application.
            IMessagingSystemFactory aTcpMessaging = new TcpMessagingSystemFactory();

            // Create the TCP output channel and attach it to the BrokerClient.
            IDuplexOutputChannel aTcpOutputChannel =
                aTcpMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:4510");

            myBrokerClient.AttachDuplexOutputChannel(aTcpOutputChannel);
        }


        private void LayoutRoot_Unloaded(object sender, RoutedEventArgs e)
        {
            // Detach the TCP output channel and stop the communication.
            myBrokerClient.DetachDuplexOutputChannel();
        }

        private void SubscribeBtn_Click(object sender, RoutedEventArgs e)
        {
            // If not subscribed, then subscribe for the same type
            // as is notified from the desktop.
            if (!myIsSubscribedFlag)
            {
                myBrokerClient.Subscribe("MyResultMessageId");
                myIsSubscribedFlag = true;
            }
        }

        private void UnsubscribeBtn_Click(object sender, RoutedEventArgs e)
        {
            // If subscribed, then unsubscribe.
            if (myIsSubscribedFlag)
            {
                myBrokerClient.Unsubscribe();
                myIsSubscribedFlag = false;
            }
        }

        private void OnBrokerMessageReceived(object sender, BrokerMessageReceivedEventArgs e)
        {
            // Display the notified message.
            ResultTextBox.Text = e.Message as string;
        }
    }
}

Communicating Applications

Have a nice day :-)

Eneter Messaging Framework 3.0

2011-10-21T00:23:00.007+02:00

Summary: The third version of the messaging framework for the interprocess communication.

Eneter Messaging Framework is a lightweight framework for the interprocess communication based on messages.
Although the framework is lightweight (the assembly has about 300Kb), it provides quite comprehensive functionality allowing to implement advanced communication scenarios too.
(E.g. Service listening to HTTP and TCP at the same time, Communication across unstable network, Load Balancing, etc.)

The framework is free for non-comercial use (License) and runs in .NET 3.5, .NET 4.0, Windows Phone 7, Silverlight 3, Silverlight 4 and MONO 2.6.4.
Therefore, you can easily implement e.g. the communication between Windows Phone 7 and a standalone desktop application.
The framework can be downloaded from http://www.eneter.net.

Interprocess Communication
The communication between applications can be realized by various protocols or mechanisms. The right one depends on particular requirements. E.g. Are communicating applications on one machine? Are there any restrictions (e.g. Silverlight)?
The framework allows to implement the communication via:

Shared Memory - for the very fast communication between processes running on the same machine (faster than Named Pipes)
Named Pipes - for the communication between processes running on the same machine
TCP - for the communication between processes running on different machines.
HTTP - for the communication between processes running on different machines.
Silverlight Messaging - for the communication between Silverlight applications.

Encoding
Messages can be encoded with using:

XML Serializer - for simple serialization of messages into XML.
XML Data Contract Serializer - for the serialization of messages into XML using DataContract and DataMember attributes
Binary Serializer - for the fast serialization of messages into the binary format.
AES Serializer - for encrypting messages using Advanced Encryption Standard.
Rijndael Serializer - for encrypting messages using Rijndael encryption.
GZip Serializer - for compressing big messages before sending across the network.

The communication API is not bound to a particular protocol or encoding format, therefore your implementation stays same, does not matter what you use.

Routing Messages
The routing functionality provides components that can be placed on the communication path to control the sending behavior. E.g. forwarding messages to subscribed receivers, forwarding messages to a different address, load balancing, etc.

Broker - for sending notification messages to subscribed clients (i.e. publish-subscribe scenarios).
Router - for re-routing messages to a different address.
Dispatcher - for routing messages to multiple receivers (the same request processed by more services in parallel).
Load Balancer - for distributing workload across more computers (or processes, or threads).
Channel Wrapper/Unwrapper - for receiving various types of messages on one address (no need for long "if ... then" statements to recognize the type of received messages.)

Reliability
The communication across the network is typically less reliable as a local call performed inside the application. The network connection can be interrupted, or the receiving application can be temporarily unavailable. If your communication scenario requires to overcome these issues, the framework provides the following functionality:

Monitoring of the connection availability - for early detection of a disconnection.
Buffering of sent messages in case of a disconnection and automatic reconnect - for overcoming short disconnections e.g. caused by an unstable network.
Acknowledged messages - for confirmation if the message was delivered or not.

Security
The communication across the network is very easy to be observed and confidential data can be acquired by unauthorized persons. Therefore you may want to protect your data during the communication.

HTTPS, SSL and fast symetric encryption by using AES or Rijndael serializers.

If you are interested in more technical details about the framework, you can visit Eneter Online Info.

Enjoy the third version.

Independent Startup Order of Communicating Applications

2011-05-22T18:14:00.005+02:00

Summary: A simple example showing how to implement the communication where the client application can start to communicate before the service application is running.

Typically, the startup order matters in the interprocess communication. It means, the client application assumes, that the service application is running and is ready to communicate. This behavior does not have to be a problem for systems, where the service is running the most of the time and clients start and stop regularly.
But for systems consisting of more applications running on separate machines and starting approximately at the same time, this behavior causes, that somebody (or something) must start the system in a defined order, what complicates the life and makes the startup error prone.

The example bellow implements a simple client-service communication where communicating applications can start independently from each other and the client can start to communicate even before the service is able to receive messages.

The example is based on the Eneter Messaging Framework 2.0 that provides components for various communication scenarios.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from http://www.eneter.net. The online help for developers can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.)

Buffered Messaging
To implement the independent startup order behavior, we will use Buffered Messaging from the Eneter Messaging Framework.
In case, the receiving application is not connected, the Buffered Messaging automatically tries to open the connection and meanwhile stores sent messages into the buffer. Then, when the connection is open, it sends the stored messages to the receiver.

In our independent startup order scenario, if the client starts before the service and sends some message, the message is stored in the buffer. Then, when the service is started and the connection is open, the message from the buffer is sent to the service.

Service Application
The service application is a simple console application communicating via TCP and returning the time.
The whole implementation is very simple.

using System;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace TimeService
{
    class Program
    {
        // The message receiver.
        // It receives 'string' and responses 'DateTime'.
        // Note: the 'string' is not used in this example.
        static IDuplexTypedMessageReceiver<DateTime, string> myReceiver;

        static void Main(string[] args)
        {
            // Create TCP based messaging.
            IMessagingSystemFactory aTcpMessaging = new TcpMessagingSystemFactory();
            IDuplexInputChannel anInputChannel = 
                aTcpMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:7083/");

            // Create typed message receiver.
            IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
            myReceiver = aTypedMessagesFactory.CreateDuplexTypedMessageReceiver<DateTime, string>();
            myReceiver.MessageReceived += OnMessageReceived;

            // Attach the receiver to the channel and start listening.
            myReceiver.AttachDuplexInputChannel(anInputChannel);

            Console.WriteLine("The service is listening.");
            Console.WriteLine("Press Enter to stop.");
            Console.ReadLine();

            myReceiver.DetachDuplexInputChannel();
        }

        static void OnMessageReceived(object sender, TypedRequestReceivedEventArgs<string> e)
        {
            // Process the incoming request:
            // Just return the current time.
            myReceiver.SendResponseMessage(e.ResponseReceiverId, DateTime.Now);
        }
    }
}

Client Application
The client application is a simple application using the service to retrieve the exact time.
The client application can start and can request the time before the service application is running.
In such case, the request is stored in the buffer. Then, when the service is ready, the request is delivered and the service responses the time.

Try the following scenario:
1. Start the client application.
2. Invoke the request to get the exact time.
3. Wait few seconds and start the service application.
4. The client displays the time from the service.

The implementation is very simple.

using System;
using System.Windows.Forms;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.Composites.BufferedMessagingComposit;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace TimeClient
{
    public partial class Form1 : Form
    {
        // The message sender.
        // It sends 'string' and gets 'DateTime' as the response.
        // Note: the 'string' is not used in this example.
        IDuplexTypedMessageSender<DateTime, string> mySender;

        public Form1()
        {
            InitializeComponent();

            // Create TCP based messaging.
            IMessagingSystemFactory aTcpMessaging = new TcpMessagingSystemFactory();

            // Create the buffered messaging.
            // If the connection is not available, the buffered messaging tries to reconnect
            // and meanwhile stores sent messages to the buffer.
            // Then, when reconnected, it sends sent messages to the receiver.
            // The following buffered messaging is based on TCP messaging
            // and can work offline 1 minute.
            IMessagingSystemFactory aBufferedMessaging = 
                new BufferedMessagingFactory(aTcpMessaging, TimeSpan.FromMinutes(1));

            IDuplexOutputChannel anOutputChannel = 
                aBufferedMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:7083/");


            // Create the message sender.
            IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
            mySender = aTypedMessagesFactory.CreateDuplexTypedMessageSender<DateTime, string>();
            mySender.ResponseReceived += OnResponseReceived;

            // Attach the output channel and be able to send requests and receive
            // response messages.
            mySender.AttachDuplexOutputChannel(anOutputChannel);
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Correctly close the connection.
            mySender.DetachDuplexOutputChannel();
        }

        private void RequestServiceTimeButton_Click(object sender, EventArgs e)
        {
            // Invoke the request to get the current time from the service.
            mySender.SendRequestMessage("not used");
        }

        private void OnResponseReceived(object sender, TypedResponseReceivedEventArgs<DateTime> e)
        {
            if (e.ReceivingError == null)
            {
                // Display the time returned from the service.
                // Note: The response does not come in the UI thread, therefore
                //       it must be transfered to UI thread.
                DateTime aTime = e.ResponseMessage;
                InvokeInUIThread(() => ServiceTimeTextBox.Text = aTime.ToString());
            }
        }

        // Helper method to invoke the given delegate
        // in the UI thread.
        private void InvokeInUIThread(Action action)
        {
            if (InvokeRequired)
            {
                Invoke(action);
            }
            else
            {
                action();
            }
        }
    }
}

And here are communicating applications

Service Listening to TCP, HTTP and Named Pipe at the same Time

2011-05-15T16:51:00.005+02:00

Summary: A simple example showing how to implement a service listening to TCP, HTTP and Named Pipe at the same time.

The example below implements a simple service that is able to receive requests via TCP, HTTP and Named Pipe. Therefore, the service can be available for clients using different communications. E.g. Windows Phone 7 environment supports only HTTP.

The example is based on the Eneter Messaging Framework 2.0 that provides components for various communication scenarios.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from http://www.eneter.net. The online help for developers can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.)

Multiple Listening
To implement the multiple listener, we will use the Dispatcher component from the Eneter Messaging Framework.
The Dispatcher receives messages from all attached input channels and forwards them to all attached output channels.
In our scenario, the dispatcher will have three input channels (TCP, HTTP and Named Pipe) and only one output channel (local channel to the message receiver).
So, if a message is received e.g. via the TCP input channel, the dispatcher will forward it through the output channel to the typed message receiver. The typed message receiver then notifies the user code implementing the service.

Multiple Listening Service Application
The service is implemented as a simple console application. The most important part is using of the dispatcher component for the multiple listening (TCP, HTTP and Named Pipe).
Since the service listens also to HTTP, you must execute it under sufficient user rights. (I recommend administrator for the debug purposes.)
The whole implementation is very simple.

using System;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.HttpMessagingSystem;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.NamedPipeMessagingSystem;
using Eneter.Messaging.MessagingSystems.SynchronousMessagingSystem;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.Nodes.Dispatcher;

namespace MultiReceivingService
{
    public class RequestData
    {
        public int Number1 { get; set; }
        public int Number2 { get; set; }
    }

    class Program
    {
        // Receiver receiving 'RequestData' and responding 'int'.
        // Note: Duplex typed message receiver can receive messages of specified type
        //       and send response messages of specified type.
        private static IDuplexTypedMessageReceiver<int, RequestData> myReceiver;

        static void Main(string[] args)
        {
            // Create local messaging connecting the dispatcher with the receiver.
            IMessagingSystemFactory aLocalMessaging = new SynchronousMessagingSystemFactory();
            IDuplexInputChannel aLocalInputChannel =
                aLocalMessaging.CreateDuplexInputChannel("MyLocalAddress");

            IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
            myReceiver = aTypedMessagesFactory.CreateDuplexTypedMessageReceiver<int, RequestData>();
            myReceiver.MessageReceived += OnMessageReceived;

            // Attach the local input channel to the receiver and start to receive messages.
            myReceiver.AttachDuplexInputChannel(aLocalInputChannel);


            // Create messaging using HTTP.
            IMessagingSystemFactory anHttpMessaging = new HttpMessagingSystemFactory();
            IDuplexInputChannel anHttpInputChannel =
                anHttpMessaging.CreateDuplexInputChannel("http://127.0.0.1:8035/MyService/");

            // Create messaging using TCP.
            IMessagingSystemFactory aTcpMessaging = new TcpMessagingSystemFactory();
            IDuplexInputChannel aTcpInputChannel =
                aTcpMessaging.CreateDuplexInputChannel("tcp://127.0.0.1:8036/");

            // Create messaging using Named Pipe.
            // Note: Do not use '/' at the end of the named pipe address.
            IMessagingSystemFactory aPipeMessaging = new NamedPipeMessagingSystemFactory();
            IDuplexInputChannel aPipeInputChannel =
                aPipeMessaging.CreateDuplexInputChannel("net.pipe://127.0.0.1/MyService");


            // Create dispatcher that will receive messages via HTTP, TCP and Named Pipe
            // and forward them to the local address "MyLocalAddress" -> i.e. to our receiver.
            IDuplexDispatcherFactory aDispatcherFactory = new DuplexDispatcherFactory(aLocalMessaging);
            IDuplexDispatcher aDispatcher = aDispatcherFactory.CreateDuplexDispatcher();
            aDispatcher.AddDuplexOutputChannel("MyLocalAddress");

            aDispatcher.AttachDuplexInputChannel(anHttpInputChannel);
            Console.WriteLine("Listening to HTTP.");

            aDispatcher.AttachDuplexInputChannel(aTcpInputChannel);
            Console.WriteLine("Listening to TCP.");

            aDispatcher.AttachDuplexInputChannel(aPipeInputChannel);
            Console.WriteLine("Listening to Named Pipe.");

            Console.WriteLine("To stop the service press enter ...");
            Console.ReadLine();

            // Stop listening and detach all input channels.
            aDispatcher.DetachDuplexInputChannel();
        }


        // The handler called when a message is received.
        static void OnMessageReceived(object sender, TypedRequestReceivedEventArgs<RequestData> e)
        {
            if (e.ReceivingError == null)
            {
                int aResult = e.RequestMessage.Number1 + e.RequestMessage.Number2;
                Console.WriteLine("{0} + {1} = {2}", e.RequestMessage.Number1, e.RequestMessage.Number2, aResult);

                // Send the result back to the client.
                myReceiver.SendResponseMessage(e.ResponseReceiverId, aResult);
            }
        }
    }
}

Client Application
The client is a simple windows form application using the service to calculate two numbers provided by the user. The client can communicate with the service via TCP, HTTP or Named Pipe.
Since the service application is executed under administrator user rights, the named pipe client must also be executed under same rights. (HTTP and TCP clients do not have to run under administrator user rights.)

using System;
using System.Windows.Forms;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace TcpClient
{
    public partial class Form1 : Form
    {
        // Structure of 2 numbers that will be sent to
        // the service to be calculated.
        public class RequestData
        {
            public int Number1 { get; set; }
            public int Number2 { get; set; }
        }

        // Sender sending 'RequestData' and receiving 'int'.
        // Note: Duplex typed message sender can send messages of specified type
        //       and receive response messages of specified type.
        private static IDuplexTypedMessageSender<int, RequestData> mySender;

        public Form1()
        {
            InitializeComponent();

            // Create messaging using TCP.
            IMessagingSystemFactory aTcpMessaging = new TcpMessagingSystemFactory();
            IDuplexOutputChannel anOutputChannel =
                aTcpMessaging.CreateDuplexOutputChannel("tcp://127.0.0.1:8036/");

            //// Create messaging using HTTP.
            //IMessagingSystemFactory anHttpMessaging = new HttpMessagingSystemFactory();
            //IDuplexOutputChannel anOutputChannel = 
            //    anHttpMessaging.CreateDuplexOutputChannel("http://127.0.0.1:8035/MyService/");

            //// Create messaging using Named Pipe.
            //// Note: Do not use '/' at the end of the named pipe address.
            //IMessagingSystemFactory aNamedPipeMessaging = new NamedPipeMessagingSystemFactory();
            //IDuplexOutputChannel anOutputChannel =
            //    aNamedPipeMessaging.CreateDuplexOutputChannel("net.pipe://127.0.0.1/MyService");

            // Create the sender, that sends 'RequestData' and receives 'int'.
            IDuplexTypedMessagesFactory aTypedMessagesFactory = new DuplexTypedMessagesFactory();
            mySender = aTypedMessagesFactory.CreateDuplexTypedMessageSender<int, RequestData>();

            // Register the handler receiving the result from the service.
            mySender.ResponseReceived += OnResponseReceived;

            // Attach the TCP duplex output channel and be able to send messages
            // and receive response messages.
            mySender.AttachDuplexOutputChannel(anOutputChannel);
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            mySender.DetachDuplexOutputChannel();
        }

        private void CalculateButton_Click(object sender, EventArgs e)
        {
            // Create the message.
            RequestData aRequestData = new RequestData();
            aRequestData.Number1 = int.Parse(Number1TextBox.Text);
            aRequestData.Number2 = int.Parse(Number2TextBox.Text);

            // Send the message to the service.
            mySender.SendRequestMessage(aRequestData);
        }

        // When a result from the service is received, display it.
        private void OnResponseReceived(object sender, TypedResponseReceivedEventArgs<int> e)
        {
            if (e.ReceivingError == null)
            {
                // Display the result of the calculation.
                // Note: The response message does not come in the UI thread.
                //       Therefore, do not forget to route it if you touch UI controls.
                InvokeInUIThread(() => ResultTextBox.Text = e.ResponseMessage.ToString());
            }
        }

        // Helper executing the given delegate in the UI thread.
        private void InvokeInUIThread(Action action)
        {
            // If we are not in the UI thread then we must synchronize 
            // via the invoke mechanism.
            if (InvokeRequired)
            {
                Invoke(action);
            }
            else
            {
                action();
            }
        }
    }
}

And here are communicating applications.

Windows Phone 7: How to Encrypt Communication with Desktop Application

2011-04-21T15:49:00.003+02:00

Summary: Simple example showing how to implement encrypted communication between Windows Phone 7 and standalone .NET application.

The example bellow implements a simple .NET application as a service and a Windows Phone 7 application as a client. The service counts the number of words in the given text. The client then uses the service to get amount of words in the text and displays the result.

The communication between the client and the service is protected by AES (Advanced Encryption Standard).

Also, since the network connection does not have to be stable (e.g. weak signal), the example uses the buffered messaging. The buffered messaging detects disconnections, automatically tries to reconnect and meanwhile stores sent messages in the buffer. Then, when the connection is available again, the messages stored in the buffer are sent to the receiver.

The example is based on the Eneter Messaging Framework 2.0.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from http://www.eneter.net. The online help for developers can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.)

Service Application
The service is a standalone .NET application and is responsible for the receiving of messages and counting words in the given text.
Please notice, to run the HTTP listening application you must execute it under sufficient user rights. Otherwise the application will run, but will not listen. (The framework logs the Access denied error on the debug port.)
The whole implementation is very simple.

using System;
using System.Text.RegularExpressions;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.Composites;
using Eneter.Messaging.MessagingSystems.HttpMessagingSystem;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;

namespace EncryptedService
{
    class Program
    {
        // Receiver receiving a text message and returning back the number
        // of words in the text message.
        private static IDuplexTypedMessageReceiver<int, string> myReceiver;

        static void Main(string[] args)
        {
            // Create Http messaging.
            IMessagingSystemFactory anUnderlyingMessaging = new HttpMessagingSystemFactory();

            // The network can be unstable. Therefore, let's use the buffered messaging with
            // the monitor checking the connection.
            // If the client does not ping longer than 5 seconds, the client is considered to be disconnected
            // and its response messages are stored in the buffer.
            // If the connection occurs within 15 seconds, the response messages are sent to the client.
            IMessagingSystemFactory aBufferedMessaging = new BufferedMonitoredMessagingFactory(
                anUnderlyingMessaging,
                new XmlStringSerializer(),
                TimeSpan.FromMilliseconds(15000),   // maximum time, the client can be offline
                TimeSpan.FromMilliseconds(500),     // 'ping' frequency - not applicable for the service
                TimeSpan.FromMilliseconds(5000)     // maximum time, the 'ping' message does not have to be received
                );


            IDuplexInputChannel anInputChannel = aBufferedMessaging.CreateDuplexInputChannel("http://127.0.0.1:8035/MyService/");

            // Helper: If you are interested to see the encrypted message.
            anInputChannel.MessageReceived += OnEncryptedMessageReceived;

            // Create serializer using the AES encryption.
            // Note: The serializer is used to deserialize incoming messages
            //       and serialize sent response messages.
            AesSerializer aSerializer = new AesSerializer("My secret password");

            // Create message receiver - response sender.
            IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory(aSerializer);
            myReceiver = aSenderFactory.CreateDuplexTypedMessageReceiver<int, string>();
            myReceiver.MessageReceived += OnMessageReceived;

            Console.WriteLine("The service is running.");
            Console.WriteLine("Press enter to stop ...");

            // Attach the duplex input channel and start listening.
            myReceiver.AttachDuplexInputChannel(anInputChannel);

            Console.ReadLine();

            myReceiver.DetachDuplexInputChannel();
        }

        private static void OnMessageReceived(object sender, TypedRequestReceivedEventArgs<string> e)
        {
            if (e.ReceivingError == null)
            {
                // Display the incoming text message.
                Console.WriteLine("Received message: {0}\n", e.RequestMessage);

                // Calculate number of words in the string.
                MatchCollection aWords = Regex.Matches(e.RequestMessage, @"[\S]+");
                int aNumberOfWords = aWords.Count;

                // Send back the number of words.
                myReceiver.SendResponseMessage(e.ResponseReceiverId, aNumberOfWords);
            }
        }

        // This is just a helper method to display the encrypted message.
        private static void OnEncryptedMessageReceived(object sender, DuplexChannelMessageEventArgs e)
        {
            string anEncryptedMessage = "";
            byte[] anEncryptedArray = e.Message as byte[];
            foreach (byte aByte in anEncryptedArray)
            {
                anEncryptedMessage += aByte.ToString("x2");
            }

            Console.WriteLine("Encrypted Message: {0}", anEncryptedMessage);
        }

    }
}

Client Application
The client is a Windows Phone 7 application and is responsible for receiving text from the user and using the service to get the number of words in the given text. Then it displays the result.
(Notice, if you run the application from the Visual Studio, do not forget to set, that the application shall be deployed on 'Windows Phone 7 Emulator'.)
The client application uses the assembly built for the Windows Phone 7, Eneter.Messaging.Framework.Phone.dll.

using System;
using System.Windows;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.Composites;
using Eneter.Messaging.MessagingSystems.HttpMessagingSystem;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Microsoft.Phone.Controls;

namespace EncryptedClientWP7
{
    public partial class MainPage : PhoneApplicationPage
    {
        // Sender sending text messages and receiving int response messages.
        private IDuplexTypedMessageSender<int, string> mySender;

        // Constructor
        public MainPage()
        {
            InitializeComponent();

            OpenConnection();
        }

        private void OpenConnection()
        {
            // Create Http messaging.
            // Note: The default constructor routes received response
            //       messages into the Silverlight thread.
            //       If it is not desired, then it can be changed.
            IMessagingSystemFactory anUnderlyingMessaging = new HttpMessagingSystemFactory();

            // The cell-phone network can be unstable.
            // Therefore, let's use the buffered messaging and
            // the monitor checking if the connection is still open.
            // Create buffered messaging, that will be able to work offline 1 minute.
            // During the offline time, the sent messages are stored in the buffer
            // and the framework tries to reconnect.
            IMessagingSystemFactory aBufferedMessaging = new BufferedMonitoredMessagingFactory(
                anUnderlyingMessaging,
                new XmlStringSerializer(),
                TimeSpan.FromMinutes(1),            // maximum offline time
                TimeSpan.FromMilliseconds(500),     // how often the 'ping' checking the connection is invoked
                TimeSpan.FromMilliseconds(1000)     // maximum time, the response for the 'ping'
                                                    // shall be received
                );
            IDuplexOutputChannel anOutputChannel = 
                aBufferedMessaging.CreateDuplexOutputChannel("http://127.0.0.1:8035/MyService/");

            // Create serializer using the AES encryption.
            // Note: The serializer is used to serialize sent messages and
            //       deserialize incoming response messages.
            //       The password must be same as on the service side.
            AesSerializer aSerializer = new AesSerializer("My secret password");

            // Create message sender - response receiver.
            IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory(aSerializer);
            mySender = aSenderFactory.CreateDuplexTypedMessageSender<int, string>();
            mySender.ResponseReceived += OnResponseReceived;

            // Attach duplex output channel and be able to send
            // messages and receive response messages.
            mySender.AttachDuplexOutputChannel(anOutputChannel);
        }

        private void PhoneApplicationPage_Unloaded(object sender, RoutedEventArgs e)
        {
            // Disconnect from the service.
            mySender.DetachDuplexOutputChannel();
        }

        private void SendButton_Click(object sender, RoutedEventArgs e)
        {
            // Send the message.
            // Note: The message will be serialized and encrypted by AES and
            //       then sent to the service.
            mySender.SendRequestMessage(TextMessage.Text);
        }

        private void OnResponseReceived(object sender, TypedResponseReceivedEventArgs<int> e)
        {
            if (e.ReceivingError == null)
            {
                // The message is received in the Silverlight thread,
                // so we do not have to route it to the Silverlight thread.
                // Display the number of words.
                Result.Text = e.ResponseMessage.ToString();
            }
        }
    }
}

And the communicating applications are displayed here.

Silverlight: How to Communicate with Desktop Application via HTTP

2011-04-03T21:39:00.003+02:00

Summary: Simple example showing how to communicate between a Silverlight application and a standalone .NET application with using HTTP.

Introduction
This article is a free continuation of How to Receive Messages from Desktop Application and How to Send Message to Desktop Application where the Silverlight application communicates with the standalone .NET application via TCP.
In this article I would like to show how to implement the communication via HTTP.

The example bellow implements a .NET application as a service and Silverlight application as a client. The service listens to text messages and responses their length.
The client then uses the service to get the length of the given text.

The implementation uses Eneter Messaging Framework.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from http://www.eneter.net/. The online help for developers can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.)

Policy Server
Same as the TCP communication, also the HTTP communication requires the policy XML file. Silverlight automatically requests this file when the application wants to connect other than the site of origin. In case of the HTTP, Silverlight requests the policy file on the root of the HTTP request. I.e. if the Silverlight application requests http://127.0.0.1/MyHttpService/, then Silverlight asks for the policy server from the root: http://127.0.0.1/clientaccesspolicy.xml.
If the policy file is not available or its content does not allow the communication, the HTTP request is not performed.

Service Application
The service application provides the HTTP policy service for the communication with the Silverlight client. Then it implements the simple service calculating the length for the given text.
Please notice, to run the HTTP listening application, you must execute it under sufficient user rights. Otherwise you will get an exception.

The whole implemetation is very simple.

using System;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.HttpMessagingSystem;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;

namespace LengthService
{
    class Program
    {
        // Receiver receiving messages of type string and responding int.
        static private IDuplexTypedMessageReceiver<int, string> myReceiver;

        static void Main(string[] args)
        {
            // Start Http Policy Server
            // Note: Http policy server must be initialized to the root.
            HttpPolicyServer aPolicyServer = new HttpPolicyServer("http://127.0.0.1:8034/");
            aPolicyServer.StartPolicyServer();

            Console.WriteLine("Http Policy Server is running.");

            // Create Http messaging.
            IMessagingSystemFactory aMessaging = new HttpMessagingSystemFactory();

            // Create the input channel that is able to
            // receive messages and send back response messages.
            IDuplexInputChannel anInputChannel = 
                aMessaging.CreateDuplexInputChannel("http://127.0.0.1:8034/MyService/");

            // Create message receiver - response sender.
            // It receives 'string' and responses 'int'.
            IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory();
            myReceiver = aSenderFactory.CreateDuplexTypedMessageReceiver<int, string>();
            myReceiver.MessageReceived += OnMessageReceived;

            Console.WriteLine("The service is listening to Http.");
            Console.WriteLine("Press Enter to stop the service.\n");

            // Attach the duplex input channel and start listening.
            myReceiver.AttachDuplexInputChannel(anInputChannel);

            Console.ReadLine();

            myReceiver.DetachDuplexInputChannel();
            aPolicyServer.StopPolicyServer();
        }

        static private void OnMessageReceived(object sender,
            TypedRequestReceivedEventArgs<string> e)
        {
            if (e.ReceivingError == null)
            {
                int aLength = e.RequestMessage.Length;

                Console.WriteLine("Received string: {0}; Responded length: {1}",
                    e.RequestMessage, aLength);

                // Response the length of the string.
                myReceiver.SendResponseMessage(e.ResponseReceiverId, aLength);
            }
        }
    }
}

Silverlight Client Application
The client application uses the service to get the length of the given text.
The client application uses the assembly built for Silverlight, Eneter.Messaging.Framework.Silverlight.dll.
The implementation is very simple.

using System.Windows;
using System.Windows.Controls;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.HttpMessagingSystem;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;

namespace LengthClient
{
    public partial class MainPage : UserControl
    {
        // Sender sending messages of type string and
        // receiving responses of type int.
        private IDuplexTypedMessageSender<int, string> mySender;

        public MainPage()
        {
            InitializeComponent();

            OpenConnection();
        }

        private void OpenConnection()
        {
            // Create HTTP messaging with default parameters.
            // Note: The default constructor routes received response
            //       messages into the Silverlight thread.
            //       If it is not desired, then it can be changed.
            IMessagingSystemFactory aMessaging = new HttpMessagingSystemFactory();

            IDuplexOutputChannel anOutputChannel =
                aMessaging.CreateDuplexOutputChannel("http://127.0.0.1:8034/MyService/");

            // Create message sender - response receiver.
            IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory();
            mySender = aSenderFactory.CreateDuplexTypedMessageSender<int, string>();
            mySender.ResponseReceived += OnResponseReceived;

            // Attach duplex output channel and be able to send messages
            // and receive response messages.
            mySender.AttachDuplexOutputChannel(anOutputChannel);
        }

        private void UserControl_Unloaded(object sender, RoutedEventArgs e)
        {
            mySender.DetachDuplexOutputChannel();
        }

        private void GetLengthButton_Click(object sender, RoutedEventArgs e)
        {
            // Send the user text to the service.
            // Service will response the length of the text.
            mySender.SendRequestMessage(UserText.Text);
        }

        private void OnResponseReceived(object sender, TypedResponseReceivedEventArgs<int> e)
        {
            if (e.ReceivingError == null)
            {
                int aResult = e.ResponseMessage;

                // Display the response message.
                // The response message is the length of the text.
                ReceivedLength.Text = aResult.ToString();
            }
        }
    }
}

And here are communicating applications.

I hope, you found the article useful.

Windows Phone 7: How to Communicate with Desktop Application

2011-03-27T20:34:00.006+02:00

Summary: Simple example showing how to implement the communication from Windows Phone 7 to the standalone .NET application with using HTTP.

The example bellow implements a simple .NET application as a service and Windows Phone 7 application as a client. The service calculates two numbers and returns the result. The Windows Phone 7 client then uses the service to perform the calculation and displays the result.

It is typical for the cell-phone, that the network connection does not have to be stable. The signal can get weak or can be temporarily lost.
The good application should be able to handle this situation and should not stop to work.

The example bellow uses Eneter Messaging Framework, that allows to setup the communication that detects disconnections, automatically tries to reconnect and meanwhile stores sent messages in the buffer. Then, when the connection is available again, the messages stored in the buffer are sent to the receiver.

(Full, not limited and for non-commercial usage free version of the framework can be downloaded from http://www.eneter.net. The online help for developers can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.)

Service Application
The service .NET application is responsible for the calculation of two numbers and for the responding of results. The whole implementation is very simple.
Please notice, to run the HTTP listening application you must execute it under sufficient user rights. Otherwise the application will run, but will not listen. (The framework logs the Access denied error on the debug port.)
For the debugging purposes, I recommend to execute it under administrator rights.

using System;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.Composites;
using Eneter.Messaging.MessagingSystems.HttpMessagingSystem;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;

namespace CalculatorService
{
    // The message transferring numbers to be calculated.
    public class RequestMsg
    {
        public int Number1;
        public int Number2;
    }

    class Program
    {
        // Receiver receiving requests to calculate two numbers and responding the result.
        static private IDuplexTypedMessageReceiver<int, RequestMsg> myReceiver;

        static void Main(string[] args)
        {
            // Create Http messaging.
            IMessagingSystemFactory anUnderlyingMessaging = new HttpMessagingSystemFactory();

            // The network can be unstable. Therefore, let's use the buffered messaging monitoring the connection
            // and with automatic reconnect in case of the disconnection.
            // If the client does not ping longer than 5 seconds, the client is considered to be disconnected
            // and its response messages are stored in the buffer.
            // If the connection occurs within 15 seconds, the response messages are sent to the client.
            IMessagingSystemFactory aBufferedMessaging = new BufferedMonitoredMessagingFactory(
                anUnderlyingMessaging,
                new XmlStringSerializer(),
                TimeSpan.FromMilliseconds(15000),   // maximum time, the client can be offline
                TimeSpan.FromMilliseconds(500),     // 'ping' frequency - this is not applicable for the receiver
                TimeSpan.FromMilliseconds(5000)     // maximum time, the 'ping' message does not have to be received
                );


            IDuplexInputChannel anInputChannel = aBufferedMessaging.CreateDuplexInputChannel("http://127.0.0.1:8034/Calculator/");

            // Create message receiver - response sender.
            IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory();
            myReceiver = aSenderFactory.CreateDuplexTypedMessageReceiver<int, RequestMsg>();
            myReceiver.MessageReceived += OnMessageReceived;

            Console.WriteLine("Calculator service is listening to Http. Press enter to stop listening ...");

            // Attach the duplex input channel and start listening
            // on the specified address.
            myReceiver.AttachDuplexInputChannel(anInputChannel);

            Console.ReadLine();

            myReceiver.DetachDuplexInputChannel();
        }

        // The method is called when a request is received.
        static private void OnMessageReceived(object sender, TypedRequestReceivedEventArgs<RequestMsg> e)
        {
            // Calculate incoming 2 numbers.
            if (e.ReceivingError == null)
            {
                int aResult = e.RequestMessage.Number1 + e.RequestMessage.Number2;

                Console.WriteLine("{0} + {1} = {2}", e.RequestMessage.Number1, e.RequestMessage.Number2, aResult);

                // Send the result back.
                myReceiver.SendResponseMessage(e.ResponseReceiverId, aResult);
            }
        }
    }
}

Client Application
The Windows Phone 7 client application sends requests to calculate two numbers and displays results.
If the connection is lost, the messages are buffered and messaging system tries to automatically reconnect.
Then, if reconnected, the messages stored in the buffer are sent to the receiver.
(Notice, if you run the application from the Visual Studio, do not forget to set, that the application shall be deployed on 'Windows Phone 7 Emulator'.)
The client application uses the assembly built for the Windows Phone 7, Eneter.Messaging.Framework.Phone.dll.

using System;
using System.Windows;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.Composites;
using Eneter.Messaging.MessagingSystems.HttpMessagingSystem;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Microsoft.Phone.Controls;

namespace Phone7Sender
{
    public partial class MainPage : PhoneApplicationPage
    {
        // The message transferring numbers to be calculated.
        public class RequestMsg
        {
            public int Number1;
            public int Number2;
        }

        // Sender sending the request to calculate two numbers and receiving the result.
        private IDuplexTypedMessageSender<int, RequestMsg> mySender;

        // Constructor
        public MainPage()
        {
            InitializeComponent();

            OpenConnection();
        }

        private void OpenConnection()
        {
            // Create Http messaging.
            // Note: The default constructor routes received response messages into the Silverlight thread.
            //       If it is not desired, then it can be changed.
            IMessagingSystemFactory anUnderlyingMessaging = new HttpMessagingSystemFactory();

            // The cell-phone connection can be unstable.
            // Therefore, let's use the buffered messaging monitoring the connection
            // and with automatic reconnect in case of the disconnection.
            // Create buffered messaging, that will be able to work offline 1 minute.
            // During the offline time, the sent messages are stored in the buffer and the framework tries
            // to reconnect.
            IMessagingSystemFactory aBufferedMessaging = new BufferedMonitoredMessagingFactory(
                anUnderlyingMessaging, 
                new XmlStringSerializer(), 
                TimeSpan.FromMinutes(1),            // maximum offline time
                TimeSpan.FromMilliseconds(500),     // how often the 'ping' checking the connection is invoked
                TimeSpan.FromMilliseconds(1000)     // maximum time, the response for the 'ping' shall be received
                );
            IDuplexOutputChannel anOutputChannel = aBufferedMessaging.CreateDuplexOutputChannel("http://127.0.0.1:8034/Calculator/");

            // Create message sender - response receiver.
            IDuplexTypedMessagesFactory aSenderFactory = new DuplexTypedMessagesFactory();
            mySender = aSenderFactory.CreateDuplexTypedMessageSender<int, RequestMsg>();
            mySender.ResponseReceived += OnResponseReceived;

            // Attach duplex output channel and be able to send messages and receive response messages.
            mySender.AttachDuplexOutputChannel(anOutputChannel);
        }

        private void LayoutRoot_Unloaded(object sender, RoutedEventArgs e)
        {
            mySender.DetachDuplexOutputChannel();
        }

        private void SendButton_Click(object sender, RoutedEventArgs e)
        {
            // Create the request message.
            RequestMsg aMessage = new RequestMsg();
            aMessage.Number1 = int.Parse(Number1TextBox.Text);
            aMessage.Number2 = int.Parse(Number2TextBox.Text);

            // Send the message.
            // Note: If the connection is not available, the message will be stored in the buffer.
            //       We have set, the application can work offline maximum 1 minute.
            mySender.SendRequestMessage(aMessage);
        }

        private void OnResponseReceived(object sender, TypedResponseReceivedEventArgs<int> e)
        {
            if (e.ReceivingError == null)
            {
                // The response message was routed to the Silverlight thread.
                // Therefore, the value can be directly written to the UI control.
                ResultTextBox.Text = e.ResponseMessage.ToString();
            }
        }

    }
}

The following picture shows the communicating applications:

I hope, you found the article useful.

Eneter Messaging Framework 2.0

2011-03-27T18:33:00.009+02:00

Summary: The second version of the lightweight framework for the interprocess communication.

The Eneter Messaging Framework is the lightweight framework intended for the communication between processes.
The second version of the framework supports all features and API from the previous version and in addition, it comes with new features:

Reliability

Monitoring of the connection
Buffering of sent messages in case of a disconnection and automatic reconnect
Acknowledged communication

Security

SSL supported for the TCP communication
Fast symmetric encoding of messages with AES and Rijndael

General

HTTP policy server for the HTTP communication between Silverlight and the standalone .NET application

The following picture summarizes possibilities of the framework:

In summary the framework covers the following main use-cases:

Interprocess Communication

The framework enables you to implement the communication between your applications with using messages.

You can use string messages or strongly typed messages. The communication can be one-way or request-response. You also can implement publish-subscribe scenarios where applications can be subscribed to receive desired notification messages from other applications.

The reason why you could consider the communication via messages is, the communicating applications are loosely coupled. It means, they do not have many assumptions about each other. They just need to know the message format and the address (channel) where to send / receive the message. This reduces the maintenance effort and increases the flexibility.
E.g. In case of messaging communication, if you add a new message to the service, the existing client applications are not affected.
In case of Remote Procedure Call (RPC), if you add a new method to the service interface, you probably need to update clients using this interface.

Across Platform Communication
The framework is implemented for the following platforms: .NET, Silverlight, Windows Phone 7 and Mono.
Therefore, with using the framework you can use the same approach to connect applications running on different platforms:

Silverlight application and .Net application
Silverlight application and Mono application
Windows Phone 7 application and .Net application
Windows Phone 7 application and Mono application
.NET application and Mono application

Reliable Communication
The communication across the network is much less reliable as the communication on one machine. It is quite common, the network connection is interrupted or the application is not available.
To support these scenarios, the framework provides:

Buffered messaging with automatic reconnect - in case of the disconnection, the sent messages are stored in the buffer and the framework tries to reconnect. If reconnected, the messages stored in the buffer are sent to the receiver.
Acknowledged messages - the delivery of sent messages is confirmed.

Secured Communication
To secure the communication, the framework allows to use HTTPS or SSL or you can just encrypt messages with fast symmetric encryption AES or Rijndael.

If you are interested in more technical details, you can visit:
http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html

Release notes:
http://www.eneter.net/ReleaseNotes.htm

The full version of the framework is free for non-commercial usage and can be downloaded from:
http://www.eneter.net

I hope, you will enjoy the second version.

Silverlight: How to Receive Messages from Desktop Application

2010-11-06T14:35:00.003+01:00

Summary: Simple example showing how Silverlight application can receive messages from a standalone desktop application.

Introduction
The article is a free continuation of How to Send Message to Desktop Application where the Silverlight application sends a text message to the desktop application.
Now I would like to show how the Silverlight application can receive text messages from the desktop application with using TCP connection.
(Actually, the example bellow shows the bidirectional communication between the Silverlight application and the desktop application.)

The implementation uses Eneter Messaging Framework.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from http://www.eneter.net/. The online help for developers can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html)

As mentioned in the previous article, the Silverlight communication via TCP has the following specifics:

The Silverlight framework requires the policy server.
The Silverlight framework allows only ports of range 4502 - 4532.

In addition:

The Silverlight application cannot be a TCP listener.

Therefore, if the Silverlight application wants to receive messages, it must open TCP connection to the listening desktop application and receive response messages.

Eneter Messaging Framework supports these specifics. It contains the policy server, wraps the low-level socket communication and allows the request-response communication via duplex channels.
The implementation is very simple.

Desktop Application
The desktop application is responsible for starting the policy server, for receiving messages and for sending messages back to the Silverlight application.

using System;
using System.Windows.Forms;
using Eneter.Messaging.EndPoints.StringMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace DesktopApplication
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

            // Start the policy server to be able to communicate with silverlight.
            myPolicyServer.StartPolicyServer();

            // Create duplex message receiver.
            // It can receive messages and also send back response messages.
            IDuplexStringMessagesFactory aStringMessagesFactory = new DuplexStringMessagesFactory();
            myMessageReceiver = aStringMessagesFactory.CreateDuplexStringMessageReceiver();
            myMessageReceiver.ResponseReceiverConnected += ClientConnected;
            myMessageReceiver.ResponseReceiverDisconnected += ClientDisconnected;
            myMessageReceiver.RequestReceived += MessageReceived;

            // Create TCP based messaging.
            IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
            IDuplexInputChannel aDuplexInputChannel = aMessaging.CreateDuplexInputChannel("127.0.0.1:4502");

            // Attach the duplex input channel to the message receiver and start listening.
            // Note: Duplex input channel can receive messages but also send messages back.
            myMessageReceiver.AttachDuplexInputChannel(aDuplexInputChannel);
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Close listenig.
            // Note: If the listening is not closed, then listening threads are not ended
            //       and the application would not be closed properly.
            myMessageReceiver.DetachDuplexInputChannel();

            myPolicyServer.StopPolicyServer();
        }

        // The method is called when a message from the client is received.
        private void MessageReceived(object sender, StringRequestReceivedEventArgs e)
        {
            // Display received message.
            InvokeInUIThread(() =>
                {
                    ReceivedMessageTextBox.Text = e.RequestMessage;
                });
        }


        // The method is called when a client is connected.
        // The Silverlight client is connected when the client attaches the output duplex channel.
        private void ClientConnected(object sender, ResponseReceiverEventArgs e)
        {
            // Add the connected client to the listbox.
            InvokeInUIThread(() =>
                {
                    ConnectedClientsListBox.Items.Add(e.ResponseReceiverId);
                });
        }

        // The method is called when a client is disconnected.
        // The Silverlight client is disconnected if the web page is closed.
        private void ClientDisconnected(object sender, ResponseReceiverEventArgs e)
        {
            // Remove the disconnected client from the listbox.
            InvokeInUIThread(() =>
                {
                    ConnectedClientsListBox.Items.Remove(e.ResponseReceiverId);
                });
        }

        private void SendButton_Click(object sender, EventArgs e)
        {
            // Send the message to all connected clients.
            foreach (string aClientId in ConnectedClientsListBox.Items)
            {
                myMessageReceiver.SendResponseMessage(aClientId, MessageTextBox.Text);
            }
        }

        // Helper method to invoke some functionality in UI thread.
        private void InvokeInUIThread(Action uiMethod)
        {
            // If we are not in the UI thread then we must synchronize 
            // via the invoke mechanism.
            if (InvokeRequired)
            {
                Invoke(uiMethod);
            }
            else
            {
                uiMethod();
            }
        }

        private TcpPolicyServer myPolicyServer = new TcpPolicyServer();
        private IDuplexStringMessageReceiver myMessageReceiver;
    }
}

Silverlight Application
The Silverlight application is responsible for sending text messages and for receiving response messages. (The communication with the policy server is invoked automatically by Silverlight before the connection is established.)

using System.Windows;
using System.Windows.Controls;
using Eneter.Messaging.EndPoints.StringMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace SilverlightApplication
{
    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();

            // Create duplex message sender.
            // It can send messages and also receive messages.
            IDuplexStringMessagesFactory aStringMessagesFactory = new DuplexStringMessagesFactory();
            myMessageSender = aStringMessagesFactory.CreateDuplexStringMessageSender();
            myMessageSender.ResponseReceived += MessageReceived;

            // Create TCP based messaging.
            IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
            IDuplexOutputChannel aDuplexOutputChannel = aMessaging.CreateDuplexOutputChannel("127.0.0.1:4502");

            // Attach the duplex output channel to the message sender
            // and be able to send messages and receive messages.
            myMessageSender.AttachDuplexOutputChannel(aDuplexOutputChannel);
        }

        // The method is called when a message from the desktop application is received.
        private void MessageReceived(object sender, StringResponseReceivedEventArgs e)
        {
            textBox2.Text = e.ResponseMessage;
        }

        // The method is called when the button to send message is clicked.
        private void SendMessage_Click(object sender, RoutedEventArgs e)
        {
            myMessageSender.SendMessage(textBox1.Text);
        }


        private IDuplexStringMessageSender myMessageSender;
    }
}

Communicating Applications
The picture bellow shows the communicating applications. The desktop applications sent the message 'Hello Silverlight' that was received by both Silverlight clients. The first Silverlight application sent the message 'Hi Desktop' that was received by the desktop application.

I hope you found the article useful. Any feedback is welcome.

Silverlight: How to Send Message to Desktop Application

2010-10-31T11:27:00.003+01:00

Summary: Very simple example showing how to send a message from Silverlight application to standalone desktop application.

Introduction
The example bellow shows how to use Eneter Messaging Framework to send text messages from Silverlight application to standalone desktop application with using Tcp connection.

(Full, not limited and for non-commercial usage free version of the framework can be downloaded from http://www.eneter.net/. The online help for developers can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html)

When we want to use the Tcp conection in Silverlight, we must be aware of following specifics:

The Silverlight framework requires the policy server.
The Silverlight framework allows only ports of range 4502 - 4532.

Policy Server
The Policy Server is a special service listening on the port 943. The service receives '<policy-file-request>' and responses the policy file that says who is allowed to communicate.

Silverlight automatically uses this service when creates the Tcp connection. It sends the request on the port 943 and expects the policy file. If the policy server is not there or the content of the policy file does not allow the communication, the Tcp connection is not created.

Eneter Messaging Framework wraps the low-level socket communication and provides convenient API for the Tcp communication. It also provides the Policy Server for you. Therefore the implementation is very simple. See the code bellow.

Desktop Application
The desktop application is responsible for starting the policy server and receiving messages.
The whole implementation is here:

using System;
using Eneter.Messaging.EndPoints.StringMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace Receiver
{
    class Program
    {
        static void Main(string[] args)
        {
            // Start policy server enabling silverlight security to communicate via Tcp.
            TcpPolicyServer aPolicyServer = new TcpPolicyServer();
            aPolicyServer.StartPolicyServer();

            // Create receiver of string messages.
            IStringMessagesFactory aStringMessageReceiverFactory = new StringMessagesFactory();
            IStringMessageReceiver aStringMessageReceiver = aStringMessageReceiverFactory.CreateStringMessageReceiver();
            aStringMessageReceiver.MessageReceived += StringMessageReceived;

            // Create Tcp listrning channel.
            // Note: Silverlight supports only ports of range 4502 - 4532
            IMessagingSystemFactory aTcpMessagingFactory = new TcpMessagingSystemFactory();
            IInputChannel anInputChannel = aTcpMessagingFactory.CreateInputChannel("127.0.0.1:4502");

            // Attach the input channel to the string message receiver and start listening.
            Console.WriteLine("Receiver is listening.");
            aStringMessageReceiver.AttachInputChannel(anInputChannel);
        }

        static void StringMessageReceived(object sender, StringMessageEventArgs e)
        {
            // Process incoming message.
            Console.WriteLine(e.Message);
        }
    }
}

Silverlight Application
The Silverlight application is responsible for sending text messages. (The communication with the policy server is invoked automatically by Silverlight before the connection is established.)
The whole implementation is very simple:

using System.Windows;
using System.Windows.Controls;
using Eneter.Messaging.EndPoints.StringMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace SilverlightApplication
{
    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();

            // Create sender of string messages.
            IStringMessagesFactory aStringMessageReceiverFactory = new StringMessagesFactory();
            myStringMessageSender = aStringMessageReceiverFactory.CreateStringMessageSender();

            // Create output channel sending via Tcp.
            // Note1: Silverlight supports only ports of range 4502 - 4532
            IMessagingSystemFactory aTcpMessagingFactory = new TcpMessagingSystemFactory();
            IOutputChannel anOutputChannel = aTcpMessagingFactory.CreateOutputChannel("127.0.0.1:4502");

            // Attach the output channel to the string message sender
            // to be able to send messages via Tcp.
            myStringMessageSender.AttachOutputChannel(anOutputChannel);
        }

        // Send message when the button is clicked.
        private void button1_Click(object sender, RoutedEventArgs e)
        {
            string aMessage = textBox1.Text;
            myStringMessageSender.SendMessage(aMessage);
        }

        private IStringMessageSender myStringMessageSender;
    }
}

I hope you found the article useful and if you have any comments or questions feel free to ask.

Multiple Publishers - Multiple Subscribers Communication

2010-10-23T19:43:00.009+02:00

Summary: Simple example showing how to implement the communication scenario where subscribing applications can receive notification messages from more publishing applications.

Introduction
The article is a free continuation of Public-Subscribe Communication where one application (publisher) sends notifications to more applications (subscribers).
Now I would like to describe the scenario where subscribing applications need to receive notifications from more publishing applications.

The main question in this scenario is how to connect publishing applications with subscribing applications. If subscribers are connected directly to individual publishers, then we can get quickly many connections that can be difficult to manage.

To reduce the complexity and number of connections, we can implement one application as Broker that will maintain registered subscribers and forward them messages from publishers. Subscribers are so connected only to the broker and do not have to handle connections with publishers. Publishers send messages only to the broker and do not have to register/unregister subscribers.

The following example shows how to implement this scenario with using Eneter Messaging Framework.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net. The online help for developers can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html)

Broker
The Broker is responsible for receiving notification messages from publishing applications and for forwarding them to all subscribed receivers.
The implementation of broker application is really trivial with Eneter Messaging Framework.
The whole implementation is here:

using System;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.Nodes.Broker;

namespace BrokerApplication
{
    class Program
    {
        static void Main(string[] args)
        {
            // Create the broker.
            IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory(new XmlStringSerializer());
            IDuplexBroker aBroker = aBrokerFactory.CreateBroker();

            // Create the Input channel receiving messages via Tcp.
            // Note: You can also choose NamedPipes or Http.
            //       (if you choose http, do not forget to execute it with sufficient user rights)
            IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
            IDuplexInputChannel aBrokerInputChannel = aMessaging.CreateDuplexInputChannel("127.0.0.1:7091");

            // Attach the input channel to the broker and start listening.
            Console.WriteLine("The broker application is running.");
            aBroker.AttachDuplexInputChannel(aBrokerInputChannel);
        }
    }
}

Publisher
The Publisher is responsible for sending messages to the broker application. The broker application then forwards messages to subscribed receivers.
The whole implementation is here:

using System;
using System.Windows.Forms;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.Nodes.Broker;

namespace Publisher
{
    public partial class Form1 : Form
    {
        // Notification message 1
        public class NotifyMsg1
        {
            public DateTime CurrentTime { get; set; }
        }

        // Notification message 2
        public class NotifyMsg2
        {
            public int Number { get; set; }
        }

        // Notification message 3
        public class NotifyMsg3
        {
            public string TextMessage { get; set; }
        }

        public Form1()
        {
            InitializeComponent();

            // Create broker client responsible for sending messages to the broker.
            IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory(new XmlStringSerializer());
            myBrokerClient = aBrokerFactory.CreateBrokerClient();

            // Create output channel to send messages via Tcp.
            IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
            myOutputChannel = aMessaging.CreateDuplexOutputChannel("127.0.0.1:7091");

            // Attach the output channel to the broker client to be able to send messages.
            myBrokerClient.AttachDuplexOutputChannel(myOutputChannel);
        }

        // Correctly close the output channel.
        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Note: The duplex output channel can receive response messages too.
            //       Therefore we must close it to stop the thread receiving response messages.
            //       If the thred is not closed then the application could not be correctly closed.
            myBrokerClient.DetachDuplexOutputChannel();
            myOutputChannel.CloseConnection();
        }

        // Send NotifyMsg1
        private void Notify1Btn_Click(object sender, EventArgs e)
        {
            NotifyMsg1 aMsg = new NotifyMsg1();
            aMsg.CurrentTime = DateTime.Now;

            object aSerializedMsg = mySerializer.Serialize<NotifyMsg1>(aMsg);

            myBrokerClient.SendMessage("MyNotifyMsg1", aSerializedMsg);
        }

        // Send NotifyMsg2
        private void Notify2Btn_Click(object sender, EventArgs e)
        {
            NotifyMsg2 aMsg = new NotifyMsg2();
            aMsg.Number = 12345;

            object aSerializedMsg = mySerializer.Serialize<NotifyMsg2>(aMsg);

            myBrokerClient.SendMessage("MyNotifyMsg2", aSerializedMsg);
        }

        // Send NotifyMsg3
        private void Notify3Btn_Click(object sender, EventArgs e)
        {
            NotifyMsg3 aMsg = new NotifyMsg3();
            aMsg.TextMessage = "My notifying text message.";

            object aSerializedMsg = mySerializer.Serialize<NotifyMsg3>(aMsg);

            myBrokerClient.SendMessage("MyNotifyMsg3", aSerializedMsg);
        }


        // Broker client is used to send messages to the broker,
        // that forwards messages to subscribers.
        private IDuplexBrokerClient myBrokerClient;

        // The output channel used by the broker client to send messages to the broker.
        private IDuplexOutputChannel myOutputChannel;

        // Serializer used to serialize notification messages.
        // Note: It is possible to use BinarySerializer too.
        //       In that case the messages would have to be declared in a
        //       separate library that would be linked by subscribers too.
        private XmlStringSerializer mySerializer = new XmlStringSerializer();
    }
}

Subscriber
The Subscriber is responsible for its registering in the broker application to receive desired notification messages.
The whole implementation is here:

using System;
using System.Windows.Forms;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.Nodes.Broker;

namespace Subscriber
{
    public partial class Form1 : Form
    {
        // Notification message 1
        public class NotifyMsg1
        {
            public DateTime CurrentTime { get; set; }
        }

        // Notification message 2
        public class NotifyMsg2
        {
            public int Number { get; set; }
        }

        // Notification message 3
        public class NotifyMsg3
        {
            public string TextMessage { get; set; }
        }

        public Form1()
        {
            InitializeComponent();

            // Create the broker client that will receive notification messages.
            IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory(new XmlStringSerializer());
            myBrokerClient = aBrokerFactory.CreateBrokerClient();
            myBrokerClient.BrokerMessageReceived += OnNotificationMessageReceived;

            // Create the Tcp messaging for the communication with the publisher.
            // Note: For the interprocess communication you can use: Tcp, NamedPipes and Http.
            IMessagingSystemFactory aMessagingFactory = new TcpMessagingSystemFactory();

            // Create duplex output channel for the communication with the publisher.
            // Note: The duplex output channel can send requests and receive responses.
            //       In our case, the broker client will send requests to subscribe/unsubscribe
            //       and receive notifications as response messages.
            myOutputChannel = aMessagingFactory.CreateDuplexOutputChannel("127.0.0.1:7091");

            // Attach the output channel to the broker client
            myBrokerClient.AttachDuplexOutputChannel(myOutputChannel);
        }

        // Correctly close the communication.
        // Note: If the communication is not correctly closed, the thread listening to
        //       response messages will not be closed.
        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            myBrokerClient.DetachDuplexOutputChannel();
            myOutputChannel.CloseConnection();
        }

        // Method processing notification messages from the publisher.
        private void OnNotificationMessageReceived(object sender, BrokerMessageReceivedEventArgs e)
        {
            // The notification event does not come in UI thread.
            // Therefore, if we want to work with UI controls we must execute it in the UI thread.
            InvokeInUIThread(() =>
                {
                    if (e.ReceivingError == null)
                    {
                        if (e.MessageTypeId == "MyNotifyMsg1")
                        {
                            NotifyMsg1 aDeserializedMsg = mySerializer.Deserialize<NotifyMsg1>(e.Message);
                            Received1TextBox.Text = aDeserializedMsg.CurrentTime.ToString();
                        }
                        else if (e.MessageTypeId == "MyNotifyMsg2")
                        {
                            NotifyMsg2 aDeserializedMsg = mySerializer.Deserialize<NotifyMsg2>(e.Message);
                            Received2TextBox.Text = aDeserializedMsg.Number.ToString();
                        }
                        else if (e.MessageTypeId == "MyNotifyMsg3")
                        {
                            NotifyMsg3 aDeserializedMsg = mySerializer.Deserialize<NotifyMsg3>(e.Message);
                            Received3TextBox.Text = aDeserializedMsg.TextMessage;
                        }
                    }
                });
        }

        // Subscribe to notification message 1
        private void Subscribe1Btn_Click(object sender, EventArgs e)
        {
            myBrokerClient.Subscribe("MyNotifyMsg1");
        }

        // Unsubscribe from notification message 1
        private void Unsubscribe1Btn_Click(object sender, EventArgs e)
        {
            Received1TextBox.Text = "";
            myBrokerClient.Unsubscribe("MyNotifyMsg1");
        }

        // Subscribe to notification message 2
        private void Subscribe2Btn_Click(object sender, EventArgs e)
        {
            myBrokerClient.Subscribe("MyNotifyMsg2");
        }

        // Unsubscribe from notification message 2
        private void Unsubscribe2Btn_Click(object sender, EventArgs e)
        {
            Received2TextBox.Text = "";
            myBrokerClient.Unsubscribe("MyNotifyMsg2");
        }

        // Subscribe to notification message 3
        private void Subscribe3Btn_Click(object sender, EventArgs e)
        {
            myBrokerClient.Subscribe("MyNotifyMsg3");
        }

        // Unsubscribe from notification message 3
        private void Unsubscribe3Btn_Click(object sender, EventArgs e)
        {
            Received3TextBox.Text = "";
            myBrokerClient.Unsubscribe("MyNotifyMsg3");
        }

        // Helper method to invoke some functionality in UI thread.
        private void InvokeInUIThread(Action uiMethod)
        {
            // If we are not in the UI thread then we must synchronize via the invoke mechanism.
            if (InvokeRequired)
            {
                Invoke(uiMethod);
            }
            else
            {
                uiMethod();
            }
        }

        // BrokerClient provides the communication with the broker.
        private IDuplexBrokerClient myBrokerClient;

        // The output channel used by the broker client to send messages to the broker.
        private IDuplexOutputChannel myOutputChannel;

        // Serializer used to sdeerialize notification messages.
        // Note: It is possible to use BinarySerializer too.
        //       In that case the messages would have to be declared in a
        //       separate library that would be linked by publisher too.
        private XmlStringSerializer mySerializer = new XmlStringSerializer();
    }
}

And for the completeness, here are publishers and subscribers running together with the broker.

I hope, you found the article useful. If you have any comments or questions, please let me know.

Publish-Subscribe Communication

2010-10-17T13:59:00.011+02:00

Summary: Simple example showing how to implement a communication scenario where one application sends notifications to other applications.

Introduction
The scenario where one application needs to inform other applications about some particular events is very common.
The application that wants to be informed about events subscribes to get notification messages from the publishing application. Then, when the event occurs, the publishing application notifies all subscribed applications.

The example bellow shows how to implement this scenario with using Eneter Messaging Framework.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net. The online help for developers can be found at http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html)

Publisher
The publishing application in our example is very simple. It provides just three events that are invoked when the button is clicked.

To publish these events the publisher uses the Broker component. The broker component receives messages via the input channel and forwards them to all subscribed receivers.
In our scenario we want, the broker receives the message when the button is clicked and then forwards it to subscribed receivers.
Therefore we need that our broker can communicate two ways:

Internally - to receive internal messages (from the same process) when the 'Notify' button is clicked.
Interprocess - to register/unregister subscribers and to forward notifications to subscribers.

To enable the communication via 2 different channels, we can use the Dispatcher component.
The dispatcher receives messages and forwards them to all attached receivers. In our case the dispatcher receives messages from two channels (internal messages and interprocess messages) and forwards them to only one receiver - Broker.

The whole implementation is very simple:

using System;
using System.Windows.Forms;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.Infrastructure.ConnectionProvider;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.SynchronousMessagingSystem;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.Nodes.Broker;
using Eneter.Messaging.Nodes.Dispatcher;

namespace Publisher
{
    public partial class Form1 : Form
    {
        // Notification message 1
        public class NotifyMsg1
        {
            public DateTime CurrentTime { get; set; }
        }

        // Notification message 2
        public class NotifyMsg2
        {
            public int Number { get; set; }
        }

        // Notification message 3
        public class NotifyMsg3
        {
            public string TextMessage { get; set; }
        }

        public Form1()
        {
            InitializeComponent();

            // Create internal messaging system that will be used for the internal communication.
            IMessagingSystemFactory anInternalMessaging = new SynchronousMessagingSystemFactory();


            //*******************************************************************************
            // Create communication components that will model our communication scenario
            // -> DuplexBroker: to forward notification messages to subscribers
            // -> DuplexDispatcher: to connect the broker with messaging systems: Tcp, Internal
            // -> BrokerClient: to send notifications from this application to the broker
            //*******************************************************************************

            // Create broker responsible for forwarding notification messages.
            IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory(new XmlStringSerializer());
            myBroker = aBrokerFactory.CreateBroker();
            
            // Create broker client used to send notification messages from this application.
            myBrokerClient = aBrokerFactory.CreateBrokerClient();

            // Create Dispatcher that will receive messages from Tcp messaging and also from the internal
            // messaging and send them to the broker.
            // Note: Internal messages will come from myBrokerClient
            //       Tcp messages will come from other applications subscribed for notifications.
            IDuplexDispatcherFactory aDispatcherFactory = new DuplexDispatcherFactory(anInternalMessaging);
            myDispatcher = aDispatcherFactory.CreateDuplexDispatcher();


            //*******************************************************************************
            // "Click" communication components together
            // -> connect the broker with the dispatcher
            // -> connect the dispatcher with the 'broker client'
            // -> connect the dispatcher to Tcp messaging
            //*******************************************************************************

            // Create helper to create connections for 'internal messaging'.
            // Note: It internally creates input/output channels and connect them to components.
            IConnectionProviderFactory aConnectionProviderFactory = new ConnectionProviderFactory();
            IConnectionProvider aConnectionProvider = aConnectionProviderFactory.CreateConnectionProvider(anInternalMessaging);

            // Connect the broker to the internal messaging via the duplex input channel.
            aConnectionProvider.Attach(myBroker, "MyBrokerChannelId");

            // Tell dispatcher to send messages to the broker.
            myDispatcher.AddDuplexOutputChannel("MyBrokerChannelId");

            // Connect dispatcher with the 'broker client'.
            aConnectionProvider.Connect(myDispatcher, myBrokerClient, "MyInternalDispatcherChannelId");

            // Create Tcp messaging for the communication with subscribed applications.
            IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();

            // Attach Tcp duplex input channel to the dispatcher and start listening.
            IDuplexInputChannel aTcpInputChannel = aMessaging.CreateDuplexInputChannel("127.0.0.1:8091");
            myDispatcher.AttachDuplexInputChannel(aTcpInputChannel);
        }

        // Correctly close listening to Tcp messages.
        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            myDispatcher.DetachDuplexInputChannel();
        }

        // Send NotifyMsg1
        private void Notify1Btn_Click(object sender, EventArgs e)
        {
            NotifyMsg1 aMsg = new NotifyMsg1();
            aMsg.CurrentTime = DateTime.Now;

            object aSerializedMsg = mySerializer.Serialize<NotifyMsg1>(aMsg);

            myBrokerClient.SendMessage("MyNotifyMsg1", aSerializedMsg);
        }

        // Send NotifyMsg2
        private void Notify2Btn_Click(object sender, EventArgs e)
        {
            NotifyMsg2 aMsg = new NotifyMsg2();
            aMsg.Number = 12345;

            object aSerializedMsg = mySerializer.Serialize<NotifyMsg2>(aMsg);

            myBrokerClient.SendMessage("MyNotifyMsg2", aSerializedMsg);
        }

        // Send NotifyMsg3
        private void Notify3Btn_Click(object sender, EventArgs e)
        {
            NotifyMsg3 aMsg = new NotifyMsg3();
            aMsg.TextMessage = "My notifying text message.";

            object aSerializedMsg = mySerializer.Serialize<NotifyMsg3>(aMsg);

            myBrokerClient.SendMessage("MyNotifyMsg3", aSerializedMsg);
        }


        // Broker used to forward messages to subscribers.
        private IDuplexBroker myBroker;

        private IDuplexDispatcher myDispatcher;

        // Broker client is used to send messages to the broker,
        // that forwards messages to subscribers.
        private IDuplexBrokerClient myBrokerClient;

        // Serializer used to serialize notification messages.
        // Note: It is possible to use BinarySerializer too.
        //       In that case the messages would have to be declared in a
        //       separate library that would be linked by subscribers too.
        private XmlStringSerializer mySerializer = new XmlStringSerializer();
    }
}

Subscriber
The subscribing application in this example is very simple too. It can subscribe and unsubscribe via the button and simply displays the incoming notification messages.

To subscribe, unsubscribe and receive messages the subscriber uses the BrokerClient component.

The whole implementation is very simple:

using System;
using System.Windows.Forms;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.Nodes.Broker;

namespace Subscriber
{
    public partial class Form1 : Form
    {
        // Notification message 1
        public class NotifyMsg1
        {
            public DateTime CurrentTime { get; set; }
        }

        // Notification message 2
        public class NotifyMsg2
        {
            public int Number { get; set; }
        }

        // Notification message 3
        public class NotifyMsg3
        {
            public string TextMessage { get; set; }
        }

        public Form1()
        {
            InitializeComponent();

            // Create the broker client that will receive notification messages.
            IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory(new XmlStringSerializer());
            myBrokerClient = aBrokerFactory.CreateBrokerClient();
            myBrokerClient.BrokerMessageReceived += OnNotificationMessageReceived;

            // Create the Tcp messaging for the communication with the publisher.
            // Note: For the interprocess communication you can use: Tcp, NamedPipes and Http.
            IMessagingSystemFactory aMessagingFactory = new TcpMessagingSystemFactory();

            // Create duplex output channel for the communication with the publisher.
            // Note: The duplex output channel can send requests and receive responses.
            //       In our case, the broker client will send requests to subscribe/unsubscribe
            //       and receive notifications as response messages.
            IDuplexOutputChannel anOutputChannel = aMessagingFactory.CreateDuplexOutputChannel("127.0.0.1:8091");

            // Attach the output channel to the broker client
            myBrokerClient.AttachDuplexOutputChannel(anOutputChannel);
        }

        // Correctly close the communication.
        // Note: If the communication is not correctly closed, the thread listening to
        //       response messages will not be closed.
        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            myBrokerClient.DetachDuplexOutputChannel();
        }

        // Method processing notification messages from the publisher.
        private void OnNotificationMessageReceived(object sender, BrokerMessageReceivedEventArgs e)
        {
            // The notification event does not come in UI thread.
            // Therefore, if we want to work with UI controls we must execute it in the UI thread.
            InvokeInUIThread(() =>
                {
                    if (e.ReceivingError == null)
                    {
                        if (e.MessageTypeId == "MyNotifyMsg1")
                        {
                            NotifyMsg1 aDeserializedMsg = mySerializer.Deserialize<NotifyMsg1>(e.Message);
                            Received1TextBox.Text = aDeserializedMsg.CurrentTime.ToString();
                        }
                        else if (e.MessageTypeId == "MyNotifyMsg2")
                        {
                            NotifyMsg2 aDeserializedMsg = mySerializer.Deserialize<NotifyMsg2>(e.Message);
                            Received2TextBox.Text = aDeserializedMsg.Number.ToString();
                        }
                        else if (e.MessageTypeId == "MyNotifyMsg3")
                        {
                            NotifyMsg3 aDeserializedMsg = mySerializer.Deserialize<NotifyMsg3>(e.Message);
                            Received3TextBox.Text = aDeserializedMsg.TextMessage;
                        }
                    }
                });
        }

        // Subscribe to notification message 1
        private void Subscribe1Btn_Click(object sender, EventArgs e)
        {
            myBrokerClient.Subscribe("MyNotifyMsg1");
        }

        // Unsubscribe from notification message 1
        private void Unsubscribe1Btn_Click(object sender, EventArgs e)
        {
            Received1TextBox.Text = "";
            myBrokerClient.Unsubscribe("MyNotifyMsg1");
        }

        // Subscribe to notification message 2
        private void Subscribe2Btn_Click(object sender, EventArgs e)
        {
            myBrokerClient.Subscribe("MyNotifyMsg2");
        }

        // Unsubscribe from notification message 2
        private void Unsubscribe2Btn_Click(object sender, EventArgs e)
        {
            Received2TextBox.Text = "";
            myBrokerClient.Unsubscribe("MyNotifyMsg2");
        }

        // Subscribe to notification message 3
        private void Subscribe3Btn_Click(object sender, EventArgs e)
        {
            myBrokerClient.Subscribe("MyNotifyMsg3");
        }

        // Unsubscribe from notification message 3
        private void Unsubscribe3Btn_Click(object sender, EventArgs e)
        {
            Received3TextBox.Text = "";
            myBrokerClient.Unsubscribe("MyNotifyMsg3");
        }

        // Helper method to invoke some functionality in UI thread.
        private void InvokeInUIThread(Action uiMethod)
        {
            // If we are not in the UI thread then we must synchronize via the invoke mechanism.
            if (InvokeRequired)
            {
                Invoke(uiMethod);
            }
            else
            {
                uiMethod();
            }
        }


        // BrokerClient provides the communication with the broker.
        private IDuplexBrokerClient myBrokerClient;


        // Serializer used to sdeerialize notification messages.
        // Note: It is possible to use BinarySerializer too.
        //       In that case the messages would have to be declared in a
        //       separate library that would be linked by publisher too.
        private XmlStringSerializer mySerializer = new XmlStringSerializer();
    }
}

You can execute more subscribers and subscribe/unsubscribe them for desired events.

I hope you found the article helpful and if you have any questions about Eneter Messaging Framework feel free to ask.

SSL Communication Between Applications

2010-10-03T21:12:00.009+02:00

Summary:
The article shows the step by step procedure how to create the self signed certificate and how to configure the SSL connection. The example then implements the Https client server communication with using Eneter.Messaging.Framework.

Introduction
SSL (Secure Socket Layer) is a standard security protocol to verify the identity of communicating parts and establish the encrypted communication.

Here is how the communication works (if only the server is certified):

The client connects the server and asks for the digital certificate.
The client verifies the received certificate (i.e. if the certificate is issued by a trusted authority, if the domain from the certificate matches with the domain sending the certificate, ...)
The client creates a session key, encrypts it with the public key from the received certificate and sends it to the server.
The server decrypts the session key from the client and uses it to encrypt the content for the client.
The client uses the session key to decrypt the content from the server.

Digital Certificate
The digital certificate is like an Id card. It identifies its owner. And same as in the real world, where ID cards are accepted only if they are issued by trusted authorities (If I create my own driver license, it would not be probably accepted by a policeman.), also digital certificates are accepted if they are issued by trusted authorities.
Therefore, it is important to check if the "Id card" can be accepted - i.e. if the digital certificate was issued (digital signed) by a trusted authority. Typically, for the world wide communication the certificate is issued by a third party mutually trusted authority (e.g. Verisign).

Self Signed Certificate
In case, the certificate does not have to be issued (digitally signed) by a trusted third party authority, we can generate our own self signed certificate (e.g. for testing purposes or internal intranet usage, ...).

1. Create Certificate:

Execute Visual Studio command prompt with Administrator privileges.
makecert -r -n CN="127.0.0.1" -eku 1.3.6.1.5.5.7.3.1 -ss my -sr localmachine -sky exchange
(Instead of 127.0.0.1 you can use your ip address or the domain name.
Help for 'makecert' can be found here.)

2. Configure the certificate to be trusted:

Execute from the command prompt: mmc
Choose 'Add/Remove Snap-in...'
Doubleclick 'Certificates'
Choose 'Computer account'
The new certificate should be found under 'Personal Certificates'.
The new certificate is among personal certificates, but it is not trusted. When we double-click the certificate, the following message will be there: "This CA Root certificate is not trusted. To enable trust, install this certificate in the Trusted Root Certification Authorities store."
To resolve this issue, copy and paste the new certificate into 'Trusted Root Certification Authorities'.
The certificate is trusted now.

4. Configure the certificate for a desired ip address and port:
In our case, we configure the certificate for all ip addresses and the port 7788.

Copy the 'Thumbprint' from the certificate, paste it to the notepad and remove spaces between numbers - this thumbprint data will be used in the next step.
Configure the ip address and the port for the certificate. Use your own thumbprint data in the command.

The command for Windows Vista:
netsh http add sslcert ipport=0.0.0.0:7788 certhash=a357e3f991763516a4119153e137df24f88f18ac appid={00000000-0000-0000-0000-000000000000}

The command for Windows XP:
httpcfg set ssl /i 0.0.0.0:7788 /h a357e3f991763516a4119153e137df24f88f18ac
(Note: You need to download HttpCfg.exe from Microsoft)

Https Client Server Communication
The self signed certificate is now ready, and we can use it for the client server communication.
The following example implements the simple client-server with using Eneter.Messaging.Framework.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from http://www.eneter.net/. The online help for developers can be found on http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html)

Sever application
The server is a simple application listening to request to count two numbers.

Important:

The server domain must be same as the certificate name. It is 127.0.0.1 in our case. Otherwise the certificate check will fail on the client side and the connection will not be established.
The server must be executes with sufficient user rights. Execute it as Administrator for debugging purposes. Otherwise the server will fail to start.

using System;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.HttpMessagingSystem;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;


namespace HttpService
{
    // Message requesting counting of two numbers.
    public class MyRequestMessage
    {
        public int Number1 { get; set; }
        public int Number2 { get; set; }
    };

    // Message returning the counting result.
    public class MyResponseMessage
    {
        public int Result { get; set; }
    };

    class Program
    {
        static void Main(string[] args)
        {
            // Create messaging using Https.
            IMessagingSystemFactory aMessagingFactory = new HttpMessagingSystemFactory();
            IDuplexInputChannel anInputChannel = aMessagingFactory.CreateDuplexInputChannel("https://127.0.0.1:7788");

            // Create the message receiver that receives MyRequestMessage and resonses MyResponseMessage.
            IDuplexTypedMessagesFactory aTypedMessages = new DuplexTypedMessagesFactory(new XmlStringSerializer());
            IDuplexTypedMessageReceiver<MyResponseMessage, MyRequestMessage> aMessageReceiver = aTypedMessages.CreateDuplexTypedMessageReceiver<MyResponseMessage, MyRequestMessage>();
            
            // Subscribe to process incoming messages.
            aMessageReceiver.MessageReceived += MessageReceived;

            // Start listening for messages.
            Console.WriteLine("The server is listening.");
            aMessageReceiver.AttachDuplexInputChannel(anInputChannel);
        }

        // Processes incoming messages.
        static void MessageReceived(object sender, TypedRequestReceivedEventArgs<MyRequestMessage> e)
        {
            if (e.ReceivingError == null)
            {
                // Count incoming numbers.
                MyResponseMessage aResponse = new MyResponseMessage();
                aResponse.Result = e.RequestMessage.Number1 + e.RequestMessage.Number2;

                Console.WriteLine("Result = " + aResponse.Result.ToString());

                // Resonse the result back to the sender.
                IDuplexTypedMessageReceiver<MyResponseMessage, MyRequestMessage> aReceiver = (IDuplexTypedMessageReceiver<MyResponseMessage, MyRequestMessage>)sender;
                aReceiver.SendResponseMessage(e.ResponseReceiverId, aResponse);
            }
        }
    }
}

Client application
The client is a simple application sending the request to the server to count two numbers.
The whole implementation is here:

using System;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.HttpMessagingSystem;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;

namespace HttpClient
{
    // Message requesting counting of two numbers.
    public class MyRequestMessage
    {
        public int Number1 { get; set; }
        public int Number2 { get; set; }
    };

    // Message returning the counting result.
    public class MyResponseMessage
    {
        public int Result { get; set; }
    };

    class Program
    {
        static void Main(string[] args)
        {
            // Create messaging using Https.
            IMessagingSystemFactory aMessagingFactory = new HttpMessagingSystemFactory();
            IDuplexOutputChannel anOutputChannel = aMessagingFactory.CreateDuplexOutputChannel("https://127.0.0.1:7788");

            // Create the message sender that sends MyRequestMessage and receive resonses MyResponseMessage.
            IDuplexTypedMessagesFactory aTypedMessages = new DuplexTypedMessagesFactory(new XmlStringSerializer());
            IDuplexTypedMessageSender<MyResponseMessage, MyRequestMessage> aMessageSender = aTypedMessages.CreateDuplexTypedMessageSender<MyResponseMessage, MyRequestMessage>();
            
            // Subscribe to handle responses.
            aMessageSender.ResponseReceived += ResponseReceived;
            
            // Attach the the Https channel to send request messages and receive response messages.
            aMessageSender.AttachDuplexOutputChannel(anOutputChannel);

            // Very simple loop getting numbers from the user and sending requests to the server.
            while (true)
            {
                MyRequestMessage aRequest = new MyRequestMessage();

                Console.Write("Number 1: ");
                aRequest.Number1 = int.Parse(Console.ReadLine());

                Console.Write("Number 2: ");
                aRequest.Number2 = int.Parse(Console.ReadLine());

                // Send the request to count inserted numbers.
                aMessageSender.SendRequestMessage(aRequest);
            }
        }

        // Handles received response messages.
        static void ResponseReceived(object sender, TypedResponseReceivedEventArgs<MyResponseMessage> e)
        {
            if (e.ReceivingError == null)
            {
                Console.WriteLine("Result: " + e.ResponseMessage.Result.ToString());
            }
        }
    }
}

I hope you found the article useful. If you would like to have more information about Eneter.Messaging.Framework, you can find it on www.eneter.net.

Error Handling and Diagnostic in Eneter.Messaging.Framework

2010-08-15T21:19:00.007+02:00

Summary: The article describes the error handling behavior of Eneter.Messaging.Framework and shows how to use Debug View for the diagnostic.

Introduction for newcomers
If you are new, then Eneter.Messaging.Framework is a middleware that allows to implement the communication between applications based on messages. The framework supports NamedPipes, Tcp, Http and also Silverlight Messaging.
For more technical details you can refer to my previous articles or you can visit
http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net.)

Error handling behavior
The error handling in Eneter.Messaging.Framework is based on 4 main scenarios:

1. The error occurs in the framework when the user invokes some API method.
This scenario occurs when the user calls the framework API and the call fails.
E.g. the SendMessage() method is called but the output channel is not attached. Or when you create the channel and the channel id is not the valid Uri address (in case of Named Pipe, Tcp or Http).

In this case the framework logs the error to the debug port and throws an exception.
(ArgumentException, ArgumentNullException, InvalidOperationException or a communication technology specific exception)
The exception can be caught in the user code and processed.

2. The error occurs in the user code when is invoked from the framework as a callback.
This scenario typically occurs when the framework calls an event handler (or a callback) provided by the user and this handler throws an exception.
E.g. the framework calls the user code subscribed to the event MessageReceived and the user code throws some exception.

In this case the framework catches all exceptions and log them to the debug port.
(In spite of the fact, the framework handles these exceptions, it is recomended that exceptions from event handlers and callbacks are not propagated to the framework. Better, the user code should catch them.)

3. The error occurs in the framework code during processing a received message.
This scenario occurs when the framework receives a message from a sender and detects a problem during processing of the message.
E.g. the deserialization of the received message failed.

In this case the framework logs the error to the debug port and notifies the error to the user code in the MessageReceived event. The event has the property public Exception ReceivingError {get;}.
The user code should evaluate this property when processes a received message.

4. The error occurs in a framework component in runtime.
This scenario normally should not occur. But if the framework detects some error that cannot be reported to the user code via exception or event, the framework logs the error to the debug port, from where it can be read by a programmer.

Diagnostic
As described above, whenever the framework detects an error it uses the debug port to announce the issue. Except errors, the framework also recognizes potential problems and announces them to the debug port as warning messages.
Therefore, to diagnose the communication, you can use a debug port viewer. E.g. you can download one from Microsoft.
http://technet.microsoft.com/en-us/sysinternals/bb896647.aspx

To recognize messages in the debug port more effectively, you can setup the filter and colors. E.g. errors can be red and warnings yellow. The framework labels errors as ' E:' and warnings as ' W:'.

And here is the example of the output for Eneter.Messaging.Framework.

I hope, you enjoyed the article.

How to Implement Service Receiving Requests via Messages

2010-08-03T22:21:00.007+02:00

Summary: The example in the article implements the service application Calculator. This service application listens to request messages and calculate numbers (summation, subtraction, multiplication and dividing). The result is then sent back to the requesting client as the response message.

To use the implementation bellow you must include the Eneter.Messaging.Framework.dll library into your project. (Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net. The online help for developers can be found http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html)

Service application
The Calculator service provides the following functionality: summation, subtraction, multiplication and dividing. Therefore the service recognizes four types of request messages. Every request message will take two numbers as the input for the calculation.

// Input data for calculator requests
public class CalculatorInputData
{
    public double Number1 { get; set; }
    public double Number2 { get; set; }
}

When the service calculates numbers it sends back the response message with the result.

// Output result from the calculator
public class CalculatorOutputData
{
    public double Result { get; set; }
}

We also want that the service listens to request messages on one address (one input channel). (It would not be effective if every type of request message would have its own address.)
To recognize multiple message types on one address we use the Channel Unwrapper component from Eneter.Messaging.Framework.

The Channel Unwrapper component receives messages on one input channel, "unwraps" them and forwards to correct receivers.
In our case the Channel Unwrapper recognizes if the incoming message is summation, subtraction, multiplication or dividing. Then it forwards the message to the correct receiver handling the requested type of calculation.

The code implementing the behavior above is very simple with Eneter.Messaging.Framework.

using System;

namespace ServerCalculator2
{
    class Program
    {
        static void Main(string[] args)
        {
            Calculator aCalculator = new Calculator();
            Console.WriteLine("Calculator service started.");
            aCalculator.StartCalculatorService();
        }
    }
}

using System;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.Infrastructure.ConnectionProvider;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.MessagingSystems.ThreadPoolMessagingSystem;
using Eneter.Messaging.Nodes.ChannelWrapper;

namespace ServerCalculator2
{
    // Input data for calculator requests
    public class CalculatorInputData
    {
        public double Number1 { get; set; }
        public double Number2 { get; set; }
    }

    // Output result from the calculator
    public class CalculatorOutputData
    {
        public double Result { get; set; }
    }

    internal class Calculator
    {
        public Calculator()
        {
            // We want that requests do not block each other. So every request will be processed in its own thread.
            IMessagingSystemFactory anInternalMessaging = new ThreadPoolMessagingSystemFactory();

            // We want to use Xml for serialization/deserialization.
            // Note: Alternative you can use: BinarySerializer
            ISerializer aSerializer = new XmlStringSerializer();

            // All messages are received via one channel. So we must provide "unwrapper" forwarding incoming messages
            // to correct receivers.
            IChannelWrapperFactory aChannelWrapperFactory = new ChannelWrapperFactory(aSerializer);
            myDuplexChannelUnwrapper = aChannelWrapperFactory.CreateDuplexChannelUnwrapper(anInternalMessaging);

            // To connect receivers and the unwrapper with duplex channels we can use the following helper class.
            IConnectionProviderFactory aConnectionProviderFactory = new ConnectionProviderFactory();
            IConnectionProvider aConnectionProvider = aConnectionProviderFactory.CreateConnectionProvider(anInternalMessaging);

            // Factory to create message receivers.
            // Received messages will be deserialized from Xml.
            IDuplexTypedMessagesFactory aMessageReceiverFactory = new DuplexTypedMessagesFactory(aSerializer);
            
            // Create receiver to sum two numbers.
            mySumReceiver = aMessageReceiverFactory.CreateDuplexTypedMessageReceiver<CalculatorOutputData, CalculatorInputData>();
            mySumReceiver.MessageReceived += SumCmd; // attach method handling the request
            aConnectionProvider.Attach(mySumReceiver, "Sum"); // attach the input channel to get messages from unwrapper

            // Receiver to subtract two numbers.
            mySubtractReceiver = aMessageReceiverFactory.CreateDuplexTypedMessageReceiver<CalculatorOutputData, CalculatorInputData>();
            mySubtractReceiver.MessageReceived += SubCmd; // attach method handling the request
            aConnectionProvider.Attach(mySubtractReceiver, "Sub"); // attach the input channel to get messages from unwrapper

            // Receiver for multiply two numbers.
            myMultiplyReceiver = aMessageReceiverFactory.CreateDuplexTypedMessageReceiver<CalculatorOutputData, CalculatorInputData>();
            myMultiplyReceiver.MessageReceived += MulCmd; // attach method handling the request
            aConnectionProvider.Attach(myMultiplyReceiver, "Mul"); // attach the input channel to get messages from unwrapper

            // Receiver for divide two numbers.
            myDivideReceiver = aMessageReceiverFactory.CreateDuplexTypedMessageReceiver<CalculatorOutputData, CalculatorInputData>();
            myDivideReceiver.MessageReceived += DivCmd; // attach method handling the request
            aConnectionProvider.Attach(myDivideReceiver, "Div"); // attach the input channel to get messages from unwrapper
        }


        public void StartCalculatorService()
        {
            // We will use Tcp for the communication.
            IMessagingSystemFactory aServiceMessagingSystem = new TcpMessagingSystemFactory();

            // Create input channel for the calculator receiving messages via Tcp.
            IDuplexInputChannel aGlobalInputChannel = aServiceMessagingSystem.CreateDuplexInputChannel("127.0.0.1:8091");

            // Attach the input channel to the unwrapper and start to listening.
            myDuplexChannelUnwrapper.AttachDuplexInputChannel(aGlobalInputChannel);
        }

        // It is called when a request to sum two numbers was received.
        private void SumCmd(object sender, TypedRequestReceivedEventArgs<CalculatorInputData> e)
        {
            // Get input data.
            CalculatorInputData anInputData = e.RequestMessage;

            // Calculate output result.
            CalculatorOutputData aReturn = new CalculatorOutputData();
            aReturn.Result = anInputData.Number1 + anInputData.Number2;

            Console.WriteLine("{0} + {1} = {2}", anInputData.Number1, anInputData.Number2, aReturn.Result);

            // Response result to the client.
            mySumReceiver.SendResponseMessage(e.ResponseReceiverId, aReturn);
        }

        // It is called when a request to subtract two numbers was received.
        private void SubCmd(object sender, TypedRequestReceivedEventArgs<CalculatorInputData> e)
        {
            // Get input data.
            CalculatorInputData anInputData = e.RequestMessage;

            // Calculate output result.
            CalculatorOutputData aReturn = new CalculatorOutputData();
            aReturn.Result = anInputData.Number1 - anInputData.Number2;

            Console.WriteLine("{0} - {1} = {2}", anInputData.Number1, anInputData.Number2, aReturn.Result);

            // Response result to the client.
            mySubtractReceiver.SendResponseMessage(e.ResponseReceiverId, aReturn);
        }
        

        // It is called when a request to multiply two numbers was received.
        private void MulCmd(object sender, TypedRequestReceivedEventArgs<CalculatorInputData> e)
        {
            // Get input data.
            CalculatorInputData anInputData = e.RequestMessage;

            // Calculate output result.
            CalculatorOutputData aReturn = new CalculatorOutputData();
            aReturn.Result = anInputData.Number1 * anInputData.Number2;

            Console.WriteLine("{0} x {1} = {2}", anInputData.Number1, anInputData.Number2, aReturn.Result);

            // Response result to the client.
            myMultiplyReceiver.SendResponseMessage(e.ResponseReceiverId, aReturn);
        }

        // It is called when a request to divide two numbers was received.
        private void DivCmd(object sender, TypedRequestReceivedEventArgs<CalculatorInputData> e)
        {
            // Get input data.
            CalculatorInputData anInputData = e.RequestMessage;

            // Calculate output result.
            CalculatorOutputData aReturn = new CalculatorOutputData();
            aReturn.Result = anInputData.Number1 / anInputData.Number2;

            Console.WriteLine("{0} / {1} = {2}", anInputData.Number1, anInputData.Number2, aReturn.Result);

            // Response result to the client.
            myDivideReceiver.SendResponseMessage(e.ResponseReceiverId, aReturn);
        }
        


        // Block is the helper to create the infrastructure with less code.
        private IDuplexChannelUnwrapper myDuplexChannelUnwrapper;

        private IDuplexTypedMessageReceiver<CalculatorOutputData, CalculatorInputData> mySumReceiver;
        private IDuplexTypedMessageReceiver<CalculatorOutputData, CalculatorInputData> mySubtractReceiver;
        private IDuplexTypedMessageReceiver<CalculatorOutputData, CalculatorInputData> myMultiplyReceiver;
        private IDuplexTypedMessageReceiver<CalculatorOutputData, CalculatorInputData> myDivideReceiver;
    }
}

Client Application
The client application implements a simple UI taking numbers and invoking requests for the calculation.

To send multiple message types to the Calculator service via one output channel (because the service receives messages via one input channel (address)), the client must use the Channel Wrapper component. The Channel Wrapper component wrapps outgoing request messages so that they can be unwrapped by the service when they are received.

The code implementing the client behavior is very simple too.

using System;
using System.Windows.Forms;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.Infrastructure.ConnectionProvider;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;
using Eneter.Messaging.MessagingSystems.ThreadMessagingSystem;
using Eneter.Messaging.Nodes.ChannelWrapper;

namespace CalculatorClient2
{
    // Input data for calculator requests
    public class CalculatorInputData
    {
        public double Number1 { get; set; }
        public double Number2 { get; set; }
    }

    // Output result from the calculator
    public class CalculatorOutputData
    {
        public double Result { get; set; }
    }

    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();

            // We want that sending of requests will be not blocking. Therefore we will choose
            // ThreadMessaging with the queue.
            IMessagingSystemFactory anInternalMessaging = new ThreadMessagingSystemFactory();

            // We want to use Xml for serialization/deserialization.
            // Note: Alternative you can use: BinarySerializer
            ISerializer aSerializer = new XmlStringSerializer();

            // The service receives messages via one channel (i.e. it listens on one address).
            // The incoming messages are unwrapped on the server side.
            // Therefore the client must use wrapper to send messages via one channel.
            IChannelWrapperFactory aChannelWrapperFactory = new ChannelWrapperFactory(aSerializer);
            myDuplexChannelWrapper = aChannelWrapperFactory.CreateDuplexChannelWrapper();


            // To connect message senders and the wrapper with duplex channels we can use the following helper class.
            IConnectionProviderFactory aConnectionProviderFactory = new ConnectionProviderFactory();
            IConnectionProvider aConnectionProvider = aConnectionProviderFactory.CreateConnectionProvider(anInternalMessaging);

            
            // Factory to create message senders.
            // Sent messages will be serialized in Xml.
            IDuplexTypedMessagesFactory aCommandsFactory = new DuplexTypedMessagesFactory(aSerializer);

            // Sender to sum two numbers.
            mySumSender = aCommandsFactory.CreateDuplexTypedMessageSender<CalculatorOutputData, CalculatorInputData>();
            mySumSender.ResponseReceived += OnResultResponse;
            aConnectionProvider.Connect(myDuplexChannelWrapper, mySumSender, "Sum");

            // Sender to subtract two numbers.
            mySubSender = aCommandsFactory.CreateDuplexTypedMessageSender<CalculatorOutputData, CalculatorInputData>();
            mySubSender.ResponseReceived += OnResultResponse;
            aConnectionProvider.Connect(myDuplexChannelWrapper, mySubSender, "Sub");

            // Sender to multiply two numbers.
            myMulSender = aCommandsFactory.CreateDuplexTypedMessageSender<CalculatorOutputData, CalculatorInputData>();
            myMulSender.ResponseReceived += OnResultResponse;
            aConnectionProvider.Connect(myDuplexChannelWrapper, myMulSender, "Mul");

            // Sender to divide two numbers.
            myDivSender = aCommandsFactory.CreateDuplexTypedMessageSender<CalculatorOutputData, CalculatorInputData>();
            myDivSender.ResponseReceived += OnResultResponse;
            aConnectionProvider.Connect(myDuplexChannelWrapper, myDivSender, "Div");

            // We use Tcp for the communication.
            IMessagingSystemFactory aTcpMessagingSystem = new TcpMessagingSystemFactory();

            // Create output channel to send requests to the service.
            IDuplexOutputChannel anOutputChannel = aTcpMessagingSystem.CreateDuplexOutputChannel("127.0.0.1:8091");

            // Attach the output channel to the wrapper - so that we are able to send messages.
            // Note: The service has the coresponding unwrapper.
            myDuplexChannelWrapper.AttachDuplexOutputChannel(anOutputChannel);
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Stop listening by detaching the input channel.
            myDuplexChannelWrapper.DetachDuplexOutputChannel();
        }


        private void OnResultResponse(object sender, TypedResponseReceivedEventArgs<CalculatorOutputData> e)
        {
            // If everything is ok then display the result.
            if (e.ReceivingError == null)
            {
                // The response does not come in main UI thread.
                // Therefore we must transfer it to the main UI thread.
                InvokeInUIThread(() => ResultLabel.Text = e.ResponseMessage.Result.ToString() );
            }
        }

        private void CalculateButton_Click(object sender, EventArgs e)
        {
            // Prepare input data for the calculator.
            CalculatorInputData anInputForCalculator = new CalculatorInputData();
            anInputForCalculator.Number1 = double.Parse(Number1TextBox.Text);
            anInputForCalculator.Number2 = double.Parse(Number2TextBox.Text);

            // Invoke request to sum.
            mySumSender.SendRequestMessage(anInputForCalculator);
        }
         
        private void SubtractButton_Click(object sender, EventArgs e)
        {
            // Prepare input data for the calculator.
            CalculatorInputData anInputForCalculator = new CalculatorInputData();
            anInputForCalculator.Number1 = double.Parse(Number1TextBox.Text);
            anInputForCalculator.Number2 = double.Parse(Number2TextBox.Text);

            // Invoke request to substract.
            mySubSender.SendRequestMessage(anInputForCalculator);
        }

        private void MultiplyButton_Click(object sender, EventArgs e)
        {
            // Prepare input data for the calculator.
            CalculatorInputData anInputForCalculator = new CalculatorInputData();
            anInputForCalculator.Number1 = double.Parse(Number1TextBox.Text);
            anInputForCalculator.Number2 = double.Parse(Number2TextBox.Text);

            // Invoke request to multiply.
            myMulSender.SendRequestMessage(anInputForCalculator);
        }

        private void DivideButton_Click(object sender, EventArgs e)
        {
            // Prepare input data for the calculator.
            CalculatorInputData anInputForCalculator = new CalculatorInputData();
            anInputForCalculator.Number1 = double.Parse(Number1TextBox.Text);
            anInputForCalculator.Number2 = double.Parse(Number2TextBox.Text);

            // Invoke request to divide.
            myDivSender.SendRequestMessage(anInputForCalculator);
        }

        // Helper method to invoke UI always in the correct thread.
        private void InvokeInUIThread(Action action)
        {
            if (InvokeRequired)
            {
                Invoke(action);
            }
            else
            {
                action.Invoke();
            }
        }

        // Wraps requests into one output channel.
        // The service side listens to one address and uses unwrapper to unwrap
        // messages and send them to correct receivers.
        private IDuplexChannelWrapper myDuplexChannelWrapper;

        // Message senders.
        private IDuplexTypedMessageSender<CalculatorOutputData, CalculatorInputData> mySumSender;
        private IDuplexTypedMessageSender<CalculatorOutputData, CalculatorInputData> mySubSender;
        private IDuplexTypedMessageSender<CalculatorOutputData, CalculatorInputData> myMulSender;
        private IDuplexTypedMessageSender<CalculatorOutputData, CalculatorInputData> myDivSender;
    }
}

I hope you found this example useful. If you would like to read more technical details or you would need the online help you can use
http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.

If you have any questions, do not hesitate to ask me.

Interprocess Communication

2010-07-29T00:02:00.003+02:00

Summary: The article provides an overview about approaches for the interprocess communication.

When you need to realize the communication between applications, usually you consider the following approaches:

File Transfer
Applications communicate via files. Producing applications write data to files and consuming applications read files to get data.

The advantage is that applications are loosely coupled. They do not have to know about internal implementations of each other. They just need to know the file format and a location of files.

On the other hand writing and reading files is not so fast. Therefore, files cannot be updated very frequently (e.g. many times per second) but usually they are updated in intervals, e.g. hourly. However, this causes delays and applications reading the file must often deal with the fact that data is not up to date -> synchronization issues.

Database Storage
Applications communicate via shared data in a database. Share data is written into the database from where it can be read by other applications.

The advantage is that the database provides a unified access to all data (e.g. via SQL). So applications do not have to deal with different file formats. In addition, the transaction mechanism helps to keep data consistent.

The drawback is that applications using the database depends on the data schema. Therefore, the change in the data structure (data schema) can cause changes in applications using the database.

Also the performance can be problematic - especially, if multiple applications frequently read and update the same data or the database is distributed across different locations.

Remote Procedure Call
Applications communicate via exposed functionality. Application providing the functionality uses a middleware (e.g. WCF) to hide the interprocess communication. The intention is that remote calls look like local calls. The communication is usually synchronous.

The advantage of this approach is that the application provides a specified functionality and encapsulates (hides) data.

The disadvantage is that the communicating applications are coupled. E.g.:
The calling application assumes that the other side implements the particular interface. If you add a new method to the interface, then all client applications are affected and must be updated and recompiled.

Also the illusion that remote calls are same as local calls can be confusing. The problem is that the interprocess communication (especially across the network) is much slower and fails more often than simple local calls. To address these differences you may face to resolve issues that usually do not exist in local calls. E.g.:
"How long can the call be blocked waiting for the response? Do you need some mechanism to cancel the call?"
"What if the connection is broken? Do you need to reconnect and recover the call?"
Therefore, although the Remote Procedure Call approach provides an abstraction that the communication between two applications is a simple local call, you cannot follow this idea because if you do not want to have troubles you cannot ignore specifics of the interprocess communication.

Messaging
Applications communicate via messages. Communicating applications use a middleware (message oriented middleware) to send and receive messages. The sending application sends messages through the channel and the receiving application listens the channel to receive incoming messages. The communication is usually asynchronous. (I.e. the sending application is not blocked until the message is processed by the receiving application.)

The advantage is that the communicating applications are loosely coupled. They do not have to know about internal implementations of each other. They just need to know the message format and the channel to send / receive the message.
(If you add a new message, client applications are not affected.)

Another advantage is that the service application provides a specified functionality and encapsulates (hides) data.
(Request message invokes a functionality and response message returns results.)

The price for the messaging communication is that the implementation deals with asynchronous programming. The asynchronous programming is more difficult and can add some complexity to the implementation.

Conclusion
It is not possible to say that one communication approach is good and another is bad. All have its own pros and cons. The point is to choose approach (or combination of approaches) that fits the best the particular project. The communication needs should not be underestimated but also they should not be over-engineered with fancy technologies. Also a tendency applying always the same approach does not have to work - if the preferred approach does not fit then its using causes workarounds and additional complexity.
Specifically, I have a feeling that for the interactive communication there is a tendency to prefer Remote Procedure Calls. But if coupling or synchronous approach should be problematic then Messaging could be a better alternative.

Silverlight: Notification Messages from the Server

2010-07-18T18:30:00.006+02:00

Summary: The article shows how to implement receiving of notification messages from the hosting server in the Silverlight application with using Eneter.Messaging.Framework.

Basically there are two approaches, if you need to implement the communication scenario where the Silverlight client needs to be notified about some events on the server:

Polling
The Silverlight client regularly initiates the Http connection and asks the server for messages. The server then responses messages intended for the client or returns an empty response if messages are not available (that can be the majority of requests).
The advantage of the polling is that it does not block resources. (The problem is that browsers typically limit the number of concurrent Http connections per server to 2 - 8. The polling needs this connection only for short time.)
The disadvantage of the polling is that it can cause a lot of useless communication. (In case the majority of requests return empty response.)

Pushing
The Silverlight client initiates the Http connection. The server receives the request but does not answer until messages for the client are not available - the connection stays open (that can be long time). When the server answers, the client processes notifications and initiates the Http connection again.
The advantage of the pushing is that there is not a useless communication.
The disadvantage of the pushing is that it consumes the Http connection. And because browsers typically limit the number of concurrent Http connections per server to 2 - 8, it can happen that connections are occupied and the client application is blocked.

If you prefer to get notification messages based on the pushing, you can choose WCF. The server can implement the service and the Silverlight client can get notification messages via some call-back interface.

If you prefer to get notification messages based on the polling, you do not have many possibilities. Probably you would need to implement the communication in yourself with using .Net functionality for Http. (The client regularly polls and recognizes messages and the server constantly collects messages and responses them to the client on demand.)

Another possibility you can consider is to use Eneter.Messaging.Framework. The framework provides a great support to implement the notification scenario based on polling.

The example bellow shows how the Silverlight application can get notification messages with using Eneter.Messaging.Framework. The client subscribes to be notified from the server and server notifies the client when the event occurs. (In the example, the server generates numbers based on the timer.)

1. Server Site - ASP.NET Web Application
To use the messaging framework functionality you must add Eneter.Messaging.Framework.dll into references. (Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net.)

One of major responsibilities of the server in this communication scenario is to allow Silverlight clients to subscribe for messages. To support publish-subscribe scenario the framework provides the Broker component. The broker receives messages and sends them to subscribers.

We also must ensure that Silverlight eneter messaging is properly connected with Asp.Net Server eneter messaging. To do so the server uses the Bridge component. (The bridge ensures the messages received as Http requests via 'Generic Handler' (ashx file) are correctly forwarded to the eneter messaging on the server site.)

using System;
using System.Timers;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.SynchronousMessagingSystem;
using Eneter.Messaging.Nodes.Bridge;
using Eneter.Messaging.Nodes.Broker;


namespace SilverlightNotifiedFromAsp.Web
{
    public class Global : System.Web.HttpApplication
    {

        protected void Application_Start(object sender, EventArgs e)
        {
            // MessagingSystem that will be used by the Silverlight-ASP messaging "bridge".
            //myServerMessagingSystem = new ThreadMessagingSystemFactory();
            myServerMessagingSystem = new SynchronousMessagingSystemFactory();

            // Create the duplex input channel for the broker.
            // Note: The broker will listen to this channel.
            IDuplexInputChannel aBrokerDuplexInputChannel = myServerMessagingSystem.CreateDuplexInputChannel("BrokerChannel");

            // Create broker.
            // Because we communicate with Silverlight it must be XmlSerialization.
            IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory(new XmlStringSerializer());
            myBroker = aBrokerFactory.CreateBroker();
            myBroker.AttachDuplexInputChannel(aBrokerDuplexInputChannel);

            // Create the duplex output channel for the client that will send notifications.
            IDuplexOutputChannel aClientDuplexOutputChannel = myServerMessagingSystem.CreateDuplexOutputChannel("BrokerChannel");

            // Create sender of notification messages.
            myBrokerClient = aBrokerFactory.CreateBrokerClient();
            myBrokerClient.AttachDuplexOutputChannel(aClientDuplexOutputChannel);

            // Create bridge to connect Silverligh with Asp
            IBridgeFactory aBridgeFactory = new BridgeFactory();
            myBridge = aBridgeFactory.CreateDuplexBridge(myServerMessagingSystem, "BrokerChannel");

            // Store the bridge to be used from MessagingHandler.ashx.cs
            Application["Bridge"] = myBridge;

            // Start timer generating notification messages.
            myTimer = new Timer(1000);
            myTimer.AutoReset = false;
            myTimer.Elapsed += OnTimerElapsed;
            myTimer.Start();
        }

        protected void Session_Start(object sender, EventArgs e){}

        protected void Application_BeginRequest(object sender, EventArgs e){}

        protected void Application_AuthenticateRequest(object sender, EventArgs e){}

        protected void Application_Error(object sender, EventArgs e){}

        protected void Session_End(object sender, EventArgs e){}

        protected void Application_End(object sender, EventArgs e){}


        // Generate the number and send the message to the broker.
        private void OnTimerElapsed(object sender, ElapsedEventArgs e)
        {
            ++myNumber;

            myBrokerClient.SendMessage("MyMessageType", myNumber);

            myTimer.Start();
        }



        private Timer myTimer;
        private int myNumber = -1;

        private IMessagingSystemFactory myServerMessagingSystem;

        private IDuplexBroker myBroker;
        private IDuplexBrokerClient myBrokerClient;

        private IDuplexBridge myBridge;

    }
}

The following code shows how to implement the generic handler (ashx) to receive messages from Silverlight eneter messaging system. It uses the bridge to forward incoming messages to the messaging system in the server.

using System.Web;
using Eneter.Messaging.Nodes.Bridge;

namespace SilverlightNotifiedFromAsp.Web
{
    // Handles messaging communication with Silverlight clients.
    public class MessagingHandler : IHttpHandler
    {
        public void ProcessRequest(HttpContext context)
        {
            context.Application.Lock();
            
            // Get the bridge to the broker and forward the message to the messaging system
            // connected with the bridge.
            IDuplexBridge aBridge = context.Application["Bridge"] as IDuplexBridge;
            aBridge.ProcessRequestResponse(context.Request.InputStream, context.Response.OutputStream);
            
            context.Application.UnLock();
        }

        public bool IsReusable { get { return false; } }
    }
}

2. Client Site - Silverlight Application
To use the messaging framework functionality you must add Eneter.Messaging.Framework.Silverlight.dll into references. (Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net.)

The client subscribes to be notified about generated numbers. The received messages are displayed in UI.

using System.Windows;
using System.Windows.Controls;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.MessagingSystems.HttpMessagingSystem;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.Nodes.Broker;

namespace SilverlightNotifiedFromAsp
{
    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();

            // Create Http messaging for the specified message handler on the server side.
            myHttpMessagingFactory = new HttpMessagingSystemFactory(1000);
            string aChannelId = ServerUri.GetServerUri("/MessagingHandler.ashx");
            IDuplexOutputChannel aDuplexOutputChannel = myHttpMessagingFactory.CreateDuplexOutputChannel(aChannelId);


            // Create broker client to receive notifications from the server.
            IDuplexBrokerFactory aBrokerFactory = new DuplexBrokerFactory(new XmlStringSerializer());
            myBrokerClient = aBrokerFactory.CreateBrokerClient();
            myBrokerClient.BrokerMessageReceived += OnBrokerMessageReceived;
            myBrokerClient.AttachDuplexOutputChannel(aDuplexOutputChannel);
        }

        // Subscribes the broker receiver to get notifications from the server.
        private void SubscribeBtn_Click(object sender, RoutedEventArgs e)
        {
            string[] aMessageTypes = {"MyMessageType"};
            myBrokerClient.Subscribe(aMessageTypes);
        }


        // Unsubscribes the broker message receiver.
        private void UnsubscribeBtn_Click(object sender, RoutedEventArgs e)
        {
            myBrokerClient.Unsubscribe();
        }


        // Is called when the notification message from the broker is received.
        private void OnBrokerMessageReceived(object sender, BrokerMessageReceivedEventArgs e)
        {
            // Display the message in the listbox.
            MessagesList.Items.Insert(0, e.Message);
        }


        private IMessagingSystemFactory myHttpMessagingFactory;
        private IDuplexBrokerClient myBrokerClient;
    }
}

For the completeness here is the simple UI in Silverlight displaying generated numbers notified from the server.

I hope you found the article useful and you enjoyed the reading. If you would like to get more technical information you can visit http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html.

Your feedback is always welcome.

Silverlight: Interprocess Communicatin from Silverlight Application

2010-07-11T17:45:00.009+02:00

Summary: The article shows how to implement the communication between Silverlight application and some Non-Silverlight application with using Eneter.Messaging.Framework. The example shows Silverlight client invoking requests to the console application. The request can be paused, resumed or canceled.

There are not many possibilities if you need to implement the communication between Silverlight application and some Non-Silverlight application (e.g. standard desktop application).
Basically, you can choose sockets to implement your own communication based on Tcp or you can choose WCF to communicate via remote calls.

Another option you can consider is to use Eneter.Messaging.Framework. The framework enables you to implement the message based communication scenarios. E.g. Silverlight client can invoke a request and manipulate it with 'pause', 'resume' and 'cancel'. It means the request being processed in the console application can be paused, resumed or canceled from Silverlight client.

The example bellow shows how to implement the Silverlight client invoking a request to the Non-Silverlight application that can be 'paused', 'resumed' or 'canceled'.

1. Create server - standard console application

Create standard console application in Visual Studio and add Eneter.Messaging.Framework.dll to references.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net.)

Implement the main method the following way:

using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace TcpCommandServer
{
    class Program
    {
        static void Main(string[] args)
        {
            // Start policy server to allow the communication with the Silverlight client.
            TcpPolicyServer aPolicyServer = new TcpPolicyServer(System.Net.IPAddress.Loopback);
            aPolicyServer.StartPolicyServer();

            // Create the communication based on Tcp.
            // Note: Silverlight clients can communicate on the following ports: 4502 - 4532.
            IMessagingSystemFactory aMessagingFactory = new TcpMessagingSystemFactory();
            IDuplexInputChannel aDuplexInputChannel = aMessagingFactory.CreateDuplexInputChannel("127.0.0.1:4530");

            // Start listening for requests.
            CommandReceiver aCommandReceiver = new CommandReceiver();
            aCommandReceiver.StartCommandReceiver(aDuplexInputChannel);
        }
    }
}

Note: The policy server listens to port 943 and returns Xml telling to Silveright that the communication is allowed. The framework returns a basic Xml but you can also set your own if it is needed.

Implement the CommandReceiver class responsible for processing requests.

using System;
using System.Threading;
using Eneter.Messaging.DataProcessing.Sequencing;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.Commands;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;

namespace TcpCommandServer
{
    public class TSomeRequestMessage
    {
        public string SomeParam1 { get; set; }
        public int SomeParam2 { get; set; }
    }

    public class TSomeResponseMessage
    {
        public int Progress { get; set; }
    }


    internal class CommandReceiver
    {
        public CommandReceiver()
        {
            // Silverlight does not support binary serialization.
            // In Silverlight, the framework uses serialization to Xml by default.
            // Therefore we must set here Xml serialization too.
            ISerializer aSerializer = new XmlStringSerializer();

            // Create command that puts incoming requests to the queue and
            // processes them in one thread.
            // CommandProcessingMethod - is the user provided method called to process the request.
            ICommandsFactory aCommandsFactory = new CommandsFactory(aSerializer);
            myCommand = aCommandsFactory.CreateCommand<TSomeResponseMessage, TSomeRequestMessage>(CommandProcessingMethod, EProcessingStrategy.SingleThread);
        }

        // Starts listening to commands.
        public void StartCommandReceiver(IDuplexInputChannel duplexInputChannel)
        {
            // Attach the duplex input channel to the command - the command starts the listening.
            myCommand.AttachDuplexInputChannel(duplexInputChannel);
        }

        // Stops listening.
        public void StopCommandReceiver()
        {
            // Detach the input channel from the command.
            // Note: If the input channel is not detached the thread processing command requests would leak
            //       and prevent the closing the application.
            myCommand.DetachDuplexInputChannel();
        }

        // This method is called when the command is executed.
        private void CommandProcessingMethod(ICommandContext<TSomeResponseMessage, TSomeRequestMessage> commandContext)
        {
            try
            {
                // Read the input data.
                DataFragment<TSomeRequestMessage> anInputDataFragment = commandContext.DequeueInputData();
                TSomeRequestMessage anInputData = anInputDataFragment.Data;

                Console.WriteLine("Request received: " + anInputData.SomeParam1);

                for (int i = 0; i < 100; ++i)
                {
                    // Simulate some work.
                    Thread.Sleep(100);

                    // Wait if pause is requested.
                    if (commandContext.CurrentRequest == ECommandRequest.Pause)
                    {
                        // Notify the command proxy that the command was paused.
                        commandContext.ResponsePause();

                        // Wait until resumed or canceled.
                        commandContext.WaitIfPause();
                    }

                    // If the cancel is requested then stop the command.
                    if (commandContext.CurrentRequest == ECommandRequest.Cancel)
                    {
                        // Notify the command proxy that the command was canceled.
                        commandContext.ResponseCancel();
                        return;
                    }

                    // Create response message with the progress.
                    TSomeResponseMessage aResponseMessage = new TSomeResponseMessage();
                    aResponseMessage.Progress = i + 1;

                    // Notify the progress.
                    ECommandState aState = (i == 99) ? ECommandState.Completed : ECommandState.InProgress;
                    commandContext.Response(aState, aResponseMessage);
                }
            }
            catch (Exception err)
            {
                commandContext.ResponseFailure(err.Message);
            }
        }

        private ICommand<TSomeResponseMessage, TSomeRequestMessage> myCommand;
    }
}

2. Create client - Silverlight application

Create Silverlight application in Visual Studio and add Eneter.Messaging.Framework.Silverlight.dll to references.
(Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net.)

Implement the Silverlight client sending requests to the console application (server).

using System.Windows;
using System.Windows.Controls;
using Eneter.Messaging.EndPoints.Commands;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.TcpMessagingSystem;

namespace SilverlightTcpCommandClient
{
    public class TSomeRequestMessage
    {
        public string SomeParam1 { get; set; }
        public int SomeParam2 { get; set; }
    }

    public class TSomeResponseMessage
    {
        public int Progress { get; set; }
    }

    public partial class MainPage : UserControl
    {
        public MainPage()
        {
            InitializeComponent();

            // Create messaging system to send messages to the command.
            // Note: It can be any messaging system but in this case is the fastest one is Synchronous.
            IMessagingSystemFactory aMessaging = new TcpMessagingSystemFactory();
            IDuplexOutputChannel anOutputChannel = aMessaging.CreateDuplexOutputChannel("127.0.0.1:4530");

            // Create command proxy to send requests and receive responses.
            // The command responses progress 
            ICommandsFactory aCommandsFactory = new CommandsFactory();
            myCommandProxy = aCommandsFactory.CreateCommandProxy<TSomeResponseMessage, TSomeRequestMessage>();
            myCommandProxy.CommandResponseReceived += OnCommandResponseReceived;

            // Attach the output channel to the command proxy and enable sending of requests.
            myCommandProxy.AttachDuplexOutputChannel(anOutputChannel);
        }

        private void ExecuteBtn_Click(object sender, RoutedEventArgs e)
        {
            // Create the message.
            TSomeRequestMessage aRequestMessage = new TSomeRequestMessage();
            aRequestMessage.SomeParam1 = "Some text.";
            aRequestMessage.SomeParam2 = 100;

            // Execute the command.
            myCommandProxy.Execute("MyCommandId", aRequestMessage);
        }

        private void PauseBtn_Click(object sender, RoutedEventArgs e)
        {
            myCommandProxy.Pause("MyCommandId");
        }

        private void ResumeBtn_Click(object sender, RoutedEventArgs e)
        {
            myCommandProxy.Resume("MyCommandId");
        }

        private void CancelBtn_Click(object sender, RoutedEventArgs e)
        {
            myCommandProxy.Cancel("MyCommandId");
        }

        private void OnCommandResponseReceived(object sender, CommandResponseReceivedEventArgs<TSomeResponseMessage> e)
        {
            // Display the progress from incomming response message.
            if (e.CommandState == ECommandState.InProgress)
            {
                myProgressBar.Value = e.ReturnData.Progress;
            }
            else if (e.CommandState == ECommandState.Canceled ||
                     e.CommandState == ECommandState.Completed)
            {
                myProgressBar.Value = 0;
            }
        }

        private ICommandProxy<TSomeResponseMessage, TSomeRequestMessage> myCommandProxy;
    }
}

For sake of completeness here is the Xaml file for the Silverlight client defining buttons and progress bar.

<UserControl x:Class="SilverlightTcpCommandClient.MainPage"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    mc:Ignorable="d"
    d:DesignHeight="300" d:DesignWidth="400">

    <Grid x:Name="LayoutRoot" Background="White" Height="181" Width="273">
        <Button Content="Execute Task" Height="23" HorizontalAlignment="Left" Margin="28,35,0,0" Name="ExecuteBtn" VerticalAlignment="Top" Width="89" Click="ExecuteBtn_Click" />
        <Button Content="Pause" Height="23" HorizontalAlignment="Left" Margin="179,35,0,0" Name="PauseBtn" VerticalAlignment="Top" Width="75" Click="PauseBtn_Click" />
        <Button Content="Resume" Height="23" HorizontalAlignment="Left" Margin="179,64,0,0" Name="ResumeBtn" VerticalAlignment="Top" Width="75" Click="ResumeBtn_Click" />
        <Button Content="Cancel" Height="23" HorizontalAlignment="Left" Margin="179,93,0,0" Name="CancelBtn" VerticalAlignment="Top" Width="75" Click="CancelBtn_Click" />
        <ProgressBar Height="22" HorizontalAlignment="Left" Margin="28,138,0,0" Name="myProgressBar" VerticalAlignment="Top" Width="226" />
    </Grid>
</UserControl>

As you can see the implementation requires just little coding. I hope you like my posts about Eneter.Messaging.Framework. I am going to write more articles. If you are interested in more technical information you can try here:
http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html

Silverlight: Comunication between Silverlight Applications with Typed Messages

2010-07-10T00:43:00.006+02:00

Summary: The article shows how to use Eneter.Messaging.Framework for the communication between Silverlight applications to send typed messages (no size limitation).

Silverlight is a nice technology with many useful features to develop cool web-applications. But if you want to communicate between Silverlight applications the possibilities are very limited. Silverlight supports only string messages with limited size (max 40 kilobytes long). If the communication scenario is very simple this basic possibilities can be sufficient. But if your communication needs to recognize between different messages, or you need to communicate request-response with different message types, or you just need messages bigger than 40 KB then the basic Silverlight messaging is not sufficient and you must implement the whole communication "plumbing" in yourself.

Eneter.Messaging.Framework provides a lot of possibilities for the communication between Silverlight applications. For the beginning I would like to show how to use the framework to overcome the known limitations of Silverlight.

The example bellow shows how to send messages of desired type from one silverlight application to another.

1. Add Eneter.Messaging.Framework.Silverlight.dll into your Silverlight applications references to use the messaging functionality. (Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net.)

2. Implement Silverlight application receiving typed messages.
The code with using the framework is very simple:

using System.Collections.ObjectModel;
using System.Windows.Controls;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.SilverlightMessagingSystem;

namespace StrongTypeReceiver
{
    public partial class MainPage : UserControl
    {
        // Data type to be sent as the message.
        public class BasketItem
        {
            public string Id { get; set; }
            public string Name { get; set; }
            public int Price { get; set; }
        }

        public MainPage()
        {
            InitializeComponent();

            // Initialize your UI.
            BasketItems.ItemsSource = myBasketItems;

            // Create input channel to receive message from Silverlight.
            // Note: The channel id (in our case BasketId) represents the address of the receiver.
            IMessagingSystemFactory aMessagingFactory = new SilverlightMessagingSystemFactory();
            IInputChannel anInputChannel = aMessagingFactory.CreateInputChannel("BasketId");

            // Instantiate strong typed receiver.
            ITypedMessagesFactory aTypedMessagesFactory = new TypedMessagesFactory();
            myTypedMessageReceiver = aTypedMessagesFactory.CreateTypedMessageReceiver<BasketItem>();
            
            // Handler for received messages.
            myTypedMessageReceiver.MessageReceived += OnTypedMessageReceived;

            // Attach input channel and listen.
            myTypedMessageReceiver.AttachInputChannel(anInputChannel);
        }

        // Processes the recived message - the message is of type BasketItem.
        private void OnTypedMessageReceived(object sender, TypedMessageReceivedEventArgs<BasketItem> e)
        {
            // Store received data into a collection observed by your UI.
            myBasketItems.Add(e.MessageData);
        }


        private ObservableCollection<BasketItem> myBasketItems = new ObservableCollection<BasketItem>();

        //Strong typed message receiver.
        private ITypedMessageReceiver<BasketItem> myTypedMessageReceiver;
    }
}

3. Implement Silverlight application sending typed messages.
The sender side (client) is very simple too.

using System.Windows;
using System.Windows.Controls;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.SilverlightMessagingSystem;

namespace StrongTypeSender
{
    public partial class MainPage : UserControl
    {
        // Data structure to be sent.
        public class BasketItem
        {
            public string Id { get; set; }
            public string Name { get; set; }
            public int Price { get; set; }
        }

        public MainPage()
        {
            InitializeComponent();

            // Create output channel to send message via Silverlight.
            // Note: Use the same channel id (address) as receiver.
            IMessagingSystemFactory aMessagingFactory = new SilverlightMessagingSystemFactory();
            IOutputChannel anOutputChannel = aMessagingFactory.CreateOutputChannel("BasketId");

            // Instantiate strong typed sender.
            ITypedMessagesFactory aTypedMessagesFactory = new TypedMessagesFactory();
            myTypedMessageSender = aTypedMessagesFactory.CreateTypedMessageSender<BasketItem>();
            myTypedMessageSender.AttachOutputChannel(anOutputChannel);
        }

        private void SendButton_Click(object sender, RoutedEventArgs e)
        {
            BasketItem aBasketItem = new BasketItem();
            aBasketItem.Id = IdTextBox.Text;
            aBasketItem.Name = NameTextBox.Text;
            
            int aPrice;
            if (int.TryParse(PriceTextBox.Text, out aPrice))
            {
                aBasketItem.Price = aPrice;

                // Send the the message.
                myTypedMessageSender.SendMessage(aBasketItem);
            }
        }


        // Strong typed message sender.
        private ITypedMessageSender<BasketItem> myTypedMessageSender;
    }
}

This is really all what you need if you use the framework.

Eneter.Messaging.Framework has much more capabilities as described above. It offers also request-response communication, well defined components (e.g Broker for publish-subscribe communication), ... .
The same framework can be used for communication between the Silverlight application and the hosting server. And the same framework can be also used to implement the message based communication between threads inside the Silverlight application.
I will write more articles about the communication based on this platform.

Would you like to know more technical details about this platform, you can read here: http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html

Request-Response Communication

2010-07-06T22:35:00.036+02:00

Summary: Simple example showing how to implement the request-response communication between applications.

The request-response communication is a communication scenario where messages flow in both directions - request messages from the sender to the receiver and response messages from the receiver back to the sender.

The example bellow shows the server receiving messages and sending responses back to the client. It also shows how to implement the client sending messages to the server and receiving response messages.

1. Add Eneter.Messaging.Framework.dll to use the messaging functionality in your .Net applications. (Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net.)

2. Define message types.
For the request-response communication you must define type of the request message and type of the response message.
And same as described in the previous part, you should consider what serialization will be used.
(Because the serialization can require some additional attributes in the declarations.)

In our example we will use the binary serialization. The request message type is 'Person' and the response type is the string.

using System;
using CommonTypes;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.NamedPipeMessagingSystem;

namespace DuplexTypedMessageServer
{
    class Program
    {
        // Duplex typed message receicer that receives type Person and responses type string.
        static IDuplexTypedMessageReceiver<string, Person> myMessageReceiver;

        static void Main(string[] args)
        {
            // Create factory to create input channel based on Named Pipes
            IMessagingSystemFactory aMessagingSystemFactory = new NamedPipeMessagingSystemFactory();
            IDuplexInputChannel anDuplexInputChannel =
                aMessagingSystemFactory.CreateDuplexInputChannel("//127.0.0.1/MyPipeName3");

            // Create duplex typed message receiver using the binary serialization.
            ISerializer aSerializer = new BinarySerializer();
            IDuplexTypedMessagesFactory aDuplexTypedMessagesFactory =
                new DuplexTypedMessagesFactory(aSerializer);
            myMessageReceiver = aDuplexTypedMessagesFactory.CreateDuplexTypedMessageReceiver<string, Person>();
            myMessageReceiver.MessageReceived += OnMessageReceived;

            // Attach the input channel to the string message receiver and start listening.
            myMessageReceiver.AttachDuplexInputChannel(anDuplexInputChannel);

            Console.WriteLine("The service is listening. Press enter to stop.\n");
            Console.ReadLine();

            myMessageReceiver.DetachDuplexInputChannel();
        }

        static void OnMessageReceived(object sender, TypedRequestReceivedEventArgs<Person> e)
        {
            Console.WriteLine("Received Message:");
            Console.WriteLine("Name: " + e.RequestMessage.Name);
            Console.WriteLine("Number of items: " + e.RequestMessage.NumberOfItems.ToString());
            Console.WriteLine();

            // As a response send the current time.
            string aResponseMessage = DateTime.Now.ToString();
            myMessageReceiver.SendResponseMessage(e.ResponseReceiverId, aResponseMessage);
        }
    }
}

4. Implement the client.
The client bellow sends the message type of 'Person' and receives the response message type of string.

using System;
using System.Windows.Forms;
using CommonTypes;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.NamedPipeMessagingSystem;

namespace DuplexTypedMessageClient
{
    public partial class Form1 : Form
    {
        // Duplex typed message sender that sends type Person and
        // receives responses of type string.
        private IDuplexTypedMessageSender<string, Person> myMessageSender;

        public Form1()
        {
            InitializeComponent();

            OpenConnection();
        }

        private void OpenConnection()
        {
            // Create factory to create input channel based on Named Pipes
            IMessagingSystemFactory aMessagingSystemFactory = new NamedPipeMessagingSystemFactory();
            IDuplexOutputChannel anOutputChannel =
                aMessagingSystemFactory.CreateDuplexOutputChannel("//127.0.0.1/MyPipeName3");

            // Create duplex typed message sender that uses the binnary serializer.
            ISerializer aSerializer = new BinarySerializer();
            IDuplexTypedMessagesFactory aDuplexTypedMessagesFactory =
                new DuplexTypedMessagesFactory(aSerializer);
            myMessageSender = aDuplexTypedMessagesFactory.CreateDuplexTypedMessageSender<string, Person>();
            myMessageSender.ResponseReceived += OnResponseReceived;

            // Attach duplex output channel and be able to send messages
            // and receive response messages.
            myMessageSender.AttachDuplexOutputChannel(anOutputChannel);
        }

        private void Form1_FormClosed(object sender, FormClosedEventArgs e)
        {
            // Correctly close connection.
            // Otherwise the thread listening to response messages will leak.
            myMessageSender.DetachDuplexOutputChannel();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            // Prepare the message.
            Person aPerson = new Person();
            aPerson.Name = NameTextBox.Text;
            aPerson.NumberOfItems = int.Parse(NumberOfItemsTextBox.Text);

            // Send the message.
            myMessageSender.SendRequestMessage(aPerson);
        }

        private void OnResponseReceived(object sender, TypedResponseReceivedEventArgs<string> e)
        {
            string aResponseMessage = e.ResponseMessage;
            InvokeInUIThread(() => ReceivedResponseTextBox.Text = aResponseMessage);
        }

        // Helper method to invoke the given delegate
        // in the UI thread.
        private void InvokeInUIThread(Action action)
        {
            if (InvokeRequired)
            {
                Invoke(action);
            }
            else
            {
                action();
            }
        }
    }
}

And here are communicating applications.

One-Way Communication

2010-07-04T12:29:00.099+02:00

Summary: Simple example showing how to implement the one-way communication between applications.

The one-way communication is a communication scenario where messages flow only in one direction - from sender to receiver.Although the scenario sounds simple it can be quite complex programming if you use just default .Net functionality (e.g. sockets). To simplify the implementation and reduce the effort you would probably consider to use some communication framework.

I would like to show you how the one-way communication with typed messages works with Eneter.Messaging.Framework.
The example shows, how to implement the server receiving messages of the specified type and the client sending messages of the same type.

1. Add Eneter.Messaging.Framework.dll to use the messaging functionality in your .Net applications. (Full, not limited and for non-commercial usage free version of the framework can be downloaded from www.eneter.net.)

2. Define message types
You need to define message types you want to use for the communication. Because the serialization and deserialization (used during sending and receiving) can require some additional attributes in the declaration of the type you also should consider what serialization will be used.

Binary Serialization
The data is serialized into array of bytes. The serialization is fast and consumes less memory as string serializations.
It requires to use 'Serializable' attribute and the data must be declared in an assembly that is linked by the server and also by the client.
(Here you can consider to create some assembly for shared data types.)
The binary serialization is not supported by Silverlight.
The serialization is based on BinaryFormater provided by .Net platform.

Xml Serialization
The data is serialized into the string. The serialization is slower and consumes more memory as the binary serialization.
It does not require, the server and the client link the same assembly with data types. The data can be declared separately on both sides.
The xml serialization works in Silverlight too.
The serialization is based on XmlSerializer provided by .Net platform..

Data Contract Serialization
The data is serialized as Xml into the string. The serialization is based DataContractSerializer provided by .Net platform. Therefore, you can use all data contract attributes to declare the data for the serialization / deserialization.

Our example uses the binary serialization, therefore here is the declaration for our message.

using System;

namespace CommonTypes
{
    [Serializable]
    public class Person
    {
        public string Name { get; set; }
        public int NumberOfItems { get; set; }
    }
}

3. Implement the server
When you implement the interprocess communication you must choose if you want to communicate via Named Pipes, Tcp or Http protocol.

Named Pipes

// Create factory for messaging via Named Pipes.
IMessagingSystemFactory aMessagingSystemFactory =
new NamedPipeMessagingSystemFactory();

// Create input channel for listening to messages.
IInputChannel anInputChannel =
aMessagingSystemFactory.CreateInputChannel("//127.0.0.1/MyPipeName2");

Tcp

// Create factory for messaging via Tcp.
IMessagingSystemFactory aMessagingSystemFactory =
new TcpMessagingSystemFactory();

// Create input channel for listening to messages.
IInputChannel anInputChannel = aMessagingSystemFactory.CreateInputChannel("127.0.0.1:8091");

Http

// Create factory for messaging via Http.
IMessagingSystemFactory aMessagingSystemFactory =
new HttpMessagingSystemFactory();

// Create input channel for listening to messages.
IInputChannel anInputChannel =
aMessagingSystemFactory.CreateInputChannel("127.0.0.1:8091");

Let's use Named Pipes in our example.

using System;
using CommonTypes;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.NamedPipeMessagingSystem;

namespace TypedMessageServer
{
    class Program
    {
        // Strong type receiver for the type Person.
        static private ITypedMessageReceiver<Person> myReceiver;

        static void Main(string[] args)
        {
            // Create receiver for the message type 'Person' with binary serializer.
            ISerializer aSerializer = new BinarySerializer();
            ITypedMessagesFactory aTypedMessagesFactory = new TypedMessagesFactory(aSerializer);
            myReceiver = aTypedMessagesFactory.CreateTypedMessageReceiver<Person>();
            myReceiver.MessageReceived += OnMessageReceived;

            // Create input channel listening to Named Pipe.
            // Note: This is a one-way channel. Therefore, it can just receive messages.
            // Note: Do not use '/' at the end of the address.
            IMessagingSystemFactory aMessaging = new NamedPipeMessagingSystemFactory();
            IInputChannel anInputChannel = aMessaging.CreateInputChannel("//127.0.0.1/MyPipeName2");

            // Attach input channel ans start listening.
            myReceiver.AttachInputChannel(anInputChannel);

            Console.WriteLine("The service is listening. Press enter to stop.\n");
            Console.ReadLine();

            myReceiver.DetachInputChannel();
        }

        static void OnMessageReceived(object sender, TypedMessageReceivedEventArgs<Person> e)
        {
            // If there was a problem with the receiving.
            if (e.ReceivingError != null)
            {
                Console.WriteLine("Detected problem during receiving: " + e.ReceivingError.Message);
            }
            else
            {
                Console.WriteLine("Received Message:");
                Console.WriteLine("Name: " + e.MessageData.Name);
                Console.WriteLine("Number of items: " + e.MessageData.NumberOfItems.ToString());
                Console.WriteLine();
            }
        }
    }
}

4. Implement the client
And here is the implementation for the client sending messages of type Person.

using System;
using System.Windows.Forms;
using CommonTypes;
using Eneter.Messaging.DataProcessing.Serializing;
using Eneter.Messaging.EndPoints.TypedMessages;
using Eneter.Messaging.MessagingSystems.MessagingSystemBase;
using Eneter.Messaging.MessagingSystems.NamedPipeMessagingSystem;

namespace TypedMessageClient
{
    public partial class Form1 : Form
    {
        private ITypedMessageSender<Person> myMessageSender;

        public Form1()
        {
            InitializeComponent();

            // Create input channel listening to Named Pipe.
            // Note: This is a one-way channel. Therefore, it can just receive messages.
            IMessagingSystemFactory aMessaging = new NamedPipeMessagingSystemFactory();
            IOutputChannel anOutputChannel = aMessaging.CreateOutputChannel("//127.0.0.1/MyPipeName2");

            // Create the message sender sending the class of type 'Person'.
            // The sender will use the binary serializer.
            ISerializer aSerializer = new BinarySerializer();
            ITypedMessagesFactory aTypedMessagesFactory = new TypedMessagesFactory(aSerializer);
            myMessageSender = aTypedMessagesFactory.CreateTypedMessageSender<Person>();

            // Attach the output channel and be able to send messages.
            myMessageSender.AttachOutputChannel(anOutputChannel);
        }

        private void SendButton_Click(object sender, EventArgs e)
        {
            // Prepare the message.
            Person aPerson = new Person();
            aPerson.Name = NameTextBox.Text;
            aPerson.NumberOfItems = int.Parse(NumberOfItemsTextBox.Text);

            // Send the message.
            myMessageSender.SendMessage(aPerson);
        }
    }
}

And here are communicating applications.

Eneter.Messaging.Framework 1.0

2010-07-03T11:15:00.013+02:00

The article briefly describes Eneter.Messaging.Framework version 1.0 as a platform for the communication between applications.

This article describes the first version of the framework. The latest version you can find here:

Eneter Messaging Framework version 2.0

Applications typically do not run isolated but they communicate to each other. Also internally the application can consist of components or layers (running in different threads) that need to communicate. Dealing with different technologies, communication protocols and possibilities how to resolve the communication between applications and inside the application adds the complexity and increases the effort.
Eneter.Messaging.Framework is the message oriented middleware providing the unified approach for communication with messages. It means, you use the same functionality to communicate between processes and between components inside the process.

The framework wraps the communication protocols and technologies for you and provides well defined components you can use to realize communication scenarios.

For the interprocess communication, the framework supports:

Named Pipes
TCP
Http
Silverlight Messaging (yes, you can use it for Silverlight applications too)

For the communication inside the application, the framework supports:

Synchronous messaging - messages processed in the context of caller thread.
Thread messaging - messages for one processing thread.
Thread Pool messaging - messages for more processing threads.

The communication can be one-way or request-response. It can be string messages or strongly typed messages.

And you can use the following components to create your communication scenario:

Bridge - connects messaging systems.
Broker - receives messages and forwards them to subscribed receivers.
Router - receives messages and forwards them to preconfigured receivers.
Dispatcher - receives messages and forwards them to all receivers.
Channel Wrapper - wraps messages from more channels and sends via one channel
Channel Unwrapper - unwraps messages from one channel and sends them to respective channels.

For more technical details, please refer to http://www.eneter.net/OnlineHelp/EneterMessagingFramework/Index.html

Beginning

2010-07-03T00:26:00.006+02:00

Today I am starting the web-page www.eneter.net. The page is dedicated to the software development and will offer various solutions for challenges we frequently experience during the software development.

The intention is, solutions are lightweight, easy to use and will reduce the complexity of your development. To support developers, there is also the online documentation with examples.

The software is offered for free for non-commercial purposes. The commercial usage requires the license you can obtain for the fair price. (Please refer to the license agreement on the page.)

I invite you to visit www.eneter.net and I hope you will download the software, find it useful and send me your feedback.