internal static StorageTask <WebResponse> GetResponseAsyncWithTimeout(this WebRequest req, CloudBlobClient service, TimeSpan?timeout) { StorageTask <WebResponse> serverTask = req.GetResponseAsyncEx(service); StorageTask <WebResponse> wrappedTask = TimeoutHelper.GetTimeoutWrappedTask(timeout, serverTask); return(wrappedTask); }
public TaskAsyncResult(StorageTask <T> async, AsyncCallback callback, object state) { this.realTask = async; this.userCallback = callback; this.userState = state; // We don't need finalization, we just implement IDisposable to let users close the event GC.SuppressFinalize(this); this.realTask.ExecuteStep(this.OnComplete); }
/// <summary> /// Gets a timeout wrapped task. /// </summary> /// <typeparam name="T">The type of the result.</typeparam> /// <param name="timeout">The timeout.</param> /// <param name="originalTask">The original task.</param> /// <returns>A <see cref="Task<T>"/> that has been wrapped with a timeout if specified.</returns> internal static StorageTask <T> GetTimeoutWrappedTask <T>(TimeSpan?timeout, StorageTask <T> originalTask) { TraceHelper.WriteLine("Creating timeout wrapped task " + timeout); if (timeout.HasValue) { StorageTask <T> wrappedTimeoutTask = new InvokeTaskSequenceTask <T>((setResult) => GetTimeoutTaskSequence(timeout.Value, setResult)); return(new RaceTask <T>(wrappedTimeoutTask, originalTask)); } else { return(originalTask); } }
protected override void ExecuteInternal() { TraceHelper.WriteLine("RaceTask, ExecuteInternal"); // kick off the tasks foreach (StorageTask <T> async in this.tasks) { if (this.Completed) { break; } StorageTask <T> a2 = async; a2.ExecuteStep(delegate { this.OnComplete(a2); }); } }
internal static TaskSequence ReadToString(this Stream stream, System.Text.Encoding encoding, Action <string> result) { using (var ms = new SmallBlockMemoryStream()) { int read = -1; while (read != 0) { byte[] buffer = new byte[1024]; StorageTask <int> count = stream.ReadAsyncEx(buffer, 0, 1024); yield return(count); ms.Write(buffer, 0, count.Result); read = count.Result; } ms.Seek(0, SeekOrigin.Begin); using (var strm = new StreamReader(ms, encoding)) { result(strm.ReadToEnd()); } } }
private void OnComplete(StorageTask <T> winner) { TraceHelper.WriteLine("RaceTask, OnComplete"); if (this.Completed) { return; ////throw new InvalidOperationException("completion already occurred"); } int currentlyAborting = Interlocked.CompareExchange(ref this.aborting, 1, 0); if (currentlyAborting == 1) { // the loser tasks (ie. this) are 'completing' return; } // winner reaches here // abort the other tasks foreach (StorageTask <T> loser in this.tasks) { if (!object.ReferenceEquals(loser, winner)) { loser.Abort(); } } if (winner.Exception != null) { this.Exception = winner.Exception; } else { SetResult(() => winner.Result); } Complete(winner.CompletedSynchronously); }
internal static IAsyncResult ToAsyncResult(this StorageTask <NullTaskReturn> async, AsyncCallback callback, object state) { return(new TaskAsyncResult <NullTaskReturn>(async, callback, state)); }