I'm trying to implement a Solution, where on service schedules some work to a number of Workers. The scheduling itself should happen over a custom tcp-based protocol, because the Workers can run either on the same or on a different machine.
After some research I found this post. After reading it, I found out that there were at least 3 different possible solutions, each with its advantages and disatvantages.
I decided to go for the Begin-End solution, and wrote a little test program to play around with it. My client is just a simple program that sends some data to the server and then exits. This is the Client-Code:
class Client
{
static void Main(string[] args)
{
var ep = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345);
var s = new Socket(ep.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
s.Connect(ep);
Console.WriteLine("client Startet, socket connected");
s.Send(Encoding.ASCII.GetBytes("1234"));
s.Send(Encoding.ASCII.GetBytes("ABCDEFGH"));
s.Send(Encoding.ASCII.GetBytes("A1B2C3D4E5F6"));
Console.ReadKey();
s.Close();
}
}
My Server is nearly as simple, following the example provided:
class Program
{
static void Main(string[] args)
{
var server = new BeginEndTcpServer(8, 1, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345));
// var server = new ThreadedTcpServer(8, new IPEndPoint(IPAddress.Parse("127.0.0.1"), 12345));
//server.ClientConnected += new EventHandler<ClientConnectedEventArgs>(server_ClientConnected);
server.DataReceived += new EventHandler<DataReceivedEventArgs>(server_DataReceived);
server.Start();
Console.WriteLine("Server Started");
Console.ReadKey();
}
static void server_DataReceived(object sender, DataReceivedEventArgs e)
{
Console.WriteLine("Receveived Data: " + Encoding.ASCII.GetString(e.Data));
}
}
using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Sockets;
namespace TcpServerTest
{
public sealed class BeginEndTcpServer
{
private class Connection
{
public Guid id;
public byte[] buffer;
public Socket socket;
}
private readonly Dictionary<Guid, Connection> _sockets;
private Socket _serverSocket;
private readonly int _bufferSize;
private readonly int _backlog;
private readonly IPEndPoint serverEndPoint;
public BeginEndTcpServer(int bufferSize, int backlog, IPEndPoint endpoint)
{
_sockets = new Dictionary<Guid, Connection>();
serverEndPoint = endpoint;
_bufferSize = bufferSize;
_backlog = backlog;
}
public bool Start()
{
//System.Net.IPHostEntry localhost = System.Net.Dns.GetHostEntry(System.Net.Dns.GetHostName());
try
{
_serverSocket = new Socket(serverEndPoint.Address.AddressFamily, SocketType.Stream, ProtocolType.Tcp);
}
catch (System.Net.Sockets.SocketException e)
{
throw new ApplicationException("Could not create socket, check to make sure not duplicating port", e);
}
try
{
_serverSocket.Bind(serverEndPoint);
_serverSocket.Listen(_backlog);
}
catch (Exception e)
{
throw new ApplicationException("Error occured while binding socket, check inner exception", e);
}
try
{
//warning, only call this once, this is a bug in .net 2.0 that breaks if
// you're running multiple asynch accepts, this bug may be fixed, but
// it was a major pain in the ass previously, so make sure there is only one
//BeginAccept running
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
}
catch (Exception e)
{
throw new ApplicationException("Error occured starting listeners, check inner exception", e);
}
return true;
}
public void Stop()
{
_serverSocket.Close();
lock (_sockets)
foreach (var s in _sockets)
s.Value.socket.Close();
}
private void AcceptCallback(IAsyncResult result)
{
Connection conn = new Connection();
try
{
//Finish accepting the connection
System.Net.Sockets.Socket s = (System.Net.Sockets.Socket)result.AsyncState;
conn = new Connection();
conn.id = Guid.NewGuid();
conn.socket = s.EndAccept(result);
conn.buffer = new byte[_bufferSize];
lock (_sockets)
_sockets.Add(conn.id, conn);
OnClientConnected(conn.id);
//Queue recieving of data from the connection
conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
//Queue the accept of the next incomming connection
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
}
catch (SocketException)
{
if (conn.socket != null)
{
conn.socket.Close();
lock (_sockets)
_sockets.Remove(conn.id);
}
//Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
}
catch (Exception)
{
if (conn.socket != null)
{
conn.socket.Close();
lock (_sockets)
_sockets.Remove(conn.id);
}
//Queue the next accept, think this should be here, stop attacks based on killing the waiting listeners
_serverSocket.BeginAccept(new AsyncCallback(AcceptCallback), _serverSocket);
}
}
private void ReceiveCallback(IAsyncResult result)
{
//get our connection from the callback
Connection conn = (Connection)result.AsyncState;
//catch any errors, we'd better not have any
try
{
//Grab our buffer and count the number of bytes receives
int bytesRead = conn.socket.EndReceive(result);
//make sure we've read something, if we haven't it supposadly means that the client disconnected
if (bytesRead > 0)
{
//put whatever you want to do when you receive data here
conn.socket.Receive(conn.buffer);
OnDataReceived(conn.id, (byte[])conn.buffer.Clone());
//Queue the next receive
conn.socket.BeginReceive(conn.buffer, 0, conn.buffer.Length, SocketFlags.None, new AsyncCallback(ReceiveCallback), conn);
}
else
{
//Callback run but no data, close the connection
//supposadly means a disconnect
//and we still have to close the socket, even though we throw the event later
conn.socket.Close();
lock (_sockets)
_sockets.Remove(conn.id);
}
}
catch (SocketException)
{
//Something went terribly wrong
//which shouldn't have happened
if (conn.socket != null)
{
conn.socket.Close();
lock (_sockets)
_sockets.Remove(conn.id);
}
}
}
public bool Send(byte[] message, Guid connectionId)
{
Connection conn = null;
lock (_sockets)
if (_sockets.ContainsKey(connectionId))
conn = _sockets[connectionId];
if (conn != null && conn.socket.Connected)
{
lock (conn.socket)
{
//we use a blocking mode send, no async on the outgoing
//since this is primarily a multithreaded application, shouldn't cause problems to send in blocking mode
conn.socket.Send(message, message.Length, SocketFlags.None);
}
}
else
return false;
return true;
}
public event EventHandler<ClientConnectedEventArgs> ClientConnected;
private void OnClientConnected(Guid id)
{
if (ClientConnected != null)
ClientConnected(this, new ClientConnectedEventArgs(id));
}
public event EventHandler<DataReceivedEventArgs> DataReceived;
private void OnDataReceived(Guid id, byte[] data)
{
if (DataReceived != null)
DataReceived(this, new DataReceivedEventArgs(id, data));
}
public event EventHandler<ConnectionErrorEventArgs> ConnectionError;
}
public class ClientConnectedEventArgs : EventArgs
{
private readonly Guid _ConnectionId;
public Guid ConnectionId { get { return _ConnectionId; } }
public ClientConnectedEventArgs(Guid id)
{
_ConnectionId = id;
}
}
public class DataReceivedEventArgs : EventArgs
{
private readonly Guid _ConnectionId;
public Guid ConnectionId { get { return _ConnectionId; } }
private readonly byte[] _Data;
public byte[] Data { get { return _Data; } }
public DataReceivedEventArgs(Guid id, byte[] data)
{
_ConnectionId = id;
_Data = data;
}
}
public class ConnectionErrorEventArgs : EventArgs
{
private readonly Guid _ConnectionId;
public Guid ConnectionId { get { return _ConnectionId; } }
private readonly Exception _Error;
public Exception Error { get { return _Error; } }
public ConnectionErrorEventArgs(Guid id, Exception ex)
{
_ConnectionId = id;
_Error = ex;
}
}
}
My problem is: The Server receives only a potion of the data (in the example it receives only 'EFGHA1B2'). Also if I send only 4byte of Data, the server does not receive it until the connection is closed. What am I missing or doing wrong?
The other thing is, at the moment I'm really confused by the different possibilities, is the way I'm doing this a good solution? Or should I try something else?
Any help would be greatly appreciated!
