Ejemplo n.º 1
0
        public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request)
        {
            var tcs = new TaskCompletionSource<Stream>();

            try
            {
                request.BeginGetRequestStream(iar =>
                {
                    try
                    {
                        var response = request.EndGetRequestStream(iar);
                        tcs.SetResult(response);
                    }
                    catch (Exception exc)
                    {
                        tcs.SetException(exc);
                    }
                }, null);
            }
            catch (Exception exc)
            {
                tcs.SetException(exc);
            }

            return tcs.Task;
        }
Ejemplo n.º 2
0
        public static Task<Stream> GetStreamAsync(this HttpWebRequest context, object state)
        {
            // this will be our sentry that will know when our async operation is completed
            var tcs = new TaskCompletionSource<Stream>();

            try
            {
                context.BeginGetRequestStream((iar) =>
                {
                    try
                    {
                        var result = context.EndGetRequestStream(iar as IAsyncResult);
                        tcs.TrySetResult(result);
                    }
                    catch (OperationCanceledException ex)
                    {
                        // if the inner operation was canceled, this task is cancelled too
                        tcs.TrySetCanceled();
                    }
                    catch (Exception ex)
                    {
                        // general exception has been set
                        tcs.TrySetException(ex);
                    }
                }, state);
            }
            catch
            {
                tcs.TrySetResult(default(Stream));
                // propagate exceptions to the outside
                throw;
            }

            return tcs.Task;
        }
Ejemplo n.º 3
0
        /// <include file='../_Doc/System.xml' path='doc/members/member[@name="M:System.Net.WebRequest.GetRequestStream"]/*' />
        /// <param name="request">HTTP web request object on which to get request stream.</param>
        public static Stream GetRequestStream(this WebRequest request)
        {
#if DOTNET
            return request.GetRequestStream();
#else
            return request.EndGetRequestStream(request.BeginGetRequestStream(null, null));
#endif
        }
Ejemplo n.º 4
0
 public static Stream GetRequestStream(this WebRequest request)
 {
     AutoResetEvent autoResetEvent = new AutoResetEvent(false);
     IAsyncResult asyncResult = request.BeginGetRequestStream(r => autoResetEvent.Set(), null);
     // Wait until the call is finished
     autoResetEvent.WaitOne();
     return request.EndGetRequestStream(asyncResult);
 }
Ejemplo n.º 5
0
 public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request)
 {
     var taskComplete = new TaskCompletionSource<Stream>();
     request.BeginGetRequestStream(ar =>
     {
         Stream requestStream = request.EndGetRequestStream(ar);
         taskComplete.TrySetResult(requestStream);
     }, request);
     return taskComplete.Task;
 }
Ejemplo n.º 6
0
        internal static void WriteBody(this HttpWebRequest request, byte[] data)
        {
#if PORTABLE45
            Stream outs = null;
            //outs = request.GetRequestStreamAsync().Result;
            //outs.Write(data, 0, (int)data.Length);
            //outs.Flush();
            //outs.Dispose();

            ManualResetEvent requestReady = new ManualResetEvent(initialState: false);
            Exception caught = null;

            AsyncCallback callback = new AsyncCallback(ar =>
            {
                //var request = (WebRequest)ar.AsyncState;
                try
                {
                    outs = request.EndGetRequestStream(ar);
                }
                catch (Exception ex)
                {
                    caught = ex;
                }
                finally
                {
                    requestReady.Set();
                }
            });

            var async = request.BeginGetRequestStream(callback, null);

            if (!async.IsCompleted)
            {
                //async.AsyncWaitHandle.WaitOne();
                // Not having thread affinity seems to work better with ManualResetEvent
                // Using AsyncWaitHandle.WaitOne() gave unpredictable results (in the
                // unit tests), when EndGetResponse would return null without any error
                // thrown
                requestReady.WaitOne();
                //async.AsyncWaitHandle.WaitOne();
            }

            if (caught != null) throw caught;

            outs.Write(data, 0, (int)data.Length);
            outs.Flush();
            outs.Dispose();
#else
            Stream outs = request.GetRequestStream();
            outs.Write(data, 0, (int)data.Length);
            outs.Flush();
            outs.Dispose();
#endif
        }
Ejemplo n.º 7
0
 public static Stream GetRequestStream(this WebRequest request)
 {
     ManualResetEvent evt = new ManualResetEvent(false);
     Stream requestStream = null;
     request.BeginGetRequestStream((IAsyncResult ar) => {
         requestStream = request.EndGetRequestStream(ar);
         evt.Set();
     }, null);
     evt.WaitOne();
     return requestStream;
 }
