WPF+Prism模块化MVVM应用：WCF共享服务应注入Model还是ViewModel？

Hey there! Let's break this down clearly—you're right to think through where to inject your WCF service reference, since keeping concerns separated is key in Prism (and MVVM in general).

核心原则：坚守关注点分离 #

First, let's anchor ourselves to MVVM basics:

• Model层/数据处理层: This is where data retrieval, business logic, and external service interactions belong. It's responsible for getting clean, usable data ready for the UI.
• ViewModel层: Its job is to expose data to the View and handle UI-specific logic—it should never directly talk to external services like WCF.

So straight up: don't inject the WCF service directly into your ViewModel. Instead, wrap it in a dedicated service layer and let your ViewModel depend on a higher-level data handler.

具体实现步骤 #

1. 封装WCF服务为共享接口 #

Start by creating an abstraction for your WCF service in your WCF module. This lets your Shell module depend on an interface instead of concrete WCF details, making your code way more flexible.

// WCF模块中定义服务接口
public interface IRegisterDataService
{
    Task<IEnumerable<RegisterDto>> GetRegisterDataAsync();
}

// WCF模块中实现接口，封装WCF调用逻辑
public class RegisterDataService : IRegisterDataService
{
    private readonly YourWcfClient _wcfClient;

    public RegisterDataService()
    {
        _wcfClient = new YourWcfClient(); // 初始化WCF客户端
    }

    public async Task<IEnumerable<RegisterDto>> GetRegisterDataAsync()
    {
        // 调用WCF服务并转换为干净的Dto返回
        var rawRegisterData = await _wcfClient.FetchRegistersAsync();
        return rawRegisterData.Select(r => new RegisterDto 
        { 
            Name = r.RegisterName, 
            Value = r.RegisterValue 
        });
    }
}

2. 注册共享服务到Prism容器 #

In your WCF module's initialization code, register the service with Prism's DI container so it's available to other modules:

public class WcfDataModule : IModule
{
    public void RegisterTypes(IContainerRegistry containerRegistry)
    {
        // 注册为单例（根据你的业务需求调整生命周期）
        containerRegistry.RegisterSingleton<IRegisterDataService, RegisterDataService>();
    }

    public void OnInitialized(IContainerProvider containerProvider)
    {
        // 模块初始化逻辑（如果不需要可以留空）
    }
}

3. 在数据处理类/Model中注入服务 #

Create a data handler or Model class in your Shell module that depends on the IRegisterDataService. This class will handle any extra data processing (like filtering, formatting) before passing it to the ViewModel:

// Shell模块中的数据处理类
public class RegisterDataHandler
{
    private readonly IRegisterDataService _dataService;

    // 通过构造函数注入WCF服务接口
    public RegisterDataHandler(IRegisterDataService dataService)
    {
        _dataService = dataService;
    }

    public async Task<IEnumerable<RegisterDto>> LoadAndProcessRegisterDataAsync()
    {
        var rawData = await _dataService.GetRegisterDataAsync();
        // 这里可以添加自定义处理逻辑，比如过滤无效寄存器
        return rawData.Where(r => !string.IsNullOrWhiteSpace(r.Name));
    }
}

4. ViewModel依赖数据处理类 #

Finally, your main window's ViewModel only needs to depend on this data handler. It calls the handler to get data and exposes it to the View:

// 主窗口ViewModel
public class MainWindowViewModel : BindableBase
{
    private IEnumerable<RegisterDto> _registers;
    private readonly RegisterDataHandler _dataHandler;

    public IEnumerable<RegisterDto> Registers
    {
        get => _registers;
        set => SetProperty(ref _registers, value);
    }

    public ICommand LoadRegistersCommand { get; }

    public MainWindowViewModel(RegisterDataHandler dataHandler)
    {
        _dataHandler = dataHandler;
        LoadRegistersCommand = new DelegateCommand(async () => await LoadRegisters());
    }

    private async Task LoadRegisters()
    {
        Registers = await _dataHandler.LoadAndProcessRegisterDataAsync();
    }
}

为什么这种方式更好？ #

• 解耦: If you ever need to replace WCF with a REST API or another service, you only have to update the RegisterDataService implementation—no changes needed in the ViewModel or data handler.
• Testability: You can easily mock the IRegisterDataService for unit testing your ViewModel and data handler, without spinning up a real WCF service.
• Cleaner code: Each layer has a clear responsibility, making your app easier to maintain and debug.

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