Replaced ImageCacheItem by Tuple

FileDbCache/Shared/FileDbCache.cs

@@ -19,7 +19,7 @@ namespace MapControl.Caching
         private const string valueField = "Value";
         private const string expiresField = "Expires";
 
-        private readonly FileDb fileDb = new FileDb() { AutoFlush = true };
+        private readonly FileDb fileDb = new FileDb { AutoFlush = true };
 
         public FileDbCache(string path)
         {
@@ -91,7 +91,7 @@ namespace MapControl.Caching
             }
             catch (Exception ex)
             {
-                Debug.WriteLine("FileDbCache.GetRecordByKey(\"{0}\"): {1}", key, ex.Message);
+                Debug.WriteLine("FileDbCache.GetRecordByKey({0}): {1}", key, ex.Message);
             }
 
             return null;
@@ -114,12 +114,10 @@ namespace MapControl.Caching
                     fieldValues.Add(keyField, key);
                     fileDb.AddRecord(fieldValues);
                 }
-
-                //Debug.WriteLine("FileDbCache: Writing \"{0}\", Expires {1}", key, imageCacheItem.Expiration.ToLocalTime());
             }
             catch (Exception ex)
             {
-                Debug.WriteLine("FileDbCache.AddOrUpdateRecord(\"{0}\"): {1}", key, ex.Message); return;
+                Debug.WriteLine("FileDbCache.AddOrUpdateRecord({0}): {1}", key, ex.Message); return;
             }
         }
     }

FileDbCache/UWP/FileDbCache.UWP.cs

@@ -9,7 +9,7 @@ namespace MapControl.Caching
 {
     public partial class FileDbCache : IImageCache
     {
-        public Task<ImageCacheItem> GetAsync(string key)
+        public Task<Tuple<byte[], DateTime>> GetAsync(string key)
         {
             return Task.Run(() =>
             {
@@ -20,17 +20,13 @@ namespace MapControl.Caching
                     return null;
                 }
 
-                return new ImageCacheItem
+                return Tuple.Create((byte[])record[0], (DateTime)record[1]);
-                {
-                    Buffer = (byte[])record[0],
-                    Expiration = (DateTime)record[1]
-                };
             });
         }
 
-        public Task SetAsync(string key, ImageCacheItem cacheItem)
+        public Task SetAsync(string key, byte[] buffer, DateTime expiration)
         {
-            return Task.Run(() => AddOrUpdateRecord(key, cacheItem.Buffer, cacheItem.Expiration));
+            return Task.Run(() => AddOrUpdateRecord(key, buffer, expiration));
         }
     }
 }

FileDbCache/WPF/FileDbCache.WPF.cs

@@ -75,7 +75,7 @@ namespace MapControl.Caching
             }
             catch (Exception ex)
             {
-                Debug.WriteLine("FileDbCache.Contains(\"{0}\"): {1}", key, ex.Message);
+                Debug.WriteLine("FileDbCache.Contains({0}): {1}", key, ex.Message);
             }
 
             return false;
@@ -100,11 +100,7 @@ namespace MapControl.Caching
                 return null;
             }
 
-            return new ImageCacheItem
+            return Tuple.Create((byte[])record[0], (DateTime)record[1]);
-            {
-                Buffer = (byte[])record[0],
-                Expiration = (DateTime)record[1]
-            };
         }
 
         public override CacheItem GetCacheItem(string key, string regionName = null)
@@ -131,12 +127,12 @@ namespace MapControl.Caching
                 throw new ArgumentNullException(nameof(key));
             }
 
-            if (!(value is ImageCacheItem imageCacheItem))
+            if (!(value is Tuple<byte[], DateTime> cacheItem))
             {
-                throw new ArgumentException("The value argument must be a MapControl.Caching.ImageCacheItem instance.", nameof(value));
+                throw new ArgumentException("The value argument must be a Tuple<byte[], DateTime>.", nameof(value));
             }
 
-            AddOrUpdateRecord(key, imageCacheItem.Buffer, imageCacheItem.Expiration);
+            AddOrUpdateRecord(key, cacheItem.Item1, cacheItem.Item2);
         }
 
         public override void Set(string key, object value, DateTimeOffset absoluteExpiration, string regionName = null)
