TCP client and server API

Question

I made a server and client API for TCP connection. It is intended to shorten the work you need to do to prepare the server and client.

It's separated into 3 projects - TCPServer, TCPClient, Common.

I've made an extended tcpclient type IdentifiableTcpClient, allowing for various modifications, the base additions are a Name and an ID. The class implements IComponentConsumer which allows for components based system to be created, further extending the flexibility of the client. There is also a DTO type used for serialization to pass through the network IdentifiableTcpClientDTO.

All components are required to inherit a marker interface IComponent.

IComponent

public interface IComponent
{

}

IComponentConsumer

public interface IComponentConsumer
{
    IComponentConsumer AddComponent<T>(T component) where T : class, IComponent;
    T GetComponent<T>() where T : class, IComponent;
}

IdentifiableTcpClient

public class IdentifiableTcpClient : IEquatable<IdentifiableTcpClient>, IComponentConsumer, ICloneable
{
    private readonly Dictionary<Type, IComponent> _components = new Dictionary<Type, IComponent>();

    private readonly Guid _internalID;

    public string Name { get; set; }

    public TcpClient TcpClient { get; }

    public IdentifiableTcpClient(TcpClient tcpClient, string name)
        : this(tcpClient, name, Guid.NewGuid())
    {
    }

    public IdentifiableTcpClient(TcpClient tcpClient)
        : this(tcpClient, Environment.UserName)
    {
    }

    //Used for cloning
    private IdentifiableTcpClient(TcpClient tcpClient, string name, Guid internalID)
    {
        _internalID = internalID;
        TcpClient = tcpClient;
        Name = name;
    }

    public bool Equals(IdentifiableTcpClient other)
    {
        if (ReferenceEquals(null, other)) return false;
        if (ReferenceEquals(this, other)) return true;
        return _internalID.Equals(other._internalID);
    }

    public override bool Equals(object obj)
    {
        return obj is IdentifiableTcpClient client && Equals(client);
    }

    public override int GetHashCode()
    {
        return _internalID.GetHashCode();
    }

    public object Clone()
    {
        return new IdentifiableTcpClient(TcpClient, Name, _internalID);
    }

    public IComponentConsumer AddComponent<T>(T component)
        where T : class, IComponent
    {
        var type = typeof(T);
        if (_components.ContainsKey(type))
        {
            _components[type] = component;
        }
        else
        {
            _components.Add(type, component);
        }

        return this;

    }

    public T GetComponent<T>()
        where T : class, IComponent
    {
        if (_components.TryGetValue(typeof(T), out var component))
        {
            return (T)component;
        }

        return null;
    }
}

IdentifiableTcpClientDTO

[Serializable]
public class IdentifiableTcpClientDTO
{
    public string Name { get; set; }
    public int HashCode { get; set; }

    public IdentifiableTcpClientDTO(IdentifiableTcpClient client)
    {
        Name = client.Name;
        HashCode = client.GetHashCode();
    }

    public IdentifiableTcpClientDTO()
    {
    }
}

There is also support for messages, commands and direct modifications on the client:

Message

public enum MessageType
{
    Message,
    Command
}

[Serializable]
public class Message
{
    public IdentifiableTcpClientDTO SenderDTO { get; }
    public string Data { get; }
    public MessageType MessageType { get; }
    public IEnumerable<IModification<IdentifiableTcpClient>> Modifications { get; }

    public Message(IdentifiableTcpClientDTO senderDTO, string data, MessageType messageType,
        IEnumerable<IModification<IdentifiableTcpClient>> modifications)
    {
        SenderDTO = senderDTO;
        Data = data;
        MessageType = messageType;
        Modifications = modifications;
    }
}

Where Modifications are a couple of types allowing direct modifications to the client's properties/fields, they are not really relevant for this question so I will leave them at that.

Those messages are later serialized/deserialized by MessageSerializer

MessageSerializer

public static class MessageSerializer
{
    public static byte[] Serialize(Message message)
    {
        using (var memoryStream = new MemoryStream())
        {
            new BinaryFormatter().Serialize(memoryStream, message);
            return memoryStream.ToArray();
        }
    }

    public static Message Deserialize(byte[] messageData)
    {
        using (var memoryStream = new MemoryStream(messageData))
        {
            return (Message) new BinaryFormatter().Deserialize(memoryStream);
        }
    }
}

Moving on to the tcp server:

ClientDataEventArgs

public class ClientDataEventArgs
{
    public IdentifiableTcpClient Client { get; }
    public string Message { get; }

    public ClientDataEventArgs(IdentifiableTcpClient client, string message)
    {
        Client = client;
        Message = message;
    }
}

TCPServerMain

