// // Methods // void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { try { if (this._connection != null && this._connection.Client.Poll(-1, SelectMode.SelectRead)) { if (Tools.RuntimePlatform == RuntimePlatform.Mono) { int len = this._connection.GetStream().Read(data, offset, size); if (callback != null) { callback(state, len); } } else { this._connection.GetStream().BeginRead(data, offset, size, new AsyncCallback(this.ReadCallback), new Tuple <SocketReceiveCallback, object>(callback, state)); } } } catch (ObjectDisposedException) { } catch (Exception e) { // Tools.WriteLine(e); throw e; } }
public void AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state = null) { var arg = _receivePool.PopFront(); arg.SetBuffer(data, offset, size); arg.ReceiveCallback = callback; arg.UserToken = state; arg.Socket = this; if (_socket != null) { if (!_socket.ReceiveAsync(arg)) { //The receive was processed synchronously which means the callback wont be executed. OnReceiveComplete(arg); } } else if (_connection != null) { if (!_connection.Client.ReceiveAsync(arg)) { //The receive was processed synchronously which means the callback wont be executed. OnReceiveComplete(arg); } } }
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { if (test == null) { test = new AsyncCallback() { Callback = callback, Buffer = data, Offset = offset, Size = size, State = state }; } else { // test.Data = data; test.Offset = offset; // test.Data = data; } // readQueue.Enqueue(new AsyncCallback() // { // Callback = callback, // Buffer = data, // Offset = offset, // Size = size, // State = state // }); // Flush(); }
public void Dispose() { Callback = null; Offset = 0; Size = 0; Buffer = null; State = null; }
void ISocket.AsyncReceive( byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { this._connection.GetStream().BeginRead(data, offset, size, new AsyncCallback(this.ReadCallback), (object)new Tuple <SocketReceiveCallback, object>(callback, state)); }
void ISocket.AsyncReceive( byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { new SocialSocket.InternalReadCallback(this.ReadCallback).BeginInvoke(data, offset, size, callback, state, (AsyncCallback)null, (object)null); }
private void ReadCallback(byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { int size2; while ((size2 = SocialAPI.Network.Receive(this._remoteAddress, data, offset, size)) == 0) { Thread.Sleep(1); } callback(state, size2); }
private void ReadCallback(byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { int size2; while ((size2 = SocialAPI.Network.Receive(_remoteAddress, data, offset, size)) == 0) { Thread.Sleep(1); } callback(state, size2); }
private void ReadCallback(byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { int num; while (true) { int num1 = SocialAPI.Network.Receive(this._remoteAddress, data, offset, size); num = num1; if (num1 != 0) { break; } Thread.Sleep(1); } callback(state, num); }
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { if (_callback == null) { _callback = new AsyncCallback() { Callback = callback, Buffer = data, Offset = offset, Size = size, State = state }; StartReading(); } else { _callback.Offset = offset; } }
void Terraria.Net.Sockets.ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { SocialSocket.InternalReadCallback internalReadCallback = new SocialSocket.InternalReadCallback(this.ReadCallback); internalReadCallback.BeginInvoke(data, offset, size, callback, state, null, null); }
public void AsyncReceive(byte[] data, int offset, int count, SocketReceiveCallback callback, object state = null) { if (_connected && storeWriteOffset > 0) { //lock (storeBuffer) lock (_rxSyncRoot) { //var received = storeWriteOffset - storeReadOffset; int received; if (!reset) { received = storeWriteOffset - storeReadOffset; } else { received = receiveBuffer.Length - storeReadOffset; //reset = false; } if (count > received) count = received; if (count == 0) return; Array.Copy(receiveBuffer, storeReadOffset, data, offset, count); storeReadOffset += count; if (reset || storeReadOffset == receiveBuffer.Length) { storeReadOffset = 0; ////The write buffer will also be at the end, so it must now also be reset //storeWriteOffset = 0; reset = false; Console.WriteLine("Queue reset"); } ////Recallibrate offsets //if (storeReadOffset + count >= storeWriteOffset) //{ // //We have caught up to the receive writer; // storeReadOffset = 0; // storeWriteOffset = 0; //} //else //{ // storeReadOffset += count; //} available -= count; } if (count > 0 && callback != null) { callback(state, count); } } }
public void AsyncReceive(byte[] data, int offset, int count, SocketReceiveCallback callback, object state = null) { if (_connected && storeWriteOffset > 0) { //lock (storeBuffer) lock (_rxSyncRoot) { //var received = storeWriteOffset - storeReadOffset; int received; if (!reset) { received = storeWriteOffset - storeReadOffset; } else { received = receiveBuffer.Length - storeReadOffset; //reset = false; } if (count > received) { count = received; } if (count == 0) { return; } Array.Copy(receiveBuffer, storeReadOffset, data, offset, count); storeReadOffset += count; if (reset || storeReadOffset == receiveBuffer.Length) { storeReadOffset = 0; ////The write buffer will also be at the end, so it must now also be reset //storeWriteOffset = 0; reset = false; Console.WriteLine("Queue reset"); } ////Recallibrate offsets //if (storeReadOffset + count >= storeWriteOffset) //{ // //We have caught up to the receive writer; // storeReadOffset = 0; // storeWriteOffset = 0; //} //else //{ // storeReadOffset += count; //} available -= count; } if (count > 0 && callback != null) { callback(state, count); } } }
// // Methods // void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { try { if (this._connection != null && this._connection.Client.Poll(-1, SelectMode.SelectRead)) { if (Tools.RuntimePlatform == RuntimePlatform.Mono) { int len = this._connection.GetStream().Read(data, offset, size); if (callback != null) callback(state, len); } else this._connection.GetStream().BeginRead(data, offset, size, new AsyncCallback(this.ReadCallback), new Tuple<SocketReceiveCallback, object>(callback, state)); } } catch (ObjectDisposedException) { } catch (Exception e) { // Tools.WriteLine(e); throw e; } }
public void AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state = null) { _client?.AsyncReceive(data, offset, size, callback, state); }
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { new InternalReadCallback(ReadCallback).BeginInvoke(data, offset, size, callback, state, null, null); }
void ISocket.AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state) { this._connection.GetStream().BeginRead(data, offset, size, new AsyncCallback(this.ReadCallback), (object)new Tuple<SocketReceiveCallback, object>(callback, state)); }
public void AsyncReceive(byte[] data, int offset, int size, SocketReceiveCallback callback, object state = null) { // we don't use terrarias async callbacks, we do it ourself so we arent limited to their buffer sizes }