Exemple #1
0
        /// <summary>
        /// Creates a new <see cref="LoadContext"/> for individual mods/plugins.
        /// </summary>
        public static LoadContext BuildModLoadContext(string assemblyPath, bool isUnloadable, Type[] sharedTypes, AssemblyLoadContext defaultContext = null)
        {
            var builder = new AssemblyLoadContextBuilder()
                          .SetMainAssemblyPath(assemblyPath)
                          .IsLazyLoaded(true);

            if (defaultContext != null)
            {
                builder.SetDefaultContext(defaultContext);
            }

            if (isUnloadable)
            {
                builder.EnableUnloading();
            }

            foreach (var type in sharedTypes)
            {
                builder.PreferDefaultLoadContextAssembly(type.Assembly.GetName());
            }

            var context = builder.Build();

            return(new LoadContext(context, assemblyPath));
        }
        private static AssemblyLoadContext CreateLoadContext(string assemblyPath, Core.ILogger logger = null)
        {
            var validatedPath = ValidateFilePath(assemblyPath, logger);

            if (validatedPath == null)
            {
                return(null);
            }

            var mainAssemblyName = Path.GetFileNameWithoutExtension(validatedPath);
            var builder          = new AssemblyLoadContextBuilder();

            // Set base directory.
            var baseDir = Path.GetDirectoryName(validatedPath);

            builder.SetBaseDirectory(baseDir);
            logger?.LogTrace($"Base directory: '{baseDir}'");

            // Add deps file as a source for finding dependencies.
            var depsJsonFile = Path.Combine(baseDir, $"{mainAssemblyName}.deps.json");

            if (File.Exists(depsJsonFile))
            {
                builder.AddDependencyContext(depsJsonFile);
                logger?.LogTrace($"Added '{depsJsonFile}' as a deps file dependency");
            }

            // Add runtimeconfig file as a source for finding dependencies.
            var pluginRuntimeConfigFile = Path.Combine(baseDir, $"{mainAssemblyName}.runtimeconfig.json");

            builder.TryAddAdditionalProbingPathFromRuntimeConfig(pluginRuntimeConfigFile, includeDevConfig: true, out _);

            return(builder.Build());
        }
        private static AssemblyLoadContext CreateLoadContext(
            string baseDir,
            PluginConfig config,
            Type[] sharedTypes)
        {
            var depsJsonFile = Path.Combine(baseDir, config.MainAssembly.Name + ".deps.json");

            var builder = new AssemblyLoadContextBuilder();

            if (File.Exists(depsJsonFile))
            {
                builder.AddDependencyContext(depsJsonFile);
            }

            builder.SetBaseDirectory(baseDir);

            foreach (var ext in config.PrivateAssemblies)
            {
                builder.PreferLoadContextAssembly(ext);
            }

            if (sharedTypes != null)
            {
                foreach (var type in sharedTypes)
                {
                    builder.PreferDefaultLoadContextAssembly(type.Assembly.GetName());
                }
            }

            var runtimeConfigFile = Path.Combine(baseDir, config.MainAssembly.Name + ".runtimeconfig.json");

            builder.TryAddAdditionalProbingPathFromRuntimeConfig(runtimeConfigFile, includeDevConfig: true, out _);

            return(builder.Build());
        }