public class TCPServerMain
{
    public event EventHandler<IdentifiableTcpClient> ClientConnected;
    public event EventHandler<IdentifiableTcpClient> ClientDisconnected;
    public event EventHandler<ClientDataEventArgs> ClientDataReceived;

    public TimeSpan DisconnectInterval { get; set; } = TimeSpan.FromMilliseconds(100);

    public IdentifiableTcpClientDTO Identity => SharedConfiguration.ServerIdentity;

    private static readonly object _padlock = new object();

    private readonly Timer _disconnectTimer;

    public HashSet<IdentifiableTcpClient> Clients { get; } = new HashSet<IdentifiableTcpClient>();

    public TCPServerMain()
    {
        _disconnectTimer = new Timer(
            callback: DisconnectTimerCallback,
            state: null,
            dueTime: (int) DisconnectInterval.TotalMilliseconds,
            period: (int) DisconnectInterval.TotalMilliseconds);

        var localAdd = IPAddress.Parse(ConfigurationResources.IPAdress);
        var listener = new TcpListener(localAdd, int.Parse(ConfigurationResources.PortNumber));
        listener.Start();
        listener.BeginAcceptTcpClient(ClientConnectedCallback, listener);
    }

    private void DisconnectTimerCallback(object state)
    {
        lock (_padlock)
        {
            var faultedClients = new HashSet<IdentifiableTcpClient>();
            foreach (var tcpClient in Clients)
            {
                if (!tcpClient.TcpClient.Client.IsConnected())
                {
                    faultedClients.Add(tcpClient);
                }
            }

            foreach (var tcpClient in faultedClients)
            {
                OnDisconnectedClient(tcpClient);
            }
        }
    }

    private void ClientConnectedCallback(IAsyncResult ar)
    {
        lock (_padlock)
        {
            var listener = (TcpListener) ar.AsyncState;
            try
            {
                var client = new IdentifiableTcpClient(listener.EndAcceptTcpClient(ar));
                OnClientConnected(client);

                BeginReadClientDataCallback(client);
            }
            catch (Exception e)
            {
                Console.WriteLine(e);
            }
            finally
            {
                listener.BeginAcceptTcpClient(ClientConnectedCallback, listener);
            }
        }
    }

    private void BeginReadClientDataCallback(IdentifiableTcpClient client)
    {
        var buffer = new byte[client.TcpClient.ReceiveBufferSize];
        try
        {
            client.TcpClient.GetStream().BeginRead(buffer, 0, client.TcpClient.ReceiveBufferSize,
                ar => ClientDataReceivedCallback(buffer, ar), client);
        }
        catch (InvalidOperationException e)
        {
            OnDisconnectedClient(client);
            Console.WriteLine(e);
        }
    }

    private void ClientDataReceivedCallback(byte[] buffer, IAsyncResult ar)
    {
        var client = (IdentifiableTcpClient)ar.AsyncState;
        try
        {
            var clientStream = client.TcpClient.GetStream();
            var bytesRead = clientStream.EndRead(ar);
            if (bytesRead == 0)
            {
                return;
            }

            var data = Encoding.GetEncoding("Windows-1251").GetString(buffer, 0, bytesRead);

            OnClientDataReceived(client, data);
        }
        catch (InvalidOperationException)
        {
        }
        catch (IOException e)
        {
            if (!(e.InnerException is SocketException))
            {
                throw;
            }
        }
        finally
        {
            BeginReadClientDataCallback(client);
        }
    }

    private void OnClientConnected(IdentifiableTcpClient client)
    {
        Clients.Add(client);
        ClientConnected?.Invoke(this, client);
    }

    private void OnClientDataReceived(IdentifiableTcpClient client, string message)
    {
        ClientDataReceived?.Invoke(this, new ClientDataEventArgs(client, message));
    }

    private void OnDisconnectedClient(IdentifiableTcpClient client)
    {
        Clients.Remove(client);
        ClientDisconnected?.Invoke(this, client);
    }
}

TCPClientMain

public class TCPClientMain
{
    public event EventHandler<string> ServerDataReceived;

    private readonly IdentifiableTcpClient _currentClient;

    public IdentifiableTcpClientDTO Identity => new IdentifiableTcpClientDTO(_currentClient);

    public TCPClientMain(string serverIP, int portNumber)
    {
        _currentClient = new IdentifiableTcpClient(new TcpClient(serverIP, portNumber));
    }

    public TCPClientMain()
        : this(ConfigurationResources.IPAdress, int.Parse(ConfigurationResources.PortNumber))
    {

    }

    public void SendMessageToServer(string message)
    {
        var bytesToSend = Encoding.GetEncoding("Windows-1251").GetBytes(message);

        _currentClient.TcpClient.GetStream().Write(bytesToSend, 0, bytesToSend.Length);
    }

