Merge pull request #2418 from Flow-Launcher/binary_formatter

use memorypack instead of binaryformatter

Author: jjw24

Flow.Launcher.Infrastructure/Flow.Launcher.Infrastructure.csproj

@@ -53,6 +53,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
+    <PackageReference Include="MemoryPack" Version="1.10.0" />
     <PackageReference Include="Microsoft.VisualStudio.Threading" Version="17.7.30" />
     <PackageReference Include="NLog" Version="4.7.10" />
     <PackageReference Include="NLog.Schema" Version="4.7.10" />

Flow.Launcher.Infrastructure/Image/ImageLoader.cs

@@ -3,6 +3,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using System.Threading.Tasks;
 using System.Windows.Media;
 using System.Windows.Media.Imaging;
@@ -15,6 +16,7 @@ namespace Flow.Launcher.Infrastructure.Image
     public static class ImageLoader
     {
         private static readonly ImageCache ImageCache = new();
+        private static SemaphoreSlim storageLock { get; } = new SemaphoreSlim(1, 1);
         private static BinaryStorage<Dictionary<(string, bool), int>> _storage;
         private static readonly ConcurrentDictionary<string, string> GuidToKey = new();
         private static IImageHashGenerator _hashGenerator;
@@ -25,24 +27,18 @@ public static class ImageLoader
         public const int FullIconSize = 256;
 
 
-        private static readonly string[] ImageExtensions =
-        {
-            ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".ico"
-        };
+        private static readonly string[] ImageExtensions = { ".png", ".jpg", ".jpeg", ".gif", ".bmp", ".tiff", ".ico" };
 
-        public static void Initialize()
+        public static async Task InitializeAsync()
         {
             _storage = new BinaryStorage<Dictionary<(string, bool), int>>("Image");
             _hashGenerator = new ImageHashGenerator();
 
-            var usage = LoadStorageToConcurrentDictionary();
+            var usage = await LoadStorageToConcurrentDictionaryAsync();
 
             ImageCache.Initialize(usage.ToDictionary(x => x.Key, x => x.Value));
 
-            foreach (var icon in new[]
-                     {
-                         Constant.DefaultIcon, Constant.MissingImgIcon
-                     })
+            foreach (var icon in new[] { Constant.DefaultIcon, Constant.MissingImgIcon })
             {
                 ImageSource img = new BitmapImage(new Uri(icon));
                 img.Freeze();
@@ -58,29 +54,41 @@ await Stopwatch.NormalAsync("|ImageLoader.Initialize|Preload images cost", async
                         await LoadAsync(path, isFullImage);
                     }
                 });
-                Log.Info($"|ImageLoader.Initialize|Number of preload images is <{ImageCache.CacheSize()}>, Images Number: {ImageCache.CacheSize()}, Unique Items {ImageCache.UniqueImagesInCache()}");
+                Log.Info(
+                    $"|ImageLoader.Initialize|Number of preload images is <{ImageCache.CacheSize()}>, Images Number: {ImageCache.CacheSize()}, Unique Items {ImageCache.UniqueImagesInCache()}");
             });
         }
 