Exemple #4
0
        private static AssemblyLoadContext CreateLoadContext(PluginConfig config)
        {
            var builder = new AssemblyLoadContextBuilder();

            builder.SetMainAssemblyPath(config.MainAssemblyPath);

            foreach (var ext in config.PrivateAssemblies)
            {
                builder.PreferLoadContextAssembly(ext);
            }

            if (config.PreferSharedTypes)
            {
                builder.PreferDefaultLoadContext(true);
            }

            if (config.IsUnloadable)
            {
                builder.EnableUnloading();
            }

            foreach (var assemblyName in config.SharedAssemblies)
            {
                builder.PreferDefaultLoadContextAssembly(assemblyName);
            }


            builder.SetupSharedAssemblyPrefix(config.SharedAssemblyPrefixes);

            return(builder.Build());
        }
        private static AssemblyLoadContext CreateLoadContext(
            string baseDir,
            PluginConfig config,
            Type[] sharedTypes,
            PluginLoaderOptions loaderOptions)
        {
            var depsJsonFile = Path.Combine(baseDir, config.MainAssembly.Name + ".deps.json");

            var builder = new AssemblyLoadContextBuilder();

            if (File.Exists(depsJsonFile))
            {
                builder.AddDependencyContext(depsJsonFile);
            }

            builder.SetBaseDirectory(baseDir);

            foreach (var ext in config.PrivateAssemblies)
            {
                builder.PreferLoadContextAssembly(ext);
            }

            if (loaderOptions.HasFlag(PluginLoaderOptions.PreferSharedTypes))
            {
                builder.PreferDefaultLoadContext(true);
            }

#if FEATURE_UNLOAD
            if (loaderOptions.HasFlag(PluginLoaderOptions.IsUnloadable))
            {
                builder.EnableUnloading();
            }
#endif

            if (sharedTypes != null)
            {
                foreach (var type in sharedTypes)
                {
                    builder.PreferDefaultLoadContextAssembly(type.Assembly.GetName());
                }
            }

            var pluginRuntimeConfigFile = Path.Combine(baseDir, config.MainAssembly.Name + ".runtimeconfig.json");

            builder.TryAddAdditionalProbingPathFromRuntimeConfig(pluginRuntimeConfigFile, includeDevConfig: true, out _);

            // Always include runtimeconfig.json from the host app.
            // in some cases, like `dotnet test`, the entry assembly does not actually match with the
            // runtime config file which is why we search for all files matching this extensions.
            foreach (var runtimeconfig in Directory.GetFiles(AppContext.BaseDirectory, "*.runtimeconfig.json"))
            {
                builder.TryAddAdditionalProbingPathFromRuntimeConfig(runtimeconfig, includeDevConfig: true, out _);
            }

            return(builder.Build());
        }
 /// <summary>
 /// Initialize an instance of <see cref="PluginLoader" />
 /// </summary>
 /// <param name="config">The configuration for the plugin.</param>
 public PluginLoader(PluginConfig config)
 {
     _config         = config ?? throw new ArgumentNullException(nameof(config));
     _contextBuilder = CreateLoadContextBuilder(config);
     _context        = (ManagedLoadContext)_contextBuilder.Build();
     if (config.EnableHotReload)
     {
         StartFileWatcher();
     }
 }
        private static AssemblyLoadContext CreateLoadContext(PluginConfig config)
        {
            var builder = new AssemblyLoadContextBuilder();

            builder.SetMainAssemblyPath(config.MainAssemblyPath);

            foreach (var ext in config.PrivateAssemblies)
            {
                builder.PreferLoadContextAssembly(ext);
            }

            if (config.PreferSharedTypes)
            {
                builder.PreferDefaultLoadContext(true);
            }

#if FEATURE_UNLOAD
            if (config.IsUnloadable)
            {
                builder.EnableUnloading();
            }
#endif

            foreach (var assemblyName in config.SharedAssemblies)
            {
                builder.PreferDefaultLoadContextAssembly(assemblyName);
            }

#if !FEATURE_NATIVE_RESOLVER
            // In .NET Core 3.0, this code is unnecessary because the API, AssemblyDependencyResolver, handles parsing these files.
            var baseDir          = Path.GetDirectoryName(config.MainAssemblyPath);
            var assemblyFileName = Path.GetFileNameWithoutExtension(config.MainAssemblyPath);

            var depsJsonFile = Path.Combine(baseDir, assemblyFileName + ".deps.json");
            if (File.Exists(depsJsonFile))
            {
                builder.AddDependencyContext(depsJsonFile);
            }

            var pluginRuntimeConfigFile = Path.Combine(baseDir, assemblyFileName + ".runtimeconfig.json");

            builder.TryAddAdditionalProbingPathFromRuntimeConfig(pluginRuntimeConfigFile, includeDevConfig: true, out _);

            // Always include runtimeconfig.json from the host app.
            // in some cases, like `dotnet test`, the entry assembly does not actually match with the
            // runtime config file which is why we search for all files matching this extensions.
            foreach (var runtimeconfig in Directory.GetFiles(AppContext.BaseDirectory, "*.runtimeconfig.json"))
            {
                builder.TryAddAdditionalProbingPathFromRuntimeConfig(runtimeconfig, includeDevConfig: true, out _);
            }
#endif

            return(builder.Build());
        }
Exemple #8
0
        /// <summary>
        /// Initialize an instance of <see cref="PluginLoader" />
        /// </summary>
        /// <param name="config">The configuration for the plugin.</param>
        public PluginLoader(PluginConfig config)
        {
            _config         = config ?? throw new ArgumentNullException(nameof(config));
            _contextBuilder = CreateLoadContextBuilder(config);
            _context        = _contextBuilder.Build();
#if FEATURE_UNLOAD
            if (config.EnableHotReload)
            {
                StartFileWatcher();
            }
#endif
        }
