Fleck Fun

ICommandInvoker.cs

public interface ICommandInvoker
{
    void InvokeFor(SocketMessage message);
}

public class CommandInvoker : ICommandInvoker
{
    public void InvokeFor(SocketMessage message)
    {
        //no-op..just an example
    }
}

IJsonService.cs

public interface IJsonService
{
    T Deserialize<T>(string source) where T : class;
    object Deserialize(Type type, string source);
    string Serialize(object message);
}

IMessageDispatcher.cs

public interface IMessageDispatcher
{
    void Dispatch(object message);
}

public class MessageDispatcher : IMessageDispatcher
{
    private readonly IJsonService _jsonService;
    private readonly ISocketProvider _socketProvider;

    public MessageDispatcher(IJsonService jsonService, ISocketProvider socketProvider)
    {
        _jsonService = jsonService;
        _socketProvider = socketProvider;
    }

    public void Dispatch(object message)
    {
        var socketMsg = new SocketMessage
                            {
                                Type = message.GetType().Name,
                                Message = _jsonService.Serialize(message)
                            };

        _socketProvider.Send(_jsonService.Serialize(socketMsg));
    }
}

ISocketMessageDeserializer.cs

public interface ISocketMessageDeserializer
{
    object Deserialize(SocketMessage message);
}

public class SocketMessageDeserializer : ISocketMessageDeserializer
{
    private readonly DefaultSocketMessageParser _defaultParser;
    private readonly IEnumerable<ISocketMessageParser> _parsers;

    public SocketMessageDeserializer(DefaultSocketMessageParser defaultParser, IEnumerable<ISocketMessageParser> parsers)
    {
        _defaultParser = defaultParser;
        _parsers = parsers;
    }

    public object Deserialize(SocketMessage message)
    {
        var type = message.Type;
        if (!type.ToLower().EndsWith("command"))
        {
            type = "{0}Command".ToFormat(type);
        }

        var messageType = Type.GetType("{0}.{1}, {2}".ToFormat(typeof(CommandBase).Namespace, type,
            typeof(CommandBase).Assembly.FullName), false, true);

        var parser = _parsers.LastOrDefault(p => p.AppliesTo(message)) ?? _defaultParser;
        return parser.Parse(messageType, message);
    }
}

ISocketMessageParser.cs

public interface ISocketMessageParser
{
    bool AppliesTo(SocketMessage message);
    object Parse(Type type, SocketMessage message);
}

public class DefaultSocketMessageParser : ISocketMessageParser
{
    private readonly IJsonService _jsonService;

    public DefaultSocketMessageParser(IJsonService jsonService)
    {
        _jsonService = jsonService;
    }

    public bool AppliesTo(SocketMessage message)
    {
        return true;
    }

    public object Parse(Type type, SocketMessage message)
    {
        return _jsonService.Deserialize(type, message.Message);
    }
}

ISocketProvider.cs

public interface ISocketProvider
{
    void Send(string message);
    void Listen();
}

SocketMessage.cs

public class SocketMessage
{
    public string Type { get; set; }
    public string Version { get; set; }
    public string Message { get; set; }
}

SocketProvider.cs

public class SocketProvider : ISocketProvider
{
    private readonly IJsonService _jsonService;
    private readonly ICommandInvoker _commandInvoker;
    private readonly IList<IWebSocketConnection> _connections = new List<IWebSocketConnection>();

    public SocketProvider(WebSocketServer server, IJsonService jsonService, ICommandInvoker commandInvoker)
    {
        Configure(server);
        _jsonService = jsonService;
        _commandInvoker = commandInvoker;
    }

    public void Configure(WebSocketServer server)
    {
        server.Start(socket =>
        {
            socket.OnOpen = () => _connections.Add(socket);
            socket.OnClose = () => _connections.Remove(socket);
            socket.OnMessage = (m =>
            {
                var msg = _jsonService.Deserialize<SocketMessage>(m);
                _commandInvoker.InvokeFor(msg);
            });
        });
    }

    public void Listen()
    {
        // this is here for semantics. We need to move the configure stuff into here
    }

    public void Send(string message)
    {
        _connections
            .ToList()
            .Each(socket => socket.Send(message));
    }
}