private BeginRead ( byte buffer, int offset, int count, AsyncCallback callback, Object state ) : IAsyncResult | ||
buffer | byte | |
offset | int | |
count | int | |
callback | AsyncCallback | |
state | Object | |
return | IAsyncResult |
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); } }
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); }
void dataRead(IAsyncResult result) { byte[] buffer = result.AsyncState as byte[]; string data = ASCIIEncoding.ASCII.GetString(buffer, 0, buffer.Length); OnDataRecived.Invoke(data); if (!stopReciver) { buffer = new byte[BufferSize]; connectionStream.BeginRead(buffer, 0, BufferSize, dataRead, buffer); } }
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; }
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); } }
public override IAsyncResult BeginRead(byte [] buffer, int offset, int count, AsyncCallback cback, object state) { if (disposed) { throw new ObjectDisposedException(typeof(RequestStream).ToString()); } int nread = FillFromBuffer(buffer, offset, count); if (nread > 0 || nread == -1) { HttpStreamAsyncResult ares = new HttpStreamAsyncResult(); ares.Buffer = buffer; ares.Offset = offset; ares.Count = count; ares.Callback = cback; ares.State = state; ares.SynchRead = nread; ares.Complete(); return(ares); } // Avoid reading past the end of the request to allow // for HTTP pipelining if (remaining_body >= 0 && count > remaining_body) { count = (int)Math.Min(Int32.MaxValue, remaining_body); } return(stream.BeginRead(buffer, offset, count, cback, state)); }
/// <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 Connect() { try { // Initialize Packet Factory PacketHandler.Initialize(); // Connect Socket m_Socket = new TcpClient(m_ServerIP, m_Port); m_Stream = m_Socket.GetStream(); m_Stream.BeginRead(m_bRecvBuffer, 0, MAX_PACKET_SIZE, new AsyncCallback(EndDataReceive), null); if (m_Socket.Connected) { Debugger.Log("Connected to {0} on {1}", m_ServerIP, m_Port); } else { Disconnect(); throw new ApplicationException("Failed to connect to server"); } return true; } catch(Exception e) { Debugger.Log (Debugger.LogLevel.Info, "SocketServer", "Connect: {0}", e.Message); } return false; }
static void Main(string[] args) { _readBuffer = new byte[960]; Console.WriteLine("Opening \"{0}\" for playback", OpenALHelper.PlaybackDevices[0].DeviceName); Console.WriteLine("Opening \"{0}\" for capture", OpenALHelper.CaptureDevices[0].DeviceName); _playback = OpenALHelper.PlaybackDevices[0].OpenStream(48000, OpenALAudioFormat.Mono16Bit); _playback.Listener.Position = new Vector3() { X = 0.0f, Y = 0.0f, Z = 0.0f }; _playback.Listener.Velocity = new Vector3() { X = 0.0f, Y = 0.0f, Z = 0.0f }; _playback.Listener.Orientation = new Orientation() { At = new Vector3() { X = 0.0f, Y = 0.0f, Z = 1.0f }, Up = new Vector3() { X = 0.0f, Y = 1.0f, Z = 0.0f } }; _playback.ALPosition = new Vector3() { X = 0.0f, Y = 0.0f, Z = 0.0f }; _playback.Velocity = new Vector3() { X = 0.0f, Y = 0.0f, Z = 0.0f }; _capture = OpenALHelper.CaptureDevices[0].OpenStream(48000, OpenALAudioFormat.Mono16Bit, 10); _capture.BeginRead(_readBuffer, 0, _readBuffer.Length, Callback, null); while (true) { PrintUI(); if (ProcessInput()) break; } _playback.Close(); _playback.Dispose(); _capture.Close(); _capture.Dispose(); }
private AsyncComparer(Stream source, byte[] expected, Action<bool> completed) { _expected = expected; _src = source; _completed = completed; _src.BeginRead(_buffer, 0, ChunkSize, OnRead, null); }
public void Connect() { _channel = StreamFactory.CreateStream(_connString); readOp = _channel.BeginRead(headerBuffer, 0, 1, callback, null); // Give the qosManager a handle to the streams qosManager.SetStreamManager(this); _connected = true; }
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); }
public IAsyncResult BeginRead( Stream stream, AsyncCallback callback ) { if ( IsFull ) { Debug.Print( "FancyBuffer.BeginRead: buffer is full" ); throw new Exception( "Read buffer is full." ); } _stream = stream; return _stream.BeginRead( Buffer, Offset, Available, callback, this ); }
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; }
public AsyncStreamReader(Stream stream, Action<byte[]> completed, int bufferSize) { _bufferSize = bufferSize; _buffer = new byte[_bufferSize]; _completed = completed; _stream = stream; _all = new List<byte>(); _stream.BeginRead(_buffer, 0, _bufferSize, Callback, this); }
public static void Copy( Stream in_sourceStream, Stream out_destStream ) { Streams streams = new Streams( in_sourceStream, out_destStream ); IAsyncResult ar = in_sourceStream.BeginRead( streams.Buffer, 0, streams.BufferSize, new AsyncCallback( CopyStreamCallback ), streams ); }
public override IAsyncResult BeginRead( byte[] buffer, int offset, int count, AsyncCallback callback, object state ) { Trace.WriteLine("TraceStream", String.Format("BeginRead(): offset({0}), count({1})", offset, count)); return(m_in.BeginRead(buffer, offset, count, callback, state)); }
/// <summary> /// Creates a redirector between the two streams /// </summary> public StreamRedirect(Stream from, Stream to, string connInfo) { _logger = null; _from = from; _to = to; _connectionInfo = connInfo; _closed = new ManualResetEvent(false); _buffer = new byte[BUFF_SIZE]; _result = _from.BeginRead(_buffer, 0, _buffer.Length, OnRead, null); }
public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state) { _lock.AcquireReaderLock(); try { if (this.IsClosed) { throw new ObjectDisposedException(null); } } finally { _lock.ReleaseReaderLock(); } return(_innerStream.BeginRead(buffer, offset, count, callback, state)); }
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; }
protected void StartRecording() { //Create or overwrite tempfile this.TempFile = File.Create(PathSettings.TempFilePath); //Getting stream WebRequest wReq = WebRequest.Create(this.StreamURL); HttpWebResponse hRes = (HttpWebResponse)wReq.GetResponse(); System.IO.Stream RadioStream = hRes.GetResponseStream(); //Start reading process this.ReadHandle = RadioStream.BeginRead(this.Buffer, 0, this.Buffer.Length, new System.AsyncCallback(this.TempSave), RadioStream); }
public AsyncStreamReader(Stream aStream, Encoding anEncoding, EventHandler<LineReceivedEventArgs> aLineReceivedCallback) { if (aStream == null) throw new ArgumentNullException("aStream"); if (anEncoding == null) throw new ArgumentNullException("anEncoding"); if (!aStream.CanRead) throw new ArgumentException("Stream does not support reading"); theBaseStream = aStream; theEncoding = anEncoding; theLineReaded = aLineReceivedCallback; theBaseStream.BeginRead(theReadBuffer, 0, theReadBuffer.Length, AsyncCallback, null); }
private void ReadAsync(Stream responseStream) { Task.Factory.FromAsync<int>((callback, o) => responseStream.BeginRead(buffer, posInBuffer, buffer.Length- posInBuffer, callback, o), responseStream.EndRead, null) .ContinueWith(task => { var read = task.Result; if (read == 0)// will for a reopening of the connection throw new EndOfStreamException(); // find \r\n in newly read range var startPos = 0; byte prev = 0; bool foundLines = false; for (int i = posInBuffer; i < posInBuffer + read; i++) { if (prev == '\r' && buffer[i] == '\n') { foundLines = true; // yeah, we found a line, let us give it to the users var data = Encoding.UTF8.GetString(buffer, startPos, i - 1 - startPos); startPos = i + 1; Dispatcher.BeginInvoke(() => { ServerResults.Text += data + Environment.NewLine; }); } prev = buffer[i]; } posInBuffer += read; if (startPos >= posInBuffer) // read to end { posInBuffer = 0; return; } if (foundLines == false) return; // move remaining to the start of buffer, then reset Array.Copy(buffer, startPos, buffer, 0, posInBuffer - startPos); posInBuffer -= startPos; }) .ContinueWith(task => { if (task.IsFaulted) return; ReadAsync(responseStream); }); }
public void StartReceive(Stream stream) { if (stream == null) throw new ArgumentNullException("stream"); if (this.stream != null) throw new InvalidOperationException("StartReceive can be called only once."); this.stream = stream; try { stream.BeginRead(buffer, 0, buffer.Length, OnReceive, null); } catch (ObjectDisposedException) { OnConnectionLost(); } catch (IOException) { OnConnectionLost(); } }
public void AsyncFileReadTestCase() { buffer = new Byte[BufferSize]; myCallBack = new AsyncCallback(this.OnCompletedRead); isoReaderStreamCallBack = File.OpenRead(@"/Users/tomohiro/gitrepo/study/CSharp-Study/kinmokusei/AsyncText.txt"); isoReaderStreamCallBack.BeginRead( // 非同期読み込み buffer, // 読み込み結果を格納するバッファ 0, // 読み込みの始点 buffer.Length, // バッファのサイズ myCallBack, // 読み込み完了時のコールバック null // 状態を取得するためのオブジェクト ); for( int i = 0; i < 100; i++ ) Console.WriteLine("i={0}", i); isoReaderStreamCallBack.Close (); }
/// <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); }
private void startStreamAsyncRead() { byte[] buffer = new byte[1000000]; if (this.isConnected() == false) { System.Diagnostics.Debug.WriteLine("isconnected is false"); this.OnServerDisconnected(new ServerEventArgs(this.tcpClient)); this.Disconnect(); return; } if (useExplicitStreams) { AsyncCallback networkReadCallback = new AsyncCallback(dataReceivedSsh); sshStreamRead.BeginRead(buffer, 0, 100000, networkReadCallback, buffer); } else { if (!tcpStream.CanRead) { return; /* program probably died */ } AsyncCallback networkReadCallback = new AsyncCallback(dataReceived); try { if (tcpStreamGzipRead != null) { tcpStreamGzipRead.BeginRead(buffer, 0, 1000000, networkReadCallback, buffer); } else { tcpStream.BeginRead(buffer, 0, 1000000, networkReadCallback, buffer); } } catch (Exception) { MessageBox.Show("Disconnected?"); } // tcpStream.Read(buffer, p, p_3); } }
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 void CopyStream(Stream media) { // Make sure the stream is ready first. int tries = 10000; // 10 Seconds do { if (this.IsReady) break; System.Threading.Thread.Sleep(1); } while (--tries != 0); if (IsReady) { buffer = new byte[0x1000]; media.BeginRead(buffer, 0, buffer.Length, MediaReadAsyncCallback, media); } else { throw new Exception("Pipe Stream isn't ready."); } }
public void Connect(IPAddress address) { m_Address = address; try { m_Socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); m_Socket.Connect(new IPEndPoint(address, 48888)); m_NetworkStream = new NetworkStream(m_Socket); m_NetworkStream.BeginRead(m_ReadBuffer, 0, READ_BUFFER_SIZE, m_cbDataRead, null); parent.PostMessage("Successfully connected to robot host."); } catch(Exception ex) { parent.PostMessage("Error connecting to robot host.\r\n " + ex.Message); m_Socket = null; m_NetworkStream = null; } parent.UpdateStatus(); }
private bool VerifyReadException(System.IO.Stream serialStream, Type expectedException) { bool retValue = true; System.IAsyncResult readAsyncResult; try { readAsyncResult = serialStream.BeginRead(new byte[defaultByteArraySize], 0, defaultByteArraySize, null, null); readAsyncResult.AsyncWaitHandle.WaitOne(); Console.WriteLine("ERROR!!!: No Excpetion was thrown"); retValue = false; } catch (System.Exception e) { if (e.GetType() != expectedException) { Console.WriteLine("ERROR!!!: {0} exception was thrown expected {1}", e.GetType(), expectedException); retValue = false; } } return(retValue); }
public override void recv(byte[] buffer, int offset, int size, ResultHandler rh) { mStream.BeginRead(buffer, offset, size, new AsyncCallback(RecvCallback), rh); }
/// <summary> /// Begins an asynchronous read operation. /// </summary> /// <param name="stream">The stream to read from.</param> /// <param name="buffer">The buffer to read the data into.</param> /// <param name="callback">The callback to which a System.IO.AsyncStreamOperationState object is passed.</param> public static void BeginRead(this Stream stream, byte[] buffer, AsyncCallback callback) { stream.BeginRead(buffer, 0, buffer.Length, callback, new StreamAsyncState(stream, buffer)); }
/// <inheritdoc /> public override IAsyncResult BeginRead(byte[] buffer, int offset, int count, AsyncCallback callback, object state) { return(_stream.BeginRead(buffer, offset, count, callback, state)); }
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()); }
public static IAsyncResult BeginReadStreamToEnd(Stream stream, byte[] buffer, int offset, int count, AsyncCallback callback, Object state) { byte[] tempBuffer = new byte[count]; ByteArrayAsyncResult result = new ByteArrayAsyncResult(callback, state, buffer, offset, tempBuffer); ByteArrayAsyncState asyncState = new ByteArrayAsyncState(); asyncState.Result = result; asyncState.Stream = stream; stream.BeginRead(tempBuffer, 0, count, OnRead, asyncState); return result; }
public void Start() { Console.WriteLine("Sensor: Starting Speed Sensor"); port.Open(); stream = port.BaseStream; // C# serial port class is dangerous, only the BaseStream is safe // http://www.sparxeng.com/blog/software/must-use-net-system-io-ports-serialport stream.BeginRead(recvBuffer, 0, recvBuffer.Length, OnRecv, null); }