Minor refactoring

MapControl/Shared/Intersections.cs

@@ -81,7 +81,7 @@ namespace MapControl
             return numIntersections > 0;
         }
 
-        private static bool GetIntersection(ref Point p1, ref Point p2, Point p3, Point p4, Func<Point, bool> condition)
+        private static bool GetIntersection(ref Point p1, ref Point p2, Point p3, Point p4, Predicate<Point> predicate)
         {
             var intersection = GetIntersection(p1, p2, p3, p4);
 
@@ -90,7 +90,7 @@ namespace MapControl
                 return false;
             }
 
-            if (condition(p1))
+            if (predicate(p1))
             {
                 p1 = intersection.Value;
             }

MapControl/Shared/MapItemsControl.cs

@@ -36,7 +36,7 @@ namespace MapControl
             return item is MapItem;
         }
 
-        public void SelectItems(Func<object, bool> predicate)
+        public void SelectItems(Predicate<object> predicate)
         {
             if (SelectionMode == SelectionMode.Single)
             {
@@ -61,7 +61,7 @@ namespace MapControl
             }
         }
 
-        public void SelectItemsByLocation(Func<Location, bool> predicate)
+        public void SelectItemsByLocation(Predicate<Location> predicate)
         {
             SelectItems(item =>
             {
@@ -70,7 +70,7 @@ namespace MapControl
             });
         }
 
-        public void SelectItemsByPosition(Func<Point, bool> predicate)
+        public void SelectItemsByPosition(Predicate<Point> predicate)
         {
             SelectItems(item =>
             {

MapControl/Shared/TileImageLoader.cs

@@ -51,17 +51,15 @@ namespace MapControl
         }
 
         private readonly TileQueue tileQueue = new TileQueue();
-        private Func<Tile, Task> loadTileImage;
+        private Func<Tile, Task> loadTile;
         private int taskCount;
 
         /// <summary>
         /// Loads all pending tiles from the tiles collection.
         /// If tileSource.UriFormat starts with "http" and sourceName is a non-empty string,
-        /// tile images will be cached in the TileImageLoader's Cache (if it's not null).
-        /// The method is async void because it implements void ITileImageLoader.LoadTiles
-        /// and is not awaited when it is called in MapTileLayer.UpdateTiles().
+        /// tile images will be cached in the TileImageLoader's Cache (if that is not null).
         /// </summary>
-        public async void LoadTiles(IEnumerable<Tile> tiles, TileSource tileSource, string sourceName)
+        public void LoadTiles(IEnumerable<Tile> tiles, TileSource tileSource, string sourceName)
         {
             tileQueue.Clear();
 
@@ -74,45 +72,44 @@ namespace MapControl
                     tileSource.UriFormat.StartsWith("http") &&
                     !string.IsNullOrEmpty(sourceName))
                 {
-                    loadTileImage = tile => LoadCachedTileImageAsync(tile, tileSource, sourceName);
+                    loadTile = tile => LoadCachedTileAsync(tile, tileSource, sourceName);
                 }
                 else
                 {
-                    loadTileImage = tile => LoadTileImageAsync(tile, tileSource);
+                    loadTile = tile => LoadTileAsync(tile, tileSource);
                 }
 
                 tileQueue.Enqueue(tiles);
 
-                var numTasks = Math.Min(tileQueue.Count, MaxLoadTasks);
-                var tasks = Enumerable.Range(0, numTasks).Select(n => LoadTilesFromQueueAsync());
+                while (taskCount < Math.Min(tileQueue.Count, MaxLoadTasks))
+                {
+                    Interlocked.Increment(ref taskCount);
 
-                await Task.WhenAll(tasks).ConfigureAwait(false);
+                    Task.Run(() => LoadTilesFromQueueAsync());
+                }
             }
         }
 
         private async Task LoadTilesFromQueueAsync()
         {
-            if (Interlocked.Increment(ref taskCount) <= MaxLoadTasks)
+            while (tileQueue.TryDequeue(out Tile tile))
             {
-                while (tileQueue.TryDequeue(out Tile tile))
-                {
-                    tile.Pending = false;
+                tile.Pending = false;
 
-                    try
-                    {
-                        await loadTileImage(tile).ConfigureAwait(false);
-                    }
-                    catch (Exception ex)
-                    {
-                        Debug.WriteLine("TileImageLoader: {0}/{1}/{2}: {3}", tile.ZoomLevel, tile.XIndex, tile.Y, ex.Message);
-                    }
+                try
+                {
+                     await loadTile(tile).ConfigureAwait(false);
+                }
+                catch (Exception ex)
+                {
+                    Debug.WriteLine("TileImageLoader: {0}/{1}/{2}: {3}", tile.ZoomLevel, tile.XIndex, tile.Y, ex.Message);
                 }
             }
 
             Interlocked.Decrement(ref taskCount);
         }
 
-        private static async Task LoadCachedTileImageAsync(Tile tile, TileSource tileSource, string sourceName)
+        private static async Task LoadCachedTileAsync(Tile tile, TileSource tileSource, string sourceName)
         {
             var uri = tileSource.GetUri(tile.XIndex, tile.Y, tile.ZoomLevel);
 
@@ -127,7 +124,7 @@ namespace MapControl
 
                 var cacheKey = string.Format(CacheKeyFormat, sourceName, tile.ZoomLevel, tile.XIndex, tile.Y, extension);
 
-                await LoadCachedTileImageAsync(tile, uri, cacheKey).ConfigureAwait(false);
+                await LoadCachedTileAsync(tile, uri, cacheKey).ConfigureAwait(false);
             }
         }
 

