public EndRead ( IAsyncResult asyncResult ) : int | ||
asyncResult | IAsyncResult | |
Результат | int |
public static void StreamReadAsync( Stream stream, byte[] buffer, int offset, int count, SynchronizationContextWrapper syncContext, Action<int, Exception> callback) { Exception error = null; int length = 0; try { stream.BeginRead(buffer, offset, count, delegate(IAsyncResult ar) { try { length = stream.EndRead(ar); } catch (Exception e) { error = e; } callback(length, error); }, null); } catch (Exception e) { error = e; callback(length, error); } }
private static Task<int> ReadTask(Stream stream, byte[] buffer, int offset, int count, object state) { var tcs = new TaskCompletionSource<int>(); stream.BeginRead(buffer, offset, count, ar => { try { tcs.SetResult(stream.EndRead(ar)); } catch (Exception exc) { tcs.SetException(exc); } }, state); return tcs.Task; }
public static int ReadStream(Stream stream, byte[] buffer, int offset, int count, int timeout) { if (stream == null || buffer == null || buffer.Length < (offset + count)) return -1; IAsyncResult arRead = stream.BeginRead(buffer, offset, count, null, null); if (!arRead.AsyncWaitHandle.WaitOne(timeout)) { throw new TimeoutException("Could not read within the timeout period."); } return stream.EndRead(arRead); }
public bool Connect() { try { //_socket.Connect(host, port); var connect_result = _socket.BeginConnect(host, port, null, null); if(!connect_result.AsyncWaitHandle.WaitOne(1500)) { throw new Exception(); } _socket.EndConnect(connect_result); } catch { this.Destruct("Failed to connect.", true); return false; } _stream = _socket.GetStream(); isConnected = true; Program._RconBox.SomethingToSend.Enabled = true; byte[] buff = new byte[1]; AsyncCallback callback = null; callback = ar => { try { int bytes = _stream.EndRead(ar); //Program._RconBox.OutputBox.Text += buff; Program.wattosend.Add(buff[0]); buff[0] = 0; if (!this.isConnected || bytes == 0) { this.Destruct("Disconnected!"); return; } _stream.BeginRead(buff, 0, 1, callback, null); } catch { this.Destruct("Reading has failed"); } }; _stream.BeginRead(buff, 0, 1, callback, null); this.Send("set redrawcmd false"); this.Send("login " + this.pass); return true; }
static IEnumerable<Task> CopyStream(Stream input, Stream output) { var buffer = new byte[0x2000]; while (true) { // Create task to read from the input stream var read = Task<int>.Factory.FromAsync((buf, offset, count, callback, state) => { Console.WriteLine("Issuing BeginRead"); return input.BeginRead(buf, offset, count, callback, state); }, ar => { Console.WriteLine("Read completed"); return input.EndRead(ar); }, buffer, 0, buffer.Length, null); yield return read; // If we read no data, return if (read.Result == 0) break; // Create task to write to the output stream yield return Task.Factory.FromAsync((buf, offset, count, callback, state) => { Console.WriteLine("Issuing BeginWrite"); return output.BeginWrite(buf, offset, count, callback, state); }, ar => { Console.WriteLine("Write completed"); output.EndWrite(ar); }, buffer, 0, read.Result, null); } }
public override int EndRead( IAsyncResult asyncResult ) { Trace.WriteLine("TraceStream", "EndRead()"); return(m_in.EndRead(asyncResult)); }
public override int EndRead(IAsyncResult ares) { if (disposed) { throw new ObjectDisposedException(typeof(RequestStream).ToString()); } if (ares == null) { throw new ArgumentNullException("async_result"); } if (ares is HttpStreamAsyncResult) { HttpStreamAsyncResult r = (HttpStreamAsyncResult)ares; if (!ares.IsCompleted) { ares.AsyncWaitHandle.WaitOne(); } return(r.SynchRead); } // Close on exception? int nread = stream.EndRead(ares); if (remaining_body > 0 && nread > 0) { remaining_body -= nread; } return(nread); }
/// <summary> /// Pipes data from one stream to another /// </summary> /// <param name="input">Stream to read from</param> /// <param name="output">Stream to write to</param> /// <param name="MaxBufferSize">Size of buffer to use</param> /// <returns>Number of bytes piped</returns> public static int Pipe(Stream input, Stream output, int MaxBufferSize) { //Internal buffer are two buffers, each half of allowed buffer size, aligned to 1kb blocks int bufferSize = (MaxBufferSize / 2) & ~1023; if (bufferSize <= 0) throw new Exception("Specified buffer size to small"); byte[][] buffer = new byte[2][]; buffer[0] = new byte[bufferSize]; buffer[1] = new byte[bufferSize]; int currentBuffer = 0; int r, total=0; IAsyncResult asyncRead,asyncWrite; //Read first block r = input.Read(buffer[currentBuffer], 0, bufferSize); //Continue while we're getting data while (r > 0) { //read and write simultaneously asyncWrite = output.BeginWrite(buffer[currentBuffer], 0, r, null, null); asyncRead = input.BeginRead(buffer[1-currentBuffer], 0, bufferSize, null, null); //Wait for both output.EndWrite(asyncWrite); r = input.EndRead(asyncRead); //Switch buffers currentBuffer = 1 - currentBuffer; //Count bytes total += r; } //Return number of bytes piped return total; }
public bool VerifyEndReadException(System.IO.Stream serialStream, IAsyncResult asyncResult, Type expectedException) { bool retValue = true; try { serialStream.EndRead(asyncResult); if (null != expectedException) { Console.WriteLine("ERROR!!!: No Excpetion was thrown"); retValue = false; } } catch (System.Exception e) { if (null == expectedException) { Console.WriteLine("ERROR!!!: Expected no exception to be thrown and {0} was thrown", e); retValue = false; } else if (e.GetType() != expectedException) { Console.WriteLine("ERROR!!!: Expected {0} to be thrown and the following exception was thrown:\n{1}", expectedException, e); retValue = false; } } return(retValue); }
private static string ReadDataFromStream(Stream str) { var buff = new byte[10000]; var asyncResult = str.BeginRead(buff, 0, buff.Length, null, null); var bytesRead = str.EndRead(asyncResult); return Encoding.UTF8.GetString(buff, 0, bytesRead); }
private IAsyncResult OnEnter(Object sender, EventArgs e, AsyncCallback cb, Object state) { Debug.Assert(_inputStream == null); _app = (HttpApplication)sender; HttpContext context = _app.Context; HttpRequest request = context.Request; HttpWorkerRequest wr = context.WorkerRequest; HttpAsyncResult httpAsyncResult = new HttpAsyncResult(cb, state); AsyncPreloadModeFlags asyncPreloadMode = context.AsyncPreloadMode; int contentLength; bool isForm = false; bool isFormMultiPart = false; if (asyncPreloadMode == AsyncPreloadModeFlags.None || request.ReadEntityBodyMode != ReadEntityBodyMode.None || wr == null || !wr.SupportsAsyncRead || !wr.HasEntityBody() || wr.IsEntireEntityBodyIsPreloaded() || context.Handler == null || context.Handler is TransferRequestHandler || context.Handler is DefaultHttpHandler || (contentLength = request.ContentLength) > RuntimeConfig.GetConfig(context).HttpRuntime.MaxRequestLengthBytes || ((isForm = StringUtil.StringStartsWithIgnoreCase(request.ContentType, "application/x-www-form-urlencoded")) && (asyncPreloadMode & AsyncPreloadModeFlags.Form) != AsyncPreloadModeFlags.Form) || ((isFormMultiPart = StringUtil.StringStartsWithIgnoreCase(request.ContentType, "multipart/form-data")) && (asyncPreloadMode & AsyncPreloadModeFlags.FormMultiPart) != AsyncPreloadModeFlags.FormMultiPart) || !isForm && !isFormMultiPart && (asyncPreloadMode & AsyncPreloadModeFlags.NonForm) != AsyncPreloadModeFlags.NonForm ) { Debug.Trace("AsyncPreload", " *** AsyncPreload skipped *** "); httpAsyncResult.Complete(true, null, null); return httpAsyncResult; } Debug.Trace("AsyncPreload", " *** AsyncPreload started *** "); try { if (_callback == null) { _callback = new AsyncCallback(OnAsyncCompletion); } _inputStream = request.GetBufferedInputStream(); byte[] buffer = _app.EntityBuffer; int bytesRead = 0; // loop to prevent recursive calls and potential stack overflow if/when it completes synchronously do { IAsyncResult readAsyncResult = _inputStream.BeginRead(buffer, 0, buffer.Length, _callback, httpAsyncResult); if (!readAsyncResult.CompletedSynchronously) { return httpAsyncResult; } bytesRead = _inputStream.EndRead(readAsyncResult); } while (bytesRead != 0); } catch { Reset(); throw; } httpAsyncResult.Complete(true, null, null); return httpAsyncResult; }
protected void RecvCallback(IAsyncResult ar) { ResultHandler rh = (ResultHandler)ar.AsyncState; int result = mStream.EndRead(ar); if (result == 0) { result = MoSync.Constants.CONNERR_CLOSED; } rh(mHandle, MoSync.Constants.CONNOP_READ, result); }
void dataReceivedSsh(IAsyncResult i) { byte[] buffer = (byte[])i.AsyncState; int nBytes = sshStreamRead.EndRead(i); if (nBytes != 0) { processBytes(buffer, nBytes); } startStreamAsyncRead(); }
private static int EndRead(Stream stream, IAsyncResult ar, byte[] buffer) { try { return stream.EndRead(ar); } catch (Exception) { return stream.ReadAsync(buffer).Result; } }
private static void ReadUnsignedVarint( Stream stream, Bcp.ReadState readState, ProcessReadVarint processReadVarint, BcpDelegate.ExceptionHandler exceptionHandler) { var buffer = new byte[1]; var i = 0; uint result = 0U; AsyncCallback asyncCallback = null; asyncCallback = asyncResult => { try { int numBytesRead = stream.EndRead(asyncResult); if (numBytesRead != 1) { exceptionHandler(new EndOfStreamException()); } uint b = buffer[0]; if (i < 32) { if (b >= 0x80) { result |= ((b & 0x7f) << i); i += 7; stream.BeginRead(buffer, 0, 1, asyncCallback, readState); } else { result |= (b << i); processReadVarint(result); } } else { exceptionHandler(new BcpException.VarintTooBig()); } } catch (Exception e) { exceptionHandler(e); } }; try { stream.BeginRead(buffer, 0, 1, asyncCallback, readState); } catch (Exception e) { exceptionHandler(e); } }
private void SslRead(IAsyncResult ar) { if (m_IsDisposed) { return; } try { int byteCount = -1; int bufferSize = m_Buffer.Length; m_LastRead = DateTime.Now; byteCount = m_NetworkStream.EndRead(ar); m_BytesRead += byteCount; if (!m_HasHeaders || m_RequestType == RequestType.GET) { string sBuffer = Encoding.ASCII.GetString(m_Buffer, 0, byteCount); m_ReadData += sBuffer; } AppendBuffer(m_Buffer, byteCount); m_HasHeaders = UpdateUniqueHeaders(); if (!m_HasHeaders && m_BytesRead > 1024) { Program.BlacklistIP(m_RemoteIP, m_ReadData, "No HTTP headers found in the first 1024 bytes"); return; } if (byteCount > 0) { if (m_RequestType != RequestType.POST && m_RequestType != RequestType.None) { m_NetworkStream.BeginRead(m_Buffer, 0, bufferSize, new AsyncCallback(SslRead), m_NetworkStream); } else if (m_EndBoundaryIndex == -1) // as long as we haven't found the end of the stream continue reading { m_NetworkStream.BeginRead(m_Buffer, 0, bufferSize, new AsyncCallback(SslRead), m_NetworkStream); return; } } } catch (Exception e) { return; } ProcessRequest(m_ReadData); }
public bool StreamContainsSeqeunce(Stream contentStream) { int num; if (contentStream == null) { throw new ArgumentNullException("contentStream"); } if (this.FSequence == null) { throw new ArgumentNullException("sequence"); } if (this.FSequence.Length == 0) { return false; } byte[] buffer = new byte[0x40000]; byte[] buffer2 = new byte[0x40000]; byte[] buffer3 = buffer; byte[] buffer4 = buffer2; int offset = 0; bool flag = false; IAsyncResult asyncResult = contentStream.BeginRead(buffer3, 0, buffer3.Length, null, null); do { if (!base.OnProgress(0)) { break; } num = contentStream.EndRead(asyncResult); if (num > 0) { buffer3 = Interlocked.Exchange<byte[]>(ref buffer4, buffer3); int num3 = offset; offset = Math.Min(this.FSequence.Length - 1, num); asyncResult = contentStream.BeginRead(buffer3, offset, buffer3.Length - offset, null, null); flag = ByteArrayHelper.IndexOf(this.FSequence, buffer4, buffer4.Length) >= 0; Array.Copy(buffer4, (num + num3) - offset, buffer3, 0, offset); } else { asyncResult = null; } } while ((num > 0) && !flag); if (asyncResult != null) { contentStream.EndRead(asyncResult); } return flag; }
private static AsyncEvent StreamCopy(Stream src, Stream dst, Func<bool> assertContinuation, Action onException = null, Action<int> onProgress = null) { var evt = new AsyncEvent(false, false); var exception = false; AsyncCallback cb = null; cb = (ar) => { var count = src.EndRead(ar); var readed = (byte[])ar.AsyncState; if (exception) return; if (count != 0) { lock (evt) { if (exception) return; var newArray = new byte[BLOCK_SIZE]; if (!assertContinuation()) return; if (onProgress != null) onProgress(count); src.BeginRead(newArray, 0, BLOCK_SIZE, cb, newArray); try { dst.Write(readed, 0, count); } catch (Exception e) { exception = true; if(onException != null) onException(); } } } else { lock (evt) { src.Close(); evt.Set(); } } }; var startBuffer = new byte[BLOCK_SIZE]; src.BeginRead(startBuffer, 0, BLOCK_SIZE, cb, startBuffer); return evt; }
/// <summary> /// Ends reading from stream /// </summary> /// <param name="stream">Stream to stop reading from</param> /// <param name="ar">Result of reading</param> /// <returns></returns> public Int32 EndReadFrom(Stream stream, IAsyncResult ar) { if (_connection.State == IrcConnectionState.Opened) { var read = stream.EndRead(ar); if (read > 0) { _count += read; } var str = IrcDefinition.Encoding.GetString(_buffer, 0, _count); return read; } else { return 0; } }
/// <summary> /// Read from a stream asynchronously. /// </summary> /// <param name="stream">The stream.</param> /// <param name="length">The number of bytes to read.</param> /// <param name="completed">The completed action.</param> /// <param name="error">The error action.</param> public static void ReadAsync(this System.IO.Stream stream, int length, Action <byte[]> completed, Action <Exception> error) { var buff = new byte[length]; stream.BeginRead( buff, 0, length, ar => { try { byte[] bytes = null; try { var len = stream.EndRead(ar); bytes = len < 1 ? new byte[0] : len < length ? stream.ReadBytes(buff, len, length - len) : buff; } catch { bytes = new byte[0]; } if (completed != null) { completed(bytes); } } catch (Exception ex) { if (error != null) { error(ex); } } }, null); }
public static BodyAction FromStream(Stream stream) { return (next, error, complete) => { var buffer = new byte[4096]; var continuation = new AsyncCallback[1]; bool[] stopped = {false}; continuation[0] = result => { if (result != null && result.CompletedSynchronously) return; try { for (;;) { if (result != null) { var count = stream.EndRead(result); if (stopped[0]) return; if (count <= 0) { complete(); return; } var data = new ArraySegment<byte>(buffer, 0, count); if (next(data, () => continuation[0](null))) return; } if (stopped[0]) return; result = stream.BeginRead(buffer, 0, buffer.Length, continuation[0], null); if (!result.CompletedSynchronously) return; } } catch (Exception ex) { error(ex); } }; continuation[0](null); return () => { stopped[0] = true; }; }; }
private static IEnumerator<Int32> CopyStream(AsyncEnumerator<Int64> ae, Stream source, Stream destination, Int32 bufferSize, Action<Int64> reportProgress) { Byte[] buffer = new Byte[bufferSize]; Int64 totalBytesRead = 0; while (true) { ae.SetOperationTag("Reading from source stream"); // Read whichever is smaller (number of bytes left to read OR the buffer size) source.BeginRead(buffer, 0, buffer.Length, ae.End(), null); yield return 1; Int32 bytesReadThisTime = source.EndRead(ae.DequeueAsyncResult()); totalBytesRead += bytesReadThisTime; ae.SetOperationTag("Writing to destination stream"); destination.BeginWrite(buffer, 0, bytesReadThisTime, ae.End(), null); yield return 1; destination.EndWrite(ae.DequeueAsyncResult()); if (reportProgress != null) reportProgress(totalBytesRead); if (bytesReadThisTime < buffer.Length) break; } ae.Result = totalBytesRead; }
public static IEnumerable<CompletionPort> ReadBytesAsync(AsyncMachine<byte[]> machine, Stream stream, int length) { var attributeHelper = new AttributeHelper<VhdHeader>(); var buffer = new byte[length]; int readCount = 0; int remaining = length; while (remaining > 0) { stream.BeginRead(buffer, readCount, remaining, machine.CompletionCallback, null); yield return CompletionPort.SingleOperation; var currentRead = stream.EndRead(machine.CompletionResult); if (currentRead == 0) { break; } readCount += currentRead; remaining -= currentRead; } machine.ParameterValue = buffer; yield break; }
public static IEnumerator<int> ReadBytes( byte[] buffer, Stream stream, AsyncEnumerator ae, string type, bool expectedToHaveNoData) { var totalBytesRead = 0; while (totalBytesRead < buffer.Length) { stream.BeginRead(buffer, totalBytesRead, buffer.Length - totalBytesRead, ae.End(), null); yield return 1; int bytesRead = stream.EndRead(ae.DequeueAsyncResult()); if(bytesRead == 0) { if (expectedToHaveNoData) yield break; throw new InvalidOperationException("Could not read value for " + type); } totalBytesRead += bytesRead; } }
public override int EndRead(IAsyncResult asyncResult) { return(_innerStream.EndRead(asyncResult)); }
private CopyItemAction CopyStreamAsync(Stream sourceStream, Stream destStream, IVirtualItem sourceItem, IVirtualItem destItem) { object obj2; lock ((obj2 = this.FSnapshotLock)) { this.FCopyMode = CopyMode.Async; } if (this.Buffer2 == null) { this.Buffer2 = new byte[this.Buffer1.Length]; } byte[] buffer = this.Buffer1; byte[] buffer2 = this.Buffer2; int count = 0; ProcessedSize processed = CreateFileProcessed(sourceStream, sourceItem); if (!((processed.Total <= buffer.Length) || this.RaiseFileProgress(ref processed))) { return CopyItemAction.SkipUndoDest; } IAsyncResult asyncResult = sourceStream.BeginRead(buffer, 0, buffer.Length, null, null); do { count = sourceStream.EndRead(asyncResult); if (base.CheckCancellationPending()) { return CopyItemAction.SkipUndoDest; } IAsyncResult result2 = destStream.BeginWrite(buffer, 0, count, null, null); byte[] buffer3 = buffer; if (count > 0) { asyncResult = sourceStream.BeginRead(buffer2, 0, buffer2.Length, null, null); buffer2 = Interlocked.Exchange<byte[]>(ref buffer, buffer2); } try { destStream.EndWrite(result2); } catch (IOException exception) { CopyItemAction action = this.HandleCopyIOException(destItem, sourceItem, destItem, destStream, buffer3, count, exception); if (action != CopyItemAction.Next) { return action; } } lock ((obj2 = this.FSnapshotLock)) { this.FTotalProcessed.AddProcessedSize((long) count); } this.RaiseProgress(); processed.AddProcessedSize((long) count); if (!this.RaiseFileProgress(ref processed)) { return CopyItemAction.SkipUndoDest; } } while (count > 0); return CopyItemAction.Next; }
private static int FileReadStreamSeekAndCompare(Stream fileStream, byte[] bufferToCompare, long offset, int readSize, int expectedReadCount, bool isAsync) { byte[] testBuffer = new byte[readSize]; if (isAsync) { using (ManualResetEvent waitHandle = new ManualResetEvent(false)) { IAsyncResult result = fileStream.BeginRead(testBuffer, 0, readSize, ar => waitHandle.Set(), null); waitHandle.WaitOne(); int readCount = fileStream.EndRead(result); Assert.AreEqual(expectedReadCount, readCount); } } else { int readCount = fileStream.Read(testBuffer, 0, readSize); Assert.AreEqual(expectedReadCount, readCount); } for (int i = 0; i < expectedReadCount; i++) { Assert.AreEqual(bufferToCompare[i + offset], testBuffer[i]); } return expectedReadCount; }
private Result<int> Read(Action<string> activity, Stream stream, byte[] buffer, int offset, int count, Result<int> result) { // asynchronously execute read operation Result<IAsyncResult> inner = new Result<IAsyncResult>(TimeSpan.MaxValue); inner.WhenDone(delegate(Result<IAsyncResult> _unused) { try { activity(string.Format("pre {0}!EndRead", stream.GetType().FullName)); int readCount = stream.EndRead(inner.Value); activity("post EndRead"); result.Return(readCount); } catch(Exception e) { activity("throw Read 1"); result.Throw(e); } }); try { activity(string.Format("pre {0}!BeginRead", stream.GetType().FullName)); stream.BeginRead(buffer, offset, count, inner.Return, stream); activity("post BeginRead"); } catch(Exception e) { activity("throw Read 2"); result.Throw(e); } // return yield handle return result; }
public static void StreamReadAsync( Stream stream, byte[] buffer, int offset, int count, SynchronizationContextWrapper syncContext, Action<int, Exception> callback) { Debug.Assert(syncContext != null); stream.BeginRead( buffer, offset, count, delegate(IAsyncResult ar) { if (ar.IsCompleted) { int bytesRead = 0; Exception error = null; try { bytesRead = stream.EndRead(ar); } catch (IOException ioe) { error = ioe; } finally { syncContext.Post(() => callback(bytesRead, error)); } } }, null); }
// All of this download code could be abstracted // and put in a helper class. private void Download (Stream st) { long cLength = (response.ContentLength + range); if (cLength == 0) { return; } int nread = -1; int offset = 0; int length = (cLength == -1 || cLength > 8192) ? 8192 : (int) cLength; Stream dest = null; readTimeoutHandle = new AutoResetEvent (false); byte[] buffer = null; bool dataDownload = false; bool writeToStream = false; if (type != DownloadType.String) { tsm.TotalBytes = cLength; tsm.BytesReceivedPreviously = range; } switch (type) { case DownloadType.String: case DownloadType.Data: dataDownload = true; if (cLength != -1) { length = (int) cLength; buffer = new byte[cLength]; } else { writeToStream = true; buffer = new byte[length]; dest = OpenMemoryStream (); } break; case DownloadType.File: writeToStream = true; buffer = new byte [length]; if (localFile == null) { dest = OpenLocalFile (fileName); } else { dest = localFile; } break; } registeredTimeoutHandle = ThreadPool.RegisterWaitForSingleObject ( readTimeoutHandle, new WaitOrTimerCallback (OnTimeout), null, timeout, false ); IAsyncResult ar; while (nread != 0) { // <hack> // Yeah, Yeah, Yeah, I'll change this later, // it's here to get around abort issues. ar = st.BeginRead (buffer, offset, length, null, null); nread = st.EndRead (ar); // need an auxiliary downloader class to replace this. // </hack> readTimeoutHandle.Set (); if (writeToStream) { dest.Write (buffer, 0, nread); } else { offset += nread; length -= nread; } if (type != DownloadType.String) { tsm.AddBytes (nread); } } CleanUpHandles (); if (type != DownloadType.String) { if (tsm.TotalBytes == -1) { tsm.TotalBytes = tsm.BytesReceived; } } if (dataDownload) { if (writeToStream) { result = memoryStream.ToArray (); } else { result = buffer; } } }
static string ReadLineWithTimeout(Stream strm, ref byte[] buffer, ref int filled, TimeSpan timeout) { if (buffer == null) buffer = new byte[8192]; while (true) { for (int i = 0; i < filled; i++) { if (buffer[i] == '\r' || buffer[i] == '\n') { string ret = Encoding.UTF8.GetString (buffer, 0, i); if (i + 1 < filled) { Array.Copy (buffer, i + 1, buffer, 0, filled - i - 1); filled -= i + 1; } else { filled = 0; } return ret.Trim ('\n', '\r', '\0'); } } IAsyncResult ar = strm.BeginRead (buffer, filled, buffer.Length - filled, null, null); if (!ar.AsyncWaitHandle.WaitOne (timeout)) throw new TimeoutException (); int read_size = strm.EndRead (ar); if (read_size <= 0) throw new IOException (); filled += read_size; if (buffer.Length == filled) Array.Resize<byte> (ref buffer, buffer.Length * 2); } }
public static string ReceiveWithTimeout (Stream stream, int size, int timeout, out bool timed_out) { byte [] bytes = new byte [size]; IAsyncResult ares = stream.BeginRead (bytes, 0, size, null, null); timed_out = !ares.AsyncWaitHandle.WaitOne (timeout, false); if (timed_out) return null; int nread = stream.EndRead (ares); return Encoding.ASCII.GetString (bytes, 0, nread); }
public int RunCommand(string command, Stream stdoutOutput, TextWriter stderrOutput) { m_channel = GetChannelExec(command); System.IO.Stream stdout = m_channel.getInputStream(); System.IO.Stream stderr = ((ChannelExec)m_channel).getErrStream(); m_channel.connect(); byte[] stdoutByteBuffer = new byte[1024]; byte[] stderrByteBuffer = new byte[32]; //////////////////////////////////////////////////////////////////////////// bool stdoutIsExhausted = false; AsyncCallback stdoutReadCallback = null; stdoutReadCallback = readResult => { int bytesRead = stdout.EndRead(readResult); if (bytesRead > 0) { stdoutOutput.Write( stdoutByteBuffer, 0, bytesRead ); stdout.BeginRead(stdoutByteBuffer, 0, stdoutByteBuffer.Length, stdoutReadCallback, null); } else if (bytesRead < 0) { stdoutOutput.Flush(); stdoutIsExhausted = true; } }; //////////////////////////////////////////////////////////////////////////// bool stderrIsExhausted = false; AsyncCallback stderrReadCallback = null; stderrReadCallback = readResult => { int bytesRead = stderr.EndRead(readResult); if (bytesRead > 0) { string text = System.Text.ASCIIEncoding.ASCII.GetString(stderrByteBuffer, 0, bytesRead); text = text.Replace("\n", Environment.NewLine); stderrOutput.Write(text); stderr.BeginRead(stderrByteBuffer, 0, stderrByteBuffer.Length, stderrReadCallback, null); } else if (bytesRead < 0) { stderrIsExhausted = true; } }; //////////////////////////////////////////////////////////////////////////// stdout.BeginRead(stdoutByteBuffer, 0, stdoutByteBuffer.Length, stdoutReadCallback, null); stderr.BeginRead(stderrByteBuffer, 0, stderrByteBuffer.Length, stderrReadCallback, null); while (!(stdoutIsExhausted && stderrIsExhausted)) { // empty loop; wait until reads are complete before returning } m_channel.disconnect(); return(m_channel.getExitStatus()); }
/// <summary> /// Ends to read bytes /// </summary> /// <param name="this">This Stream</param> /// <param name="result">The IAsyncResult representing the result of the Begin operation</param> public static void EndReadBytes(this Stream @this, IAsyncResult result) => @this.EndRead(result) ;
private void readComplete(IAsyncResult result, Stream stream) { int bytesRead = stream.EndRead(result); var chunk = _chunks[_chunks.Count - 1]; chunk.Length += bytesRead; if (_dataEvent != null) { var newBytes = new byte[bytesRead]; Array.Copy(chunk.Data, chunk.Length - bytesRead, newBytes, 0, bytesRead); _dataEvent(newBytes); } if (_textEvent != null) { var newChars = new char[bytesRead + 1]; // can have at most one char buffered up in the decoder, plus bytesRead new chars int bytesUsed, charsUsed; bool completed; _decoder.Convert(chunk.Data, chunk.Length - bytesRead, bytesRead, newChars, 0, newChars.Length, false, out bytesUsed, out charsUsed, out completed); Ut.Assert(completed); // it could still be halfway through a character; what this means is that newChars was large enough to accommodate everything _textEvent(new string(newChars, 0, charsUsed)); } if (bytesRead > 0) // continue reading ReadBegin(stream); else { Ended = true; if (_textEvent != null) { var newChars = new char[1]; int bytesUsed, charsUsed; bool completed; _decoder.Convert(new byte[0], 0, 0, newChars, 0, newChars.Length, true, out bytesUsed, out charsUsed, out completed); Ut.Assert(completed); if (charsUsed > 0) _textEvent(new string(newChars, 0, charsUsed)); } } }
private static MemoryStream ReadStreamToMemoryStream(Stream inputStream) { int bytesRead = 0; var buffer = new byte[4096]; MemoryStream result = new MemoryStream(); do { IAsyncResult asyncRead = inputStream.BeginRead(buffer, 0, buffer.Length, null, null); if (asyncRead.AsyncWaitHandle.WaitOne(250)) { bytesRead = inputStream.EndRead(asyncRead); result.Write(buffer, 0, bytesRead); } } while (bytesRead == buffer.Length); return result; }
private static int SafeRead(Stream readStream, byte[] packet) { try { if (null == readStream) return 0; var ar = readStream.BeginRead(packet, 0, packet.Length, null, null); int result = readStream.EndRead(ar); return result; } catch (IOException) { return 0; } catch (OperationCanceledException) { return 0; } catch (Exception ex) { return 0; } }
private static int ReadBuffersAsync(Stream stream1, Stream stream2, Buffers buffers, int readSize) { int offset = 0; int num2 = 0; int num3 = 1; int num4 = 1; do { IAsyncResult asyncResult = null; IAsyncResult result2 = null; if (num3 > 0) { asyncResult = stream1.BeginRead(buffers.Buffer1, offset, readSize - offset, null, null); } if (num4 > 0) { result2 = stream2.BeginRead(buffers.Buffer2, num2, readSize - num2, null, null); } if (asyncResult != null) { num3 = stream1.EndRead(asyncResult); } if (result2 != null) { num4 = stream2.EndRead(result2); } offset += num3; num2 += num4; } while (((num3 != 0) || (num4 != 0)) && ((offset != readSize) || (num2 != readSize))); if (offset == num2) { return offset; } return -1; }
private static int SafeRead(Stream readStream, byte[] packet, TimeSpan waitSpan) { try { if (TimeSpan.Zero >= waitSpan) return readStream.Read(packet, 0, packet.Length); var tempPacket = new byte[packet.Length]; var ar = readStream.BeginRead(tempPacket, 0, tempPacket.Length, null, null); var waitInterval = MinReadTimeSpan > waitSpan ? waitSpan : MinReadTimeSpan; DateTime start = DateTime.Now; do { Thread.Sleep(waitInterval); if (ar.IsCompleted) { break; } } while ((DateTime.Now - start) <= waitInterval); if (ar.IsCompleted) { var readLength = readStream.EndRead(ar); Array.Copy(tempPacket, packet, readLength); return readLength; } readStream.Close(); readStream.Dispose(); return -1; } catch (IOException) { return 0; } catch (OperationCanceledException) { return 0; } catch (Exception ex) { return 0; } }
private void CopyStreamAsync(Stream input, Stream output, bool flushInput, bool flushOutput, StreamCopyCompletedDelegate completed) { byte[] buffer = new byte[1024 * 4]; var asyncOp = System.ComponentModel.AsyncOperationManager.CreateOperation(null); Action<Exception> done = e => { if (completed != null) asyncOp.Post(delegate { completed(input, output, e); }, null); }; AsyncCallback rc = null; rc = readResult => { try { int read = input.EndRead(readResult); if (read > 0) { if (flushInput) input.Flush(); output.BeginWrite(buffer, 0, read, writeResult => { try { output.EndWrite(writeResult); if (flushOutput) output.Flush(); input.BeginRead(buffer, 0, buffer.Length, rc, null); } catch (Exception exc) { done(exc); } }, null); } else done(null); } catch (Exception exc) { done(exc); } }; input.BeginRead(buffer, 0, buffer.Length, rc, null); }
public override int EndRead(IAsyncResult asyncResult) { lock (_stream) return(_stream.EndRead(asyncResult)); }