C# SocketException Can not connect because the target machine has actively declined the connection

Question

I'm trying to write a chat client/server in c# locally to get familiar with Sockets.

First I start the server with (very simplified) following code:

Server.cs

    private readonly MessageManager _messageManager;
    private readonly ChatServer _chatServer;

    public ChatServerSkeleton()
    {
        _messageManager = new MessageManager();
        _chatServer = new ChatServer();
        Console.WriteLine("Server is running on: " + _messageManager.MyAddress);
    }

Then I start the Client with +- same way, except I store the serveraddress in the client (I copied the server address into a prompt).

Client.cs

    private readonly MessageManager _messageManager;
    public ChatClient ChatClient { get; }

    public ChatClientSkeleton(IPEndPoint serverAddress, string name)
    {
        _messageManager = new MessageManager();
        ChatClient = new ChatClient(new ChatServerStub(serverAddress, _messageManager), name);

        Console.WriteLine($"IPAddress of {name} is: {_messageManager.MyAddress}");
        Console.WriteLine($"IPAddress of Server is: { serverAddress}");
    }

MessageManager.cs

    private readonly TcpListener _serverSocket;
    public IPEndPoint MyAddress { get; }

    public MessageManager()
    {
        try
        {
            //Create server socket on random port
            _serverSocket = new TcpListener(IPAddress.Any, FindFreeTcpPort());

            //Get host ip address
            IPAddress[] localIps = Dns.GetHostAddresses(Dns.GetHostName());
            IPAddress localhost = localIps.First(ip => ip.AddressFamily == AddressFamily.InterNetwork);

            //Get port of serversocket
            IPEndPoint ipEndPoint = _serverSocket.LocalEndpoint as IPEndPoint;
            int port = ipEndPoint.Port;

            //Create address
            MyAddress = new IPEndPoint(localhost, port);
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine("Something went wrong with the serversocket:");
            Console.Error.WriteLine(ex);
        } 
    }

FindFreeTcp port comes from here: https://stackoverflow.com/a/150974/5985593

Everything up till now seems to work. Let's say for example the server has now 192.168.0.219:51080 and the client 192.168.0.219:51085.

The problem occurs when I'm trying to send a message using this code in MessageManager.cs

    public void Send(MethodCallMessage message, IPEndPoint address)
    {
        try
        {
            _serverSocket.Start();
            TcpClient destination = new TcpClient(address.Address.ToString(), address.Port);
            NetworkStream output = destination.GetStream();
            MessageReaderWriter.Write(message, output);
            destination.Close();
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine("Failed to write a message:");
            Console.Error.WriteLine(ex);
        }
        finally
        {
            _serverSocket.Stop();
        }
    }

More specific on the _server.Start(); line.

Anyone knows what I'm doing wrong?

Thanks in advance!

EDIT: it runs fine 1 time, when registering the client on the server. But after that if I want to send a message I get the SocketException where target machine actively refused.

I do use AcceptTcpClient() here:

MessageManager.cs

    public MethodCallMessage WReceive()
    {
        MethodCallMessage result = null;

        try
        {
            //_serverSocket.Start();
            TcpClient client = _serverSocket.AcceptTcpClient();
            NetworkStream input = new NetworkStream(client.Client, true);
            result = MessageReaderWriter.Read(input);
            client.Close();
        }
        catch (Exception ex)
        {
            Console.Error.WriteLine("Failed to receive a message:");
            Console.Error.WriteLine(ex);
        }
        finally
        {
            //_serverSocket.Stop();
        }

        return result;
    }

This method is used in the ServerSkeleton & ClientSkeleton as follows:

    public void Run()
    {
        while (true)
        {
            MethodCallMessage request = _messageManager.WReceive();
            HandleRequest(request);
        }
    }

So the flow is basically as follows:

1. I start the server (instantiate new messagemanager, 3rd snippet and run serverskeleton (last snippet)
2. Server prints IP in console, i copy the ip & start the client
3. Instantiate client & set server ip to what I copy pasted
4. Start client skeleton (last snippet)

Answer 1

A TcpListener that has called Start() listens for incoming connections and then stacks them on a queue. Once that queue is full then a socket exception results. To remove connections from the queue you need to use the AcceptTcpClient or AcceptSocket methods of TcpListener. This then gives you a connection that you can send and receive data on.

What I am guessing may be happening is that you receive your first incoming client, but dont accept and remove it to send and receive data on, and your subsequent connections are refused as the pending queue list is full (this is just a guess).

There is an overloaded method ... TcpListener.Start(int backlog) ... that allows you to set the size of the pending queue list (so you can have 5, 10 or more connections waiting to be accepted in the TcpListener)

With a server TCP socket the process is that you set it listening on a local address and a port. Clients then try to connect to that endpoint. When they connect the TCP listening socket accepts the connection and then passes that to a socket which is the socket on which data is transfered. The listening socket carries on listening for new connections, it doesnt itself transmit data.

I hope that makes sense ?

So the server would behave more like this ...

_serverSocket.Start();
TcpClient myAcceptedConnection = _serverSocket.AcceptTcpClient();
// in synchronous blocking socket situation the program flow halts 
// here til a connection is established
// once you have a connection ... do stuff with myAcceptedConnection

if you wished to avoid the blocking scenario you can use TcpListener.Pending() to see if you have any connections waiting in the queue

EDIT 1:

Ok so the only weird thing I see is that you call the _serverSocket.Start() method in the MessageSend method ? A server doesnt normally start by sending out a message ... it normally waits listening for a connection, receives and reads the connection and then replies (or it might send out a greeting or such on connection).

Personally I would separate the listening aspect of the server from the sending and receiving of data ... have it in its own separate method, after all you want your server to be listening for incoming connections until you close it down. When you detect an incoming connection (perhaps by checking Pending() in a loop), then you can accept it and send and receive on the new TcpClient. When you are finished with whatever data you are transmitting/receiving on that client you can close it down , if thats what you want ... you dont need to close and open a tcp connection every time you send a message, you can leave it open til you are finished with it, in fact opening and closing tcp connections generates a bit of overhead in the handshake protocol that they go through.

There are caveats though ... Tcp connections can become "half open" especially with wireless which can lead to issues. Its a bit complicated to get into here, but I recommend this stellar set of articles by Stephen Cleary as a good read through. Read the whole blog, as there is a ton of good info in there.

So, back to simple, I would have ...

1. A serverStart() method where you start your server listening.
2. A serverAccept() method where you check if you have any pending connections and accept them if they are there.
3. A clientConnect() method for your client where you connect to a server
4. Read() and Write() methods for the server and the client where you do the data transmission.

Normally the flow would be ...

1. Server Listens
2. Client Connects
3. Server Accepts
4. Client Sends
5. Server Receives
6. (then server sends/receives, client sends/receives)
7. everything closes and shuts down