@@ -184,7 +180,7 @@ namespace MapControl.Caching
                 }
                 catch (Exception ex)
                 {
-                    Debug.WriteLine("FileDbCache.Remove(\"{0}\"): {1}", key, ex.Message);
+                    Debug.WriteLine("FileDbCache.Remove({0}): {1}", key, ex.Message);
                 }
             }
 

FileDbCache/WPF/FileDbCache.WPF.csproj

@@ -46,8 +46,4 @@
         <Reference Include="System.Runtime.Caching" />
         <PackageReference Include="FileDb.NET" Version="7.4.3" />
     </ItemGroup>
-
-    <ItemGroup>
-        <ProjectReference Include="..\..\MapControl\WPF\MapControl.WPF.csproj" />
-    </ItemGroup>
 </Project>

MapControl/Shared/ImageFileCache.cs

@@ -13,7 +13,7 @@ namespace MapControl.Caching
 {
     /// <summary>
     /// Image Cache implementation based on local image files.
-    /// The only valid data type for cached values is ImageCacheItem.
+    /// The only valid data type for cached values is Tuple<byte[], DateTime>.
     /// </summary>
     public partial class ImageFileCache
     {

MapControl/Shared/TileImageLoader.cs

@@ -13,15 +13,6 @@ using System.Threading.Tasks;
 
 namespace MapControl
 {
-    namespace Caching
-    {
-        public class ImageCacheItem
-        {
-            public byte[] Buffer { get; set; }
-            public DateTime Expiration { get; set; }
-        }
-    }
-
 #if NETFRAMEWORK
     static class ConcurrentQueueEx
     {

MapControl/UWP/ImageFileCache.UWP.cs

@@ -11,9 +11,9 @@ namespace MapControl.Caching
 {
     public partial class ImageFileCache : IImageCache
     {
-        public async Task<ImageCacheItem> GetAsync(string key)
+        public async Task<Tuple<byte[], DateTime>> GetAsync(string key)
         {
-            ImageCacheItem cacheItem = null;
+            Tuple<byte[], DateTime> cacheItem = null;
             var path = GetPath(key);
 
             try
@@ -23,13 +23,7 @@ namespace MapControl.Caching
                     var buffer = await File.ReadAllBytesAsync(path);
                     var expiration = ReadExpiration(ref buffer);
 
-                    cacheItem = new ImageCacheItem
+                    cacheItem = Tuple.Create(buffer, expiration);
-                    {
-                        Buffer = buffer,
-                        Expiration = expiration
-                    };
-
-                    //Debug.WriteLine("ImageFileCache: Read {0}, Expires {1}", path, expiration.ToLocalTime());
                 }
             }
             catch (Exception ex)
@@ -40,11 +34,11 @@ namespace MapControl.Caching
             return cacheItem;
         }
 
-        public async Task SetAsync(string key, ImageCacheItem cacheItem)
+        public async Task SetAsync(string key, byte[] buffer, DateTime expiration)
         {
             var path = GetPath(key);
 
-            if (cacheItem.Buffer != null && cacheItem.Buffer.Length > 0 && path != null)
+            if (buffer != null && buffer.Length > 0 && path != null)
             {
                 try
                 {
@@ -52,11 +46,9 @@ namespace MapControl.Caching
 
                     using (var stream = File.Create(path))
                     {
-                        await stream.WriteAsync(cacheItem.Buffer, 0, cacheItem.Buffer.Length);
+                        await stream.WriteAsync(buffer, 0, buffer.Length);
-                        await WriteExpirationAsync(stream, cacheItem.Expiration);
+                        await WriteExpirationAsync(stream, expiration);
                     }
-
-                    //Debug.WriteLine("ImageFileCache: Wrote {0}, Expires {1}", path, expiration.ToLocalTime());
                 }
                 catch (Exception ex)
                 {

MapControl/UWP/TileImageLoader.UWP.cs

@@ -4,7 +4,6 @@
 
 using System;
 using System.Threading.Tasks;
-using MapControl.Caching;
 #if WINDOWS_UWP
 using Windows.UI.Core;
 using Windows.UI.Xaml.Media;
@@ -19,9 +18,9 @@ namespace MapControl
     {
         public interface IImageCache
         {
-            Task<ImageCacheItem> GetAsync(string key);
+            Task<Tuple<byte[], DateTime>> GetAsync(string key);
 
-            Task SetAsync(string key, ImageCacheItem cacheItem);
+            Task SetAsync(string key, byte[] buffer, DateTime expiration);
         }
     }
 
@@ -39,15 +38,15 @@ namespace MapControl
         /// <summary>
         /// The IImageCache implementation used to cache tile images. The default is null.
         /// </summary>
-        public static IImageCache Cache { get; set; }
+        public static Caching.IImageCache Cache { get; set; }
 
 
         private static async Task LoadCachedTileAsync(Tile tile, Uri uri, string cacheKey)
         {
             var cacheItem = await Cache.GetAsync(cacheKey).ConfigureAwait(false);
-            var buffer = cacheItem?.Buffer;
+            var buffer = cacheItem?.Item1;
 
-            if (cacheItem == null || cacheItem.Expiration < DateTime.UtcNow)
+            if (cacheItem == null || cacheItem.Item2 < DateTime.UtcNow)
             {
                 var response = await ImageLoader.GetHttpResponseAsync(uri).ConfigureAwait(false);
 
@@ -55,15 +54,10 @@ namespace MapControl
                 {
                     buffer = response.Buffer; // may be null or empty when no tile available, but still be cached
 
-                    cacheItem = new ImageCacheItem
+                    await Cache.SetAsync(cacheKey, buffer, GetExpiration(response.MaxAge)).ConfigureAwait(false);
-                    {
-                        Buffer = buffer,
-                        Expiration = GetExpiration(response.MaxAge)
-                    };
-
-                    await Cache.SetAsync(cacheKey, cacheItem).ConfigureAwait(false);
                 }
             }
+            else System.Diagnostics.Debug.WriteLine("Cached: " + cacheKey);
 
             if (buffer != null && buffer.Length > 0)
             {

MapControl/WPF/ImageFileCache.WPF.cs

@@ -95,7 +95,7 @@ namespace MapControl.Caching
                 throw new ArgumentNullException(nameof(key));
             }
 
-            var cacheItem = memoryCache.Get(key) as ImageCacheItem;
+            var cacheItem = memoryCache.Get(key) as Tuple<byte[], DateTime>;
 
             if (cacheItem == null)
             {
@@ -108,15 +108,9 @@ namespace MapControl.Caching
                         var buffer = File.ReadAllBytes(path);
                         var expiration = ReadExpiration(ref buffer);
 
-                        cacheItem = new ImageCacheItem
+                        cacheItem = new Tuple<byte[], DateTime>(buffer, expiration);
-                        {
-                            Buffer = buffer,
-                            Expiration = expiration
-                        };
 
                         memoryCache.Set(key, cacheItem, new CacheItemPolicy { AbsoluteExpiration = expiration });
-
-                        //Debug.WriteLine("ImageFileCache: Read {0}, Expires {1}", path, cacheItem.Expiration.ToLocalTime());
                     }
                 }
                 catch (Exception ex)
@@ -152,16 +146,17 @@ namespace MapControl.Caching
                 throw new ArgumentNullException(nameof(key));
             }
 
-            if (!(value is ImageCacheItem cacheItem))
+            if (!(value is Tuple<byte[], DateTime> cacheItem))
             {
-                throw new ArgumentException("The value argument must be a MapControl.Caching.ImageCacheItem instance.", nameof(value));
+                throw new ArgumentException("The value argument must be a Tuple<byte[], DateTime>.", nameof(value));
             }
 
             memoryCache.Set(key, cacheItem, policy);
 
+            var buffer = cacheItem.Item1;
             var path = GetPath(key);
 
-            if (cacheItem.Buffer != null && cacheItem.Buffer.Length > 0 && path != null)
+            if (buffer != null && buffer.Length > 0 && path != null)
             {
                 try
                 {
@@ -169,16 +164,14 @@ namespace MapControl.Caching
 
                     using (var stream = File.Create(path))
                     {
-                        stream.Write(cacheItem.Buffer, 0, cacheItem.Buffer.Length);
+                        stream.Write(buffer, 0, buffer.Length);
-                        WriteExpiration(stream, cacheItem.Expiration);
+                        WriteExpiration(stream, cacheItem.Item2);
                     }
 
                     var fileInfo = new FileInfo(path);
                     var fileSecurity = fileInfo.GetAccessControl();
                     fileSecurity.AddAccessRule(fullControlRule);
                     fileInfo.SetAccessControl(fileSecurity);
-
-                    //Debug.WriteLine("ImageFileCache: Wrote {0}, Expires {1}", path, cacheItem.Expiration.ToLocalTime());
                 }
                 catch (Exception ex)
                 {

MapControl/WPF/TileImageLoader.WPF.cs

@@ -6,7 +6,6 @@ using System;
 using System.IO;
 using System.Runtime.Caching;
 using System.Threading.Tasks;
-using MapControl.Caching;
 
 namespace MapControl
 {
@@ -21,7 +20,7 @@ namespace MapControl
         }
 
         /// <summary>
-        /// An ObjectCache instance used to cache tile image data (i.e. ImageCacheItem objects).
+        /// An ObjectCache instance used to cache tile image data, i.e. (byte[],DateTime) tuples.
         /// The default ObjectCache value is MemoryCache.Default.
         /// </summary>
         public static ObjectCache Cache { get; set; } = MemoryCache.Default;
@@ -29,26 +28,23 @@ namespace MapControl
 
         private static async Task LoadCachedTileAsync(Tile tile, Uri uri, string cacheKey)
         {
-            var cacheItem = Cache.Get(cacheKey) as ImageCacheItem;
+            var cacheItem = Cache.Get(cacheKey) as Tuple<byte[], DateTime>;
-            var buffer = cacheItem?.Buffer;
+            var buffer = cacheItem?.Item1;
 
-            if (cacheItem == null || cacheItem.Expiration < DateTime.UtcNow)
+            if (cacheItem == null || cacheItem.Item2 < DateTime.UtcNow)
             {
                 var response = await ImageLoader.GetHttpResponseAsync(uri).ConfigureAwait(false);
 
                 if (response != null) // download succeeded
                 {
-                    buffer = response.Buffer;
+                    buffer = response.Buffer; // may be null or empty when no tile available, but still be cached
 
-                    cacheItem = new ImageCacheItem
+                    cacheItem = Tuple.Create(buffer, GetExpiration(response.MaxAge));
-                    {
-                        Buffer = buffer, // may be null or empty when no tile available, but still be cached
-                        Expiration = GetExpiration(response.MaxAge)
-                    };
 
-                    Cache.Set(cacheKey, cacheItem, new CacheItemPolicy { AbsoluteExpiration = cacheItem.Expiration });
+                    Cache.Set(cacheKey, cacheItem, new CacheItemPolicy { AbsoluteExpiration = cacheItem.Item2 });
                 }
             }
+            else System.Diagnostics.Debug.WriteLine("Cached: " + cacheKey);
 
             if (buffer != null && buffer.Length > 0)
             {

SQLiteCache/UWP/SQLiteCache.UWP.cs

@@ -10,7 +10,7 @@ namespace MapControl.Caching
 {
     public partial class SQLiteCache : IImageCache
     {
-        public async Task<ImageCacheItem> GetAsync(string key)
+        public async Task<Tuple<byte[], DateTime>> GetAsync(string key)
         {
             try
             {
@@ -20,36 +20,30 @@ namespace MapControl.Caching
 
                     if (await reader.ReadAsync())
                     {
-                        return new ImageCacheItem
+                        return Tuple.Create((byte[])reader["buffer"], new DateTime((long)reader["expiration"]));
-                        {
-                            Expiration = new DateTime((long)reader["expiration"]),
-                            Buffer = (byte[])reader["buffer"]
-                        };
                     }
                 }
             }
             catch (Exception ex)
             {
-                Debug.WriteLine("SQLiteCache.GetAsync(\"{0}\"): {1}", key, ex.Message);
+                Debug.WriteLine("SQLiteCache.GetAsync({0}): {1}", key, ex.Message);
             }
 
             return null;
         }
 
-        public async Task SetAsync(string key, ImageCacheItem cacheItem)
+        public async Task SetAsync(string key, byte[] buffer, DateTime expiration)
         {
             try
             {
-                using (var command = SetItemCommand(key, cacheItem.Expiration, cacheItem.Buffer))
+                using (var command = SetItemCommand(key, expiration, buffer))
                 {
                     await command.ExecuteNonQueryAsync();
                 }
-
-                //Debug.WriteLine("SQLiteCache.SetAsync(\"{0}\"): expires {1}", key, cacheItem.Expiration.ToLocalTime());
             }
             catch (Exception ex)
             {
-                Debug.WriteLine("SQLiteCache.SetAsync(\"{0}\"): {1}", key, ex.Message);
+                Debug.WriteLine("SQLiteCache.SetAsync({0}): {1}", key, ex.Message);
             }
         }
     }

SQLiteCache/WPF/SQLiteCache.WPF.cs

@@ -82,7 +82,7 @@ namespace MapControl.Caching
             }
             catch (Exception ex)
             {
-                Debug.WriteLine("SQLiteCache.Contains(\"{0}\"): {1}", key, ex.Message);
+                Debug.WriteLine("SQLiteCache.Contains({0}): {1}", key, ex.Message);
             }
 
             return false;
@@ -108,17 +108,13 @@ namespace MapControl.Caching
 
                     if (reader.Read())
                     {
-                        return new ImageCacheItem
+                        return Tuple.Create((byte[])reader["buffer"], new DateTime((long)reader["expiration"]));
-                        {
-                            Expiration = new DateTime((long)reader["expiration"]),
-                            Buffer = (byte[])reader["buffer"]
-                        };
                     }
                 }
             }
             catch (Exception ex)
             {
-                Debug.WriteLine("SQLiteCache.Get(\"{0}\"): {1}", key, ex.Message);
+                Debug.WriteLine("SQLiteCache.Get({0}): {1}", key, ex.Message);
             }
 
             return null;
@@ -148,23 +144,21 @@ namespace MapControl.Caching
                 throw new ArgumentNullException(nameof(key));
             }
 
-            if (!(value is ImageCacheItem imageCacheItem))
+            if (!(value is Tuple<byte[], DateTime> cacheItem))
             {
-                throw new ArgumentException("The value argument must be a MapControl.Caching.ImageCacheItem instance.", nameof(value));
+                throw new ArgumentException("The value argument must be a Tuple<byte[], DateTime>.", nameof(value));
             }
 
             try
             {
-                using (var command = SetItemCommand(key, imageCacheItem.Expiration, imageCacheItem.Buffer))
+                using (var command = SetItemCommand(key, cacheItem.Item2, cacheItem.Item1))
                 {
                     command.ExecuteNonQuery();
                 }
-
-                //Debug.WriteLine("SQLiteCache.Set(\"{0}\"): expires {1}", key, expiration.ToLocalTime());
             }
             catch (Exception ex)
             {
-                Debug.WriteLine("SQLiteCache.Set(\"{0}\"): {1}", key, ex.Message);
+                Debug.WriteLine("SQLiteCache.Set({0}): {1}", key, ex.Message);
             }
         }
 
@@ -216,7 +210,7 @@ namespace MapControl.Caching
                 }
                 catch (Exception ex)
                 {
-                    Debug.WriteLine("SQLiteCache.Remove(\"{0}\"): {1}", key, ex.Message);
+                    Debug.WriteLine("SQLiteCache.Remove({0}): {1}", key, ex.Message);
                 }
             }
 

SQLiteCache/WPF/SQLiteCache.WPF.csproj

@@ -48,8 +48,4 @@
     <ItemGroup>
         <PackageReference Include="System.Data.SQLite.Core" Version="1.0.114.2" />
     </ItemGroup>
-
-    <ItemGroup>
-        <ProjectReference Include="..\..\MapControl\WPF\MapControl.WPF.csproj" />
-    </ItemGroup>
 </Project>

SampleApps/WpfApplication/WpfApplication.csproj

@@ -24,7 +24,9 @@
     </ItemGroup>
 
     <ItemGroup>
+        <ProjectReference Include="..\..\FileDbCache\WPF\FileDbCache.WPF.csproj" />
         <ProjectReference Include="..\..\MapControl\WPF\MapControl.WPF.csproj" />
+        <ProjectReference Include="..\..\SQLiteCache\WPF\SQLiteCache.WPF.csproj" />
     </ItemGroup>
 
     <ItemGroup>