private void ContinuousRead()
{
byte[] buffer = new byte[4096];
Action kickoffRead = null;
kickoffRead = (Action)(() => BaseStream.BeginRead(buffer, 0, buffer.Length, delegate(IAsyncResult ar)
{
int count = BaseStream.EndRead(ar);
byte[] dst = new byte[count];
Buffer.BlockCopy(buffer, 0, dst, 0, count);
OnDataReceived(dst);
kickoffRead();
}, null)); kickoffRead();
}
public override IAsyncResult BeginRead(byte[] array, int offset, int count, AsyncCallback asyncCallback,
object asyncState)
{
EnsureDecompressionMode();
// We use this checking order for compat to earlier versions:
if (asyncOperations != 0)
throw new InvalidOperationException(SR.GetString(SR.InvalidBeginCall));
ValidateParameters(array, offset, count);
EnsureNotDisposed();
Interlocked.Increment(ref asyncOperations);
try
{
var userResult = new DeflateStreamAsyncResult(
this, asyncState, asyncCallback, array, offset, count);
userResult.isWrite = false;
// Try to read decompressed data in output buffer
var bytesRead = inflater.Inflate(array, offset, count);
if (bytesRead != 0)
{
// If decompression output buffer is not empty, return immediately.
// 'true' means we complete synchronously.
userResult.InvokeCallback(true, bytesRead);
return userResult;
}
if (inflater.Finished())
{
// end of compression stream
userResult.InvokeCallback(true, 0);
return userResult;
}
// If there is no data on the output buffer and we are not at
// the end of the stream, we need to get more data from the base stream
BaseStream.BeginRead(buffer, 0, buffer.Length, m_CallBack, userResult);
userResult.m_CompletedSynchronously &= userResult.IsCompleted;
return userResult;
}
catch
{
Interlocked.Decrement(ref asyncOperations);
throw;
}
}
private void ContinuousRead()
{
byte[] buffer = new byte[4096];
Action kickoffRead = null;
kickoffRead = (Action)(() => BaseStream.BeginRead(buffer, 0, buffer.Length, delegate (IAsyncResult ar)
{
if (!base.IsOpen) return; //if base is closed exit func, avoid port closed error
int count = BaseStream.EndRead(ar);
byte[] dst = new byte[count];
Buffer.BlockCopy(buffer, 0, dst, 0, count);
OnDataReceived(dst);
kickoffRead();
}, null)); kickoffRead();
}
/// <summary>
/// Begins an asynchronous read operation.
/// </summary>
/// <param name="buffer">The buffer to read the data into.</param>
/// <param name="offset">The byte offset in <paramref name="buffer"/> at which to begin writing data read from the stream.</param>
/// <param name="count">The maximum number of bytes to read.</param>
/// <param name="callback">An optional asynchronous callback, to be called when the read is complete.</param>
/// <param name="state">A user-provided object that distinguishes this particular asynchronous read request from other requests.</param>
/// <returns>
/// An <see cref="T:System.IAsyncResult"/> that represents the asynchronous read, which could still be pending.
/// </returns>
/// <exception cref="T:System.IO.IOException">Attempted an asynchronous read past the end of the stream, or a disk error occurs. </exception>
/// <exception cref="T:System.ArgumentException">One or more of the arguments is invalid. </exception>
/// <exception cref="T:System.ObjectDisposedException">Methods were called after the stream was closed. </exception>
/// <exception cref="T:System.NotSupportedException">The current Stream implementation does not support the read operation. </exception>
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (_proxyAsyncRequests)
{
if (CanSeek)
{
if (count + Position > Length)
{
count = (int)Math.Max(0, Length - Position);
}
}
return(BaseStream.BeginRead(buffer, offset, count, callback, state));
}
else
{
return(base.BeginRead(buffer, offset, count, callback, state));
}
}
/// <summary>
/// Reads data from the stream
/// </summary>
/// <param name="buffer">Buffer to read into</param>
/// <param name="offset">Where in the buffer to start</param>
/// <param name="count">Number of bytes to be read</param>
/// <returns></returns>
public override int Read(byte[] buffer, int offset, int count)
{
IAsyncResult ar = null;
if (!IsConnected || BaseStream == null)
{
return(0);
}
ar = BaseStream.BeginRead(buffer, offset, count, null, null);
if (!ar.AsyncWaitHandle.WaitOne(m_readTimeout, true))
{
Close();
throw new TimeoutException("Timed out trying to read data from the socket stream!");
}
return(BaseStream.EndRead(ar));
}
private void ContinuousRead()
{
byte[] buffer = new byte[4096];
Action kickoffRead = null;
kickoffRead = (Action)(() => BaseStream.BeginRead(buffer, 0, buffer.Length, delegate(IAsyncResult ar)
{
try
{
int count = BaseStream.EndRead(ar);
byte[] dst = new byte[count];
Buffer.BlockCopy(buffer, 0, dst, 0, count);
OnDataReceived(dst);
}
catch (Exception exception)
{
Console.WriteLine("OptimizedSerialPort exception !" + exception.Message);
}
kickoffRead();
}, null)); kickoffRead();
}
/// <summary>
/// Reads data from the stream
/// </summary>
/// <param name="buffer">Buffer to read into</param>
/// <param name="offset">Where in the buffer to start</param>
/// <param name="count">Number of bytes to be read</param>
/// <returns></returns>
public override int Read(byte[] buffer, int offset, int count)
{
IAsyncResult ar = null;
if (BaseStream == null)
{
return(0);
}
m_lastActivity = DateTime.Now;
ar = BaseStream.BeginRead(buffer, offset, count, null, null);
if (!ar.AsyncWaitHandle.WaitOne(m_readTimeout, true))
{
Close();
throw new TimeoutException("Timed out trying to read data from the socket stream!");
}
var x = BaseStream.EndRead(ar);
return(x);
}
/// <summary>异步开始读</summary>
/// <param name="buffer">缓冲区</param>
/// <param name="offset">偏移</param>
/// <param name="count">数量</param>
/// <param name="callback"></param>
/// <param name="state"></param>
/// <returns></returns>
public override IAsyncResult BeginRead(Byte[] buffer, Int32 offset, Int32 count, AsyncCallback callback, Object state)
{
RaiseAction("BeginRead", offset, count);
return(BaseStream.BeginRead(buffer, offset, count, callback, state));
}
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
return(BaseStream.BeginRead(buffer, offset, count, callback, state));
}