Exemple #9
0
    /// <summary>
    /// Creates a new empty Shared <see cref="LoadContext"/> used for storing plugin shared interfaces.
    /// </summary>
    public static LoadContext BuildSharedLoadContext()
    {
        var loaderFolder      = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
        var interFacesAsmName = typeof(IModLoader).Assembly.GetName();
        var interFacesAsmFile = Path.Combine(loaderFolder, $"{interFacesAsmName.Name}.dll");
        var builder           = new AssemblyLoadContextBuilder()
                                .IsLazyLoaded(true)
                                .PreferDefaultLoadContextAssembly(interFacesAsmName)
                                .SetMainAssemblyPath(interFacesAsmFile);

        var context = builder.Build();

        return(new LoadContext(context, interFacesAsmFile));
    }
Exemple #10
0
        /// <summary>
        /// Based on https://github.com/natemcmaster/DotNetCorePlugins/blob/master/src/Plugins/PluginLoader.cs
        /// </summary>
        public static AssemblyLoadContext CreateLoadContext(string baseDir,
                                                            AssemblyName mainAssemblyName,
                                                            PluginLoaderOptions loaderOptions = PluginLoaderOptions.None,
                                                            IEnumerable <AssemblyName> preferDefaultLoadContextForAssemblies = null,
                                                            IEnumerable <AssemblyName> privateAssemblies = null)
        {
            var depsJsonFile = Path.Combine(baseDir, mainAssemblyName.Name + ".deps.json");

            var builder = new AssemblyLoadContextBuilder();

            if (File.Exists(depsJsonFile))
            {
                builder.AddDependencyContextWithCompileDeps(depsJsonFile);
            }

            builder.SetBaseDirectory(baseDir);

            if (privateAssemblies != null)
            {
                foreach (var ext in privateAssemblies)
                {
                    builder.PreferLoadContextAssembly(ext);
                }
            }

            if (loaderOptions.HasFlag(PluginLoaderOptions.PreferSharedTypes))
            {
                builder.PreferDefaultLoadContext(true);
            }

            if (preferDefaultLoadContextForAssemblies != null)
            {
                foreach (var assemblyName in preferDefaultLoadContextForAssemblies)
                {
                    builder.PreferDefaultLoadContextAssembly(assemblyName);
                }
            }

            var pluginRuntimeConfigFile = Path.Combine(baseDir, mainAssemblyName.Name + ".runtimeconfig.json");

            builder.TryAddAdditionalProbingPathFromRuntimeConfig(pluginRuntimeConfigFile, true, out _);

            foreach (var runtimeconfig in Directory.GetFiles(AppContext.BaseDirectory, "*.runtimeconfig.json"))
            {
                builder.TryAddAdditionalProbingPathFromRuntimeConfig(runtimeconfig, true, out _);
            }

            return(builder.Build());
        }
        /// <summary>
        /// The unloads and reloads the plugin assemblies.
        /// This method throws if <see cref="IsUnloadable" /> is <c>false</c>.
        /// </summary>
        public void Reload()
        {
            EnsureNotDisposed();

            if (!IsUnloadable)
            {
                throw new InvalidOperationException("Reload cannot be used because IsUnloadable is false");
            }

            _context.Unload();
            _context = (ManagedLoadContext)_contextBuilder.Build();
            GC.Collect();
            GC.WaitForPendingFinalizers();
            Reloaded?.Invoke(this, new PluginReloadedEventArgs(this));
        }
Exemple #12
0
        static AssemblyLoadContext GetAssemblyLoadContext(string assemblyPath, string depsPath, bool enableUnloading)
        {
            var builder = new AssemblyLoadContextBuilder()
                          .SetMainAssemblyPath(assemblyPath)
                          .PreferDefaultLoadContext(true)
                          .AddDependencyContext(depsPath)
                          .AddProbingPath(Path.GetDirectoryName(assemblyPath))
                          .PreferDefaultLoadContextAssembly(typeof(IPlatformStartup).Assembly.GetName())
                          .PreferDefaultLoadContextAssembly(typeof(IServiceCollection).Assembly.GetName())
                          .PreferDefaultLoadContextAssembly(typeof(IServiceCollectionBusConfigurator).Assembly.GetName())
                          .PreferDefaultLoadContextAssembly(typeof(ILogger).Assembly.GetName())
                          .PreferDefaultLoadContextAssembly(typeof(IBus).Assembly.GetName())
                          .PreferDefaultLoadContextAssembly(typeof(IRabbitMqBusFactoryConfigurator).Assembly.GetName())
                          .PreferDefaultLoadContextAssembly(typeof(IActiveMqBusFactoryConfigurator).Assembly.GetName())
                          .PreferDefaultLoadContextAssembly(typeof(IAmazonSqsBusFactoryConfigurator).Assembly.GetName())
                          .PreferDefaultLoadContextAssembly(typeof(IServiceBusBusFactoryConfigurator).Assembly.GetName());

            if (enableUnloading)
            {
                builder = builder.EnableUnloading();
            }

            return(builder.Build());
        }