Exemplo n.º 1
0
        public override int Read(byte[] buffer, int offset, int count)
        {
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }
            if (offset >= buffer.Length)
            {
                throw new ArgumentOutOfRangeException("offset");
            }
            if (offset + count > buffer.Length)
            {
                throw new ArgumentOutOfRangeException("count");
            }

            ReadSyncResult readResult = new ReadSyncResult();
            bool           shouldInvokeWriter;

            if (!TryCompleteReadRequest(buffer, offset, count, readResult, out shouldInvokeWriter))
            {
                if (shouldInvokeWriter)
                {
                    InvokeWriter();
                }
            }
            return(readResult.WaitFor());
        }
Exemplo n.º 2
0
        public override int Read(byte[] buffer, int offset, int count)
        {
            if (buffer == null)
            {
                throw new ArgumentNullException("buffer");
            }
            if (offset >= buffer.Length)
            {
                throw new ArgumentOutOfRangeException("offset");
            }
            if (offset + count > buffer.Length)
            {
                throw new ArgumentOutOfRangeException("count");
            }

            ReadSyncResult readResult = new ReadSyncResult();
            bool shouldInvokeWriter;
            if (!TryCompleteReadRequest(buffer, offset, count, readResult, out shouldInvokeWriter))
            {
                if (shouldInvokeWriter)
                {
                    InvokeWriter();
                }
            }
            return readResult.WaitFor();
        }
        public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
        {
            Debug.WriteLine("BNS ({0}): BeginRead (buffer, {1}, {2}) [m_inputBuffer_pos = {3}, m_inputBuffer_read_ahead = {4}]",
                            NetworkStream.InternalSocket.InternalRemoteEndPoint, offset, count, m_inputBuffer_pos, m_inputBuffer_read_ahead);

            ReadAsyncResult rar;

            if (buffer == null)
            {
                throw new ArgumentNullException("buffer is null");
            }
            int len = buffer.Length;

            if (offset < 0 || offset > len)
            {
                throw new ArgumentOutOfRangeException("offset exceeds the size of buffer");
            }
            if (count < 0 || offset + count > len)
            {
                throw new ArgumentOutOfRangeException("offset+size exceeds the size of buffer");
            }

            CheckObjectDisposedException();

            if (!m_stream.CanRead)
            {
                throw new NotSupportedException(Locale.GetText("Cannot read from stream"));
            }

            if (m_inputBuffer_pos < m_inputBuffer_read_ahead)
            {
                int curLength = m_inputBuffer_read_ahead - m_inputBuffer_pos;
                if (count <= curLength)
                {
                    Buffer.BlockCopy(m_inputBuffer, m_inputBuffer_pos, buffer, offset, count);
                    m_inputBuffer_pos += count;

                    var rsr = new ReadSyncResult
                    {
                        AsyncState   = state,
                        DataReceived = count
                    };

                    if (callback != null)
                    {
                        callback.BeginInvokeEx(rsr, null, null);
                    }

                    return(rsr);
                }

                if (curLength != 0)
                {
                    Buffer.BlockCopy(m_inputBuffer, m_inputBuffer_pos, buffer, offset, curLength);
                    count  -= curLength;
                    offset += curLength;

                    if (!m_stream.InternalSocket.DataAvailable)
                    {
                        m_inputBuffer_pos        = 0;
                        m_inputBuffer_read_ahead = 0;

                        var rsr = new ReadSyncResult
                        {
                            AsyncState   = state,
                            DataReceived = curLength
                        };

                        if (callback != null)
                        {
                            callback.BeginInvokeEx(rsr, null, null);
                        }

                        return(rsr);
                    }
                }

                rar = new ReadAsyncResult
                {
                    DataReceived = curLength,
                    AsyncState   = state
                };
            }
            else
            {
                rar = new ReadAsyncResult
                {
                    DataReceived = 0,
                    AsyncState   = state
                };
            }

            m_inputBuffer_pos        = 0;
            m_inputBuffer_read_ahead = 0;

            if (count > m_bufferSize / 2)
            {
                if (rar.DataReceived == 0)
                {
                    return(m_stream.BeginRead(buffer, offset, count, callback, state));
                }

                m_stream.BeginRead(buffer, offset, count, iar =>
                {
                    var rs = (ReadState)iar.AsyncState;

                    rs.readAsyncResult.DataReceived += m_stream.EndRead(iar);

                    rs.readAsyncResult.IsCompleted = true;
                    ((CEvent)rs.readAsyncResult.AsyncWaitHandle).Set();

                    if (rs.callback != null)
                    {
                        try
                        {
                            rs.callback(rs.readAsyncResult);
                        }
                        catch
                        {
                        }
                    }
                }, new ReadState
                {
                    callback        = callback,
                    readAsyncResult = rar
                });

                return(rar);
            }

            EnsureInputBuffer();

            m_stream.BeginRead(m_inputBuffer, 0, m_bufferSize, iar =>
            {
                var rs = (ReadState)iar.AsyncState;

                m_inputBuffer_read_ahead = m_stream.EndRead(iar);

                if (rs.count > m_inputBuffer_read_ahead)
                {
                    rs.count = m_inputBuffer_read_ahead;
                }

                rs.readAsyncResult.DataReceived += rs.count;

                if (rs.count != 0)
                {
                    Buffer.BlockCopy(m_inputBuffer, 0, rs.buffer, rs.offset, rs.count);
                    m_inputBuffer_pos = rs.count;
                }

                rs.readAsyncResult.IsCompleted = true;
                ((CEvent)rs.readAsyncResult.AsyncWaitHandle).Set();

                if (rs.callback != null)
                {
                    try
                    {
                        rs.callback(rs.readAsyncResult);
                    }
                    catch
                    {
                    }
                }
            }, new ReadState
            {
                callback        = callback,
                readAsyncResult = rar,
                buffer          = buffer,
                offset          = offset,
                count           = count
            });

            return(rar);
        }