Question

I’m trying to design a client / server solution. Currently it contains three projects. The client, the server, and a library that each use (because they both require a lot of the same stuff).

For example, both the client and the server (in this case) read incoming data in the exact same way. Because of this, both the client and the server have their own MessageReader object. The MessageReader will first read the first 4 bytes of incoming stream data to determine the length of the data and then read the rest. This is all performed asynchronously. When all the data is read the class raises its own MessageRead event or if there was an IOException while reading it raises its own ConnectionLost event.

So this all works fine. What’s the problem? Well, the client and the server are a bit different. For example, while they may read data in the same way, they do not write data in the same way. The server has a Dictionary of clients and has a Broadcast method to write to all clients. The client only has a single TcpClient and can only Write to the server. Currently all this behavior is within each respective WinForm and I want to move it to a Client and Server class but I’m having some problems.

For example, remember earlier when I was talking about the MessageReader and how it can raise both a MessageRead event and a ConnectionLost event? Well, now there’s a bit of a problem because in designing the Client class I have to capture these two events and re-raise them because the client form should not have access to the MessageReader class. It’s a bit ugly and looks like this:

class Client
{
    private MessageReader messageReader = new MessageReader();

    public delegate void MessageReceivedHandler(string message);
    public delegate void ConnectionLostHandler(string message);

    public event ConnectionLostHandler ConnectionLost;
    public event MessageReceivedHandler MessageReceived;

    public Client()
    {
        messageReader.ConnectionLost += messageReader_ConnectionLost;
        messageReader.MessageReceived += messageReader_MessageReceived;
    }

    private void messageReader_MessageReceived(string message)
    {
        if (ConnectionLost != null)
        {
            ConnectionLost(message);
        }
    }

    private void messageReader_ConnectionLost(string message)
    {
        if (MessageReceived != null)
        {
            MessageReceived(message);
        }
    }
}

This code is ugly because its basically duplicate code. When the MessageReader raises the MessageReceieved handler the Client has to capture it and basically re-raise its own version (duplicate code) because the client form should not have access to the message reader.

Not really of a good way to solve it. I suppose both Client and Server could derive from an abstract DataReader but I don’t think a client is a data reader, nor is the server. I feel like composition makes more logical sense but I can’t figure out a way to do this without a lot of code duplication and confusing event handlers.

Ouch, this question is getting a bit long.. I hope I don’t scare anyone away with the length. It’s probably a simple question but I’m not really sure what to do.

Thanks for reading.

Answer 1

I ended up using inheritance for this even though the relationship wasn’t strong. The code duplication it got rid of was worth it. Was able to place all the events both classes shared in to the base class.