在Prism 6中加载所有模块后，使用ViewModel初始化Shell

Question

我的Shell / MainWindow的ViewModel（通过AutoWireViewModel="True" ）请求使用ConfigurationModuleCatalog在启动时加载到模块中的依赖项。
因为Shell在模块之前被初始化，所以DI容器显然无法解析它，因此应用程序崩溃了。

public class MainWindowViewModel : BindableBase
{
    // Cannot resolve IService
    public MainWindowViewModel(IService service)
    {
    }
}

我已经尝试过这篇文章的两种方法，但两种方法都没有用。

我这样试过：

public interface IShellService
{
    int NumberOfLoadedModules { get; }

    void FlagModuleAsLoaded();
}

public class ShellService : IShellService
{
    private readonly IModuleCatalog _moduleCatalog;

    public ShellService(IModuleCatalog moduleCatalog)
    {
        _moduleCatalog = moduleCatalog;
    }

    public int NumberOfLoadedModules { get; private set; }

    public void FlagModuleAsLoaded()
    {
        NumberOfLoadedModules++;

        if (NumberOfLoadedModules != _moduleCatalog.Modules.Count())
            return;

        InitializeShell();
    }

    private static void InitializeShell()
    {
         Application.Current.MainWindow.Show();
    }
}

internal class Bootstrapper : UnityBootstrapper
{
    protected override DependencyObject CreateShell()
    {
        return null;
    }

    protected override void InitializeShell()
    {
    }

    protected override void ConfigureContainer()
    {
        base.ConfigureContainer();
        Container.RegisterInstance<IShellService>(new ShellService(ModuleCatalog), new ContainerControlledLifetimeManager());
    }

    protected override IModuleCatalog CreateModuleCatalog()
    {
        return new ConfigurationModuleCatalog();
    }
}

---

用法

public abstract class ModuleBase : IModule
{
    private readonly IShellService _shellService;

    protected ModuleBase(IShellService shellService)
    {
        _shellService = shellService;
    }

    public void Initialize()
    {
        InitializeInternal();
        FlagAsLoaded();
    }

    public abstract void InitializeInternal();

    public void FlagAsLoaded()
    {
        _shellService.FlagModuleAsLoaded();
    }
}

public class FooModule : ModuleBase
{
    IUnityContainer _container;

    public MusicUIModule(IUnityContainer container, IShellService shellService) : base(shellService)
    {
        _container = container;
    }

    public override void InitializeInternal()
    {
        _container.RegisterType<IService, Service>();
    }
}

它开始计算模块，然后由于相同的原因应用程序崩溃。
如果上述方法不符合我的目的，那么该问题怎么解决？

谢谢！

Answer 1

我试图实现Haukinger的建议并以这种方式做到这一点很好：

// Factory --------------------------------------------------------

public interface IDependencyFactory
{
    IService GetService();
}

public class DependencyFactory : IDependencyFactory
{
    private readonly IUnityContainer _container;

    public DependencyFactory(IUnityContainer container)
    {
        _container = container;
    }

    public IService GetService()
    {
        return _container.Resolve<IService>();
    }
}

// PubSubEvent ------------------------------------------------------

public class AllModulesLoaded : PubSubEvent
{
}

// Bootstrapper -----------------------------------------------------

internal class Bootstrapper : UnityBootstrapper
{
    protected override DependencyObject CreateShell()
    {
        return Container.Resolve<MainWindow>();
    }

    protected override void InitializeShell()
    {
        Application.Current.MainWindow.Show();
    }

    protected override void InitializeModules()
    {
        base.InitializeModules();

        // Publishing event to tell subscribers that the modules are loaded
        var eventAggregator = Container.Resolve<IEventAggregator>();
        eventAggregator?.GetEvent<AllModulesLoaded>().Publish();
    }

    protected override void ConfigureContainer()
    {
        base.ConfigureContainer();

        // ...
        Container.RegisterType<IDependencyFactory, DependencyFactory>();
    }

    protected override IModuleCatalog CreateModuleCatalog()
    {
        return new ConfigurationModuleCatalog();
    }
}

// ViewModel ---------------------------------------------------------

public class MainWindowViewModel : BindableBase
{
    private IService _service;
    private readonly IEventAggregator _eventAggregator;
    private readonly IDependencyFactory _dependencyFactory;

    public MainWindowViewModel(IEventAggregator eventAggregator, IDependencyFactory dependencyFactory)
    {
        _eventAggregator = eventAggregator;
        _dependencyFactory = dependencyFactory;

        _eventAggregator.GetEvent<AllModulesLoaded>().Subscribe(OnAllModulesLoaded);
    }

    private void OnAllModulesLoaded()
    {
        var service = _dependencyFactory.GetService();
        if (service != null)
            _service = service ;

        _eventAggregator.GetEvent<AllModulesLoaded>().Unsubscribe(OnAllModulesLoaded);
    }
}

Answer 2

我将shell隐藏在工厂/提供程序后面，然后在加载最后一个模块时创建/获取它。 shell的视图模型订阅了一个AllModulesLoaded事件，当base.InitializeModules返回时，它会从引导程序的InitializeModules触发，以通知依赖项可用。 或者工厂/提供者订阅该事件，并且shell会轮询它，具体取决于您希望如何使用依赖项。