I'm not dead! Neither is Caleb, though I don't know if he'll begin blogging again. 

The lack of new posts here is quite depressing really.  We both left the company we were previously with and moved on to greener pastures and the blogging stopped as we both ramped up at our new gigs.

I'm going try to pump out at least one quality blog post a month and perhaps some smaller posts in between.  I've been diving into lots of new technology since I last posted and I'll try to remember the best bits and put them here.

This code uses the excellent SocketsLight library to simplify socket connections in Silverlight.  I’ve put together a simple example of a chat server and client where you can send a message back and forth immediately.

We plan to extend this idea to integrate with some hardware devices where the console application or Windows service connects to the hardware through drivers then we use sockets to communicate between that application and Silverlight.

Download

Download the example.

Launching the Server

1. Download the project and compile the solution. 
2. Run LocalServer\bin\Debug\LocalServer.exe.  This is the console application that the Silverlight application connects to via sockets.  (Run this exe manually so you can F5 debug the Silverlight application.  You can’t debug both of them at the same time).

Launching the Silverlight application

1. Set the SilverlightSockets.Web project as the startup project and run.
2. You should a message saying that the connection to the server succeeded.
3. Type in a message and verify that the message appears on the server.

Now you can type messages on the Silverlight client and on the server.

Console application (LocalServer.exe)

This is the console application that the Silverlight client connects to.  The PolicyServer and MessageServer classes are included in the SocketsLight library, and provide a simple event driven model for dealing with sockets.  The PolicyServer is just a simple web server that accepts requests to clientaccesspolicy.xml, which is necessary to use sockets in Silverlight.

TextMessage is a class that I defined on both the server and the Silverlight client.  This stores data that’s sent over the wire in both directions.

In this example, I’m firing up the PolicyServer and MessageServer on different threads and reading in any input typed in by the user.

When a client connects, the ClientStatusChangedEventArgs contains a GUID that uniquely identifies the connection.  You use this GUID when you want to send a message to the client.  This example just supports a single connection, but you can easily keep track of the GUIDs for the different collections to support multiple connections.

class Program
{
    private static Guid _clientID = Guid.Empty;

    private static bool IsConnected
    {
        get { return _clientID != Guid.Empty; }
    }

    static void Main(string[] args)
    {
        var policyServer = new PolicyServer("../../clientaccesspolicy.xml");
        IMessageServer messageServer = new MessageServer(
            IPAddress.Any,
            4530,
            new JsonMessageSerializer(new List<Type>() { typeof(TextMessage) }));

        messageServer.ClientConnected += new EventHandler<ClientStatusChangedEventArgs>(messageServer_ClientConnected);
        messageServer.ClientDisconnected += new EventHandler<ClientStatusChangedEventArgs>(messageServer_ClientDisconnected);

        ThreadPool.QueueUserWorkItem((o) => { policyServer.Start(); });
        ThreadPool.QueueUserWorkItem((o) => { messageServer.Start(); });

        var textService = new TextService(messageServer);

        // Wait for messages to be typed and send to client.
        while (true)
        {
            string input = Console.ReadLine();
            if (IsConnected)
            {
                messageServer.SendMessageToClient(_clientID, new TextMessage { Text = input });
            }
            else
            {
                Console.WriteLine("Warning: there are not clients connected to receive the message.");
            }
        }
    }

    static void messageServer_ClientDisconnected(object sender, ClientStatusChangedEventArgs e)
    {
        _clientID = Guid.Empty;
        Console.WriteLine("Connection closed for " + e.ClientId);
    }

    static void messageServer_ClientConnected(object sender, ClientStatusChangedEventArgs e)
    {
        _clientID = e.ClientId;
        Console.WriteLine("Connection opened for " + e.ClientId);
    }
}

TextService.cs (runs on the console application)

The data contract I defined between the server and client. It needs to inherit from the Message class included in the SocketsLight library.

namespace LocalServer
{
    using Witcraft.SocketsLight.Server;
    using System.Runtime.Serialization;
    
    [DataContract]
    public class TextMessage : Message
    {
        [DataMember]
        public string Text { get; set; }
    }
}

TextService.cs (runs on the console application)

public class TextService
{
    private IMessageServer _messageServer;
    Guid _clientID = Guid.Empty;

    public bool IsConnected
    {
        get { return _clientID != Guid.Empty; }
    }

    public TextService(IMessageServer messageServer)
    {
        _messageServer = messageServer;
        _messageServer.ClientConnected += new EventHandler<ClientStatusChangedEventArgs>(_messageServer_ClientConnected);
        _messageServer.ClientDisconnected += new EventHandler<ClientStatusChangedEventArgs>(_messageServer_ClientDisconnected);
        _messageServer.MessageRecieved += new EventHandler<MessageRecievedEventArgs>(_messageServer_MessageRecieved);
    }

    void _messageServer_MessageRecieved(object sender, MessageRecievedEventArgs e)
    {
        if (IsConnected)
        {
            TextMessage message = e.Message as TextMessage;
            if (message != null)
            {
                Console.WriteLine("Message Received: " + message.Text);
            }
        }
    }

    void _messageServer_ClientDisconnected(object sender, ClientStatusChangedEventArgs e)
    {
        _clientID = Guid.Empty;
    }

    void _messageServer_ClientConnected(object sender, ClientStatusChangedEventArgs e)
    {
        _clientID = e.ClientId;
    }
}

Code-behind for Silverlight UserControl

public partial class MainPage : UserControl
{
    const int TCP_PORT = 4530;
    IMessageClient _messageClient;

    public MainPage()
    {
        InitializeComponent();
    }

