Exemplo n.º 1
0
 // Use the ASP.NET Core DI system to inject these dependencies
 public PluginLoadOptions(
     IPluginLogger <T> logger,
     IAssemblyScanner <T> assemblyScanner,
     ISharedServicesProvider <T> sharedServicesProvider,
     IPluginTypesProvider <T> pluginTypesProvider,
     IPluginActivationContextProvider <T> pluginActivationContextProvider,
     IRemotePluginActivator <T> activator,
     IParameterConverter parameterConverter,
     IResultConverter resultConverter,
     IPluginAssemblyLoader <T> assemblyLoader,
     IPluginProxyCreator <T> proxyCreator,
     IHostTypesProvider <T> hostTypesProvider,
     IRemoteTypesProvider <T> remoteTypesProvider,
     IRuntimePlatformContext runtimePlatformContext,
     IAssemblySelector <T> assemblySelector,
     IPluginSelector <T> pluginSelector
     )
 {
     this.logger                          = logger;
     this.assemblyScanner                 = assemblyScanner;
     this.sharedServicesProvider          = sharedServicesProvider;
     this.pluginTypesProvider             = pluginTypesProvider;
     this.pluginActivationContextProvider = pluginActivationContextProvider;
     this.activator                       = activator;
     this.parameterConverter              = parameterConverter;
     this.resultConverter                 = resultConverter;
     this.assemblyLoader                  = assemblyLoader;
     this.proxyCreator                    = proxyCreator;
     this.hostTypesProvider               = hostTypesProvider;
     this.remoteTypesProvider             = remoteTypesProvider;
     this.runtimePlatformContext          = runtimePlatformContext;
     this.assemblySelector                = assemblySelector;
     this.pluginSelector                  = pluginSelector;
 }
Exemplo n.º 2
0
        public PluginLoadOptionsBuilder <T> WithDefaultOptions(string pluginPath = null, ServiceLifetime serviceLifetime = ServiceLifetime.Scoped)
        {
            if (String.IsNullOrEmpty(pluginPath))
            {
                pluginPath = Path.Join(GetLocalExecutionPath(), "Plugins");
            }

            this.priseServiceLifetime   = ServiceLifetime.Scoped;
            this.loggerType             = typeof(NullPluginLogger <T>);
            this.pluginPathProvider     = new DefaultPluginPathProvider <T>(pluginPath);
            this.dependencyPathProvider = new DependencyPathProvider <T>(pluginPath);
            this.cacheOptions           = CacheOptions <IPluginCache <T> > .ScopedPluginCache();

            this.runtimePlatformContext = new RuntimePlatformContext();
            this.ScanForAssemblies(composer =>
                                   composer.WithDefaultOptions <DefaultAssemblyScanner <T>, DefaultAssemblyScannerOptions <T> >());

            this.pluginAssemblyNameProvider      = new PluginAssemblyNameProvider <T>($"{typeof(T).Name}.dll");
            this.sharedServicesProvider          = new DefaultSharedServicesProvider <T>(this.hostServices, this.sharedServices);
            this.pluginActivationContextProvider = new DefaultPluginActivationContextProvider <T>();
            this.pluginTypesProvider             = new DefaultPluginTypesProvider <T>();
            this.activator    = new DefaultRemotePluginActivator <T>(this.sharedServicesProvider);
            this.proxyCreator = new PluginProxyCreator <T>();

            // Use System.Text.Json in 3.0
            this.parameterConverter  = new JsonSerializerParameterConverter();
            this.resultConverter     = new JsonSerializerResultConverter();
            this.assemblyLoaderType  = typeof(DefaultAssemblyLoaderWithNativeResolver <T>);
            this.assemblySelector    = new DefaultAssemblySelector <T>();
            this.assemblyLoadOptions = new DefaultAssemblyLoadOptions <T>(
                PluginPlatformVersion.Empty(),
                false,
                this.useCollectibleAssemblies,
                NativeDependencyLoadPreference.PreferInstalledRuntime);

            this.probingPathsProvider = new ProbingPathsProvider <T>();

            var hostTypesProvider = new HostTypesProvider <T>();

            hostTypesProvider.AddHostType(typeof(Prise.Plugin.PluginAttribute)); // Add the Prise.Infrastructure assembly to the host types
            hostTypesProvider.AddHostType(typeof(ServiceCollection));            // Adds the BuildServiceProvider assembly to the host types
            this.hostTypesProvider = hostTypesProvider;

            var remoteTypesProvider = new RemoteTypesProvider <T>();

            remoteTypesProvider.AddRemoteType(typeof(T)); // Add the contract to the remote types, so that we can have backwards compatibility
            this.remoteTypesProvider = remoteTypesProvider;

            this.pluginSelector               = new DefaultPluginSelector <T>();
            this.depsFileProviderType         = typeof(DefaultDepsFileProvider <T>);
            this.pluginDependencyResolverType = typeof(DefaultPluginDependencyResolver <T>);
            // Typically used for downloading and storing plugins from the network, but it could be useful for caching local plugins as well
            this.tempPathProviderType = typeof(UserProfileTempPathProvider <T>);

            this.nativeAssemblyUnloaderType = typeof(DefaultNativeAssemblyUnloader);
            this.hostFrameworkProviderType  = typeof(HostFrameworkProvider);

            return(this);
        }
Exemplo n.º 3
0
 public DefaultPluginActivator(
     Func <IPluginActivationContextProvider> pluginActivationContextProviderFactory,
     Func <IRemotePluginActivator> remotePluginActivatorFactory,
     Func <IPluginProxyCreator> proxyCreatorFactory)
 {
     this.disposables = new ConcurrentBag <IDisposable>();
     this.pluginActivationContextProvider = pluginActivationContextProviderFactory.ThrowIfNull(nameof(pluginActivationContextProviderFactory))();
     this.remotePluginActivator           = remotePluginActivatorFactory.ThrowIfNull(nameof(remotePluginActivatorFactory))();
     this.proxyCreator = proxyCreatorFactory.ThrowIfNull(nameof(proxyCreatorFactory))();
 }
Exemplo n.º 4
0
        protected virtual void Dispose(bool disposing)
        {
            if (!this.disposed && disposing)
            {
                this.remotePluginActivator?.Dispose();
                this.proxyCreator?.Dispose();

                foreach (var disposable in this.disposables)
                {
                    disposable.Dispose();
                }

                this.remotePluginActivator = null;
                this.proxyCreator          = null;
                this.disposables           = null;
            }
            this.disposed = true;
        }
Exemplo n.º 5
0
 public PluginLoadOptionsBuilder <T> WithProxyCreator(IPluginProxyCreator <T> proxyCreator)
 {
     this.proxyCreator = proxyCreator;
     return(this);
 }