public Task <T> ExecuteTaskAsync <T>(Func <Task <T> > TaskReference, TaskParams executionQuery)
{
//var res = await Task.Run(()=>TaskReference());
//return res;
var tcs = new TaskCompletionSource <T>();
TaskParams <T> executionParams = new TaskParams <T>(executionQuery.taskPriority)
{
shouldRunOnUIThread = executionQuery.shouldRunOnUIThread,
forceCancelResponseIfExecuting = executionQuery.forceCancelResponseIfExecuting,
suppressCancellationExceptions = executionQuery.suppressCancellationExceptions
};
executionQuery.AddCancelOperation(executionParams);
executionParams.TaskParamsInitialize(TaskReference, tcs);
executionParams.TaskCompleted += (o, e) =>
{
tcs.SetResult(e.OperationResult);
lock (obj)
{
if (executionParams.taskPriority != Priority.Immediate)
{
currentExecCounter--;
ProcessLoop();
}
}
};
executionParams.TaskFailed += (o, e) =>
{
lock (obj)
{
if (executionParams.taskPriority != Priority.Immediate)
{
currentExecCounter--;
ProcessLoop();
}
}
};
lock (obj)
{
switch (executionParams.taskPriority)
{
case Priority.High:
HighPriorityTasks.Enqueue(executionParams.ProcessExecutionQueryAsync);
break;
case Priority.Immediate:
executionParams.ProcessExecutionQueryAsync();
return(tcs.Task); //RETURNED BEFORE
case Priority.Low:
LowPriorityTasks.Enqueue(executionParams.ProcessExecutionQueryAsync);
break;
case Priority.Idle:
IdlePriorityTasks.Enqueue(executionParams.ProcessExecutionQueryAsync);
break;
case Priority.Medium:
MediumPriorityTasks.Enqueue(executionParams.ProcessExecutionQueryAsync);
break;
}
ProcessLoop();
}
return(tcs.Task);
}
public async Task ExecuteTaskAsync(Action TaskReference, TaskParams executionQuery)
{
await ExecuteTaskAsync <int>(TaskConverters.ConvertToActionToTask <int>(TaskReference), executionQuery);
}
public Task <T> ExecuteTaskAsync <T>(Func <T> TaskReference, TaskParams executionQuery)
{
return(ExecuteTaskAsync <T>(TaskConverters.ConvertToFuncToTask(TaskReference), executionQuery));
}
public async Task <BenchClass <T> > BenchmarkAndExecuteTaskAsync <T>(Func <Task <T> > TaskReference, TaskParams executionQuery)
{
DateTime startTime = DateTime.Now;
var OperationResult = await ExecuteTaskAsync <T>(TaskReference, executionQuery);
DateTime endTime = DateTime.Now;
BenchClass <T> BenchmarkResult = new BenchClass <T>();
BenchmarkResult.executionTimeInMilliseconds = (endTime - startTime).TotalMilliseconds;
BenchmarkResult.OperationResult = OperationResult;
return(BenchmarkResult);
}
public async Task <BenchClass> BenchmarkAndExecuteTaskAsync(Action TaskReference, TaskParams executionQuery)
{
BenchClass returnBenchResult = new BenchClass();
returnBenchResult.executionTimeInMilliseconds = (await BenchmarkAndExecuteTaskAsync <int>(TaskConverters.ConvertToActionToTask <int>(TaskReference), executionQuery)).executionTimeInMilliseconds;
return(returnBenchResult);
}
public Task <BenchClass <T> > BenchmarkAndExecuteTaskAsync <T>(Func <T> TaskReference, TaskParams executionQuery)
{
return(BenchmarkAndExecuteTaskAsync <T>(TaskConverters.ConvertToFuncToTask(TaskReference), executionQuery));
}