    private void UserControl_Loaded(object sender, RoutedEventArgs e)
    {
        _messageClient = new MessageClient
        (
            TCP_PORT,
            new JsonMessageSerializer(new List<Type>() { typeof(TextMessage) })
        );
        _messageClient.MessageRecieved += 
            new EventHandler<MessageRecievedEventArgs>(_messageClient_MessageRecieved);
        _messageClient.ConnectCompleted += 
            new EventHandler<AsyncCompletedEventArgs>(
                _messageClient_ConnectCompleted);
        _messageClient.ConnectAsync();

        AddMessage("System", "Trying to connect on TCP port " + TCP_PORT + "...");

        SendText.Focus();
    }        

    void _messageClient_ConnectCompleted(object sender, AsyncCompletedEventArgs e)
    {
        AddMessage("System", "Connected!");
        this.Dispatcher.BeginInvoke(() => this.SendButton.IsEnabled = true );
    }

    void _messageClient_MessageRecieved(object sender, MessageRecievedEventArgs e)
    {
        TextMessage message = e.Message as TextMessage;
        if (message != null)
            AddMessage("Server", message.Text);
    }

    private void Button_Click(object sender, RoutedEventArgs e)
    {
        SendMessage();
    }

    private void SendText_KeyDown(object sender, KeyEventArgs e)
    {
        if (e.Key == Key.Enter)
            SendMessage();
    }

    private void SendMessage()
    {
        AddMessage("Me", SendText.Text);
        _messageClient.SendMessageAsync(new TextMessage { Text = SendText.Text });
        SendText.Text = string.Empty;
    }

    // Updates UI with messages sent/received.
    private void AddMessage(string sender, string message)
    {
        this.Dispatcher.BeginInvoke
        (() =>
            {
                this.Received.Text += string.Format("{0}: {1}", sender, message) + Environment.NewLine;
                this.Scroller.UpdateLayout();
                this.Scroller.ScrollToVerticalOffset(double.MaxValue);
            }
        );
    }        
}

I remember always being told to not return early from a method.  However, I think it makes sense in some cases when you would otherwise have a set of nested “if” statements.

Take this example I ran across while working in our production system:

private void GetDiscountCode(Registration registration, Registrant registrant)
{
    if (registration.EventProfile.DiscountCodesEnabled &&
        registration.EventProfile.DiscountCodes.Count > 0)
    {
        if (tbDiscountCode.Text.Trim() != string.Empty)
        {
            DiscountCode discountCode = registration.EventProfile.DiscountCodes.Find(tbDiscountCode.Text);
            if (discountCode != null)
            {
                if (discountCode.Active)
                {
                    if (!discountCode.Limited
                        || discountCode.DiscountsUsed < discountCode.MaximumAllowed)
                    {
                        if (registrant.DiscountCodeApplied != discountCode.DiscountCodeId)
                        {
                            if (registrant.DiscountCodePercentage <= discountCode.DiscountPercentage)
                            {
                                registrant.DiscountCodeApplied = discountCode.DiscountCodeId;
                                registrant.DiscountCodePercentage = discountCode.DiscountPercentage;
                                registrant.DiscountCodeAmountPerLineItem = discountCode.DiscountAmount;
                                
                            }
                        }
                    }
                    else
                    {
                        errorMessages.Add(string.Format("The {0} you entered is no longer available", registration.EventProfile.DiscountCodeLabel));
                    }
                }
                else
                {
                    errorMessages.Add(string.Format("The {0} you entered is not currently active", registration.EventProfile.DiscountCodeLabel));
                }
            }
            else
            {
                errorMessages.Add(string.Format("The {0} you entered is not valid for this event", registration.EventProfile.DiscountCodeLabel));
            }
        }
        else
        {
            registrant.DiscountCodeApplied = -1;
            registrant.DiscountCodePercentage = 0;
        }
    }
}

After refactoring (with the same behavior):

private void GetDiscountCode(Registration registration, Registrant registrant)
{
    if (!registration.EventProfile.DiscountCodesEnabled ||
        registration.EventProfile.DiscountCodes.Count == 0)
        return;

    string codeText = tbDiscountCode.Text.Trim();
    if (codeText == string.Empty)
    {
        registrant.DiscountCodeApplied = -1;
        registrant.DiscountCodePercentage = 0;
        registrant.DiscountCodeAmountPerLineItem = 0;
        return;
    }

    DiscountCode discountCode = registration.EventProfile.DiscountCodes.Find(codeText);
    if (discountCode == null)
    {
        errorMessages.Add(string.Format("The {0} you entered is not valid for this event",
            registration.EventProfile.DiscountCodeLabel));
        return;
    }

    if (!discountCode.Active)
    {
        errorMessages.Add(string.Format("The {0} you entered is no longer available",
            registration.EventProfile.DiscountCodeLabel));
        return;
    }

    if (discountCode.Limited && (discountCode.DiscountsUsed >= discountCode.MaximumAllowed))
    {
        errorMessages.Add(string.Format("The {0} you entered is no longer available",
            registration.EventProfile.DiscountCodeLabel));
        return;
    }

    if (registrant.DiscountCodeApplied != discountCode.DiscountCodeId)
    {
        if (registrant.DiscountCodePercentage <= discountCode.DiscountPercentage)
        {
            registrant.DiscountCodeApplied = discountCode.DiscountCodeId;
            registrant.DiscountCodePercentage = discountCode.DiscountPercentage;
            registrant.DiscountCodeAmountPerLineItem = discountCode.DiscountAmount;
        }
    }
}

I tend to think the refactored code is easier to read and maintain.