C# 소켓 클라이언트 socket client

using System;

using System.Collections.Generic;

using System.Linq;

using System.Net;

using System.Net.Sockets;

using System.Text;

using System.Threading;

using System.Threading.Tasks;



namespace SocketClient

{

class Program

{

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();

}



static void Main(string[] args)

{

Console.WriteLine("끝내시려면 q, 아니면 내용을 입력해주세요");



SynchronousSocketClient.StartClient();



bool bExit = false;

while (!bExit)

{

String sInput = Console.ReadLine();

if (sInput == "q") bExit = true;

else SynchronousSocketClient.SendMsg(sInput);

}



SynchronousSocketClient.Quit();

}



public class SynchronousSocketClient

{

static Socket sender;



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);



private static String response = String.Empty;





// 바이트 배열을 String으로 변환

private static string ByteToString(byte[] strByte)

{

string str = Encoding.Default.GetString(strByte); return str;

}



// String을 바이트 배열로 변환

private static byte[] StringToByte(string str)

{

byte[] StrByte = Encoding.UTF8.GetBytes(str); return StrByte;

}



public static void SendMsg(String sMsg)

{

// Data buffer for incoming data.

byte[] bytes = new byte[1024];



try

{

// Encode the data string into a byte array.

//byte[] msg = Encoding.ASCII.GetBytes("This is a test<EOF>");

//byte[] msg = StringToByte(sMsg);



Send(sender, sMsg);

sendDone.WaitOne();



// Receive the response from the remote device.

Receive(sender);

receiveDone.WaitOne();



// Write the response to the console.

Console.WriteLine("Response received : {0}", response);

}

catch (ArgumentNullException ane)

{

Console.WriteLine("ArgumentNullException : {0}", ane.ToString());

}

catch (SocketException se)

{

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

}

catch (Exception e)

{

Console.WriteLine("Unexpected exception : {0}", e.ToString());

}

}



public static void Quit()

{

// Release the socket.

sender.Shutdown(SocketShutdown.Both);

sender.Close();

}



public static void StartClient()

{

// Connect to a remote device.

try

{

// Establish the remote endpoint for the socket.

// This example uses port 11000 on the local computer.

IPHostEntry ipHostInfo = Dns.Resolve(Dns.GetHostName());

IPAddress ipAddress = ipHostInfo.AddressList[0];

IPEndPoint remoteEP = new IPEndPoint(ipAddress, 11000);



// Create a TCP/IP socket.

sender = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);



// Connect the socket to the remote endpoint. Catch any errors.

try

{

sender.BeginConnect(remoteEP, new AsyncCallback(ConnectCallback), sender);

connectDone.WaitOne();



Console.WriteLine("Socket connected to {0}",

sender.RemoteEndPoint.ToString());



}

catch (ArgumentNullException ane)

{

Console.WriteLine("ArgumentNullException : {0}", ane.ToString());

}

catch (SocketException se)

{

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

}

catch (Exception e)

{

Console.WriteLine("Unexpected exception : {0}", e.ToString());

}

}

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());

}

}



}

}

}