improve plugin loading performance

Author: Jack251970

Flow.Launcher.Core/ExternalPlugins/Environments/AbstractPluginEnvironment.cs

@@ -8,6 +8,7 @@
 using System.Linq;
 using System.Windows.Forms;
 using Flow.Launcher.Core.Resource;
+using System.Threading.Tasks;
 
 namespace Flow.Launcher.Core.ExternalPlugins.Environments
 {
@@ -37,10 +38,10 @@ internal AbstractPluginEnvironment(List<PluginMetadata> pluginMetadataList, Plug
             PluginSettings = pluginSettings;
         }
 
-        internal IEnumerable<PluginPair> Setup()
+        internal IEnumerable<Task> Setup()
         {
             if (!PluginMetadataList.Any(o => o.Language.Equals(Language, StringComparison.OrdinalIgnoreCase)))
-                return new List<PluginPair>();
+                return new List<Task>();
 
             if (!string.IsNullOrEmpty(PluginsSettingsFilePath) && FilesFolders.FileExists(PluginsSettingsFilePath))
             {
@@ -87,7 +88,7 @@ internal IEnumerable<PluginPair> Setup()
                     $"Not able to successfully set {EnvName} path, setting's plugin executable path variable is still an empty string.",
                     $"{Language}Environment");
 
-                return new List<PluginPair>();
+                return new List<Task>();
             }
         }
 
@@ -106,17 +107,17 @@ private void EnsureLatestInstalled(string expectedPath, string currentPath, stri
 
         internal abstract PluginPair CreatePluginPair(string filePath, PluginMetadata metadata);
 
-        private IEnumerable<PluginPair> SetPathForPluginPairs(string filePath, string languageToSet)
+        private IEnumerable<Task> SetPathForPluginPairs(string filePath, string languageToSet)
         {
-            var pluginPairs = new List<PluginPair>();
+            var tasks = new List<Task>();
 
             foreach (var metadata in PluginMetadataList)
             {
                 if (metadata.Language.Equals(languageToSet, StringComparison.OrdinalIgnoreCase))
-                    pluginPairs.Add(CreatePluginPair(filePath, metadata));
+                    tasks.Add(Task.Run(() => CreatePluginPair(filePath, metadata)));
             }
 
-            return pluginPairs;
+            return tasks;
         }
 
         private string GetFileFromDialog(string title, string filter = "")

Flow.Launcher.Core/Plugin/PluginManager.cs

@@ -146,12 +146,12 @@ static PluginManager()
         /// todo happlebao The API should be removed
         /// </summary>
         /// <param name="settings"></param>
-        public static void LoadPlugins(PluginsSettings settings)
+        public static async Task LoadPluginsAsync(PluginsSettings settings)
         {
             _metadatas = PluginConfig.Parse(Directories);
             Settings = settings;
             Settings.UpdatePluginSettings(_metadatas);
-            AllPlugins = PluginsLoader.Plugins(_metadatas, Settings);
+            AllPlugins = await PluginsLoader.PluginsAsync(_metadatas, Settings);
         }
 
         /// <summary>

Flow.Launcher.Core/Plugin/PluginsLoader.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Collections.Concurrent;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -16,7 +17,11 @@ namespace Flow.Launcher.Core.Plugin
 {
     public static class PluginsLoader
     {
-        public static List<PluginPair> Plugins(List<PluginMetadata> metadatas, PluginsSettings settings)
+        private static readonly ConcurrentQueue<PluginPair> Plugins = new();
+
+        private static readonly ConcurrentQueue<string> ErroredPlugins = new();
+
+        public static async Task<List<PluginPair>> PluginsAsync(List<PluginMetadata> metadatas, PluginsSettings settings)
         {
             var dotnetPlugins = DotNetPlugins(metadatas);
 
@@ -46,17 +51,34 @@ public static List<PluginPair> Plugins(List<PluginMetadata> metadatas, PluginsSe
                 .Concat(executablePlugins)
                 .Concat(executableV2Plugins)
                 .ToList();
-            return plugins;
+
+            await Task.WhenAll(plugins);
+
+            if (!ErroredPlugins.IsEmpty)
+            {
+                var errorPluginString = String.Join(Environment.NewLine, ErroredPlugins);
+
+                var errorMessage = "The following "
+                                   + (ErroredPlugins.Count > 1 ? "plugins have " : "plugin has ")
+                                   + "errored and cannot be loaded:";
+
+                _ = Task.Run(() =>
+                {
+                    MessageBox.Show($"{errorMessage}{Environment.NewLine}{Environment.NewLine}" +
+                                    $"{errorPluginString}{Environment.NewLine}{Environment.NewLine}" +
+                                    $"Please refer to the logs for more information", "",
+                        MessageBoxButtons.OK, MessageBoxIcon.Warning);
+                });
+            }
+
+            return Plugins.ToList();
         }
 
-        public static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source)
+        public static IEnumerable<Task> DotNetPlugins(List<PluginMetadata> source)
         {
-            var erroredPlugins = new List<string>();
-
-            var plugins = new List<PluginPair>();
             var metadatas = source.Where(o => AllowedLanguage.IsDotNet(o.Language));
 
-            foreach (var metadata in metadatas)
+            return metadatas.Select(metadata => Task.Run(() =>
             {
                 var milliseconds = Stopwatch.Debug(
                     $"|PluginsLoader.DotNetPlugins|Constructor init cost for {metadata.Name}", () =>
@@ -100,53 +122,42 @@ public static IEnumerable<PluginPair> DotNetPlugins(List<PluginMetadata> source)
 
                         if (plugin == null)
                         {
-                            erroredPlugins.Add(metadata.Name);
+                            ErroredPlugins.Enqueue(metadata.Name);
                             return;
                         }
 
-                        plugins.Add(new PluginPair { Plugin = plugin, Metadata = metadata });
+                        Plugins.Enqueue(new PluginPair { Plugin = plugin, Metadata = metadata });
                     });
                 metadata.InitTime += milliseconds;
-            }
-
-            if (erroredPlugins.Count > 0)
-            {
-                var errorPluginString = String.Join(Environment.NewLine, erroredPlugins);
-
-                var errorMessage = "The following "
-                                   + (erroredPlugins.Count > 1 ? "plugins have " : "plugin has ")
-                                   + "errored and cannot be loaded:";
-
-                _ = Task.Run(() =>
-                {
-                    MessageBox.Show($"{errorMessage}{Environment.NewLine}{Environment.NewLine}" +
-                                    $"{errorPluginString}{Environment.NewLine}{Environment.NewLine}" +
-                                    $"Please refer to the logs for more information", "",
-                        MessageBoxButtons.OK, MessageBoxIcon.Warning);
-                });
-            }
-
-            return plugins;
+            }));
         }
 
-        public static IEnumerable<PluginPair> ExecutablePlugins(IEnumerable<PluginMetadata> source)
+        public static IEnumerable<Task> ExecutablePlugins(IEnumerable<PluginMetadata> source)
         {
             return source
                 .Where(o => o.Language.Equals(AllowedLanguage.Executable, StringComparison.OrdinalIgnoreCase))
-                .Select(metadata => new PluginPair
+                .Select(metadata => Task.Run(() => 
                 {
-                    Plugin = new ExecutablePlugin(metadata.ExecuteFilePath), Metadata = metadata
-                });
+                    return new PluginPair
+                    {
+                        Plugin = new ExecutablePlugin(metadata.ExecuteFilePath),
+                        Metadata = metadata
+                    };
+                }));
         }
 
