public void GetOutputAsync(Action <Exception, string> callback)
        {
            Ensure.NotNull(callback, "callback");
            _callback = callback;

            var info = new ProcessStartInfo
            {
                RedirectStandardOutput = true,
                UseShellExecute        = false,
                CreateNoWindow         = true,
                FileName  = Command,
                Arguments = Args ?? string.Empty
            };

            // note MM: takes time to start a process. no async API available
            ThreadPool.QueueUserWorkItem(_ =>
            {
                Stream inputStream;
                try
                {
                    _process    = Process.Start(info);
                    inputStream = _process.StandardOutput.BaseStream;
                }
                catch (Exception ex)
                {
                    OnCompleted(ex, null);
                    return;
                }

                var copier        = new AsyncStreamCopier <object>(inputStream, _outputStream, null);
                copier.Completed += OnStreamCopied;
                copier.Start();
            });
        }
        private void ResponseAcquired(IAsyncResult ar)
        {
            var state = (ClientOperationState)ar.AsyncState;

            try
            {
                var response      = (HttpWebResponse)state.Request.EndGetResponseExtended(ar);
                var networkStream = response.GetResponseStream();

                if (networkStream == null)
                {
                    throw new ArgumentNullException("networkStream", "Response stream was null");
                }

                state.Response     = new HttpResponse(response);
                state.InputStream  = networkStream;
                state.OutputStream = new MemoryStream();

                var copier = new AsyncStreamCopier <ClientOperationState>(state.InputStream, state.OutputStream, state);
                copier.Completed += ResponseRead;
                copier.Start();
            }
            catch (Exception e)
            {
                state.DisposeIOStreams();
                state.OnError(e);
            }
        }
        public void ReadRequestAsync(Action<HttpEntityManager, byte[]> onReadSuccess, Action<Exception> onError)
        {
            Ensure.NotNull(onReadSuccess, "OnReadSuccess");
            Ensure.NotNull(onError, "onError");

            var state = new ManagerOperationState(
                HttpEntity.Request.InputStream, new MemoryStream(), onReadSuccess, onError);
            var copier = new AsyncStreamCopier<ManagerOperationState>(
                state.InputStream, state.OutputStream, state, RequestRead);
            copier.Start();
        }
    public static void NetToFile_Option2(NetworkStream net, FileStream file)
    {
        var completedEvent = new ManualResetEvent(false);

        // copy as usual but listen for completion
        var copier = new AsyncStreamCopier(net, file);

        copier.Completed += (s, e) => completedEvent.Set();
        copier.Start();

        completedEvent.WaitOne();
    }
        private void WriteResponseAsync(byte[] response, Action <Exception> onError)
        {
            SetResponseLength(response.Length);

            var state = new ManagerOperationState(HttpEntity, (sender, e) => {}, onError)
            {
                InputStream  = new MemoryStream(response),
                OutputStream = HttpEntity.Response.OutputStream
            };
            var copier = new AsyncStreamCopier <ManagerOperationState>(state.InputStream, state.OutputStream, state);

            copier.Completed += ResponseWritten;
            copier.Start();
        }
