Skip to content

Instantly share code, notes, and snippets.

@s0mprasong

s0mprasong/Client.cs

Forked from leandrosilva/Client.cs
Created September 23, 2021 13:56
Show Gist options
  • Save s0mprasong/86a7819e655d0792eb3ce08b47431771 to your computer and use it in GitHub Desktop.
Save s0mprasong/86a7819e655d0792eb3ce08b47431771 to your computer and use it in GitHub Desktop.
Download ZIP

Revisions

  1. @leandrosilva leandrosilva created this gist Oct 31, 2010.
    167 changes: 167 additions & 0 deletions Client.cs
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,167 @@
    // Asynchronous Client Socket Example
    // http://msdn.microsoft.com/en-us/library/bew39x2a.aspx

    using System;
    using System.Net;
    using System.Net.Sockets;
    using System.Threading;
    using System.Text;

    // State object for receiving data from remote device.
    public class StateObject {
    // Client socket.
    public Socket workSocket = null;
    // Size of receive buffer.
    public const int BufferSize = 256;
    // Receive buffer.
    public byte[] buffer = new byte[BufferSize];
    // Received data string.
    public StringBuilder sb = new StringBuilder();
    }

    public class AsynchronousClient {
    // The port number for the remote device.
    private const int port = 11000;

    // ManualResetEvent instances signal completion.
    private static ManualResetEvent connectDone =
    new ManualResetEvent(false);
    private static ManualResetEvent sendDone =
    new ManualResetEvent(false);
    private static ManualResetEvent receiveDone =
    new ManualResetEvent(false);

    // The response from the remote device.
    private static String response = String.Empty;

    private static void StartClient() {
    // Connect to a remote device.
    try {
    // Establish the remote endpoint for the socket.
    // The name of the
    // remote device is "host.contoso.com".
    IPHostEntry ipHostInfo = Dns.Resolve("host.contoso.com");
    IPAddress ipAddress = ipHostInfo.AddressList[0];
    IPEndPoint remoteEP = new IPEndPoint(ipAddress, port);

    // Create a TCP/IP socket.
    Socket client = new Socket(AddressFamily.InterNetwork,
    SocketType.Stream, ProtocolType.Tcp);

    // Connect to the remote endpoint.
    client.BeginConnect( remoteEP,
    new AsyncCallback(ConnectCallback), client);
    connectDone.WaitOne();

    // Send test data to the remote device.
    Send(client,"This is a test<EOF>");
    sendDone.WaitOne();

    // Receive the response from the remote device.
    Receive(client);
    receiveDone.WaitOne();

    // Write the response to the console.
    Console.WriteLine("Response received : {0}", response);

    // Release the socket.
    client.Shutdown(SocketShutdown.Both);
    client.Close();

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

    private static void ConnectCallback(IAsyncResult ar) {
    try {
    // Retrieve the socket from the state object.
    Socket client = (Socket) ar.AsyncState;

    // Complete the connection.
    client.EndConnect(ar);

    Console.WriteLine("Socket connected to {0}",
    client.RemoteEndPoint.ToString());

    // Signal that the connection has been made.
    connectDone.Set();
    } catch (Exception e) {
    Console.WriteLine(e.ToString());
    }
    }

    private static void Receive(Socket client) {
    try {
    // Create the state object.
    StateObject state = new StateObject();
    state.workSocket = client;

    // Begin receiving the data from the remote device.
    client.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
    new AsyncCallback(ReceiveCallback), state);
    } catch (Exception e) {
    Console.WriteLine(e.ToString());
    }
    }

    private static void ReceiveCallback( IAsyncResult ar ) {
    try {
    // Retrieve the state object and the client socket
    // from the asynchronous state object.
    StateObject state = (StateObject) ar.AsyncState;
    Socket client = state.workSocket;

    // Read data from the remote device.
    int bytesRead = client.EndReceive(ar);

    if (bytesRead > 0) {
    // There might be more data, so store the data received so far.
    state.sb.Append(Encoding.ASCII.GetString(state.buffer,0,bytesRead));

    // Get the rest of the data.
    client.BeginReceive(state.buffer,0,StateObject.BufferSize,0,
    new AsyncCallback(ReceiveCallback), state);
    } else {
    // All the data has arrived; put it in response.
    if (state.sb.Length > 1) {
    response = state.sb.ToString();
    }
    // Signal that all bytes have been received.
    receiveDone.Set();
    }
    } catch (Exception e) {
    Console.WriteLine(e.ToString());
    }
    }

    private static void Send(Socket client, String data) {
    // Convert the string data to byte data using ASCII encoding.
    byte[] byteData = Encoding.ASCII.GetBytes(data);

    // Begin sending the data to the remote device.
    client.BeginSend(byteData, 0, byteData.Length, 0,
    new AsyncCallback(SendCallback), client);
    }

    private static void SendCallback(IAsyncResult ar) {
    try {
    // Retrieve the socket from the state object.
    Socket client = (Socket) ar.AsyncState;

    // Complete sending the data to the remote device.
    int bytesSent = client.EndSend(ar);
    Console.WriteLine("Sent {0} bytes to server.", bytesSent);

    // Signal that all bytes have been sent.
    sendDone.Set();
    } catch (Exception e) {
    Console.WriteLine(e.ToString());
    }
    }

    public static int Main(String[] args) {
    StartClient();
    return 0;
    }
    }
    10 changes: 10 additions & 0 deletions README
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,10 @@
    Sample codes from MSDN library about socket programming, specially the asynchronous approach.

    Asynchronous Server Socket Example
    http://msdn.microsoft.com/en-us/library/fx6588te.aspx

    Asynchronous Client Socket Example
    http://msdn.microsoft.com/en-us/library/bew39x2a.aspx

    Using an Asynchronous Server Socket
    http://msdn.microsoft.com/en-us/library/5w7b7x5f.aspx
    152 changes: 152 additions & 0 deletions Server.cs
    View file
    Original file line number Diff line number Diff line change
    @@ -0,0 +1,152 @@
    // Asynchronous Server Socket Example
    // http://msdn.microsoft.com/en-us/library/fx6588te.aspx

    using System;
    using System.Net;
    using System.Net.Sockets;
    using System.Text;
    using System.Threading;

    // State object for reading client data asynchronously
    public class StateObject {
    // Client socket.
    public Socket workSocket = null;
    // Size of receive buffer.
    public const int BufferSize = 1024;
    // Receive buffer.
    public byte[] buffer = new byte[BufferSize];
    // Received data string.
    public StringBuilder sb = new StringBuilder();
    }

    public class AsynchronousSocketListener {
    // Thread signal.
    public static ManualResetEvent allDone = new ManualResetEvent(false);

    public AsynchronousSocketListener() {
    }

    public static void StartListening() {
    // Data buffer for incoming data.
    byte[] bytes = new Byte[1024];

    // Establish the local endpoint for the socket.
    // The DNS name of the computer
    // running the listener is "host.contoso.com".
    IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());
    IPAddress ipAddress = ipHostInfo.AddressList[0];
    IPEndPoint localEndPoint = new IPEndPoint(ipAddress, 11000);

    // Create a TCP/IP socket.
    Socket listener = new Socket(AddressFamily.InterNetwork,
    SocketType.Stream, ProtocolType.Tcp );

    // Bind the socket to the local endpoint and listen for incoming connections.
    try {
    listener.Bind(localEndPoint);
    listener.Listen(100);

    while (true) {
    // Set the event to nonsignaled state.
    allDone.Reset();

    // Start an asynchronous socket to listen for connections.
    Console.WriteLine("Waiting for a connection...");
    listener.BeginAccept(
    new AsyncCallback(AcceptCallback),
    listener );

    // Wait until a connection is made before continuing.
    allDone.WaitOne();
    }

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

    Console.WriteLine("\nPress ENTER to continue...");
    Console.Read();

    }

    public static void AcceptCallback(IAsyncResult ar) {
    // Signal the main thread to continue.
    allDone.Set();

    // Get the socket that handles the client request.
    Socket listener = (Socket) ar.AsyncState;
    Socket handler = listener.EndAccept(ar);

    // Create the state object.
    StateObject state = new StateObject();
    state.workSocket = handler;
    handler.BeginReceive( state.buffer, 0, StateObject.BufferSize, 0,
    new AsyncCallback(ReadCallback), state);
    }

    public static void ReadCallback(IAsyncResult ar) {
    String content = String.Empty;

    // Retrieve the state object and the handler socket
    // from the asynchronous state object.
    StateObject state = (StateObject) ar.AsyncState;
    Socket handler = state.workSocket;

    // Read data from the client socket.
    int bytesRead = handler.EndReceive(ar);

    if (bytesRead > 0) {
    // There might be more data, so store the data received so far.
    state.sb.Append(Encoding.ASCII.GetString(
    state.buffer,0,bytesRead));

    // Check for end-of-file tag. If it is not there, read
    // more data.
    content = state.sb.ToString();
    if (content.IndexOf("<EOF>") > -1) {
    // All the data has been read from the
    // client. Display it on the console.
    Console.WriteLine("Read {0} bytes from socket. \n Data : {1}",
    content.Length, content );
    // Echo the data back to the client.
    Send(handler, content);
    } else {
    // Not all data received. Get more.
    handler.BeginReceive(state.buffer, 0, StateObject.BufferSize, 0,
    new AsyncCallback(ReadCallback), state);
    }
    }
    }

    private static void Send(Socket handler, String data) {
    // Convert the string data to byte data using ASCII encoding.
    byte[] byteData = Encoding.ASCII.GetBytes(data);

    // Begin sending the data to the remote device.
    handler.BeginSend(byteData, 0, byteData.Length, 0,
    new AsyncCallback(SendCallback), handler);
    }

    private static void SendCallback(IAsyncResult ar) {
    try {
    // Retrieve the socket from the state object.
    Socket handler = (Socket) ar.AsyncState;

    // Complete sending the data to the remote device.
    int bytesSent = handler.EndSend(ar);
    Console.WriteLine("Sent {0} bytes to client.", bytesSent);

    handler.Shutdown(SocketShutdown.Both);
    handler.Close();

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


    public static int Main(String[] args) {
    StartListening();
    return 0;
    }
    }