-        public static void Save()
+        public static async Task Save()
         {
-            lock (_storage)
+            await storageLock.WaitAsync();
+
+            try
             {
-                _storage.Save(ImageCache.Data
+                _storage.SaveAsync(ImageCache.Data
                     .ToDictionary(
                         x => x.Key,
                         x => x.Value.usage));
             }
+            finally
+            {
+                storageLock.Release();
+            }
         }
 
-        private static ConcurrentDictionary<(string, bool), int> LoadStorageToConcurrentDictionary()
+        private static async Task<ConcurrentDictionary<(string, bool), int>> LoadStorageToConcurrentDictionaryAsync()
         {
-            lock (_storage)
+            await storageLock.WaitAsync();
+            try
             {
-                var loaded = _storage.TryLoad(new Dictionary<(string, bool), int>());
+                var loaded = await _storage.TryLoadAsync(new Dictionary<(string, bool), int>());
 
                 return new ConcurrentDictionary<(string, bool), int>(loaded);
             }
+            finally
+            {
+                storageLock.Release();
+            }
         }
 
         private class ImageResult
@@ -129,6 +137,7 @@ private static async ValueTask<ImageResult> LoadInternalAsync(string path, bool
                     ImageCache[path, loadFullImage] = image;
                     return new ImageResult(image, ImageType.ImageFile);
                 }
+
                 if (path.StartsWith("data:", StringComparison.OrdinalIgnoreCase))
                 {
                     var imageSource = new BitmapImage(new Uri(path));
@@ -158,6 +167,7 @@ private static async ValueTask<ImageResult> LoadInternalAsync(string path, bool
 
             return imageResult;
         }
+
         private static async Task<BitmapImage> LoadRemoteImageAsync(bool loadFullImage, Uri uriResult)
         {
             // Download image from url
@@ -173,6 +183,7 @@ private static async Task<BitmapImage> LoadRemoteImageAsync(bool loadFullImage,
                 image.DecodePixelHeight = SmallIconSize;
                 image.DecodePixelWidth = SmallIconSize;
             }
+
             image.StreamSource = buffer;
             image.EndInit();
             image.StreamSource = null;
@@ -188,8 +199,8 @@ private static ImageResult GetThumbnailResult(ref string path, bool loadFullImag
             if (Directory.Exists(path))
             {
                 /* Directories can also have thumbnails instead of shell icons.
-                 * Generating thumbnails for a bunch of folder results while scrolling 
-                 * could have a big impact on performance and Flow.Launcher responsibility. 
+                 * Generating thumbnails for a bunch of folder results while scrolling
+                 * could have a big impact on performance and Flow.Launcher responsibility.
                  * - Solution: just load the icon
                  */
                 type = ImageType.Folder;
@@ -208,9 +219,9 @@ private static ImageResult GetThumbnailResult(ref string path, bool loadFullImag
                     }
                     else
                     {
-                        /* Although the documentation for GetImage on MSDN indicates that 
+                        /* Although the documentation for GetImage on MSDN indicates that
                          * if a thumbnail is available it will return one, this has proved to not
-                         * be the case in many situations while testing. 
+                         * be the case in many situations while testing.
                          * - Solution: explicitly pass the ThumbnailOnly flag
                          */
                         image = GetThumbnail(path, ThumbnailOptions.ThumbnailOnly);
@@ -236,7 +247,8 @@ private static ImageResult GetThumbnailResult(ref string path, bool loadFullImag
             return new ImageResult(image, type);
         }
 
-        private static BitmapSource GetThumbnail(string path, ThumbnailOptions option = ThumbnailOptions.ThumbnailOnly, int size = SmallIconSize)
+        private static BitmapSource GetThumbnail(string path, ThumbnailOptions option = ThumbnailOptions.ThumbnailOnly,
+            int size = SmallIconSize)
         {
             return WindowsThumbnailProvider.GetThumbnail(
                 path,
@@ -261,17 +273,19 @@ public static async ValueTask<ImageSource> LoadAsync(string path, bool loadFullI
 
             var img = imageResult.ImageSource;
             if (imageResult.ImageType != ImageType.Error && imageResult.ImageType != ImageType.Cache)
-            { // we need to get image hash
+            {
+                // we need to get image hash
                 string hash = EnableImageHash ? _hashGenerator.GetHashFromImage(img) : null;
                 if (hash != null)
                 {
-
                     if (GuidToKey.TryGetValue(hash, out string key))
-                    { // image already exists
+                    {
+                        // image already exists
                         img = ImageCache[key, loadFullImage] ?? img;
                     }
                     else
-                    { // new guid
+                    {
+                        // new guid
 
                         GuidToKey[hash] = path;
                     }
@@ -289,7 +303,7 @@ private static BitmapImage LoadFullImage(string path)
             BitmapImage image = new BitmapImage();
             image.BeginInit();
             image.CacheOption = BitmapCacheOption.OnLoad;
-            image.UriSource = new Uri(path);            
+            image.UriSource = new Uri(path);
             image.CreateOptions = BitmapCreateOptions.IgnoreColorProfile;
             image.EndInit();
 
@@ -314,8 +328,10 @@ private static BitmapImage LoadFullImage(string path)
                     resizedHeight.EndInit();
                     return resizedHeight;
                 }
+
                 return resizedWidth;
             }
+
             return image;
         }
     }

Flow.Launcher.Infrastructure/Storage/BinaryStorage.cs

@@ -4,115 +4,78 @@
 using System.Runtime.Serialization;
 using System.Runtime.Serialization.Formatters;
 using System.Runtime.Serialization.Formatters.Binary;
+using System.Threading.Tasks;
 using Flow.Launcher.Infrastructure.Logger;
 using Flow.Launcher.Infrastructure.UserSettings;
+using MemoryPack;
 
 namespace Flow.Launcher.Infrastructure.Storage
 {
-#pragma warning disable SYSLIB0011 // BinaryFormatter is obsolete.
     /// <summary>
     /// Stroage object using binary data
     /// Normally, it has better performance, but not readable
     /// </summary>
+    /// <remarks>
+    /// It utilize MemoryPack, which means the object must be MemoryPackSerializable
+    /// https://github.com/Cysharp/MemoryPack
+    /// </remarks>
     public class BinaryStorage<T>
     {
+        const string DirectoryName = "Cache";
+
+        const string FileSuffix = ".cache";
+
         public BinaryStorage(string filename)
         {
-            const string directoryName = "Cache";
-            var directoryPath = Path.Combine(DataLocation.DataDirectory(), directoryName);
+            var directoryPath = Path.Combine(DataLocation.DataDirectory(), DirectoryName);
             Helper.ValidateDirectory(directoryPath);
 
-            const string fileSuffix = ".cache";
-            FilePath = Path.Combine(directoryPath, $"{filename}{fileSuffix}");
+            FilePath = Path.Combine(directoryPath, $"{filename}{FileSuffix}");
         }
 
         public string FilePath { get; }
 
-        public T TryLoad(T defaultData)
+        public async ValueTask<T> TryLoadAsync(T defaultData)
         {
             if (File.Exists(FilePath))
             {
                 if (new FileInfo(FilePath).Length == 0)
                 {
                     Log.Error($"|BinaryStorage.TryLoad|Zero length cache file <{FilePath}>");
-                    Save(defaultData);
+                    await SaveAsync(defaultData);
                     return defaultData;
                 }
 
-                using (var stream = new FileStream(FilePath, FileMode.Open))
-                {
-                    var d = Deserialize(stream, defaultData);
-                    return d;
-                }
+                await using var stream = new FileStream(FilePath, FileMode.Open);
+                var d = await DeserializeAsync(stream, defaultData);
+                return d;
             }
             else
             {
                 Log.Info("|BinaryStorage.TryLoad|Cache file not exist, load default data");
-                Save(defaultData);
+                await SaveAsync(defaultData);
                 return defaultData;
             }
         }
 
-        private T Deserialize(FileStream stream, T defaultData)
+        private async ValueTask<T> DeserializeAsync(Stream stream, T defaultData)
         {
-            //http://stackoverflow.com/questions/2120055/binaryformatter-deserialize-gives-serializationexception
-            AppDomain.CurrentDomain.AssemblyResolve += CurrentDomain_AssemblyResolve;
-            BinaryFormatter binaryFormatter = new BinaryFormatter
-            {
-                AssemblyFormat = FormatterAssemblyStyle.Simple
-            };
-
             try
             {
-                var t = ((T)binaryFormatter.Deserialize(stream)).NonNull();
+                var t = await MemoryPackSerializer.DeserializeAsync<T>(stream);
                 return t;
             }
             catch (System.Exception e)
             {
                 Log.Exception($"|BinaryStorage.Deserialize|Deserialize error for file <{FilePath}>", e);
                 return defaultData;
             }
-            finally
-            {
-                AppDomain.CurrentDomain.AssemblyResolve -= CurrentDomain_AssemblyResolve;
-            }
         }
 
-        private Assembly CurrentDomain_AssemblyResolve(object sender, ResolveEventArgs args)
+        public async ValueTask SaveAsync(T data)
         {
-            Assembly ayResult = null;
-            string sShortAssemblyName = args.Name.Split(',')[0];
-            Assembly[] ayAssemblies = AppDomain.CurrentDomain.GetAssemblies();
-            foreach (Assembly ayAssembly in ayAssemblies)
-            {
-                if (sShortAssemblyName == ayAssembly.FullName.Split(',')[0])
-                {
-                    ayResult = ayAssembly;
-                    break;
-                }
-            }
-            return ayResult;
-        }
-
-        public void Save(T data)
-        {
-            using (var stream = new FileStream(FilePath, FileMode.Create))
-            {
-                BinaryFormatter binaryFormatter = new BinaryFormatter
-                {
-                    AssemblyFormat = FormatterAssemblyStyle.Simple
-                };
-
-                try
-                {
-                    binaryFormatter.Serialize(stream, data);
-                }
-                catch (SerializationException e)
-                {
-                    Log.Exception($"|BinaryStorage.Save|serialize error for file <{FilePath}>", e);
-                }
-            }
+            await using var stream = new FileStream(FilePath, FileMode.Create);
+            await MemoryPackSerializer.SerializeAsync(stream, data);
         }
     }
-#pragma warning restore SYSLIB0011
 }

Flow.Launcher/App.xaml.cs

@@ -52,12 +52,13 @@ await Stopwatch.NormalAsync("|App.OnStartup|Startup cost", async () =>
             {
                 _portable.PreStartCleanUpAfterPortabilityUpdate();
 
-                Log.Info("|App.OnStartup|Begin Flow Launcher startup ----------------------------------------------------");
+                Log.Info(
+                    "|App.OnStartup|Begin Flow Launcher startup ----------------------------------------------------");
                 Log.Info($"|App.OnStartup|Runtime info:{ErrorReporting.RuntimeInfo()}");
                 RegisterAppDomainExceptions();
                 RegisterDispatcherUnhandledException();
 
-                ImageLoader.Initialize();
+                var imageLoadertask = ImageLoader.InitializeAsync();
 
                 _settingsVM = new SettingWindowViewModel(_updater, _portable);
                 _settings = _settingsVM.Settings;
@@ -78,6 +79,8 @@ await Stopwatch.NormalAsync("|App.OnStartup|Startup cost", async () =>
                 Http.Proxy = _settings.Proxy;
 
                 await PluginManager.InitializePluginsAsync(API);
+                await imageLoadertask;
+                
                 var window = new MainWindow(_settings, _mainVM);
 
                 Log.Info($"|App.OnStartup|Dependencies Info:{ErrorReporting.DependenciesInfo()}");
@@ -103,7 +106,8 @@ await Stopwatch.NormalAsync("|App.OnStartup|Startup cost", async () =>
                 AutoUpdates();
 
                 API.SaveAppAllSettings();
-                Log.Info("|App.OnStartup|End Flow Launcher startup ----------------------------------------------------  ");
+                Log.Info(
+                    "|App.OnStartup|End Flow Launcher startup ----------------------------------------------------  ");
             });
         }
 
@@ -122,7 +126,8 @@ private void AutoStartup()
                     // but if it fails (permissions, etc) then don't keep retrying
                     // this also gives the user a visual indication in the Settings widget
                     _settings.StartFlowLauncherOnSystemStartup = false;
-                    Notification.Show(InternationalizationManager.Instance.GetTranslation("setAutoStartFailed"), e.Message);
+                    Notification.Show(InternationalizationManager.Instance.GetTranslation("setAutoStartFailed"),
+                        e.Message);
                 }
             }
         }