How to close the continues reading of port when server OFF

Mann Maurya

7y942Learn iOS Programming

public void TcpListener()

{

// set the TcpListener on port 1080

int port = 1080;

TcpListener server = new TcpListener(IPAddress.Any, port);

try

{

while (true)

{

Console.Write("Waiting for a connection... ");

// Start listening for client requests

server.Start();

client = server.AcceptTcpClient();

Console.WriteLine("Connected!");

NetworkStream stream = client.GetStream();

int i;

i = stream.Read(bytes, 0, bytes.Length);

while(i != 0)

{

data = System.Text.Encoding.Default.GetString(bytes, 0, i);

Console.WriteLine(String.Format("Received: {0}", data));

hexString = "0800630003000000006301";

HexString2Ascii(hexString);

msgSend = System.Text.Encoding.ASCII.GetBytes(Send);

stream.Write(msgSend, 0, msgSend.Length);

Console.WriteLine(String.Format("Sent: {0}", data));

i = stream.Read(bytes, 0, bytes.Length);

}

client.Close();

}

catch (SocketException e)

{

Console.WriteLine("SocketException: {0}", e);

}

finally

{

server.Stop();

}

I want that port should always be in listening mode (achieved).

but when server pc shutdown or software closed, because of port is continue in listening mode it throws an error.

Line : i = stream.Read(bytes, 0, bytes.Length);

Error : Unable to read data from the transport connection: An existing connection was forcibly closed by the remote host.

basically I just want how to stop port from listening when software closed or Sever PC Shutdown , also in a listening mode when the Server pc working fine.

2 Replies

Know the answer? Post it — somebody with the same question will find it here.

Mario Scheeren7y ago
Accepted answer
Looks like you have no clue about asynchronous networking and such nor OOP ...

Not knowing what Framework you use this should be compatible with Framework 2.0 - 4.7.2
public class MyTCPServer
{
    public delegate void NewTcpClient_Handler(object sender, MyClient client);
    public event NewTcpClient_Handler NewTcpClient;

    TcpListener _Listener = null;
    int _Port;

    public MyTCPServer(int port = 1080)
    {
        _Port = port;
    }

    public void Start()
    {
        if (_Listener != null)
        {
            Stop();
        }
        _Listener = new TcpListener(IPAddress.Any, _Port);
        _Listener.Start();
        _Listener.BeginAcceptTcpClient(new AsyncCallback(NewClientConnection), null);
    }

    public void Stop()
    {
        if (_Listener != null)
        {
            try
            {
                _Listener.Stop();
            }
            catch { }
            finally
            {
                _Listener = null;
            }
        }
    }

    private void NewClientConnection(IAsyncResult ar)
    {
        try
        {
            var client = _Listener.EndAcceptTcpClient(ar);

            _Listener.BeginAcceptTcpClient(new AsyncCallback(NewClientConnection), null);

            NewTcpClient?.Invoke(this, new MyClient(client));
        }
        catch (ObjectDisposedException)
        {
            // happens on _listener.Stop()
        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine(ex.Message);
        }
    }
}

public class MyClient
{
    public delegate void DataReceived_Handler(object sender, string data);
    public event DataReceived_Handler DataReceived;

    TcpClient _Client;
    NetworkStream _Stream;
    byte[] buffer = new byte[1024 * 1024];

    public MyClient(TcpClient client)
    {
        _Client = client;
        _Stream = _Client.GetStream();

        _Stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(ReadCallback), null);
    }

    public void Send(string data)
    {
        try
        {
            byte[] bData = Encoding.Default.GetBytes(data);
            _Stream.Write(bData, 0, bData.Length);
        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine(ex.Message);
        }
    }

    private void ReadCallback(IAsyncResult ar)
    {
        try
        {
            int readBytes = _Stream.EndRead(ar);

            string data = Encoding.Default.GetString(buffer, 0, readBytes);
            DataReceived?.Invoke(this, data);

            _Stream.BeginRead(buffer, 0, buffer.Length, new AsyncCallback(ReadCallback), null);
        }
        catch (Exception ex)
        {
            System.Diagnostics.Debug.WriteLine(ex.Message);
        }
    }
}
+2
Mann Maurya7y ago
Thanks for the reply Mario Scheeren

Can i get to know more about asynchronous networking Like how i suppose to implement in my code

once again thanks for your reply
0