C # socket programming
3 answers
You can read
Asynchronous socket programming in C # Part 1
and
Asynchronous socket programming in C #: Part II
These are Google quick search results.
+9
source to share
The server can be organized like this: a split-stream listening port for client connections.
/// Async server
public class AsyncServer
{
/// Server socket
private Socket _serverSocket;
/// Element for sync wait
private static ManualResetEvent _connectionMutex =
new ManualResetEvent(false);
/// Client handler
private ClientManager _clientManager;
public AsyncServer(string ipAddrees, int port)
{
try
{
this._serverSocket = new Socket(AddressFamily.InterNetwork,
SocketType.Stream, ProtocolType.Tcp);
this._serverSocket.Bind(
new IPEndPoint(IPAddress.Parse(ipAddrees), port));
}
catch (Exception ex)
{
throw new Exception("Server Init Error.", ex);
}
}
private BackgroundWorker _listenThread = new BackgroundWorker();
public void Start()
{
this._clientManager = new ClientManager(this._clientConnections);
this._listenThread.WorkerReportsProgress = true;
this._listenThread.WorkerSupportsCancellation = true;
this._listenThread.DoWork +=
new DoWorkEventHandler(ListenThread_DoWork);
this._listenThread.RunWorkerAsync(this._serverSocket);
}
/// Thread for listening port
private void ListenThread_DoWork(object sender, DoWorkEventArgs e)
{
Socket serverSocket = (Socket)e.Argument;
serverSocket.Listen(100);
while (true)
{
// reset mutex
_connectionMutex.Reset();
serverSocket.BeginAccept(
new AsyncCallback(this.AcceptCallback), this._serverSocket);
// waiting for the next connection
_connectionMutex.WaitOne();
}
}
/// List of client connections
private List _clientConnections = new List();
public int ConnectionsCount
{
get { return this._clientConnections.Count; }
}
/// Callback method for handling connections
private void AcceptCallback(IAsyncResult asyncResult)
{
_connectionMutex.Set();
Socket serverSocket = (Socket)asyncResult.AsyncState;
Socket clientSocket = (Socket)serverSocket.EndAccept(asyncResult);
this._clientConnections.Add(clientSocket);
this._clientManager.HandleClient(clientSocket);
}
}
The AcceptCallback (IAsyncResult asyncResult) method handles all new client connections and passes them on to the ClientManager, which is created for each individual client thread.
public class ClientManager
{
private List _clientProcessors = new List();
private List _connections;
public ClientManager(List connections)
{
this._connections = connections;
}
/// Handling of client connection
public void HandleClient(Socket clientSocket)
{
BackgroundWorker clientProcessor = new BackgroundWorker();
clientProcessor.DoWork += new DoWorkEventHandler(ClientProcessing);
this._clientProcessors.Add(clientProcessor);
List args = new List();
//
// args.Add(...);
clientProcessor.RunWorkerAsync(args);
}
private void ClientProcessing(object sender, DoWorkEventArgs e)
{
// reading args
List args = (List)e.Argument;
ProtocolSerializer serializer = new ProtocolSerializer();
try
{
while (socket.Connected)
{
// ...
}
}
catch (SocketException)
{
// ...
}
catch (Exception)
{
// ...
}
}
}
+4
source to share
The following link gives a step-by-step guide to programming a C # asynchronous socket.
http://csharp.net-informations.com/communications/csharp-socket-programming.htm
Aldo.
0
source to share