title: TCP Server to Client
body: <p>I have made a connection between server and client, the client send data to the server and receive a response, but i wanna send data from the server to client and receive the response from client to server, is it possible ? Here is my code :
  [Client] :</p>
  
  <pre><code>using System;
  using System.Collections.Generic;
  using System.Linq;
  using System.Net.Sockets;
  using System.Net;
  using System.Text;
  using System.Threading.Tasks;
  using System.Threading;
  
  namespace Multi_Client
  {
      class Program
      {
          private static Socket _clientSocket = new Socket
              (AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
  
          static void Main(string[] args)
          {
              Console.Title = "Client";
              ConnectToServer();
              RequestLoop();
              Exit();
          }
  
          private static void ConnectToServer()
          {
              int attempts = 0;
  
              while (!_clientSocket.Connected)
              {
                  try
                  {
                      attempts++;
                      Console.WriteLine("Connection attempt " + attempts);
                      _clientSocket.Connect(IPAddress.Loopback, 100);
                  }
                  catch (SocketException)
                  {
                      Console.Clear();
                  }
              }
  
              Console.Clear();
              Console.WriteLine("Connected");
              _clientSocket.Send(Encoding.ASCII.GetBytes("C1"));
          }
  
          private static void RequestLoop()
          {
              Console.WriteLine(@"&lt;Type ""exit"" to properly disconnect client&gt;");
  
              SendRequest();
              ReceiveResponse();
  
          }
  
          /// &lt;summary&gt;
          /// Close socket and exit app
          /// &lt;/summary&gt;
          private static void Exit()
          {
              SendString("exit"); // Tell the server we re exiting
              _clientSocket.Shutdown(SocketShutdown.Both);
              _clientSocket.Close();
              Environment.Exit(0);
          }
  
          private static void SendRequest()
          {
              Console.Write("Send a request: ");
              string request = Console.ReadLine();
              SendString(request);
  
              if (request.ToLower() == "exit")
              {
                  Exit();
                  return;
              }
          }
  
          private static void SendString(string text)
          {
              byte[] buffer = Encoding.ASCII.GetBytes(text);
              _clientSocket.Send(buffer, 0, buffer.Length, SocketFlags.None);
          }
  
          private static void ReceiveResponse()
          {
              byte[] buffer = new byte[2048];
              int received = _clientSocket.Receive(buffer, SocketFlags.None);
  
              if (received == 0) return;
  
              byte[] data = new byte[received];
              Array.Copy(buffer, data, received);
              string text = Encoding.ASCII.GetString(data);
              Console.WriteLine(text);
          }
      }
  }
  </code></pre>
  
  <p>[Server] :</p>
  
  <pre><code>using System;
  using System.Collections.Generic;
  using System.ComponentModel;
  using System.Data;
  using System.Drawing;
  using System.Linq;
  using System.Text;
  using System.Windows.Forms;
  using System.Threading;
  using System.Net;
  using System.IO;
  using NetworkCommsDotNet;
  using System.Net.Sockets;
  
  namespace Server
  {
      public partial class Form1 : Form
      {
          public Form1()
          {
              InitializeComponent();
          }
          private static Socket _serverSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
          private static List&lt;Socket&gt; _clientSockets = new List&lt;Socket&gt;();
          private static readonly int _BUFFER_SIZE = 2048;
          private static byte[] _buffer = new byte[_BUFFER_SIZE];
          string text;
          Socket current;
          Socket test;
          delegate void SetTextCallback(string text);
  
          private void SetText(string text)
          {
              // InvokeRequired required compares the thread ID of the
              // calling thread to the thread ID of the creating thread.
              // If these threads are different, it returns true.
              if (this.richTextBox1.InvokeRequired)
              {
                  SetTextCallback d = new SetTextCallback(SetText);
                  this.Invoke(d, new object[] { text });
              }
              else
              {
                  this.richTextBox1.Text += text + "\n";
              }
          }
          private void SetupServer()
          {
              SetText("Setting up server...");
              _serverSocket.Bind(new IPEndPoint(IPAddress.Any, 100));
              _serverSocket.Listen(5);
              _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null);
              SetText("Server Setup");
          }
  
          /// &lt;summary&gt;
          /// Close all connected client (we do not need to shutdown the server socket as its connections
          /// are already closed with the clients)
          /// &lt;/summary&gt;
          private static void CloseAllSockets()
          {
              foreach (Socket socket in _clientSockets)
              {
                  socket.Shutdown(SocketShutdown.Both);
                  socket.Close();
              }
  
              _serverSocket.Close();
          }
  
          private void AcceptCallback(IAsyncResult AR)
          {
              Socket socket = null;
  
              try
              {
                  socket = _serverSocket.EndAccept(AR);
              }
              catch (ObjectDisposedException) // I cannot seem to avoid this (on exit when properly closing sockets)
              {
                  return;
              }
  
              _clientSockets.Add(socket);
              socket.BeginReceive(_buffer, 0, _BUFFER_SIZE, SocketFlags.None, new AsyncCallback(ReceiveCallback), socket);
              SetText("Client connected, waiting for request...");
              test = (Socket)AR.AsyncState;
              _serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), null);
          }
          private void ReceiveCallback(IAsyncResult AR)
          {
              current = (Socket)AR.AsyncState;
              int received = 0;
  
              try
              {
                  received = current.EndReceive(AR);
              }
              catch (SocketException)
              {
                  SetText("Client forcefully disconnected");
                  current.Close(); // Dont shutdown because the socket may be disposed and its disconnected anyway
                  _clientSockets.Remove(current);
                  return;
              }
  
              byte[] recBuf = new byte[received];
              Array.Copy(_buffer, recBuf, received);
              text = Encoding.ASCII.GetString(recBuf);
              SetText("Received Text: " + text);
              if (text.ToLower() == "get tim") // Client requested time
              {
                  SetText("Text is a get time request");
                  byte[] data = Encoding.ASCII.GetBytes(DateTime.Now.ToLongTimeString());
                  current.Send(data);
                  SetText("Time sent to client");
              }
              else if (text.ToString() == "C1") // Client wants to exit gracefully
              {
                  SetText("Received :: C1");
                  byte[] data = Encoding.ASCII.GetBytes(DateTime.Now.ToLongTimeString());
                  current.Send(data);
              }
  
              else
              {
                  SetText("Server is sending invalid packet");
                  SetText("Warning Sent");
              }
              current.BeginReceive(_buffer, 0, _BUFFER_SIZE, SocketFlags.None, new AsyncCallback(ReceiveCallback), current);
          }
  
          private void Form1_Load(object sender, EventArgs e)
          {
              SetupServer();
          }
          private void Send_Received(string mess)
          {
              byte[] data = Encoding.ASCII.GetBytes(mess);
              test.Send(data);
          }
          private void button2_Click(object sender, EventArgs e)
          {
              CloseAllSockets();
          }
  
          private void button1_Click(object sender, EventArgs e)
          {
              Send_Received(textBox1.Text);
          }
  
  
      }
  }
  </code></pre>