private static T ReadPropFromForm <T>(HttpRequest request, LaunchData ld, string propKeyPrefix, TaskSettingProp prop, T defaultValue) { string key = propKeyPrefix + TaskSetting.ShorPropNames[prop]; if (request.Form.TryGetValue(key, out StringValues sVal)) { if (!String.IsNullOrEmpty(sVal)) { var val = TaskExtensions.ConvertValue(defaultValue.GetType(), sVal, null); if (val != null && val is T) { ld.Settings.SetProps |= prop; return((T)val); } } } return(defaultValue); }
public LoginView() { InitializeComponent(); #if DEBUG Loaded += (sender, args) => { var loginVm = (LoginViewModel)DataContext; loginVm.Username = "******"; var pw = new SecureString(); foreach (var c in "admin") { pw.AppendChar(c); } TaskExtensions.Forget(loginVm.LoginCommand.Execute(pw)); }; #endif }
public static void Main(string[] args) { System.Console.WriteLine( typeof(object).AssemblyQualifiedName ); var ut = new Task <Task <string> >( delegate { return(Task.FromResult( "async value " + new { Thread.CurrentThread.ManagedThreadId } )); } ); ut.Start(); ut.Wait(); var uu = TaskExtensions.Unwrap(ut); Console.WriteLine(new { uu.Result, Thread.CurrentThread.ManagedThreadId }); // java.lang.Object, rt //{ Result = async value { ManagedThreadId = 8 }, ManagedThreadId = 1 } // { Result = async value { ManagedThreadId = 11 }, ManagedThreadId = 1 } // X:\jsc.svn\examples\javascript\async\test\TestUnwrap\TestUnwrap\Application.cs var yt = Task.Run( delegate { return(Task.FromResult( "async value " + new { Thread.CurrentThread.ManagedThreadId } )); } ); //yt.Start(); yt.Wait(); // { Result = async value { ManagedThreadId = 3 }, ManagedThreadId = 1 } Console.WriteLine(new { yt.Result, Thread.CurrentThread.ManagedThreadId }); CLRProgram.CLRMain(); }
public static void ValidateProgressiveMethod(MethodInfo method) { ValidateAsyncMethod(method); Type returnType = TaskExtensions.UnwrapReturnType(method.ReturnType); ParameterInfo lastParameter = method.GetParameters().Last(); Type expectedParameterType = typeof(IProgress <>).MakeGenericType(returnType); if (lastParameter.ParameterType != expectedParameterType) { ThrowHelper.ProgressiveParameterTypeMismatch(method, returnType); } ValidateTupleReturnTypeOfProgressiveMethod(method, lastParameter); }
public void RetryActionThrowsAfterCorrectNumberOfAttempts() { var count = 0; try { TaskExtensions.Retry(() => { ++count; throw new InvalidOperationException(); }, 3); } // ReSharper disable EmptyGeneralCatchClause catch // ReSharper restore EmptyGeneralCatchClause { } Assert.AreEqual(4, count); }
public void RetryActionThrowsImmediatelyIfRetriesIsZero() { var count = 0; try { TaskExtensions.Retry(() => { ++count; throw new InvalidOperationException(); }, 0); } // ReSharper disable EmptyGeneralCatchClause catch // ReSharper restore EmptyGeneralCatchClause { } Assert.AreEqual(1, count); }
public TaskExtensions ToTaskExtensions(List <Task> tasks) { var taskExtensions = new TaskExtensions(); taskExtensions.ExtensionName = "DockerTaskExtension"; taskExtensions.FileName = "DockerTaskExtension.cs"; taskExtensions.Namespace = "FlubuCore.Context.FluentInterface"; taskExtensions.Usings.Add("FlubuCore.Context.FluentInterface.Docker"); taskExtensions.Usings.Add("FlubuCore.Tasks.Docker"); foreach (var task in tasks) { if (string.IsNullOrEmpty(task.Parent)) { taskExtensions.Methods.Add(MapToExtensionMethod(task)); } else { var subExtension = taskExtensions.SubExtensions.FirstOrDefault(x => x.ExtensionName == task.Parent); if (subExtension != null) { subExtension.Methods.Add(MapToExtensionMethod(task)); } else { subExtension = new TaskExtensions { ExtensionName = task.Parent, FileName = $"{task.Parent}.cs", Namespace = "FlubuCore.Context.FluentInterface.Docker", }; subExtension.Usings.Add($"FlubuCore.Tasks.Docker.{task.Parent}"); subExtension.Methods.Add(MapToExtensionMethod(task)); taskExtensions.SubExtensions.Add(subExtension); } } } taskExtensions.Methods = taskExtensions.Methods.Where(x => !taskExtensions.SubExtensions.Any(y => y.ExtensionName == x.MethodName)).ToList(); return(taskExtensions); }
public static bool HasMultivaluedResult(this MethodInfo method) { WampResultAttribute resultAttribute = method.ReturnParameter.GetCustomAttribute <WampResultAttribute>(true); Type unwrapped = TaskExtensions.UnwrapReturnType(method.ReturnType); if (!unwrapped.IsArray) { return(false); } if ((resultAttribute != null) && (resultAttribute.CollectionResultTreatment == CollectionResultTreatment.Multivalued)) { return(true); } return(false); }
public StartableBlock <TData> Create <TData>(StartableBlock <TData> source, ProcessingBlock <TData>[] processors, ProcessingBlock <TData> errorHandler, ProcessingBlock <TData> output, Predicate <TData> validDataPredicate, CancellationTokenSource cancellationSource) { // The pipeline looks like this: // source -> processor1 -> processor2 -> output // \ | | ^ // \ v v / // \--> errorHandler ----------/ // Link blocks source.Output.LinkWithCompletion(processors[0].Processor, validDataPredicate); source.Output.LinkTo(errorHandler.Processor, x => !validDataPredicate(x)); for (var i = 0; i < processors.Length - 1; i++) { processors[i].Processor.LinkWithCompletion(processors[i + 1].Processor, validDataPredicate); processors[i].Processor.LinkTo(errorHandler.Processor, x => !validDataPredicate(x)); } var lastProcessor = processors.Last(); lastProcessor.Processor.LinkTo(output.Processor, validDataPredicate); lastProcessor.Processor.LinkTo(errorHandler.Processor, x => !validDataPredicate(x)); errorHandler.Processor.LinkTo(output.Processor); // Propagate completions of multiple inputs errorHandler.Processor.DeriveCompletionOrFaultFrom(new[] { source.Output }.Concat(processors.Select(x => x.Processor))); output.Processor.DeriveCompletionOrFaultFrom(lastProcessor.Processor, errorHandler.Processor); // Create global completion var completion = TaskExtensions.CreateGlobalCompletion(new[] { source.Completion }.Concat(processors.Select(x => x.Completion)) .Concat(new[] { errorHandler.Completion, output.Completion }), cancellationSource); return(new StartableBlock <TData>(source, output, completion)); }
public StartableBlock <TData> Create <TData>(StartableBlock <TData> source, ProcessingBlock <TData>[] processors, CancellationTokenSource cancellationSource) { // The pipeline looks like this: // source -> processor1 -> processor2 -> processor3 (output) // Link blocks source.Output.LinkWithCompletion(processors[0].Processor); for (var i = 0; i < processors.Length - 1; i++) { processors[i].Processor.LinkWithCompletion(processors[i + 1].Processor); } // Create global completion var completion = TaskExtensions.CreateGlobalCompletion(new[] { source.Completion }.Concat(processors.Select(x => x.Completion)), cancellationSource); return(new StartableBlock <TData>(source, processors.Last(), completion)); }
public IEnumerator Should_RemovePlayerFromQueue_IfCancellationWasRequested() { yield return(TaskExtensions.RunTaskAsIEnumerator(async() => { var task1 = BBServer.Instance.Systems.MatchMaker.FindAMatch(testPlayer01, new MatchMakingSettings()); Assert.That(BBServer.Instance.Systems.MatchMaker.IsPlayerInQueue(testPlayer01), Is.True); Assert.That(task1.IsCompleted, Is.False); BBServer.Instance.Systems.MatchMaker.CancelFindingMatchFor(testPlayer01); Assert.That(BBServer.Instance.Systems.MatchMaker.IsPlayerInQueue(testPlayer01), Is.False); Assert.That(task1.IsCompleted, Is.True); Assert.That(task1.Result, Is.Not.Null); Assert.That(task1.Result.status, Is.EqualTo(MatchMakingResult.Status.Cancelled)); // Add another player to queue and verify that he does not get matched with a cancelled player var task2 = BBServer.Instance.Systems.MatchMaker.FindAMatch(testPlayer02, new MatchMakingSettings()); Assert.That(BBServer.Instance.Systems.MatchMaker.IsPlayerInQueue(testPlayer02), Is.True); await task2; BBServer.Instance.Systems.MatchMaker.CancelFindingMatchFor(testPlayer02); Assert.That(BBServer.Instance.Systems.MatchMaker.IsPlayerInQueue(testPlayer02), Is.False); Assert.That(task2.Result.status, Is.EqualTo(MatchMakingResult.Status.TimedOut)); })); }
protected override IEnumerable <Movie> GetMoviesByGenreCore(Genre genre) { var taskOfVideos = TaskExtensions.Unwrap <IEnumerable <Movie> >(httpClient.GetAsync(serviceBaseAddress + "api/movies/" + genre.ToString()) .ContinueWith(responseTask => { using (var httpResponseMessage = responseTask.Result) { ExceptionTransformerRest.ThrowIfNotSuccessStatusCode(httpResponseMessage); return(httpResponseMessage.Content.ReadAsAsync <IEnumerable <Movie> >(mediaTypeFormatters) .ContinueWith(readTask => readTask.Result)); } })); try { return(taskOfVideos.Result); } catch (AggregateException e) { throw e.InnerException; } }
public static IWampResultExtractor GetValueTupleResultExtractor(MethodInfo method) { Type tupleType = TaskExtensions.UnwrapReturnType(method.ReturnType); IWampResultExtractor result = new PositionalTupleExtractor(tupleType); TupleElementNamesAttribute attribute = method.ReturnParameter.GetCustomAttribute <TupleElementNamesAttribute>(); if (attribute != null) { int valueTupleLength = tupleType.GetValueTupleLength(); // If the tuple is named, return a named tuple extractor if (attribute.TransformNames.Take(valueTupleLength).All(x => x != null)) { result = new NamedTupleExtractor(tupleType, attribute.TransformNames); } } return(result); }
public void GenerateTaskExtension(TaskExtensions extensions) { foreach (var subExtension in extensions.SubExtensions) { GenerateTaskExtension(subExtension); } _context.Output[extensions.FileName] .WriteLine($@" using System; using System.Collections.Generic; using System.Text; using FlubuCore.Azure.Tasks; {WriteUsings(extensions.Usings)} namespace {extensions.Namespace} {{ public class {extensions.ExtensionName} {{ {WriteSubExtensionMethods(extensions)} {WriteTasks(extensions.Methods)} }} }} "); }
private static LaunchData GetLaunchDataFromGet(HttpRequest request) { var ld = new LaunchData(); ld.File = request.Query["file"]; ld.Password = request.Query["password"]; ld.AddHtmlCode = request.Query["html"] == "1"; ld.AddCopyProtection = request.Query["nocopy"] == "1"; ld.RenderMultiTo = request.Query["multi"].ToString().ToInt(); T setProp <T>(TaskSettingProp prop, T defaultValue) { string key = TaskSetting.ShorPropNames[prop]; string sVal = request.Query[key]; if (String.IsNullOrEmpty(sVal)) { return(defaultValue); } var val = TaskExtensions.ConvertValue(defaultValue.GetType(), sVal, null); if (val == null || !(val is T)) { return(defaultValue); } ld.Settings.SetProps |= prop; return((T)val); } ld.Settings.ItemsCount = TaskLoader.LoadItemsCount(setProp(TaskSettingProp.ItemsCount, "")); ld.Settings.Level = setProp(TaskSettingProp.Level, "").Split(','); ld.Settings.RandomOrder = setProp(TaskSettingProp.RandomOrder, ld.Settings.RandomOrder); ld.Settings.Round = setProp(TaskSettingProp.Round, ld.Settings.Round); ld.Settings.SeparatePreviousPairs = setProp(TaskSettingProp.SeparatePreviousPairs, ld.Settings.SeparatePreviousPairs); ld.Settings.Seed = setProp(TaskSettingProp.Seed, ld.Settings.Seed); return(ld); }
public TaskCache(IRepository repository) { _cachedGetSomething = TaskExtensions.CacheResult(repository.GetString); }
public async Task TestTimeoutAfterOfTArgNullValidation() { await TaskExtensions.TimeoutAfter <string>(null, TimeSpan.FromSeconds(1)); }
public void Default_WithCancellation_ConfigureAwait_NoThrow() { ConfiguredCancelableAsyncEnumerable <int> e = TaskExtensions.WithCancellation((IAsyncEnumerable <int>)null, default);
public static async Task <PlayerManager> GetPlayerAsync(int index) { await TaskExtensions.WaitUntil(() => count > index); return(GetPlayer(index)); }
public static void RunSync(Func <Task> func) { TaskExtensions.Unwrap(_myTaskFactory.StartNew <Task>(func)).GetAwaiter().GetResult(); }
public static TResult RunSync <TResult>(Func <Task <TResult> > func) { return(TaskExtensions.Unwrap <TResult>(_myTaskFactory.StartNew <Task <TResult> >(func)).GetAwaiter().GetResult()); }
public void Update(List <Hearthstone.Card> cards, bool reset) { try { if (reset) { _animatedCards.Clear(); ItemsControl.Items.Clear(); } var newCards = new List <Hearthstone.Card>(); foreach (var card in cards) { var existing = _animatedCards.FirstOrDefault(x => AreEqualForList(x.Card, card)); if (existing == null) { newCards.Add(card); } else if (existing.Card.Count != card.Count || existing.Card.HighlightInHand != card.HighlightInHand) { var highlight = existing.Card.Count != card.Count; existing.Card.Count = card.Count; existing.Card.HighlightInHand = card.HighlightInHand; TaskExtensions.Forget(existing.Update(highlight)); } else if (existing.Card.IsCreated != card.IsCreated) { TaskExtensions.Forget(existing.Update(false)); } } var toUpdate = new List <AnimatedCard>(); foreach (var aCard in _animatedCards) { if (!cards.Any(x => AreEqualForList(x, aCard.Card))) { toUpdate.Add(aCard); } } var toRemove = new List <Tuple <AnimatedCard, bool> >(); foreach (var card in toUpdate) { var newCard = newCards.FirstOrDefault(x => x.Id == card.Card.Id); toRemove.Add(new Tuple <AnimatedCard, bool>(card, newCard == null)); if (newCard != null) { var newAnimated = new AnimatedCard(newCard); _animatedCards.Insert(_animatedCards.IndexOf(card), newAnimated); ItemsControl.Items.Insert(_animatedCards.IndexOf(card), newAnimated); TaskExtensions.Forget(newAnimated.Update(true)); newCards.Remove(newCard); } } foreach (var card in toRemove) { RemoveCard(card.Item1, card.Item2); } foreach (var card in newCards) { var newCard = new AnimatedCard(card); _animatedCards.Insert(cards.IndexOf(card), newCard); ItemsControl.Items.Insert(cards.IndexOf(card), newCard); TaskExtensions.Forget(newCard.FadeIn(!reset)); } } catch (Exception e) { Log.Error(e); } }
public async Task ShowErrorAsync(string message) { ShowError(message); await TaskExtensions.WaitUntil(() => fsm.currentState != states.showMessage); }
public async Task <T> Dequeue() { var t = _buffer.ReceiveAsync(); return(await TaskExtensions.WrapInControlledTask(t)); }
public static bool ReturnsTuple(this MethodInfo method) { Type unwrappedReturnType = TaskExtensions.UnwrapReturnType(method.ReturnType); return(unwrappedReturnType.IsValueTuple()); }
public LaunchData GetLaunchDataFromGetData(HttpRequest request) { try { string data64 = request.Query["data"]; string hash = request.Query["hash"]; if (String.IsNullOrEmpty(data64) || String.IsNullOrEmpty(hash)) { return(null); } string data = Encoding.UTF8.GetString(Convert.FromBase64String(data64)); string hashCals = GetHash(data); if (hashCals != hash) { return(null); } var prms = data.Split('&').Select(x => x.Split('=')).ToDictionary(k => k[0], v => v[1]); string timeOut = prms.GetValueOrDefault("timeout", ""); if (!String.IsNullOrEmpty(timeOut)) { var limit = DateTime.Parse(timeOut); if (DateTime.Now > limit) { return(null); } } var ld = new LaunchData(); T setProp <T>(TaskSettingProp prop, T defaultValue) { string key = TaskSetting.ShorPropNames[prop]; string sVal = ""; if (prms.ContainsKey(key)) { sVal = prms[key]; } if (String.IsNullOrEmpty(sVal)) { return(defaultValue); } var val = TaskExtensions.ConvertValue(defaultValue.GetType(), sVal, null); if (val == null || !(val is T)) { return(defaultValue); } ld.Settings.SetProps |= prop; return((T)val); } ld.Settings.ItemsCount = TaskLoader.LoadItemsCount(setProp(TaskSettingProp.ItemsCount, "")); ld.Settings.Level = setProp(TaskSettingProp.Level, "").Split(','); ld.Settings.RandomOrder = setProp(TaskSettingProp.RandomOrder, ld.Settings.RandomOrder); ld.Settings.Round = setProp(TaskSettingProp.Round, ld.Settings.Round); ld.Settings.SeparatePreviousPairs = setProp(TaskSettingProp.SeparatePreviousPairs, ld.Settings.SeparatePreviousPairs); ld.Settings.Seed = setProp(TaskSettingProp.Seed, ld.Settings.Seed); ld.Password = prms.GetValueOrDefault("password", ld.File); ld.File = prms.GetValueOrDefault("file", ld.File); ld.AddHtmlCode = prms.GetValueOrDefault("html", ld.File) == "1"; ld.AddCopyProtection = prms.GetValueOrDefault("nocopy", ld.File) == "1"; return(ld); } catch { return(null); } }
/// <summary> /// Creates a task that runs the specified function. /// </summary> /// <param name="function">The function to execute.</param><param name="cancellationToken">The CancellationToken to use to request cancellation of this task.</param> /// <returns> /// A task that represents the completion of the function. /// </returns> /// <exception cref="T:System.ArgumentNullException">The <paramref name="function"/> argument is null.</exception> public static Task Run(Func <Task> function, CancellationToken cancellationToken) { return(TaskExtensions.Unwrap(Task.Run <Task>(function, cancellationToken))); }
protected virtual IDbConnection RetryOpenConnection() { return(TaskExtensions.Retry(() => this.OpenConnection(), this.MaxRetries)); }
public void Fire() { bool lockTaken1 = false; object obj; Task <Task> task1; Task task2; try { Monitor.Enter(obj = this._lock, ref lockTaken1); if (this._isDisposed) { throw new ObjectDisposedException(this.GetType().FullName); } if (this._isPending || this._cancellationTokenSource.IsCancellationRequested) { return; } this._isPending = true; if (null != this._task) { return; } task1 = new Task <Task>(new Func <Task>(this.CallHandlerAsync), this._cancellationTokenSource.Token, TaskCreationOptions.DenyChildAttach); this._task = task2 = TaskExtensions.Unwrap(task1); this._taskCompletionSource = (TaskCompletionSource <bool>)null; } finally { if (lockTaken1) { Monitor.Exit(obj); } } try { if (TaskStatus.Created == task1.Status) { task1.Start(TaskScheduler.Default); } } catch (Exception ex) { Debug.WriteLine("SignalTask.Fire() task start failed: " + ex.Message); bool lockTaken2 = false; try { Monitor.Enter(obj = this._lock, ref lockTaken2); if (object.ReferenceEquals((object)task2, (object)this._task)) { this._task = (Task)null; this._taskCompletionSource = (TaskCompletionSource <bool>)null; this._isPending = false; } } finally { if (lockTaken2) { Monitor.Exit(obj); } } throw; } if (this._isDisposed) { throw new ObjectDisposedException(this.GetType().FullName); } }
public async Task ShowMessageAsync(string title, string message) { ShowMessage(title, message); await TaskExtensions.WaitUntil(() => fsm.currentState != states.showMessage); }