private void DeactivateModule(ILoadableModule module)
 {
     try
     {
         if (module != null)
         {
             System.Diagnostics.Debug.WriteLine("Deactivated " + module.ModuleName);
             this.mSelectedModule.DeactivateModule();
         }
     }
     catch (Exception ex)
     {
         Utility.EventLogger.Log(LogLevel.Error, ex);
     }
 }
Exemplo n.º 2
0
        public IModule GetModule(ILoadableModule loadableModule)
        {
            if (loadableModule == null)
            {
                throw new ArgumentNullException(nameof(loadableModule));
            }
            var assemblyName = new AssemblyName(loadableModule.AssemblyName ?? throw new InvalidOperationException());
            var assembly     = _assemblyLoader.Load(assemblyName, () => new ModuleLoadContext(loadableModule.ModuleDependencyLoader));

            var exportedTypes = assembly.GetExportedTypes();

            var type = exportedTypes.First(FilterModuleType);

            var instance = Activator.CreateInstance(type);
            var module   = instance as IModule;

            return(module);
        }
            private async void SwitchActiveModules(ILoadableModule previousModule, ILoadableModule newModule, CancellationToken cancellationToken)
            {

                try
                {
                    await Task.Run
                    (
                        () =>
                        {
                            lock (this)
                            {
                                DeactivateModule(previousModule);
                                ActivateModule(newModule);
                            }
                        }
                    );
                }
                catch (OperationCanceledException)
                {
                }
            }
Exemplo n.º 4
0
        /// <summary>
        ///     Searches in the assembly for objects that implement the <see cref="ILoadableModule"/> interface and instantiates them.
        /// </summary>
        /// <param name="loadedModule">
        ///     Object that points to an assembly that was loaded.
        /// </param>
        private Task <List <ILoadableModule> > InvokeLoadableModules(Assembly loadedModule)
        {
            return(Task.Run
                   (
                       () =>
            {
                List <ILoadableModule> result = new List <ILoadableModule>();
                foreach (TypeInfo definedType in loadedModule.DefinedTypes)
                {
                    foreach (TypeInfo implementedInterface in definedType.ImplementedInterfaces)
                    {
                        if (implementedInterface == typeof(ILoadableModule))
                        {
                            try
                            {
                                ILoadableModule module = Activator.CreateInstance(definedType) as ILoadableModule;
                                module.InitialiseModule(this.Container);
                                result.Add(module);
                            }
                            catch (Exception ex)
                            {
                                Utilities.Utility.EventLogger.Log
                                (
                                    LogLevel.Error,
                                    ex,
                                    () => String.Format(AssemblyResources.ModuleLoadingFailed, definedType.Name)
                                );
                            }
                        }
                    }
                }

                return result;
            },
                       Utility.ModuleLoadCancellationToken.Token
                   ));
        }