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);
}
