/// <summary>
/// Called by the OS when new data arrives. If the connection is closed does nothing, else
/// gets the SocketState and calls the callback function provided by the SocketState.
/// </summary>
public static void ReceiveCallback(IAsyncResult stateAsArObject)
{
SocketState state = (SocketState)stateAsArObject.AsyncState;
int bytesRead = 0;
try
{
bytesRead = state.GetSocket().EndReceive(stateAsArObject);
}
catch (SocketException e)
{
state.HasError = true;
state.ErrorMessage = e.Message;
// invoke client delegate so it can take whatever action it needs with an error
state.InvokeNetworkAction(state);
}
catch (ObjectDisposedException e)
{
state.HasError = true;
state.ErrorMessage = e.Message;
// invoke client delegate so it can take whatever action it needs with an error
state.InvokeNetworkAction(state);
}
// If the socket is still open
if (bytesRead > 0)
{
string theMessage = Encoding.UTF8.GetString(state.GetMessageBuffer(), 0, bytesRead);
// Append the received data to the growable buffer.
// It may be an incomplete message, so we need to start building it up piece by piece
state.GetStringBuilder().Append(theMessage);
// Instead, just invoke the client's delegate, so it can take whatever action it desires.
state.InvokeNetworkAction(state);
}
}
/// <summary>
/// Takes in a SocketState object, state, and loads the buffer with data coming from the socket.
/// </summary>
public static void GetData(SocketState state)
{
try
{
state.GetSocket().BeginReceive(state.GetMessageBuffer(), 0, state.GetMessageBuffer().Length, SocketFlags.None, ReceiveCallback, state);
}
catch (SocketException e)
{
// put the state object in a state of error with the given message
state.HasError = true;
state.ErrorMessage = e.Message;
// invoke client delegate so it can take whatever action it needs with an error
state.InvokeNetworkAction(state);
}
}
/// <summary>
/// This function is "called" by the operating system when the remote site acknowledges connect request
/// </summary>
/// <param name="ar"></param>
private static void ConnectedCallback(IAsyncResult ar)
{
//pull SocketState object from the IAsyncResult object, ar
SocketState state = (SocketState)ar.AsyncState;
try
{
// Complete the connection.
state.GetSocket().EndConnect(ar);
}
catch (Exception e)
{
state.HasError = true;
state.ErrorMessage = e.Message;
}
state.InvokeNetworkAction(state);
}
/// <summary>
/// This function is "called" by the operating system when a remote
/// connection request comes in.
///
/// AcceptNewClient creates a new socket and saves it in a SocketState
/// object then invokes the NetworkAction delegate stored by the
/// parameter ar and continues the event loop.
/// </summary>
public static void AcceptNewClient(IAsyncResult ar)
{
// extract the ConnectionState from ar
ConnectionState cs = (ConnectionState)ar.AsyncState;
// extract the socket from the TCP listener
Socket socket = cs.GetTcpListener().EndAcceptSocket(ar);
// save the socket along with a network action
SocketState ss = new SocketState(socket, -1);
ss.SetNetworkAction(cs.GetNetworkAction());
// invoke the network action and pass it our new socket state
ss.InvokeNetworkAction(ss);
//continue the event loop
cs.GetTcpListener().BeginAcceptSocket(AcceptNewClient, cs);
}
/// <summary>
/// Called by the OS when the socket connects to the server.
/// </summary>
public static void ConnectedToServer(IAsyncResult stateAsArObject)
{
SocketState state = (SocketState)stateAsArObject;
state.InvokeNetworkAction(state);
}