Ejemplo n.º 8
0
 public static void GetResponseContent(this HttpWebRequest request, byte[] requestContent, Action<string> result)
 {
     request.BeginGetRequestStream((iar) =>
     {
         using (Stream requestStrm = request.EndGetRequestStream(iar))
         {
             requestStrm.Write(requestContent, 0, requestContent.Length);
         }
         GetResponseContent(request, result);
     }, request);
 }
        internal static void SetContentAsync(this WebRequest request, string content)
        {
            request.BeginGetRequestStream
                (ar =>
                     {
                         using (var writer = new System.IO.StreamWriter(request.EndGetRequestStream(ar)))
                         {
                             writer.Write(content);
                         }

                     }, null);
        }
Ejemplo n.º 10
0
 public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request)
 {
     var taskComplete = new TaskCompletionSource<Stream>();
       request.BeginGetRequestStream(asyncResponse => {
     try {
       var responseRequest = (HttpWebRequest)asyncResponse.AsyncState;
       var someResponse = (Stream)responseRequest.EndGetRequestStream(asyncResponse);
       taskComplete.TrySetResult(someResponse);
     } catch (WebException webExc) {
       var failedResponse = (HttpWebResponse)webExc.Response;
       taskComplete.TrySetResult(null);
     }
       }, request);
       return taskComplete.Task;
 }
		public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request)
		{
			var taskComplete = new TaskCompletionSource<Stream>();

			request.AllowReadStreamBuffering = true;
			request.AllowWriteStreamBuffering = true;

			request.BeginGetRequestStream(ar =>
			{
				var requestStream = request.EndGetRequestStream(ar);
				taskComplete.TrySetResult(requestStream);
			}, request);

			return taskComplete.Task;
		}
Ejemplo n.º 12
0
        public static IAsyncResult ExecutePutAsync(this WebRequest request,
                                                   byte[] content,
                                                   Action
                                                       <WebResponseEventArgs>
                                                       callback)
        {
            Console.WriteLine("POST: {0}", request.RequestUri);

            ClearLastResponse();

            var state = new object[] {request, content, callback};

            return request.BeginGetRequestStream(
                BeginGetRequestStreamCompleted, state);
        }
 /// <summary>
 /// get the request stream asynchronously
 /// </summary>
 /// <param name="request">the request</param>
 /// <returns>the request stream to write on</returns>
 public static Task<Stream> GetRequestStreamAsync(this WebRequest request)
 {
     var taskComplete = new TaskCompletionSource<Stream>();
     request.BeginGetRequestStream(asyncStream =>
     {
         try
         {
             Stream requestStream = (Stream)request.EndGetRequestStream(asyncStream);
             taskComplete.TrySetResult(requestStream);
         }
         catch (Exception e)
         {
             taskComplete.TrySetException(e);
         }
     }, request);
     return taskComplete.Task;
 }
Ejemplo n.º 14
0
 public static Task<Stream> GetRequestStreamAsync(this WebRequest request)
 {
     var taskSource = new TaskCompletionSource<Stream>();
     request.BeginGetRequestStream(ar =>
     {
         try
         {
             var webRequest = ar.AsyncState as WebRequest;
             var stream = webRequest.EndGetRequestStream(ar);
             taskSource.TrySetResult(stream);
         }
         catch (Exception ex)
         {
             taskSource.TrySetException(ex);
         }
     }, request);
     return taskSource.Task;
 }
 public static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request)
 {
     var taskComplete = new TaskCompletionSource<Stream>();
     request.BeginGetRequestStream(asyncResult =>
         {
             try
             {
                 HttpWebRequest webRequest = (HttpWebRequest)asyncResult.AsyncState;
                 Stream stream = (Stream)webRequest.EndGetRequestStream(asyncResult);
                 taskComplete.TrySetResult(stream);
             }
             catch (Exception ex)
             {
                 taskComplete.SetException(ex);
             }
         }, request);
     return taskComplete.Task;
 }
        /// <summary>
        /// 异常信息与 request 的 BeginGetRequestStream, EndGetRequestStream 相同。
        /// </summary>
        /// <param name="request"></param>
        /// <returns></returns>
        public static async Task<Stream> GetRequestStreamAsync(this HttpWebRequest request)
        {
            var task = new TaskCompletionSource<Stream>();

            request.BeginGetRequestStream(ac =>
            {
                try
                {
                    task.SetResult(request.EndGetRequestStream(ac));
                }
                catch (Exception e)
                {
                    task.SetException(e);
                }
            }, null);

            return await task.Task;
        }