-        public static IEnumerable<PluginPair> ExecutableV2Plugins(IEnumerable<PluginMetadata> source)
+        public static IEnumerable<Task> ExecutableV2Plugins(IEnumerable<PluginMetadata> source)
         {
             return source
                 .Where(o => o.Language.Equals(AllowedLanguage.ExecutableV2, StringComparison.OrdinalIgnoreCase))
-                .Select(metadata => new PluginPair
+                .Select(metadata => Task.Run(() => 
                 {
-                    Plugin = new ExecutablePluginV2(metadata.ExecuteFilePath), Metadata = metadata
-                });
+                    return new PluginPair
+                    {
+                        Plugin = new ExecutablePluginV2(metadata.ExecuteFilePath),
+                        Metadata = metadata
+                    };
+                }));
         }
     }
 }

Flow.Launcher/App.xaml.cs

@@ -74,7 +74,7 @@ await Stopwatch.NormalAsync("|App.OnStartup|Startup cost", async () =>
                 InternationalizationManager.Instance.Settings = _settings;
                 InternationalizationManager.Instance.ChangeLanguage(_settings.Language);
 
-                PluginManager.LoadPlugins(_settings.PluginSettings);
+                await PluginManager.LoadPluginsAsync(_settings.PluginSettings);
                 _mainVM = new MainViewModel(_settings);
 
                 API = new PublicAPIInstance(_settingsVM, _mainVM, _alphabet);