WinForm 三层架构 MVVM 工业自动化上位机 开发详解 主界面Form 多个UserControl 完整代码示例
本方案为构建一个基于**WinForm**、融合**三层架构**与**MVVM（Model-View-ViewModel）** 模式的工业自动化上位机（HMI/SCADA）提供一套完整、详细、可直接落地的代码实现。核心是**一个主窗体（MainForm）管理多个用户控件（UserControl）**，通过数据绑定和命令实现彻底解耦，确保代码的可维护性、可测试性和扩展性[ref_1][ref_3][ref_4]。以下将从项目结构、核心类实现、交互模式到具体代码示例进行全方位拆解。
### **1. 解决方案与项目结构规划**
首先，在Visual Studio中创建解决方案，并按以下结构组织项目，这清晰体现了“三层”与“MVVM”的融合：
```
HMI.Solution (解决方案)
│
├── HMI.Core (类库)
│ ├── Models/ # 数据模型，实现 INotifyPropertyChanged
│ ├── ViewModels/ # ViewModel 基类及具体ViewModel
│ ├── Business/ # 业务逻辑层 (BLL) 接口与实现
│ ├── DataAccess/ # 数据访问层 (DAL) 接口与实现
│ ├── Common/ # 通用助手类 (RelayCommand, EventAggregator等)
│ └── Services/ # 应用层服务 (如设备通信服务)
│
├── HMI.Infrastructure (类库)
│ ├── DeviceDrivers/ # PLC/设备通信具体实现 (如Modbus, OPC UA)
│ └── Repositories/ # 数据持久化具体实现 (如EF Core DbContext)
│
└── HMI.UI (WinForms 应用程序)
├── Views/ # WinForm窗体和UserControl
│ ├── MainForm.cs
│ ├── UC_StatusPanel.ascx
│ ├── UC_ControlPanel.ascx
│ └── UC_AlarmViewer.ascx
├── Presenters/ # (可选) 如果需要更经典的MVP，可作为View和ViewModel的桥梁
└── Program.cs
```
**职责说明**：
* **`HMI.Core`**：包含核心业务模型、视图逻辑和抽象接口。它是MVVM模式的核心承载层。
* **`HMI.Infrastructure`**：是**数据访问层（DAL）** 的具体实现，依赖于Core层定义的接口。
* **`HMI.UI`**：是**表示层**，纯粹负责UI展示。其`Views`目录下的窗体和控制器的后台代码应极简，仅负责初始化和数据绑定。
### **2. 核心基础架构代码实现**
#### **2.1. 可观察对象基类 (HMI.Core/Common/ObservableObject.cs)**
所有Model和ViewModel的基类，实现属性变更通知。
```csharp
// 文件名：ObservableObject.cs
using System.ComponentModel;
using System.Runtime.CompilerServices;
namespace HMI.Core.Common
{
/// <summary>
/// 实现 INotifyPropertyChanged 接口的基类，用于支持数据绑定。
/// </summary>
public abstract class ObservableObject : INotifyPropertyChanged
{
public event PropertyChangedEventHandler PropertyChanged;
/// <summary>
/// 设置属性值并在值更改时触发 PropertyChanged 事件。
/// </summary>
/// <typeparam name="T">属性类型</typeparam>
/// <param name="field">后台字段的引用</param>
/// <param name="value">新值</param>
/// <param name="propertyName">属性名（自动获取）</param>
/// <returns>如果值被更改，返回 true；否则返回 false。</returns>
protected virtual bool SetProperty<T>(ref T field, T value, [CallerMemberName] string propertyName = null)
{
if (EqualityComparer<T>.Default.Equals(field, value))
return false;
field = value;
OnPropertyChanged(propertyName);
return true;
}
/// <summary>
/// 触发 PropertyChanged 事件。
/// </summary>
/// <param name="propertyName">发生更改的属性名称</param>
protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null)
{
PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
}
}
}
```
#### **2.2. 命令实现 (HMI.Core/Common/RelayCommand.cs)**
用于将UI事件（如按钮点击）绑定到ViewModel中的方法。
```csharp
// 文件名：RelayCommand.cs
using System;
using System.Windows.Input;
namespace HMI.Core.Common
{
/// <summary>
/// 一个通用的、无参数的ICommand实现。
/// </summary>
public class RelayCommand : ICommand
{
private readonly Action _execute;
private readonly Func<bool> _canExecute;
public event EventHandler CanExecuteChanged
{
add { CommandManager.RequerySuggested += value; }
remove { CommandManager.RequerySuggested -= value; }
}
public RelayCommand(Action execute, Func<bool> canExecute = null)
{
_execute = execute ?? throw new ArgumentNullException(nameof(execute));
_canExecute = canExecute;
}
public bool CanExecute(object parameter) => _canExecute?.Invoke() ?? true;
public void Execute(object parameter) => _execute();
}
/// <summary>
/// 一个通用的、带参数的ICommand实现。
/// </summary>
/// <typeparam name="T">命令参数类型</typeparam>
public class RelayCommand<T> : ICommand
{
private readonly Action<T> _execute;
private readonly Predicate<T> _canExecute;
public RelayCommand(Action<T> execute, Predicate<T> canExecute = null)
{
_execute = execute ?? throw new ArgumentNullException(nameof(execute));
_canExecute = canExecute;
}
public bool CanExecute(object parameter)
{
if (parameter == null && typeof(T).IsValueType)
return _canExecute?.Invoke(default(T)) ?? true;
return _canExecute?.Invoke((T)parameter) ?? true;
}
public void Execute(object parameter)
{
if (parameter == null && typeof(T).IsValueType)
_execute(default(T));
else
_execute((T)parameter);
}
public event EventHandler CanExecuteChanged
{
add { CommandManager.RequerySuggested += value; }
remove { CommandManager.RequerySuggested -= value; }
}
}
}
```
#### **2.3. 业务模型定义 (HMI.Core/Models/)**
定义应用程序的核心数据对象。
```csharp
// 文件名：DeviceStatus.cs
namespace HMI.Core.Models
{
/// <summary>
/// 设备状态模型，代表从PLC或传感器读取的一个设备单元的状态。
/// </summary>
public class DeviceStatus : ObservableObject
{
private string _deviceId;
private string _deviceName;
private double _currentValue;
private bool _isOnline;
private DateTime _lastUpdated;
public string DeviceId
{
get => _deviceId;
set => SetProperty(ref _deviceId, value);
}
public string DeviceName
{
get => _deviceName;
set => SetProperty(ref _deviceName, value);
}
public double CurrentValue
{
get => _currentValue;
set => SetProperty(ref _currentValue, value);
}
public bool IsOnline
{
get => _isOnline;
set => SetProperty(ref _isOnline, value);
}
public DateTime LastUpdated
{
get => _lastUpdated;
set => SetProperty(ref _lastUpdated, value);
}
}
}
```
```csharp
// 文件名：AlarmInfo.cs
namespace HMI.Core.Models
{
/// <summary>
/// 报警信息模型。
/// </summary>
public class AlarmInfo : ObservableObject
{
private int _id;
private string _message;
private AlarmLevel _level;
private DateTime _triggerTime;
private DateTime? _ackTime;
public int Id { get => _id; set => SetProperty(ref _id, value); }
public string Message { get => _message; set => SetProperty(ref _message, value); }
public AlarmLevel Level { get => _level; set => SetProperty(ref _level, value); }
public DateTime TriggerTime { get => _triggerTime; set => SetProperty(ref _triggerTime, value); }
public DateTime? AckTime { get => _ackTime; set => SetProperty(ref _ackTime, value); }
public bool IsAcknowledged => AckTime.HasValue;
}
public enum AlarmLevel { Info, Warning, Error, Critical }
}
```
### **3. 数据访问与业务逻辑层接口定义 (BLL/DAL)**
#### **3.1. 数据访问层接口 (HMI.Core/DataAccess/)**
定义与底层数据源（数据库、PLC）交互的契约。
```csharp
// 文件名：IDeviceDataRepository.cs
using HMI.Core.Models;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace HMI.Core.DataAccess
{
/// <summary>
/// 设备数据访问接口。
/// </summary>
public interface IDeviceDataRepository
{
/// <summary>
/// 异步获取所有设备的最新状态。
/// </summary>
Task<IEnumerable<DeviceStatus>> GetAllDeviceStatusAsync();
/// <summary>
/// 异步向指定设备写入一个控制值。
/// </summary>
Task<bool> WriteControlValueAsync(string deviceId, double value);
}
}
```
#### **3.2. 业务逻辑层接口与实现 (HMI.Core/Business/)**
封装核心业务规则，它依赖于DAL接口，并为ViewModel提供服务。
```csharp
// 文件名：IDeviceMonitoringService.cs
using HMI.Core.Models;
using System.Collections.ObjectModel;
using System.Threading.Tasks;
namespace HMI.Core.Business
{
/// <summary>
/// 设备监控业务服务接口。
/// </summary>
public interface IDeviceMonitoringService
{
/// <summary>
/// 当前活动的设备状态列表（可绑定）。
/// </summary>
ObservableCollection<DeviceStatus> ActiveDevices { get; }
/// <summary>
/// 异步启动数据监控。
/// </summary>
Task StartMonitoringAsync();
/// <summary>
/// 停止数据监控。
/// </summary>
void StopMonitoring();
/// <summary>
/// 手动请求刷新所有设备数据。
/// </summary>
Task RefreshAllAsync();
}
}
```
```csharp
// 文件名：DeviceMonitoringService.cs
using HMI.Core.DataAccess;
using HMI.Core.Models;
using System;
using System.Collections.ObjectModel;
using System.Linq;
using System.Threading.Tasks;
using System.Timers;
namespace HMI.Core.Business
{
/// <summary>
/// 设备监控业务服务的具体实现。
/// </summary>
public class DeviceMonitoringService : IDeviceMonitoringService
{
private readonly IDeviceDataRepository _deviceRepo;
private readonly Timer _pollingTimer;
private bool _isMonitoring;
public ObservableCollection<DeviceStatus> ActiveDevices { get; private set; }
public DeviceMonitoringService(IDeviceDataRepository deviceRepo)
{
_deviceRepo = deviceRepo;
ActiveDevices = new ObservableCollection<DeviceStatus>();
_pollingTimer = new Timer(2000) { AutoReset = true }; // 2秒轮询一次
_pollingTimer.Elapsed += async (s, e) => await PollDevicesAsync();
}
public async Task StartMonitoringAsync()
{
if (_isMonitoring) return;
await RefreshAllAsync(); // 启动时先获取一次
_pollingTimer.Start();
_isMonitoring = true;
}
public void StopMonitoring()
{
_pollingTimer.Stop();
_isMonitoring = false;
}
public async Task RefreshAllAsync()
{
var devices = await _deviceRepo.GetAllDeviceStatusAsync();
// 注意：需要在UI线程上更新ObservableCollection以确保绑定正确更新。
// 此处简化处理，实际应用中应通过同步上下文(SynchronizationContext)返回到UI线程。
System.Windows.Forms.Application.Current?.Invoke((Action)(() =>
{
ActiveDevices.Clear();
foreach (var device in devices)
{
ActiveDevices.Add(device);
}
}));
}
private async Task PollDevicesAsync()
{
// 模拟轮询逻辑，实际可能只读取变化的数据
await RefreshAllAsync();
}
}
}
```
### **4. ViewModel层实现**
ViewModel是连接View和Model/BLL的桥梁。
#### **4.1. 主窗体ViewModel (HMI.Core/ViewModels/MainViewModel.cs)**
协调整个应用程序，持有各个子模块的ViewModel实例。
```csharp
// 文件名：MainViewModel.cs
using HMI.Core.Business;
using HMI.Core.Common;
using System.Windows.Input;
namespace HMI.Core.ViewModels
{
/// <summary>
/// 主窗体的ViewModel，作为应用程序的根ViewModel。
/// </summary>
public class MainViewModel : ObservableObject
{
// 业务服务（通过构造函数注入）
private readonly IDeviceMonitoringService _monitoringService;
// 子模块的ViewModels
public DeviceStatusViewModel StatusVM { get; }
public AlarmOverviewViewModel AlarmVM { get; }
// 命令
public ICommand StartMonitoringCommand { get; }
public ICommand StopMonitoringCommand { get; }
public ICommand ExitApplicationCommand { get; }
private string _systemStatus = "就绪";
public string SystemStatus
{
get => _systemStatus;
set => SetProperty(ref _systemStatus, value);
}
public MainViewModel(IDeviceMonitoringService monitoringService)
{
_monitoringService = monitoringService;
// 初始化子ViewModel，并传入它们所需的服务
StatusVM = new DeviceStatusViewModel(_monitoringService);
AlarmVM = new AlarmOverviewViewModel();
// 初始化命令
StartMonitoringCommand = new RelayCommand(async () =>
{
SystemStatus = "监控中...";
await _monitoringService.StartMonitoringAsync();
}, () => !_monitoringService.ActiveDevices.Any()); // 简单示例：未启动时可执行
StopMonitoringCommand = new RelayCommand(() =>
{
_monitoringService.StopMonitoring();
SystemStatus = "已停止";
});
ExitApplicationCommand = new RelayCommand(() =>
{
// 清理资源
_monitoringService.StopMonitoring();
System.Windows.Forms.Application.Exit();
});
}
}
}
```
#### **4.2. 设备状态面板ViewModel (HMI.Core/ViewModels/DeviceStatusViewModel.cs)**
专门用于设备状态显示的用户控件。
```csharp
// 文件名：DeviceStatusViewModel.cs
using HMI.Core.Business;
using HMI.Core.Common;
using HMI.Core.Models;
using System.Collections.ObjectModel;
using System.Windows.Input;
namespace HMI.Core.ViewModels
{
public class DeviceStatusViewModel : ObservableObject
{
private readonly IDeviceMonitoringService _monitoringService;
private DeviceStatus _selectedDevice;
// 直接暴露业务层的可观察集合以供绑定
public ObservableCollection<DeviceStatus> Devices => _monitoringService.ActiveDevices;
public DeviceStatus SelectedDevice
{
get => _selectedDevice;
set => SetProperty(ref _selectedDevice, value);
}
// 命令示例：手动刷新、控制设备
public ICommand RefreshCommand { get; }
public ICommand ToggleDeviceCommand { get; }
public DeviceStatusViewModel(IDeviceMonitoringService monitoringService)
{
_monitoringService = monitoringService;
RefreshCommand = new RelayCommand(async () => await _monitoringService.RefreshAllAsync());
ToggleDeviceCommand = new RelayCommand<DeviceStatus>(async (device) =>
{
if (device != null)
{
// 调用业务逻辑，例如通过服务写入控制值
// await _someControlService.ToggleDeviceAsync(device.DeviceId);
device.IsOnline = !device.IsOnline; // 仅为示例，直接修改模型
}
});
}
}
}
```
### **5. View层实现：WinForm与UserControl**
#### **5.1. 程序入口与依赖注入配置 (HMI.UI/Program.cs)**
使用简单的依赖注入容器（如Microsoft.Extensions.DependencyInjection）来组装应用程序。
```csharp
// 文件名：Program.cs
using HMI.Core.Business;
using HMI.Core.DataAccess;
using HMI.Core.ViewModels;
using HMI.Infrastructure.DeviceDrivers;
using HMI.UI.Views;
using Microsoft.Extensions.DependencyInjection;
using System;
using System.Windows.Forms;
namespace HMI.UI
{
internal static class Program
{
[STAThread]
static void Main()
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
// 配置依赖注入容器
var services = new ServiceCollection();
ConfigureServices(services);
// 构建服务提供者
using (var serviceProvider = services.BuildServiceProvider())
{
// 解析主窗体，其依赖会自动注入
var mainForm = serviceProvider.GetRequiredService<MainForm>();
Application.Run(mainForm);
}
}
static void ConfigureServices(IServiceCollection services)
{
// 注册数据访问层实现（具体驱动）
services.AddSingleton<IDeviceDataRepository, SimulatedDeviceRepository>(); // 模拟仓库
// 注册业务逻辑层服务
services.AddSingleton<IDeviceMonitoringService, DeviceMonitoringService>();
// 注册ViewModels (Transient 或 Scoped，取决于需求)
services.AddTransient<MainViewModel>();
services.AddTransient<DeviceStatusViewModel>();
services.AddTransient<AlarmOverviewViewModel>();
// 注册主窗体
services.AddSingleton<MainForm>();
}
}
}
```
#### **5.2. 主窗体 (HMI.UI/Views/MainForm.cs)**
主窗体的后台代码应极其精简，主要职责是承载控件和设置绑定上下文。
```csharp
// 文件名：MainForm.cs
using HMI.Core.ViewModels;
using System.Windows.Forms;
namespace HMI.UI.Views
{
public partial class MainForm : Form
{
// 通过依赖注入获得主ViewModel
private readonly MainViewModel _mainViewModel;
// 子用户控件
private UC_DeviceStatus _ucStatus;
private UC_AlarmOverview _ucAlarm;
public MainForm(MainViewModel mainViewModel)
{
_mainViewModel = mainViewModel;
InitializeComponent();
InitializeLayout();
SetupDataBinding();
}
private void InitializeLayout()
{
this.Text = "工业自动化上位机 HMI";
this.WindowState = FormWindowState.Maximized;
// 使用 SplitContainer 或 Panel 来布局多个UserControl[ref_2]
var mainSplit = new SplitContainer
{
Dock = DockStyle.Fill,
Orientation = Orientation.Vertical
};
this.Controls.Add(mainSplit);
// 左侧：设备状态面板
_ucStatus = new UC_DeviceStatus();
_ucStatus.Dock = DockStyle.Fill;
mainSplit.Panel1.Controls.Add(_ucStatus);
// 右侧：报警总览面板
_ucAlarm = new UC_AlarmOverview();
_ucAlarm.Dock = DockStyle.Fill;
mainSplit.Panel2.Controls.Add(_ucAlarm);
// 可以添加工具栏、状态栏等
InitializeToolbar();
}
private void InitializeToolbar()
{
var toolStrip = new ToolStrip();
var btnStart = new ToolStripButton("启动监控") { DisplayStyle = ToolStripItemDisplayStyle.Text };
var btnStop = new ToolStripButton("停止监控") { DisplayStyle = ToolStripItemDisplayStyle.Text };
var btnExit = new ToolStripButton("退出") { DisplayStyle = ToolStripItemDisplayStyle.Text };
// **关键：将WinForm控件事件绑定到ViewModel的ICommand**
btnStart.Click += (s, e) => _mainViewModel.StartMonitoringCommand.Execute(null);
btnStop.Click += (s, e) => _mainViewModel.StopMonitoringCommand.Execute(null);
btnExit.Click += (s, e) => _mainViewModel.ExitApplicationCommand.Execute(null);
// 命令的可执行状态可以绑定到按钮的Enabled属性（这里简化处理）
toolStrip.Items.AddRange(new ToolStripItem[] { btnStart, btnStop, new ToolStripSeparator(), btnExit });
this.Controls.Add(toolStrip);
toolStrip.Dock = DockStyle.Top;
}
private void SetupDataBinding()
{
// **核心：将子用户控件的ViewModel设置为MainViewModel中对应的子ViewModel**
_ucStatus.SetViewModel(_mainViewModel.StatusVM);
_ucAlarm.SetViewModel(_mainViewModel.AlarmVM);
// 绑定主窗体的系统状态到Label（原生数据绑定示例）
lblSystemStatus.DataBindings.Add("Text", _mainViewModel, nameof(MainViewModel.SystemStatus));
}
}
}
```
#### **5.3. 用户控件示例：设备状态面板 (HMI.UI/Views/UC_DeviceStatus.ascx.cs)**
用户控件的后台代码同样精简，专注于UI控件与ViewModel的绑定。
```csharp
// 文件名：UC_DeviceStatus.ascx.cs
using HMI.Core.ViewModels;
using System.Windows.Forms;
namespace HMI.UI.Views
{
public partial class UC_DeviceStatus : UserControl
{
private DeviceStatusViewModel _viewModel;
private BindingSource _bindingSource;
public UC_DeviceStatus()
{
InitializeComponent();
_bindingSource = new BindingSource();
dataGridView1.AutoGenerateColumns = false;
dataGridView1.DataSource = _bindingSource;
// 配置列...
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn { DataPropertyName = "DeviceName", HeaderText = "设备名" });
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn { DataPropertyName = "CurrentValue", HeaderText = "当前值" });
dataGridView1.Columns.Add(new DataGridViewCheckBoxColumn { DataPropertyName = "IsOnline", HeaderText = "在线状态" });
}
// 关键方法：由主窗体调用，注入ViewModel
public void SetViewModel(DeviceStatusViewModel viewModel)
{
_viewModel = viewModel;
BindData();
WireCommands();
}
private void BindData()
{
if (_viewModel == null) return;
// 将BindingSource的数据源设置为ViewModel的Devices集合
_bindingSource.DataSource = _viewModel.Devices;
// 将DataGridView的选择项绑定到ViewModel的SelectedDevice
dataGridView1.SelectionChanged += (s, e) =>
{
if (dataGridView1.CurrentRow?.DataBoundItem is HMI.Core.Models.DeviceStatus device)
{
_viewModel.SelectedDevice = device;
}
};
// 绑定其他控件（如选中设备的详情Label）
lblSelectedDevice.DataBindings.Clear();
lblSelectedDevice.DataBindings.Add("Text", _viewModel, "SelectedDevice.DeviceName", true, DataSourceUpdateMode.OnPropertyChanged, "N/A");
}
private void WireCommands()
{
// 将按钮点击事件绑定到ViewModel的命令
btnRefresh.Click += (s, e) => _viewModel.RefreshCommand.Execute(null);
// 注意：Toggle命令需要参数，这里绑定到选中项
btnToggle.Click += (s, e) => _viewModel.ToggleDeviceCommand.Execute(_viewModel.SelectedDevice);
}
}
}
```
### **6. 数据访问层模拟实现 (HMI.Infrastructure/DeviceDrivers/SimulatedDeviceRepository.cs)**
```csharp
// 文件名：SimulatedDeviceRepository.cs
using HMI.Core.DataAccess;
using HMI.Core.Models;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
namespace HMI.Infrastructure.DeviceDrivers
{
/// <summary>
/// 模拟设备数据仓库，用于开发和测试。
/// </summary>
public class SimulatedDeviceRepository : IDeviceDataRepository
{
private readonly Random _random = new Random();
private readonly List<DeviceStatus> _simulatedDevices;
public SimulatedDeviceRepository()
{
_simulatedDevices = new List<DeviceStatus>
{
new DeviceStatus { DeviceId = "M001", DeviceName = "电机1", CurrentValue = 25.5, IsOnline = true },
new DeviceStatus { DeviceId = "V002", DeviceName = "阀门2", CurrentValue = 60.0, IsOnline = false },
new DeviceStatus { DeviceId = "T003", DeviceName = "温度传感器3", CurrentValue = 37.2, IsOnline = true },
};
}
public async Task<IEnumerable<DeviceStatus>> GetAllDeviceStatusAsync()
{
// 模拟异步延迟
await Task.Delay(50);
// 模拟数据变化
foreach (var device in _simulatedDevices)
{
if (device.IsOnline)
{
device.CurrentValue += (_random.NextDouble() - 0.5) * 2; // 微小波动
device.LastUpdated = DateTime.Now;
}
}
// 返回深拷贝，避免直接修改内部集合
return _simulatedDevices.ConvertAll(d => new DeviceStatus
{
DeviceId = d.DeviceId,
DeviceName = d.DeviceName,
CurrentValue = d.CurrentValue,
IsOnline = d.IsOnline,
LastUpdated = d.LastUpdated
});
}
public async Task<bool> WriteControlValueAsync(string deviceId, double value)
{
await Task.Delay(30);
var device = _simulatedDevices.Find(d => d.DeviceId == deviceId);
if (device != null)
{
device.CurrentValue = value;
return true;
}
return false;
}
}
}
```
### **7. 总结与进阶建议**
通过以上详细代码，构建了一个结构清晰的WinForm MVVM应用程序框架[ref_1]。主`MainForm`通过依赖注入获取`MainViewModel`，并将不同的子`ViewModel`分配给对应的`UserControl`，实现了彻底的关注点分离。
| 层/组件 | 技术要点 | 关键代码文件 |
| :--- | :--- | :--- |
| **Model** | 可观察对象，纯数据实体。 | `DeviceStatus.cs`, `AlarmInfo.cs` |
| **ViewModel** | 业务逻辑的UI抽象，持有Model和命令。 | `MainViewModel.cs`, `DeviceStatusViewModel.cs` |
| **View** | 纯UI展示，后台代码极简，仅负责绑定。 | `MainForm.cs`, `UC_DeviceStatus.ascx.cs` |
| **BLL** | 封装核心业务规则，操作Model。 | `DeviceMonitoringService.cs` |
| **DAL** | 负责与外部系统通信，实现接口。 | `SimulatedDeviceRepository.cs` |
**进阶建议**：
1. **使用更强大的绑定**：对于复杂UI（如树形图、图表），考虑使用`DevExpress`、`Telerik`等第三方控件库，它们提供了更完善的WinForm MVVM支持和数据绑定引擎[ref_4]。
2. **实现事件聚合器**：对于跨多个`UserControl`的复杂通信（如一个控件中的操作需要更新另一个控件），实现一个轻量级的事件聚合器（`EventAggregator`），让`ViewModel`之间进行松耦合的发布/订阅通信[ref_4]。
3. **异步与线程安全**：工业通信常涉及异步操作。确保在`ViewModel`中正确使用`async/await`，并通过`SynchronizationContext`或控件的`Invoke/BeginInvoke`方法确保对`ObservableCollection`的更新在UI线程上执行。
4. **结合三层架构**：本方案中的`IDeviceDataRepository`和`DeviceMonitoringService`已经体现了两层（DAL和BLL）。可以进一步将数据库操作、文件IO等更底层的持久化逻辑抽象到独立的`Infrastructure`项目中，使`Core`层完全不依赖于具体技术实现。
此架构为工业自动化上位机开发提供了坚实的、可扩展的基础，能够有效管理复杂的界面交互和业务逻辑，并极大提升代码的可测试性[ref_3][ref_4]。
热门内容
最新推荐
