public void OnImportsSatisfied()
 {
     Plugin = new AsyncPlugin(_plugin);
 }
Esempio n. 2
0
        public static IEnumerable <PluginPair> 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)
            {
                var milliseconds = Stopwatch.Debug(
                    $"|PluginsLoader.DotNetPlugins|Constructor init cost for {metadata.Name}", () =>
                {
#if DEBUG
                    var assemblyLoader = new PluginAssemblyLoader(metadata.ExecuteFilePath);
                    var assembly       = assemblyLoader.LoadAssemblyAndDependencies();
                    var type           = assemblyLoader.FromAssemblyGetTypeOfInterface(assembly,
                                                                                       typeof(IAsyncPlugin));

                    var plugin = Activator.CreateInstance(type) as IAsyncPlugin;
#else
                    Assembly assembly   = null;
                    IAsyncPlugin plugin = null;

                    try
                    {
                        var assemblyLoader = new PluginAssemblyLoader(metadata.ExecuteFilePath);
                        assembly           = assemblyLoader.LoadAssemblyAndDependencies();

                        var type = assemblyLoader.FromAssemblyGetTypeOfInterface(assembly,
                                                                                 typeof(IAsyncPlugin));

                        plugin = Activator.CreateInstance(type) as IAsyncPlugin;
                    }
                    catch (Exception e) when(assembly == null)
                    {
                        Log.Exception($"|PluginsLoader.DotNetPlugins|Couldn't load assembly for the plugin: {metadata.Name}", e);
                    }
                    catch (InvalidOperationException e)
                    {
                        Log.Exception($"|PluginsLoader.DotNetPlugins|Can't find the required IPlugin interface for the plugin: <{metadata.Name}>", e);
                    }
                    catch (ReflectionTypeLoadException e)
                    {
                        Log.Exception($"|PluginsLoader.DotNetPlugins|The GetTypes method was unable to load assembly types for the plugin: <{metadata.Name}>", e);
                    }
                    catch (Exception e)
                    {
                        Log.Exception($"|PluginsLoader.DotNetPlugins|The following plugin has errored and can not be loaded: <{metadata.Name}>", e);
                    }
#endif
                    if (plugin == null)
                    {
                        erroredPlugins.Add(metadata.Name);
                        return;
                    }

                    plugins.Add(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);
        }