private void BeginReceive()
{
if (_isDisposed)
{
return;
}
try
{
var result = _udpClient.BeginReceive(_receiveBuffer, 0, _receiveBuffer.Length, OnReceiveResult);
if (result.CompletedSynchronously)
{
OnReceiveResult(result);
}
}
catch (ObjectDisposedException)
{
//TODO Investigate and properly fix.
}
catch (Exception ex)
{
_logger.LogError(ex, "Error receiving udp message");
}
}
private void ReceiveDataComplete(IAsyncResult ar)
{
try
{
// Retrieve the state object and the client socket from the asynchronous state object.
StateObject state = (StateObject)ar.AsyncState;
ISocket client = state.WorkSocket;
int bytesRead = client.EndReceive(ar);
//put data into the buffer
if (bytesRead > 0)
{
client.BeginReceive(state.Buffer, state.Saved, bytesRead, 0, ReceiveDataComplete, state);
if (Encoding.ASCII.GetString(state.Buffer, 0, bytesRead) == Constants.FailString)
{
Console.WriteLine("Data request failed");
}
state.Saved += bytesRead;
Console.WriteLine("read " + bytesRead + " bytes");
Console.WriteLine(Encoding.ASCII.GetString(state.Buffer, 0, bytesRead));
}
else
{
Console.WriteLine("Total data recieved " + state.Saved + "bytes");
recieveData.Set();
}
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
public byte[] MakeRequest(CameraRequest request)
{
//check for valid input
if (!socket.Connected)
{
throw new Exception("Socket needs to be connnected");
}
//send the request to the camera
string sendRequest = ((int)request) + Constants.EndOfMessage;
SendData(socket, sendRequest);
sentData.WaitOne();
//wait for the request data
StateObject state = new StateObject {
WorkSocket = socket
};
try
{
socket.BeginReceive(state.Buffer, 0, Constants.ByteArraySize, 0, ReceiveDataComplete, state);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
recieveData.WaitOne();
return(state.Buffer);
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int size, AsyncCallback callback, object state)
{
try {
return(socket.BeginReceive(buffer, offset, size, SocketFlags.None, callback, state));
} catch (Exception ex) {
if (ex is ThreadAbortException || ex is StackOverflowException || ex is OutOfMemoryException)
{
throw;
}
throw new IOException(ex.Message, ex);
}
}
private void ResumeReceive()
{
try
{
_socket.BeginReceive(_receiveData, 0, _receiveData.Length, SocketFlags.None, new AsyncCallback(ReceiveData), null);
}
catch (SocketException ex)
{
Diagnostics.Trace("Exception during ResumeReceive: {0}", ex.Message);
Close();
}
}
public void SetupRecieveCallback()
{
try
{
AsyncCallback recieveData = new AsyncCallback(TextServer.OnRecievedData);
var timeout = _newSocket.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, recieveData, this);
bool intime = timeout.AsyncWaitHandle.WaitOne(10000, true);
//if(!intime)
//{
// //TODO
//}
}
catch (Exception)
{
}
}
private void BeginReceive()
{
if (_isDisposed)
{
return;
}
try
{
var result = _udpClient.BeginReceive(_receiveBuffer, 0, _receiveBuffer.Length, OnReceiveResult);
if (result.CompletedSynchronously)
{
OnReceiveResult(result);
}
}
catch (ObjectDisposedException)
{
}
catch (Exception ex)
{
_logger.ErrorException("Error receiving udp message", ex);
}
}
public bool Receive()
{
bool rt = false;
try
{
//若Socket已经打开
if (ISocket != null && ISocket.Connected)
{
ISocket.Blocking = false;
AsyncCallback OnReceived = new AsyncCallback(ReceivedCallBack);
//异步请求接收服务器数据，完成后回调：OnReceived委托
ISocket.BeginReceive(_dataBuffer, 0, _dataBuffer.Length, System.Net.Sockets.SocketFlags.None, OnReceived, ISocket);
rt = true;
}
}
catch (Exception ex)
{
}
finally
{
}
return(rt);
}
public void BeginReceive()
{
// Hook
receiveBuffer = new byte[BUFFER_SIZE];
socket.BeginReceive(receiveBuffer, 0, BUFFER_SIZE, SocketFlags.None, new AsyncCallback(ReceiveCallback), socket);
}
public void SetupRecieveCallback(ISocket sock)
{
AsyncCallback recieveData = new AsyncCallback(OnRecievedData);
sock.BeginReceive(buffer, 0, buffer.Length, SocketFlags.None, recieveData, sock);
}
