Sometimes, it is required to communicate between two local Silverlight applications. Though this situation is very limited, it may be required as per your business deal. In such a case, the local messaging mechanism comes into the place.
In this post, we will learn about this local messaging system using a small Silverlight application where we will have a sender project and a receiver project. At the end of the article, I embedded the demo which will give you more visibility on what we are going to do in the demo. Let's discuss more about this topic.
Create Project Structure
Let's start by creating the project structure for our sample demo app. In this demo, we will create two different Silverlight projects called "
Sender" and "
Sender project will broadcast some message and the receiver will catch that message and do the next operation according to that.
Here is the project structure for your reference:
Create the Sender UI
Let us create the UI of the sender application. Here we will have couple of radio buttons for selecting different colors and a button which enables the user to submit the message to broadcast. Here is the XAML code:
<Grid x:Name="LayoutRoot" Background="White">
<RadioButton x:Name="rdoRed" GroupName="color" Content="Red"/>
<RadioButton x:Name="rdoGreen" GroupName="color" Content="Green"/>
<RadioButton x:Name="rdoBlue" GroupName="color" Content="Blue"/>
<RadioButton x:Name="rdoYellow" GroupName="color" Content="Yellow"/>
<Button Content="Send" Height="26" Width="150" Click="SendButtonClick"/>
This will render as below in the UI:
Implement Message Broadcasting
It's time to send the message to the receiver application. To do this, there is a class called
LocalMessageSender and it is present under "
System.Windows.Messaging" namespace, which takes receiver name and receiver domain as constructor parameter:
public LocalMessageSender(string receiverName, string receiverDomain);
On button click, we will check which color has been selected and then we will create the instance of the class
LocalMessageSender and pass proper color as message to the
SendAsync() method as implemented below:
private void SendButtonClick(object sender, RoutedEventArgs e)
var rdoRedSelected = rdoRed.IsChecked == true;
var rdoGreenSelected = rdoGreen.IsChecked == true;
var rdoBlueSelected = rdoBlue.IsChecked == true;
var rdoYellowSelected = rdoYellow.IsChecked == true;
var localMessageSender = new LocalMessageSender("myMessagingDemo",
localMessageSender.SendAsync(rdoRedSelected ? "Red"
: rdoGreenSelected ? "Green"
: rdoBlueSelected ? "Blue"
: rdoYellowSelected ? "Yellow"
It has completed event (
SendCompleted) for the
SendAsync() method where you can check
Response if any.
Implementation of Message Receiving
Similar to the
LocalMessageSender, we have another class called
LocalMessageReceiver present in the same namespace called "
System.Windows.Messaging". It takes receiver name, receiver's namescope and allowed sender domains as constructor parameters as shown below:
public LocalMessageReceiver(string receiverName,
In the page loaded event of receiver project, we will create the instance of the
LocalMessageReceiver, register the
MessageReceived event and then call the
Listen() method to start listening to the message.
void MainPageLoaded(object sender, RoutedEventArgs e)
var localMessageReceiver = new LocalMessageReceiver("myMessagingDemo",
localMessageReceiver.MessageReceived += LocalMessageReceiverMessageReceived;
In the message received event implementation, we will check the type of message and based on the received message, we will do proper operation. In our case, based on the color information that we received, we will change the color of the background of the
LayoutRoot grid of the receiver application.
Here is the implementation of the same:
void LocalMessageReceiverMessageReceived(object sender, MessageReceivedEventArgs e)
var message = e.Message;
LayoutRoot.Background = new SolidColorBrush(Colors.Red);
LayoutRoot.Background = new SolidColorBrush(Colors.Green);
LayoutRoot.Background = new SolidColorBrush(Colors.Blue);
LayoutRoot.Background = new SolidColorBrush(Colors.Yellow);
LayoutRoot.Background = new SolidColorBrush(Colors.White);
That's all about the implementation part. Let's see it in action.
Let's run our application. As we have two projects, run each of them one by one. Once run, you will have two browser windows having one as
Sender application and the other as
Receiver application. By default, the receiver will have white background. Now go to the sender application and choose any one of the radio buttons to select the color. Then click "
Send" button to send the color message to the other Silverlight application. The receiver application will catch the message based on the name and change the color of the layout accordingly.
Have a look into the demo of the same here which will give you proper visibility to the implementation:
Hope this helped you to understand the local messaging system of Silverlight application. Remember that this will not work when your browser is in Private mode.
- 26th July, 2011: Initial post