基于WPF+Prism+Autofac的动态向导应用开发技术咨询

Hey Joel, great question—building a wizard-style WPF app with dynamic view switching (and state machine-like navigation) is a common scenario, and your initial plan using Prism + Autofac is really solid. Let’s break down your questions and walk through a practical implementation guide:

First off, Prism + Autofac is an excellent pick here. Prism’s built-in navigation system, ViewModel-first pattern, and lifecycle management are tailor-made for wizard-style workflows where you need to load/unload views and jump between arbitrary steps.

If you’re considering lighter alternatives:

• You could use Autofac + MvvmLight for a more minimal setup, but you’d have to build your own navigation and state management logic from scratch—something Prism already handles out of the box.
• For super simple workflows, even plain WPF with Autofac might work, but Prism’s conventions (like automatic View-ViewModel mapping) will save you tons of boilerplate code.

Unless you have strict constraints on app size or dependencies, Prism + Autofac is the most efficient and maintainable choice.

Short answer: No. Autofac is a pure Dependency Injection (DI) container that adheres to the Dependency Inversion Principle—dependencies are injected into classes rather than classes actively fetching them from a locator.

That said, Prism does include an IServiceLocator interface, and the Autofac-Prism integration provides an implementation of this interface. But this is just Prism adapting to its own internal needs; it’s not a core part of Autofac’s design. You should avoid using IServiceLocator directly in your code (it’s generally considered an anti-pattern) and stick to constructor injection instead.

Your plan to bind a ContentControl to an ActiveState property holding the current ViewModel is perfect—it aligns with Prism’s ViewModel-first approach. Here’s how to flesh this out:

3.1 Set Up View-ViewModel Mapping #

Prism uses convention-based mapping by default (e.g., PersonalInfoView ↔ PersonalInfoViewModel), but you can explicitly register mappings in your bootstrapper or module to avoid ambiguity:

// In your App.xaml.cs or module registration code
protected override void RegisterTypes(IContainerRegistry containerRegistry)
{
    // Register views and their corresponding viewmodels for navigation
    containerRegistry.RegisterForNavigation<PersonalInfoView, PersonalInfoViewModel>();
    containerRegistry.RegisterForNavigation<AddressView, AddressViewModel>();
    containerRegistry.RegisterForNavigation<ConfirmationView, ConfirmationViewModel>();
    
    // Register your workflow manager as a singleton
    containerRegistry.RegisterSingleton<WorkflowManager>();
}

3.2 Build a Workflow/State Manager #

Create a dedicated WorkflowManager class to handle state transitions—this will be your single source of truth for the wizard’s current step:

public enum WorkflowStep
{
    PersonalInfo,
    Address,
    Confirmation
}

public class WorkflowManager
{
    public WorkflowStep CurrentStep { get; private set; }
    public event Action<WorkflowStep> StepChanged;

    public void NavigateTo(WorkflowStep targetStep)
    {
        CurrentStep = targetStep;
        StepChanged?.Invoke(targetStep);
    }
}

3.3 Main Window ViewModel Implementation #

Your main window’s ViewModel will depend on the WorkflowManager and use it to update the ActiveState property. We’ll use Prism’s BindableBase for INotifyPropertyChanged support:

public class MainWindowViewModel : BindableBase
{
    private readonly WorkflowManager _workflowManager;
    private readonly IContainerProvider _containerProvider;
    private object _activeState;

    public object ActiveState
    {
        get => _activeState;
        set => SetProperty(ref _activeState, value);
    }

    public MainWindowViewModel(WorkflowManager workflowManager, IContainerProvider containerProvider)
    {
        _workflowManager = workflowManager;
        _containerProvider = containerProvider;
        
        // Subscribe to state changes
        _workflowManager.StepChanged += OnStepChanged;
        
        // Initialize to the first step
        _workflowManager.NavigateTo(WorkflowStep.PersonalInfo);
    }

    private void OnStepChanged(WorkflowStep newStep)
    {
        // Clean up the previous ViewModel if it implements IDisposable
        (_activeState as IDisposable)?.Dispose();
        
        // Resolve the new ViewModel from Autofac
        var viewModelType = GetViewModelTypeForStep(newStep);
        ActiveState = _containerProvider.Resolve(viewModelType);
    }

    private Type GetViewModelTypeForStep(WorkflowStep step)
    {
        return step switch
        {
            WorkflowStep.PersonalInfo => typeof(PersonalInfoViewModel),
            WorkflowStep.Address => typeof(AddressViewModel),
            WorkflowStep.Confirmation => typeof(ConfirmationViewModel),
            _ => throw new ArgumentOutOfRangeException(nameof(step))
        };
    }
}

3.4 Bind the ContentControl in XAML #

In your main window’s XAML, bind the ContentControl to the ActiveState property. Prism’s ViewModelLocator will automatically render the corresponding View for the bound ViewModel:

<Window x:Class="WizardApp.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:prism="http://prismlibrary.com/">
    <Grid>
        <!-- Bind Content to ActiveState; Prism handles View resolution -->
        <ContentControl Content="{Binding ActiveState}"
                        prism:ViewModelLocator.AutoWireViewModel="True" />
    </Grid>
</Window>

3.5 Trigger Navigation from Step ViewModels #

Each step’s ViewModel can inject the WorkflowManager to trigger navigation to other steps. For example, in the PersonalInfoViewModel:

public class PersonalInfoViewModel : BindableBase
{
    private readonly WorkflowManager _workflowManager;
    public DelegateCommand NextCommand { get; }
    public DelegateCommand SkipToConfirmationCommand { get; }

    public PersonalInfoViewModel(WorkflowManager workflowManager)
    {
        _workflowManager = workflowManager;
        NextCommand = new DelegateCommand(() => _workflowManager.NavigateTo(WorkflowStep.Address));
        SkipToConfirmationCommand = new DelegateCommand(() => _workflowManager.NavigateTo(WorkflowStep.Confirmation));
    }
}

• Lifecycle Management: Implement IDisposable in ViewModels that hold unmanaged resources (like database connections) and dispose them when switching steps to prevent memory leaks.
• Input Validation: Use Prism’s validation framework or implement IDataErrorInfo in your step ViewModels to ensure valid user input before allowing navigation.
• Progress Persistence: Add serialization logic to the WorkflowManager to save the current step and user input to a file/database, so users can resume the wizard later.
• Unit Testing: Since all dependencies are injected, you can easily mock the WorkflowManager and test ViewModel navigation logic without a running WPF app.

内容的提问来源于stack exchange，提问作者Joel Palmer