Cloud messaging made easy with Linxter

Want to allow different applications to communicate over the Internet without requiring any service infrastructure of your own and without needing to learn and understand the complexities of WCF? There is now a solution that you might want to take a look at.

I’ve been working with a company called Linxter helping them build out a cloud messaging infrastructure that makes building cloud-connected applications even easier than building them using WCF. Basically they have set up the infrastructure and provided an easy to use SDK that encapsulates all the scary code required to really do reliable messaging over the internet, while supporting occasionally connected scenarios, security, reliability, and other aspects.

Basically all you do is download the SDK, add a reference to a single DLL, run a tool to generate a supporting database (file based, SQLite), and start making calls.

The API is really simple, you just call CreateMessage to send a message, subscribe to an event to know when you have received a message, and there is a one time step to register your program instance with the back end Linxter Internet Service Bus (ISB) infrastructure.

So a simple Hello World app could look something like this:

// The API is separated into three interfaces focused on // the three aspects of using the SDK
ILinxterMessaging messaging = new LinxterSDK();
ILinxterRegistration registration = messaging as ILinxterRegistration;
ILinxterCommunicationChannel commChannels = messaging as ILinxterCommunicationChannel;
// Subscribe so received messages raise an event
messaging.MessageReceived += OnMessageReceived;
// One time step in the life of a program instance - register
registration.RegisterProgramInstance();
// Tell the SDK to start retrieving messages based on a configurable schedule// On demand also supported
messaging.StartScheduledReceive();
// Create a channel to another instance based on an ID or alias name
ProgramInstanceInfo responder =
commChannels.FindProgramInstances("HelloWorld Responder",
FindProgramInstanceType.ByAlias)[0];
commChannels.CreateRequest(responder, "Invitation message");
// Send on demand or on schedule supported
messaging.SendNow();
// Wait for channel to be opened to the receiverwhile (!IsOpenCommunicaitonChannels(commChannels, responder))
{
Console.WriteLine("Waiting for comm channel creation");
Thread.Sleep(1000);
}
// Construct a message to send to the receiver, can be many
List<Guid> receivers = new List<Guid>();
receivers.Add(responder.ProgramInstanceId);
// Each message can have an activity ID to separate different message typesstring activityId = "b9501157-be9a-4a98-aab6-1c1e17ac8d99";
// The message body is simply a string // (in which you can encode whatever data you want, however you want)
Guid msgID = messaging.CreateMessage(receivers, activityId, "Hello World");
// Messages are always queued in the client DB supporting offline scenarios well
messaging.SendNow();

There is a lot more to it of course, but the point is that you can integrate Linxter into just abobut any kind of .NET program including smart client applications, web applications, and Windows services. You don’t have to learn anything about how to get the distributed messaging done, they have done all the work for you.

Eventually there will be support for using Linxter in other platforms, so it can form the glue to integrate applications from different platforms.

Of course you could do these things yourself with WCF and .NET services, but to do it that way you would have to master a much more demanding set of skills and may have to set up some infrastructure of your own. With Linxter, you just need a reference to a library, a few method calls into that library, and an account and your applications can be connected really quickly.