/// <summary> /// Is called when asynchrounous line reading has completed. /// </summary> /// <param name="e">Callback data.</param> private void OnReadHeader_ReadLine_Completed(ReadLine_EventArgs e) { try { m_TotalReadedCount += e.ReadedCount; // We got error. if (e.Exception != null) { try { m_pBufferedStream.Flush(); m_pStoreStream.Flush(); } catch { // Just skip excpetions here, otherwise we may hide original exception, // if exceptions is thrown by flush. } // Maximum line size exceeded, but junk data wanted. if (m_ExceededAction == SizeExceededAction.JunkAndThrowException && e.Exception is LineSizeExceededException) { m_IsLineSizeExceeded = true; // Start reading next data buffer block. m_pStreamHelper.BeginReadLineInternal(m_pLineBuffer, m_ExceededAction, null, OnReadHeader_ReadLine_Completed, false, false); } // Unknown exception or ThrowException, so we are done. else { ReadHeaderCompleted(e.Exception); } } // We got terminator, so we are done now. else if (e.Count == 0 || e.ReadedCount == 0) { m_pBufferedStream.Flush(); m_pStoreStream.Flush(); // LineSizeExceeded. if (m_IsLineSizeExceeded) { ReadHeaderCompleted(new LineSizeExceededException()); } // DataSizeExceeded. else if (m_TotalReadedCount > m_MaxSize) { ReadHeaderCompleted(new DataSizeExceededException()); } // Completed successfuly. else { ReadHeaderCompleted(null); } } // Just append line to store stream and get next line. else { // Maximum allowed data size exceeded. if (m_TotalReadedCount > m_MaxSize) { if (m_ExceededAction == SizeExceededAction.ThrowException) { ReadHeaderCompleted(new DataSizeExceededException()); return; } // Junk data. //else{ //} } else { m_pBufferedStream.Write(e.LineBuffer, 0, e.Count); m_pBufferedStream.Write(m_pStreamHelper.m_LineBreak, 0, m_pStreamHelper.m_LineBreak.Length); } // Start reading new line. m_pStreamHelper.BeginReadLineInternal(m_pLineBuffer, m_ExceededAction, null, OnReadHeader_ReadLine_Completed, false, false); } } catch (Exception x) { ReadHeaderCompleted(x); } }
/// <summary> /// Default constructor. /// </summary> /// <param name="stream">Source stream.</param> /// <param name="maxLineSize">Specifies maximum line size in bytes.</param> /// <param name="bufferRead">Specifies if source stream reads are buffered..</param> public StreamHelper(Stream stream, int maxLineSize, bool bufferRead) { if (stream == null) { throw new ArgumentNullException("stream"); } if (maxLineSize < 1 || maxLineSize > Workaround.Definitions.MaxStreamLineLength) { throw new ArgumentException("Parameter maxLineSize value must be >= 1 and <= Workaround.Definitions.MaxStreamLineLength !"); } m_IsReadBuffered = bufferRead; if (m_IsReadBuffered) { m_pReadBuffer = new byte[Workaround.Definitions.MaxStreamLineLength]; } m_pStream = stream; m_pLineBuffer = new byte[maxLineSize]; m_MaxLineSize = maxLineSize; m_pRLine_EventArgs = new ReadLine_EventArgs(); m_pRLine_ByteBuffer = new byte[1]; }
/// <summary> /// Is called when BeginWritePeriodTerminated stream.BeginReadLine has completed. /// </summary> /// <param name="e">Callback data.</param> private void InternalBeginWritePeriodTerminatedReadLineCompleted(ReadLine_EventArgs e) { try { // Error happened during read. if (e.Exception != null) { InternalBeginWritePeriodTerminatedCompleted(e.Exception); } // We reached end of stream, no more data. else if (e.ReadedCount == 0) { InternalBeginWritePeriodTerminatedCompleted(null); } else { m_BeginWritePeriodTerminated_Readed += e.ReadedCount; // Maximum allowed data size exceeded. if (m_BeginWritePeriodTerminated_Readed > m_BeginWritePeriodTerminated_MaxSize) { throw new DataSizeExceededException(); } // If line starts with period, addtional period is added. if (e.LineBuffer[0] == '.') { m_pBeginWritePeriodTerminated_BufferedStream.WriteByte((int) '.'); m_BeginWritePeriodTerminated_Written++; } // Write readed line to buffered stream. m_pBeginWritePeriodTerminated_BufferedStream.Write(e.LineBuffer, 0, e.Count); m_pBeginWritePeriodTerminated_BufferedStream.Write(m_LineBreak, 0, m_LineBreak.Length); m_BeginWritePeriodTerminated_Written += e.Count + m_LineBreak.Length; } } catch (Exception x) { InternalBeginWritePeriodTerminatedCompleted(x); } }