MapControl/UWP/TileImageLoader.UWP.cs

@@ -28,7 +28,7 @@ namespace MapControl
         public static Caching.IImageCache Cache { get; set; }
 
 
-        private static async Task LoadCachedTileImageAsync(Tile tile, Uri uri, string cacheKey)
+        private static async Task LoadCachedTileAsync(Tile tile, Uri uri, string cacheKey)
         {
             var cacheItem = await Cache.GetAsync(cacheKey).ConfigureAwait(false);
             var buffer = cacheItem?.Buffer;
@@ -51,12 +51,12 @@ namespace MapControl
             }
         }
 
-        private static Task LoadTileImageAsync(Tile tile, TileSource tileSource)
+        private static Task LoadTileAsync(Tile tile, TileSource tileSource)
         {
             return SetTileImageAsync(tile, () => tileSource.LoadImageAsync(tile.XIndex, tile.Y, tile.ZoomLevel));
         }
 
-        private static async Task SetTileImageAsync(Tile tile, Func<Task<ImageSource>> loadImageFunc)
+        private static async Task SetTileImageAsync(Tile tile, Func<Task<ImageSource>> loadImage)
         {
             var tcs = new TaskCompletionSource<object>();
 
@@ -64,7 +64,7 @@ namespace MapControl
             {
                 try
                 {
-                    tile.SetImage(await loadImageFunc());
+                    tile.SetImage(await loadImage());
                     tcs.SetResult(null);
                 }
                 catch (Exception ex)

MapControl/WPF/TileImageLoader.WPF.cs

@@ -37,7 +37,7 @@ namespace MapControl
         public static ObjectCache Cache { get; set; } = MemoryCache.Default;
 
 
-        private static async Task LoadCachedTileImageAsync(Tile tile, Uri uri, string cacheKey)
+        private static async Task LoadCachedTileAsync(Tile tile, Uri uri, string cacheKey)
         {
             var cacheItem = await GetCacheAsync(cacheKey).ConfigureAwait(false);
             var buffer = cacheItem?.Buffer;
@@ -62,7 +62,7 @@ namespace MapControl
             }
         }
 
-        private static async Task LoadTileImageAsync(Tile tile, TileSource tileSource)
+        private static async Task LoadTileAsync(Tile tile, TileSource tileSource)
         {
             var image = await tileSource.LoadImageAsync(tile.XIndex, tile.Y, tile.ZoomLevel).ConfigureAwait(false);