Ejemplo n.º 17
0
        public static Stream GetRequestStream(this HttpWebRequest request)
        {
            var dataReady = new AutoResetEvent(false);
            Stream stream = null;
            var callback = new AsyncCallback(delegate(IAsyncResult asynchronousResult)
            {
                stream = (Stream)request.EndGetRequestStream(asynchronousResult);
                dataReady.Set();
            });

            request.BeginGetRequestStream(callback, request);
            if (!dataReady.WaitOne(DefaultRequestTimeout))
            {
                return null;
            }

            return stream;
        }
        /// <summary>
        /// Synchronously gets a request stream for a given request.
        /// </summary>
        /// <param name="request">The request to be sent.</param>
        /// <param name="timeout">An optional timeout.</param>
        /// <returns>The stream that was received for the request.</returns>
        /// <exception cref="TimeoutException">If the <paramref name="timeout"/>
        /// parameter was set, and no stream was received within the specified
        /// time.</exception>
        public static Stream GetRequestStream(this HttpWebRequest request, int? timeout)
        {
            if (request == null) throw new ArgumentNullException("request");

              AutoResetEvent waitHandle = new AutoResetEvent(false);
              Stream requestStream = null;
              Exception exception = null;

              AsyncCallback callback = ar =>
                                 {
                                   //get the response
                                   try
                                   {
                                     requestStream = request.EndGetRequestStream(ar);
                                   }
                                   catch (Exception e)
                                   {
                                     exception = e;
                                   }
                                   finally
                                   {
                                     //setting the handle unblocks the loop below
                                     waitHandle.Set();
                                   }
                                 };

              //request stream async
              var asyncResult = request.BeginGetRequestStream(callback, null);
              if (asyncResult.CompletedSynchronously) return requestStream;

              bool hasSignal = waitHandle.WaitOne(timeout ?? Timeout.Infinite);
              if (!hasSignal)
              {
            throw new TimeoutException("No response received in time.");
              }

              //bubble exception that occurred on worker thread
              if (exception != null) throw exception;

              return requestStream;
        }
 public static Task<Stream> GetRequestStreamAsync(this WebRequest request)
 {
     var tcs = new TaskCompletionSource<Stream>();
     request.BeginGetRequestStream(res => tcs.SetResult(request.EndGetRequestStream(res)), request);
     return tcs.Task;
 }
Ejemplo n.º 20
0
 internal static Task<Stream> GetRequestStreamAsync(this HttpWebRequest request)
 {
     var tcs = new TaskCompletionSource<Stream>();
     request.BeginGetRequestStream(asyncResponse =>
     {
         try
         {
             var asyncState = (HttpWebRequest)asyncResponse.AsyncState;
             var stream = asyncState.EndGetRequestStream(asyncResponse);
             tcs.TrySetResult(stream);
         }
         catch (WebException ex)
         {
             tcs.SetException(ex);
         }
     }, request);
     return tcs.Task;
 }
Ejemplo n.º 21
0
 public static Task<System.IO.Stream> GetRequestStreamAsync(this System.Net.WebRequest request)
 {
     return Task.Factory.FromAsync(request.BeginGetRequestStream(null, null), ia => request.EndGetRequestStream(ia));
 }
        /// <summary>
        /// Extends BeginGetRequestStream so that when a state object is not needed, null does not need to be passed.
        /// <example>
        /// ftpwebrequest.BeginGetRequestStream(callback);
        /// </example>
        /// </summary>
        public static IAsyncResult BeginGetRequestStream(this FtpWebRequest ftpwebrequest, AsyncCallback callback)
        {
            if(ftpwebrequest == null) throw new ArgumentNullException("ftpwebrequest");

            return ftpwebrequest.BeginGetRequestStream(callback, null);
        }
Ejemplo n.º 23
0
 public static Stream GetRequestStream(this HttpWebRequest source)
 {
     var ar = source.BeginGetRequestStream(null, null);
     ar.AsyncWaitHandle.WaitOne();
     return source.EndGetRequestStream(ar);
 }
Ejemplo n.º 24
0
        public static void AddBody(this HttpWebRequest request, object body)
        {
            var serializedBody = JsonConvert.SerializeObject(body);
            request.ContentType = "application/json";

            var done = new ManualResetEvent(false);

            request.BeginGetRequestStream(ar =>
            {
                var request1 = (HttpWebRequest) ar.AsyncState;
                using (var postStream = request1.EndGetRequestStream(ar))
                {
                    var byteArray = Encoding.UTF8.GetBytes(serializedBody);
                    postStream.Write(byteArray, 0, byteArray.Length);
                }
                done.Set();
            }, request);

            done.WaitOne();
        }
		public static async Task<Stream> GetRequestStreamAsync(this WebRequest request) {
			return await new Task<Stream>(() => {
				IAsyncResult result = request.BeginGetRequestStream(ar => { }, null);
				return request.EndGetRequestStream(result);
			});
		}