    public void BeginReadDataFromServer()
    {
        BeginReadServerDataCallback(_currentClient);
    }

    private void BeginReadServerDataCallback(IdentifiableTcpClient client)
    {
        var buffer = new byte[client.TcpClient.ReceiveBufferSize];
        client.TcpClient.GetStream().BeginRead(buffer, 0, client.TcpClient.ReceiveBufferSize,
            ar => ClientDataReceivedCallback(buffer, ar), client);
    }

    private void ClientDataReceivedCallback(byte[] buffer, IAsyncResult ar)
    {
        var client = (IdentifiableTcpClient) ar.AsyncState;
        var clientStream = client.TcpClient.GetStream();
        var bytesRead = clientStream.EndRead(ar);
        if (bytesRead == 0)
        {
            return; //disconnected
        }

        var message = MessageSerializer.Deserialize(buffer);

        ProcessMessageFromServer(client, message);
        BeginReadServerDataCallback(client);
    }

    private void ProcessMessageFromServer(IdentifiableTcpClient client, Message message)
    {
        if (message.MessageType == MessageType.Message)
        {
            OnServerDataReceived(message.SenderDTO, message.Data);
        }
        else
        {
            foreach (var modification in message.Modifications)
            {
                modification.Modify(client);
            }
        }
    }

    private void OnServerDataReceived(IdentifiableTcpClientDTO sender, string message)
    {
        ServerDataReceived?.Invoke(sender, message);
    }
}

A couple of helper classes:

SharedConfiguration

public static class SharedConfiguration
{
    public static IdentifiableTcpClientDTO ServerIdentity { get; }

    static SharedConfiguration()
    {
        ServerIdentity = new IdentifiableTcpClientDTO { HashCode = -1, Name = "SERVER" };
    }
}

SocketExtensions

public static class SocketExtensions
{
    public static bool IsConnected(this Socket socket)
    {
        try
        {
            return !(socket.Poll(1, SelectMode.SelectRead) && socket.Available == 0);
        }
        catch (SocketException) { return false; }
    }
}

This is my first TCP/IP client/server implementation so it's more than likely I've made some rookie mistakes and that's what I'd like the focus to be on. Code-style and optimizations are of course welcome, especially the latter, since it's pretty important.

Answer 1

I don't understand the point of the IComponent / IComponentConsumer stuff. Nothing else in the large section of code you've posted uses them. Are you sure they're at the right layer?

Also, with IComponentConsumer, I think the code falls into the trap of extending when it should compose. It seems to me that every class which implements the interface will have the same implementation, so you should probably replace the interface with a sealed class which implements the same API and compose that into whatever classes actually use the functionality.

---

    public override bool Equals(object obj)
    {
        return obj is IdentifiableTcpClient client && Equals(client);
    }

I have a slight preference for

    public override bool Equals(object obj) => Equals(client as IdentifiableTcpClient);

---

I am confused about Message. As I read it, the client sends plain strings to the server, and the server sends Message instances back to the client. So why does Message have a property public IdentifiableTcpClientDTO SenderDTO { get; }? The sender is a server, not a client, and it should be clear from context who sent the message so it shouldn't need to be transmitted across the network.

---

public class ClientDataEventArgs

It's conventional that XYZEventArgs should extend EventArgs.

---

    public HashSet<IdentifiableTcpClient> Clients { get; } = new HashSet<IdentifiableTcpClient>();

It's normally a bad idea to make a mutable collection of your state publicly available. Are you sure you don't want to have a private mutable set and make available a readonly view of it?

---

        lock (_padlock)
        {
            ...

            foreach (var tcpClient in faultedClients)
            {
                OnDisconnectedClient(tcpClient);
            }
        }

Invoking callbacks while holding a lock is potentially a source of pain in the future. I would consider refactoring so that you modify the set while holding the lock and invoke the events after releasing it. That way any deadlock is entirely the fault of the invoking class.

---

            catch (Exception e)
            {
                Console.WriteLine(e);
            }

Consider using a more sophisticated logging library. Serilog, log4net, even TraceWriter.

---

The Encoding instance is probably worth caching in a static field. And I would suggest that since it's not 1990 any more you should prefer UTF-8 (without BOM, since UTF-8-BOM is a monstrosity).

---

        catch (InvalidOperationException)
        {
        }
        catch (IOException e)
        {
            if (!(e.InnerException is SocketException))
            {
                throw;
            }
        }

Silently swallowing exceptions is worrying. You should alleviate the worry by adding some comments to explain why these particular exceptions can be safely ignored.

---

The BeginFoo/EndFoo style is now legacy. In new code, I would suggest using Task (async/await) style asynchronous code, because that seems to be the preferred modern option.