Simple TCP/IP Echo Server & Client Application in C#

1. TCP Server

The server’s job is to set up an endpoint for clients to connect to and passively wait for connections.

The typical TCP server goes through two steps:

1. Construct a TcpListener instance, specifying the local address and port, and call the Start() method.

This socket listens for incoming connections on the specified port.

2. Repeatedly:
■ Call the AcceptTcpClient() method of TcpListener to get the next incoming
   client connection. Upon establishment of a new client connection, an instance of
   TcpClient for the new connection is created and returned by the AcceptTcp-
   Client() call.
■ Communicate with the client using the Read() and Write() methods of TcpClient’s
   NetworkStream.
■ Close the new client socket connection and stream using the Close() methods of
   NetworkStream and TcpClient.

TcpEchoServer.cs

using System; // For Console, Int32, ArgumentException, Environment
using System.Net; // For IPAddress
using System.Net.Sockets; // For TcpListener, TcpClient

class TcpEchoServer
{
    private const int BUFSIZE = ; // Size of receive buffer

    static void Main(string[] args)
    {
        if (args.Length > ) // Test for correct # of args
            throw new ArgumentException("Parameters: [<Port>]");

        int servPort = (args.Length == ) ? Int32.Parse(args[]): ;

        TcpListener listener = null;

        try
        {
            // Create a TCPListener to accept client connections
            listener = new TcpListener(IPAddress.Any, servPort);
            listener.Start();
        }
        catch (SocketException se)
        {
            Console.WriteLine(se.ErrorCode + ": " + se.Message);
            Environment.Exit(se.ErrorCode);
        }

        byte[] rcvBuffer = new byte[BUFSIZE]; // Receive buffer
        int bytesRcvd; // Received byte count

        for (;;)
        {
            // Run forever, accepting and servicing connections
            TcpClient client = null;
            NetworkStream netStream = null;
            try
            {
                client = listener.AcceptTcpClient(); // Get client connection
                netStream = client.GetStream();
                Console.Write("Handling client - ");

                // Receive until client closes connection, indicated by 0 return value
                int totalBytesEchoed = ;
                while ((bytesRcvd = netStream.Read(rcvBuffer, , rcvBuffer.Length)) > )
                {
                    netStream.Write(rcvBuffer, , bytesRcvd);
                    totalBytesEchoed += bytesRcvd;
                }
                Console.WriteLine("echoed {0} bytes.", totalBytesEchoed);

                // Close the stream and socket. We are done with this client!
                netStream.Close();
                client.Close();
            }
            catch (Exception e)
            {
                Console.WriteLine(e.Message);
                netStream.Close();
            }
        }
    }
}

The TcpListener listens for client connection requests on the port specified in the constructor.

Be careful to use a port that is not in use by another application, or a SocketException will be thrown.

Loop forever, iteratively handling incoming connections.

Receive and repeat data until the client closes.

Close the client stream and socket.

TcpEchoClient.cs

using System; // For String, Int32, Console, ArgumentException
using System.Text; // For Encoding
using System.IO; // For IOException
using System.Net.Sockets; // For TcpClient, NetworkStream, SocketException

class TcpEchoClient
{
    static void Main(string[] args)
    {
        if ((args.Length < ) || (args.Length > ))
        {
            // Test for correct # of args
            throw new ArgumentException("Parameters: <Server> <Word> [<Port>]");
        }

        String server = args[]; // Server name or IP address

        // Convert input String to bytes
        byte[] byteBuffer = Encoding.ASCII.GetBytes(args[]);

        // Use port argument if supplied, otherwise default to 7
        int servPort = (args.Length == ) ? Int32.Parse(args[]) : ;

        TcpClient client = null;
        NetworkStream netStream = null;

        try
        {
            // Create socket that is connected to server on specified port
            client = new TcpClient(server, servPort);
            Console.WriteLine("Connected to server... sending echo string");
            netStream = client.GetStream();

            // Send the encoded string to the server
            netStream.Write(byteBuffer, , byteBuffer.Length);
            Console.WriteLine("Sent {0} bytes to server...", byteBuffer.Length);
            int totalBytesRcvd = ; // Total bytes received so far
            int bytesRcvd = ; // Bytes received in last read

            // Receive the same string back from the server
            while (totalBytesRcvd < byteBuffer.Length)
            {
                if ((bytesRcvd = netStream.Read(byteBuffer, totalBytesRcvd, byteBuffer.Length - totalBytesRcvd)) == )
                {
                    Console.WriteLine("Connection closed prematurely.");
                    break;
                }
                totalBytesRcvd += bytesRcvd;
            }
            Console.WriteLine("Received {0} bytes from server: {1}", totalBytesRcvd,
            Encoding.ASCII.GetString(byteBuffer, , totalBytesRcvd));
        }
        catch (Exception e)
        {
            Console.WriteLine(e.Message);
        }
        finally
        {
            netStream.Close();
            client.Close();
        }
    }
}