Exemple #6
0
        public void ReadRequestAsync(Action <HttpEntityManager, string> onSuccess, Action <Exception> onError)
        {
            Ensure.NotNull(onSuccess, "onSuccess");
            Ensure.NotNull(onError, "onError");

            var state = new ManagerOperationState(HttpEntity, onSuccess, onError)
            {
                InputStream  = HttpEntity.Request.InputStream,
                OutputStream = new MemoryStream()
            };

            var copier = new AsyncStreamCopier <ManagerOperationState>(state.InputStream, state.OutputStream, state);

            copier.Completed += RequestRead;
            copier.Start();
        }
        private void GotRequestStream(IAsyncResult ar)
        {
            var state = (ClientOperationState)ar.AsyncState;

            try
            {
                var networkStream = state.Request.EndGetRequestStream(ar);
                state.OutputStream = networkStream;
                var copier = new AsyncStreamCopier <ClientOperationState>(state.InputStream, networkStream, state, RequestWrote);
                copier.Start();
            }
            catch (Exception e)
            {
                state.DisposeIOStreams();
                state.OnError(e);
            }
        }
        public void ReadRequestAsync(Action<HttpEntityManager, byte[]> onReadSuccess, Action<Exception> onError)
        {
            Ensure.NotNull(onReadSuccess, "OnReadSuccess");
            Ensure.NotNull(onError, "onError");

            var state = new ManagerOperationState(
                HttpEntity.Request.InputStream, new MemoryStream(), onReadSuccess, onError);
            var copier = new AsyncStreamCopier<ManagerOperationState>(
                state.InputStream, state.OutputStream, state, RequestRead);
            copier.Start();
        }
 private void GotRequestStream(IAsyncResult ar)
 {
     var state = (ClientOperationState)ar.AsyncState;
     try
     {
         var networkStream = state.Request.EndGetRequestStream(ar);
         state.OutputStream = networkStream;
         var copier = new AsyncStreamCopier<ClientOperationState>(state.InputStream, networkStream, state);
         copier.Completed += RequestWrote;
         copier.Start();
     }
     catch (Exception e)
     {
         state.DisposeIOStreams();
         state.OnError(e);
     }
 }
        private void ResponseAcquired(IAsyncResult ar)
        {
            var state = (ClientOperationState)ar.AsyncState;
            try
            {
                var response = (HttpWebResponse)state.Request.EndGetResponseExtended(ar);
                var networkStream = response.GetResponseStream();

                if (networkStream == null)
                    throw new ArgumentNullException("networkStream", "Response stream was null");

                state.Response = new HttpResponse(response);
                state.InputStream = networkStream;
                state.OutputStream = new MemoryStream();

                var copier = new AsyncStreamCopier<ClientOperationState>(state.InputStream, state.OutputStream, state);
                copier.Completed += ResponseRead;
                copier.Start();
            }
            catch (Exception e)
            {
                state.DisposeIOStreams();
                state.OnError(e);
            }
        }
        public void ReadRequestAsync(Action<HttpEntityManager, string> onSuccess, Action<Exception> onError)
        {
            Ensure.NotNull(onSuccess, "onSuccess");
            Ensure.NotNull(onError, "onError");

            var state = new ManagerOperationState(HttpEntity, onSuccess, onError)
                            {
                                InputStream = HttpEntity.Request.InputStream,
                                OutputStream = new MemoryStream()
                            };

            var copier = new AsyncStreamCopier<ManagerOperationState>(state.InputStream, state.OutputStream, state);
            copier.Completed += RequestRead;
            copier.Start();
        }
        private void WriteResponseAsync(byte[] response, Action<Exception> onError)
        {
            SetResponseLength(response.Length);

            var state = new ManagerOperationState(HttpEntity, (sender, e) => {}, onError)
                            {
                                InputStream = new MemoryStream(response),
                                OutputStream = HttpEntity.Response.OutputStream
                            };
            var copier = new AsyncStreamCopier<ManagerOperationState>(state.InputStream, state.OutputStream, state);
            copier.Completed += ResponseWritten;
            copier.Start();
        }
    public static void NetToFile(NetworkStream net, FileStream file)
    {
        var copier = new AsyncStreamCopier(net, file);

        copier.Start();
    }
        public void GetOutputAsync(Action<Exception, string> callback)
        {
            Ensure.NotNull(callback, "callback");
            _callback = callback;

            var info = new ProcessStartInfo
            {
                RedirectStandardOutput = true,
                UseShellExecute = false,
                CreateNoWindow = true,
                FileName = Command,
                Arguments = Args ?? string.Empty
            };

            // note MM: takes time to start a process. no async API available
            ThreadPool.QueueUserWorkItem(_ =>
            {
                Stream inputStream;
                try
                {
                    _process = Process.Start(info);
                    inputStream = _process.StandardOutput.BaseStream;
                }
                catch (Exception ex)
                {
                    OnCompleted(ex, null);
                    return;
                }

                var copier = new AsyncStreamCopier<object>(inputStream, _outputStream, null);
                copier.Completed += OnStreamCopied;
                copier.Start();
            });
        }