Allow full size images to be garbage-collected.

Use a weak reference to get them back if they're needed again before the GC
eats them.  Also use a MemoryCache to ensure they're kept around for at least
10 seconds.

Author: adam-azarchs

PhotoTagger.Imaging/ImageLoadManager.cs

@@ -25,6 +25,11 @@ public void EnqueueLoad(Photo photo,
             makeIOThread();
         }
 
+        internal void EnqueueFullSizeRead(Photo photo, Photo.Metadata meta) {
+            fullsizeReads.Add(new Tuple<Photo, Photo.Metadata>(photo, meta));
+            makeIOThread();
+        }
+
         private BlockingCollection<Tuple<Photo, ObservableCollection<Photo>>> metadataReads =
             new BlockingCollection<Tuple<Photo, ObservableCollection<Photo>>>();
 
@@ -135,16 +140,15 @@ private async Task loadMeta(Photo photo,
                     mmap.Dispose();
                     throw;
                 }
-                if (await photo.Dispatcher.InvokeAsync(() => {
+                if (!await photo.Dispatcher.InvokeAsync(() => {
                     if (photo.Disposed) {
                         return false;
                     }
                     photo.mmap = mmap;
+                    photo.loader = this;
                     photo.ThumbImage = img;
                     return true;
                 })) {
-                    fullsizeReads.Add(new Tuple<Photo, Photo.Metadata>(photo, metadata));
-                } else {
                     mmap.Dispose();
                 }
             } catch (Exception ex) {

PhotoTagger.Imaging/Photo.cs

@@ -2,6 +2,7 @@
 using System.ComponentModel;
 using System.Diagnostics.Contracts;
 using System.IO.MemoryMappedFiles;
+using System.Runtime.Caching;
 using System.Threading;
 using System.Threading.Tasks;
 using System.Windows;
@@ -14,24 +15,61 @@ public Photo(string f) {
             this.ShortTitle = f;
         }
 
+        private WeakReference<BitmapImage> fullImageRef = null;
+
+        private int fullIsLoading = 0;
+
+        private static CacheItemPolicy cachePolicy = new CacheItemPolicy() {
+            SlidingExpiration = TimeSpan.FromSeconds(10),
+        };
+
         public BitmapImage FullImage {
             get {
-                return (BitmapImage)GetValue(FullImageProperty);
+                var imageRef = this.fullImageRef;
+                if (imageRef != null && imageRef.TryGetTarget(out BitmapImage target)) {
+                    MemoryCache.Default.Set(
+                        this.FileName,
+                        target,
+                        cachePolicy);
+                    return target;
+                } else {
+                    if (Interlocked.Exchange(ref this.fullIsLoading, 1) == 0) {
+                        this.loader?.EnqueueFullSizeRead(this, this.setFrom);
+                    }
+                    return this.ThumbImage;
+                }
             }
             set {
-                SetValue(FullImageProperty, value);
+                if (value == null) {
+                    if (Interlocked.Exchange(ref this.fullImageRef, null) != null) {
+                        this.PropertyChanged?.Invoke(this,
+                            new PropertyChangedEventArgs(nameof(FullImage)));
+                    }
+                    return;
+                } else if (this.fullImageRef == null) {
+                    this.fullImageRef = new WeakReference<BitmapImage>(value);
+                } else {
+                    this.fullImageRef.SetTarget(value);
+                }
+                fullIsLoading = 0;
+                Thread.MemoryBarrier();
+                this.PropertyChanged?.Invoke(this,
+                    new PropertyChangedEventArgs(nameof(FullImage)));
+                MemoryCache.Default.Set(
+                    this.FileName,
+                    value,
+                    cachePolicy);
             }
         }
-        public static readonly DependencyProperty FullImageProperty =
-            DependencyProperty.Register(nameof(FullImage),
-                typeof(BitmapImage), typeof(Photo));
 
         public BitmapImage ThumbImage {
             get {
                 return (BitmapImage)GetValue(ThumbImageProperty);
             }
             set {
                 SetValue(ThumbImageProperty, value);
+                this.PropertyChanged?.Invoke(this,
+                    new PropertyChangedEventArgs(nameof(FullImage)));
             }
         }
         public static readonly DependencyProperty ThumbImageProperty =
@@ -58,11 +96,13 @@ internal class Metadata {
         }
 
         private Metadata setFrom = null;
+        internal ImageLoadManager loader = null;
         private bool setting = true;
 
         internal void Set(Metadata from) {
             this.setting = true;
             this.setFrom = from;
+            Thread.MemoryBarrier();
             if (from.Title != null) {
                 this.Title = from.Title;
             } else {
@@ -236,6 +276,7 @@ public void Dispose() {
             Thread.MemoryBarrier();
             this.FullImage = null;
             this.ThumbImage = null;
+            MemoryCache.Default.Remove(this.FileName);
             ThreadPool.QueueUserWorkItem(async _ => {
                 bool locked = false;
                 try {

PhotoTagger.Imaging/PhotoTagger.Imaging.csproj

@@ -40,6 +40,7 @@
     <Reference Include="System" />
     <Reference Include="System.Core" />
     <Reference Include="System.Numerics" />
+    <Reference Include="System.Runtime.Caching" />
     <Reference Include="WindowsBase" />
   </ItemGroup>
   <ItemGroup>