public virtual void RemovePendingTask(IImageLoaderTask task)
 {
     if (task != null)
     {
         lock (_lock)
         {
             PendingTasks.TryRemove(task);
             SimilarTasks.Remove(task);
         }
     }
 }
Exemple #2
0
        protected async Task RunImageLoadingTaskAsync(IImageLoaderTask pendingTask)
        {
            string keyRaw = pendingTask.KeyRaw;

            try
            {
                if (_imageLoader.VerbosePerformanceLogging)
                {
                    IPlatformPerformance performance = _imageLoader.Performance;

                    LogSchedulerStats(performance);
                    var stopwatch = Stopwatch.StartNew();

                    await pendingTask.RunAsync().ConfigureAwait(false);

                    stopwatch.Stop();

                    _imageLoader.Logger?.Debug(string.Format("[PERFORMANCE] RunAsync - NetManagedThreadId: {0}, NativeThreadId: {1}, Execution: {2} ms, Key: {3}",
                                                             performance.GetCurrentManagedThreadId(),
                                                             performance.GetCurrentSystemThreadId(),
                                                             stopwatch.Elapsed.Milliseconds,
                                                             pendingTask.Key));
                }
                else
                {
                    await pendingTask.RunAsync().ConfigureAwait(false);
                }
            }
            finally
            {
                lock (_lock)
                {
                    RunningTasks.Remove(keyRaw);

                    if (SimilarTasks.Count > 0)
                    {
                        SimilarTasks.RemoveAll(v => v == null || v.IsCompleted || v.IsCancelled);
                        var similarItems = SimilarTasks.Where(v => v.KeyRaw == keyRaw);
                        foreach (var similar in similarItems)
                        {
                            SimilarTasks.Remove(similar);

                            LoadImage(similar);
                        }
                    }
                }

                pendingTask.TryDispose();
                await TakeFromPendingTasksAndRunAsync().ConfigureAwait(false);
            }
        }
Exemple #3
0
        public virtual void Cancel(Func <IImageLoaderTask, bool> predicate)
        {
            lock (_similarTasksLock)
            {
                foreach (var task in PendingTasks.Where(p => predicate(p)))
                {
                    task?.Cancel();
                }

                var items = SimilarTasks.Where(v => predicate(v)).ToList();
                foreach (var item in items)
                {
                    SimilarTasks.Remove(item);
                }
            }
        }