private async void ServiceDiffCalcRequest()
{
// acquire mutually exclusive entry into this method
serviceDiffCalcRequestLocked = true;
decimal stars = 0.0M, aim = 0.0M, speed = 0.0M;
while (completedDiffCalcRequest == null || completedDiffCalcRequest.RequestNumber != diffCalcRequests.Last().RequestNumber)
{
completedDiffCalcRequest = diffCalcRequests.Last();
try
{
(stars, aim, speed) = await Task.Run(() => DifficultyCalculator.CalculateStarRating(NewBeatmap));
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine("lol asdfasdf;lkjasdf");
(stars, aim, speed) = (0, 0, 0);
}
// if a new request came in, invalidate the diffcalc result and service the new request
}
// we serviced the last request, so we can commit to the diffcalc result
StarRating = stars;
AimRating = aim;
SpeedRating = speed;
BeatmapModified?.Invoke(this, EventArgs.Empty);
serviceDiffCalcRequestLocked = false;
}
private async Task <T> GetItemAsync(Uri uri, string fileName, bool throwOnError, bool preCacheOnly)
{
T instance = default(T);
ConcurrentRequest request = null;
lock (_concurrencyLock)
{
if (_concurrentTasks.ContainsKey(fileName))
{
request = _concurrentTasks[fileName];
}
}
// if similar request exists check if it was preCacheOnly and validate that current request isn't preCacheOnly
if (request != null && request.EnsureCachedCopy && !preCacheOnly)
{
await request.Task;
request = null;
}
if (request == null)
{
request = new ConcurrentRequest()
{
Task = GetFromCacheOrDownloadAsync(uri, fileName, preCacheOnly),
EnsureCachedCopy = preCacheOnly
};
lock (_concurrencyLock)
{
_concurrentTasks.Add(fileName, request);
}
}
try
{
instance = await request.Task;
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
if (throwOnError)
{
throw ex;
}
}
finally
{
lock (_concurrencyLock)
{
if (_concurrentTasks.ContainsKey(fileName))
{
_concurrentTasks.Remove(fileName);
}
}
}
return(instance);
}
private async Task <T> GetItemAsync(Uri uri, bool throwOnError, bool preCacheOnly, CancellationToken cancellationToken, List <KeyValuePair <string, object> > initializerKeyValues)
{
T instance = default(T);
string fileName = GetCacheFileName(uri);
ConcurrentRequest request = null;
_concurrentTasks.TryGetValue(fileName, out request);
// if similar request exists check if it was preCacheOnly and validate that current request isn't preCacheOnly
if (request != null && request.EnsureCachedCopy && !preCacheOnly)
{
await request.Task.ConfigureAwait(MaintainContext);
request = null;
}
if (request == null)
{
request = new ConcurrentRequest()
{
Task = GetFromCacheOrDownloadAsync(uri, fileName, preCacheOnly, cancellationToken, initializerKeyValues),
EnsureCachedCopy = preCacheOnly
};
_concurrentTasks[fileName] = request;
}
try
{
instance = await request.Task.ConfigureAwait(MaintainContext);
}
catch (Exception ex)
{
System.Diagnostics.Debug.WriteLine(ex.Message);
if (throwOnError)
{
throw;
}
}
finally
{
_concurrentTasks.TryRemove(fileName, out request);
request = null;
}
return(instance);
}
