Integrating .NET applications with other client technologies (or even .NET to .NET) may not seem to be a trivial task. I believe Microsoft has done a great job providing a fairly closed technology stack where things work as long as you stick to Microsoft’s prescription of how to go about solving problems. Take for example the task of creating a multi client messaging system between a .NET application and Flex, AIR, Android or iOS client and you will shortly feel the pain. The real challenge is the .NET messaging framework is not very open to accomodate client applications of other than native .NET or ASP.NET. As a result, you will need a messaging server which will serve the purpose of routing broker and messaging “translator” between heterogeneous client applications.

Earlier this month I wrote about Remote Shared Objects and the benefits the feature provides. Since remote shared objects are no longer a feature exclusive to Flash, Flex and AIR clients I put together a messaging example demonstrating how .NET applications can efficiently communicate with Flex and AIR  (and thus Android,  iOS and Blackberry Playbook). The .NET application is a simple (console-based) chat program which uses remote shared objects to exchange data with a Flex client. The Remote Shared Object API and RTMP connectivity comes with the RTMPClient class available in WebORB for .NET. Here’s the full listing of the C# code with an explanation right after the listing:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Threading;
using Weborb.Client;
using Weborb.Messaging.Net.RTMP;
using Weborb.Messaging.Api.Service;
using Weborb.Messaging.Api.SO;

namespace WeborbClientTest
{
  class Program : IPendingServiceCallback, ISharedObjectListener
  {
    private ThreadStart threadStart;
    private Thread chatThread;
    private AutoResetEvent rsoIsReady = new AutoResetEvent( false );

    private RTMPClient rtmpClient;
    private IClientSharedObject rso;

    static void Main( string[] args )
    {
      Program chatClient = new Program();
      chatClient.StartChat();
    }

    public void StartChat()
    {
      rtmpClient = new RTMPClient();
      rtmpClient.setServiceProvider( this );

      System.Console.WriteLine( "Connecting to the RTMP server running at localhost:2037" );
      rtmpClient.connect( "localhost", 2037, "Chat", null, this );

      threadStart = new ThreadStart( MainChat );
      chatThread = new Thread( threadStart );
      chatThread.Start();
      chatThread.IsBackground = false;
    }

    public void MainChat()
    {
      rsoIsReady.WaitOne();

      System.Console.WriteLine( "Connecting to the 'ChatSO' remote shared object" );
      rso = rtmpClient.getSharedObject( "ChatSO", false );
      rso.addSharedObjectListener( this );

      while( true )
      {
        System.Console.WriteLine( "Enter a message to put into RSO. Press \"Enter\" to stop the loop:" );
        String messageText = System.Console.ReadLine();

        if( messageText.Equals( "" ) )
          break;

        Hashtable messageObject = new Hashtable();
        messageObject[ "imText" ] = messageText;
        messageObject[ "username" ] = ".NET Client";
        messageObject[ "color" ] = 0;
        messageObject[ "isBold" ] = false;
        messageObject[ "isItalics" ] = false;
        messageObject[ "isUnderline" ] = false;

        rso.setAttribute( "UserMessage", messageObject );
      }
    }

    public void resultReceived( IPendingServiceCall call )
    {
      System.Console.WriteLine( "RTMP client connected" );
      rsoIsReady.Set();
    }

    public void onSharedObjectClear( ISharedObjectBase so )
    {
      System.Console.WriteLine( "EVENT: onSharedObjectClear" );
    }

    public void onSharedObjectConnect( ISharedObjectBase so )
    {
      System.Console.WriteLine( "EVENT: onSharedObjectConnect" );
    }

    public void onSharedObjectDelete( ISharedObjectBase so, string key )
    {
      System.Console.WriteLine( "EVENT: onSharedObjectDelete" );
    }

    public void onSharedObjectDisconnect( ISharedObjectBase so )
    {
      System.Console.WriteLine( "EVENT: onSharedObjectDisconnect" );
    }

    public void onSharedObjectSend( ISharedObjectBase so, string method, IList parms )
    {
      System.Console.WriteLine( "EVENT: onSharedObjectSend" );
    }

    public void onSharedObjectUpdate( ISharedObjectBase so, IDictionary<string, object> values )
    {
      System.Console.WriteLine( "EVENT: onSharedObjectUpdate" );
    }

    public void onSharedObjectUpdate( ISharedObjectBase so, Weborb.Messaging.Api.IAttributeStore values )
    {
      System.Console.WriteLine( "EVENT: onSharedObjectUpdate" );
    }

    public void onSharedObjectUpdate( ISharedObjectBase so, string key, object value )
    {
      System.Console.WriteLine( "EVENT: onSharedObjectUpdate" );

      Hashtable messageData = (Hashtable) value;
      System.Console.WriteLine( "property " + key + ",  imText value " + messageData[ "imText" ] );
    }
  }
}

The StartChat method is where the program connects to the localhost server running on port 2037 (WebORB’s default RTMP port). The “Chat” parameter is the name of the messaging application the client connects to. The main chat logic is in the MainChat method. As you can see from the code the MainChat method is executed by a separate thread. The reason for this is the process of establishing a connection and receiving a notification that the connection has been established (lines 34 and 72) is asynchronous. As a result, a separate thread is required so the main method of the application does not end prematurely.

Inside of the MainChat method, the code uses the getSharedObject method to obtain a reference to the specified remote shared object – ChatSO (line 47). A listener object is added to the remote shared object instance so the application receives all the RSO events, including the one when the RSO is updated (lines 111-117).

You can download the complete project from the following URL: http://examples.themidnightcoders.com/blog/RSOClient.zip

To run the example and experience the feature:

1. Compile the example code (you might need to set the weborb.dll assembly reference)
2. Run the WebORB Management Console
3. Run the .NET application
4. In the management console switch to the Help/Resources tab, then click the Examples link
5. In the examples tree in the console navigate to: FLEX Examples > Real-time Messaging (RTMP) > Basic Text Chat
6. Type in a send messages both in the Flex and .NET clients – both send and receive data

To see the contents of the Remote Shared Object used in the sample .NET application switch to the Messaging Server tab in the Management Console, select the Chat node in the tree, then select the Shared Objects tab. As the clients send data, the console shows the internal state of the shared object.

Exactly the same approach and APIs are applicable if you build Android and iOS mobile applications. I plan to write a similar post demonstrating cross platform connectivity and messaging between .NET and Android and iOS clients.

Here’s a brief video showing the example in action: