还在为复杂的工业监控系统架构头疼吗？传统的事件处理方式让你的代码变得臃肿难维护？今天我们来看看如何用Wolverine消息框架轻松构建一个企业级的工业设备监控系统。

在现代工业4.0时代，设备监控系统需要处理海量的实时数据、复杂的业务规则和多样化的用户交互。传统的紧耦合架构往往让系统变得脆弱且难以扩展。而消息驱动架构正是解决这一痛点的利器！

本文将通过一个完整的WinForms工业监控系统案例，带你深入了解Wolverine框架的核心特性，掌握CQRS模式的实际应用，让你的C#项目架构更加优雅和健壮。

💡 问题分析：传统架构的痛点

🔥 传统监控系统面临的挑战

在实际项目中，我们经常遇到这样的问题：

• 紧耦合：UI层直接调用业务逻辑，代码难以测试和维护
• 性能瓶颈：同步处理导致界面卡顿，用户体验差
• 扩展困难：新增功能需要修改多处代码，违反开闭原则
• 错误传播：一个模块的异常可能导致整个系统崩溃

c#
// ❌ 传统的紧耦合写法
private void btnUpdateDevice_Click(object sender, EventArgs e)
{
    // 直接在UI中处理业务逻辑
    var device = GetDeviceFromUI();
    ValidateDevice(device);
    SaveToDatabase(device);
    UpdateUI(device);
    SendNotification(device);
    LogOperation(device);
    // ... 更多逻辑
}

🛠️ 解决方案：Wolverine消息驱动架构

🌟 核心架构设计

Wolverine是.NET生态中的消息处理框架，它让我们能够以声明式的方式处理复杂的业务流程。核心思想是：一切皆消息。

c#
public record RegisterDevice(string DeviceId, string DeviceName, string Location, string DeviceType);
public record DeviceRegistered(string DeviceId, string DeviceName, string Location, DateTime RegisteredAt);

public record UpdateDeviceStatus(string DeviceId, DeviceStatus Status, double Temperature, double Pressure, double Vibration);
public record DeviceStatusUpdated(string DeviceId, DeviceStatus Status, double Temperature, double Pressure, double Vibration, DateTime UpdatedAt);

🔧 开篇

你有没有遇到过这种情况：

系统要显示车间里每台设备的实时温度，你用List存了一堆数值，结果领导问"3号注塑机现在多少度"——你得从头遍历整个列表，一个一个比对设备编号，代码写了一大堆，还容易出错。

更难受的是，设备一多，这段代码就开始"失控"。

其实，这个问题用一个数据结构就能解决——Dictionary字典集合。今天这篇，就把这个工具讲清楚，让你以后管设备数据，像查字典一样快。

---

📌 上节回顾

「上一节我们学了 List<T> 泛型集合，掌握了用有序列表存储和遍历一组同类型数据的方法。今天在这个基础上，我们进一步学习 Dictionary<K,V> 字典集合——一种支持"按名字查数据"的更强大工具。」

---

💡 核心知识讲解

Dictionary 是什么？用工厂比喻来理解

你见过车间里的"设备档案柜"吗？

每个抽屉上贴着设备编号（比如"CNC-03"），打开抽屉就能看到这台设备的所有参数。你不需要从第一个抽屉翻到最后一个，直接按编号找，秒取。

Dictionary 就是这个档案柜。

• Key（键）：抽屉上的编号标签，唯一，不能重复
• Value（值）：抽屉里装的内容，可以是任意类型

用代码来说，就是这样声明：

csharp
Dictionary<string, double> deviceTemperature = new Dictionary<string, double>();

这一行的意思是：创建一个字典，Key 是设备编号（string类型），Value 是温度值（double类型）。

---

Dictionary vs List，到底用哪个？

很多初学者容易混淆这两个集合，一张表帮你分清楚：

对比项	List<T>	Dictionary<K,V>
数据组织方式	按顺序排列（像流水线）	按键值对存储（像档案柜）
查找方式	按索引或遍历查找	按Key直接定位
适用场景	顺序处理、批量遍历	按名称快速查询
查找速度	数据越多越慢	无论多少条，速度稳定

「结论：要按设备编号、产品型号、工位名称查数据，优先用 Dictionary。」

---

Dictionary 的基本操作，就这几招

① 添加数据（Add）

csharp
deviceTemperature.Add("CNC-01", 68.5);
deviceTemperature.Add("CNC-02", 72.3);

② 查询数据

直接用 Key 取值，就像查字典：

csharp
double temp = deviceTemperature["CNC-01"]; // 返回 68.5

③ 更新数据

Key 存在时，直接赋值就是更新：

csharp
deviceTemperature["CNC-01"] = 71.0; // 温度更新了

④ 判断 Key 是否存在（重要！）

这一步初学者最容易忘，后面避坑环节会重点说。

csharp
if (deviceTemperature.ContainsKey("CNC-03"))
{
    Console.WriteLine(deviceTemperature["CNC-03"]);
}

⑤ 删除数据

csharp
deviceTemperature.Remove("CNC-02");

⑥ 遍历所有数据

csharp
foreach (var item in deviceTemperature)
{
    Console.WriteLine($"设备：{item.Key}，温度：{item.Value}°C");
}

---

C# 14 新写法：更简洁的初始化

在 .NET 10 + C# 14 环境下，Dictionary 支持更简洁的集合表达式初始化写法：

csharp
// C# 14 集合表达式风格（更简洁）
var alarmThreshold = new Dictionary<string, double>
{
    ["CNC-01"] = 80.0,
    ["CNC-02"] = 85.0,
    ["WELD-01"] = 120.0
};

「这种写法叫"索引器初始化"，比老写法少敲很多字，推荐在新项目中使用。」

---

💻 VS2026 操作步骤

Step 1：新建控制台项目

打开 VS2026，选择 文件 > 新建 > 项目，搜索"控制台应用"，选择 .NET 10 框架，项目名填 DictionaryDemo，点击创建。

Step 2：在 Program.cs 中编写代码

打开 Program.cs，将默认的 Hello World 代码清空，按照下方完整示例粘贴代码。

VS2026 Copilot 辅助：输入 // 创建设备温度字典 后按 Tab，Copilot 会自动补全 Dictionary 声明和初始化代码，按需接受或修改。

Step 3：运行并查看输出

按 F5 或点击顶部工具栏的 ▶ 运行 按钮，在下方"输出"窗口查看控制台打印结果。

VS2026 Copilot 辅助：如果运行报错，Copilot 会在错误行旁边显示"灯泡图标"，点击后给出修复建议，初学者直接选第一条建议通常就能解决。

Step 4（Vibe Coding 提示词写法）

如果你想让 Copilot 帮你生成整段代码，可以在注释里这样写 Prompt：

// 用 Dictionary<string, double> 存储5台CNC设备的实时温度，
// 实现添加、查询、更新、遍历功能，
// 查询时用 TryGetValue 避免 KeyNotFoundException

输入完按 Enter，Copilot 会自动生成完整代码块，你只需审查逻辑是否符合需求。

---

📋 完整代码示例

这段代码实现了一个简单的车间设备温度字典管理器，包含增删改查和安全访问的完整演示。

csharp
// =============================================
// 示例：车间设备温度字典管理
// 适用：.NET 10 + C# 14 + VS2026
// =============================================

using System;
using System.Collections.Generic;

// 创建设备温度字典：Key=设备编号，Value=当前温度(℃)
var deviceTemperature = new Dictionary<string, double>
{
    ["CNC-01"] = 68.5,
    ["CNC-02"] = 72.3,
    ["WELD-01"] = 115.8,
    ["INJECT-01"] = 210.0  // 注塑机温度较高
};

Console.OutputEncoding = System.Text.Encoding.UTF8; // 允许输出特殊符号
Console.WriteLine("=== 车间设备温度监控 ===\n");

// ① 遍历输出所有设备温度
Console.WriteLine("【当前所有设备温度】");
foreach (var device in deviceTemperature)
{
    string status = device.Value > 100 ? "⚠️ 注意" : "✅ 正常";
    Console.WriteLine($"  {device.Key,-12} {device.Value,6:F1}°C  {status}");
}

// ② 安全查询：用 TryGetValue 避免崩溃
Console.WriteLine("\n【查询指定设备】");
string queryTarget = "CNC-02";
if (deviceTemperature.TryGetValue(queryTarget, out double currentTemp))
{
    Console.WriteLine($"  {queryTarget} 当前温度：{currentTemp:F1}°C");
}
else
{
    Console.WriteLine($"  设备 {queryTarget} 不存在，请检查编号");
}

// ③ 更新温度（模拟采集到新数据）
Console.WriteLine("\n【更新 CNC-01 温度】");
deviceTemperature["CNC-01"] = 91.2;
Console.WriteLine($"  CNC-01 温度已更新为：{deviceTemperature["CNC-01"]:F1}°C");

// ④ 报警阈值字典：每台设备阈值不同
var alarmThreshold = new Dictionary<string, double>
{
    ["CNC-01"] = 90.0,
    ["CNC-02"] = 90.0,
    ["WELD-01"] = 130.0,
    ["INJECT-01"] = 240.0
};

// ⑤ 交叉比对：检查哪些设备超温
Console.WriteLine("\n【超温报警检查】");
foreach (var device in deviceTemperature)
{
    // 用 TryGetValue 安全获取该设备的阈值
    if (alarmThreshold.TryGetValue(device.Key, out double threshold))
    {
        if (device.Value >= threshold)
        {
            Console.WriteLine($"  ❌ 报警！{device.Key} 温度 {device.Value:F1}°C，超过阈值 {threshold:F1}°C");
        }
        else
        {
            Console.WriteLine($"  ✅ {device.Key} 温度正常（{device.Value:F1}°C / 阈值{threshold:F1}°C）");
        }
    }
}

// ⑥ 移除已下线设备
Console.WriteLine("\n【移除下线设备 WELD-01】");
deviceTemperature.Remove("WELD-01");
Console.WriteLine($"  当前在线设备数：{deviceTemperature.Count} 台");

运行后，你会看到控制台按格式打印出所有设备的温度和状态标记。更新 CNC-01 温度后，报警检查会立刻识别出它已超过阈值 90°C，并输出红色报警提示。整个流程走下来，你就能感受到 Dictionary 在设备数据管理上的直观和高效。

🤔 你有没有遇到过这种"手滑"时刻？

点了个按钮，数据没了。

不是程序崩溃，不是Bug——就是你自己点的。那一刻的感受，做过几年开发的人都懂，心里凉了半截，鼠标还没来得及放下。

我在给一个Windows本地工具做数据管理模块时，就踩过这个坑。删除按钮和编辑按钮挨得太近，用户（其实就是我自己）手快了一下，一批测试数据没了。从那以后，我对"危险操作确认流程"这件事有了完全不同的理解——它不是"多此一举的弹窗"，而是用户体验的最后一道防线。

今天咱们就聊聊，用CustomTkinter怎么把这道防线做得既好看又好用。

---

🧩 先搞清楚：什么叫"危险操作"

不是所有操作都需要确认弹窗。这玩意儿用多了，用户会产生"确认疲劳"——每次都点"确定"，根本不看提示内容，那弹窗就废了。

危险操作的判断标准，我习惯用三个维度来衡量：

• 不可逆性：操作完成后能不能撤销？删除文件、清空数据库、格式化磁盘，这些都是典型的不可逆。
• 影响范围：影响一条记录和影响全部数据，完全是两个量级。
• 数据价值：用户花了多少时间和精力才产生这份数据？

符合其中两条及以上的，就值得做确认流程。只符合一条的，酌情处理。这不是死规定，是个思考框架。

---

🏗️ CustomTkinter的弹窗机制：从原生到自定义

Tkinter自带的messagebox用起来快，但说实话，那个UI放在2024年的Windows应用里，显得有点格格不入。CustomTkinter没有直接封装messagebox的替代品，但它给了我们CTkToplevel——一个可以完全自定义的顶层窗口，这才是做高质量确认弹窗的正确姿势。

基础结构：一个可复用的确认对话框类

python
import customtkinter as ctk  
from typing import Optional, Callable  
  
  
class ConfirmDialog(ctk.CTkToplevel):  
    """  
    通用危险操作确认对话框  
    支持自定义标题、消息、按钮文字和回调  
    """  
    def __init__(  
            self,  
            parent,  
            title: str = "确认操作",  
            message: str = "确定要执行此操作吗？",  
            confirm_text: str = "确认",  
            cancel_text: str = "取消",  
            danger_level: str = "warning",  # "warning" | "danger"  
            on_confirm: Optional[Callable] = None,  
    ):  
        super().__init__(parent)  
  
        self.on_confirm = on_confirm  
        self.result = False  
  
        # 窗口基础配置  
        self.title(title)  
        self.geometry("420x200")  
        self.resizable(False, False)  
        self.grab_set()  # 模态：锁定父窗口交互  
        self.focus_force()  # 强制获取焦点  
  
        # 根据危险等级设置颜色方案  
        self._danger_colors = {  
            "warning": ("#FFA500", "#CC7700"),  # 橙色系  
            "danger": ("#E53935", "#B71C1C"),  # 红色系  
        }  
        btn_color, btn_hover = self._danger_colors.get(  
            danger_level, self._danger_colors["warning"]  
        )  
        self._build_ui(message, confirm_text, cancel_text, btn_color, btn_hover)  
  
        # 居中显示（相对父窗口）  
        self._center_on_parent(parent)  
  
        # ESC键关闭 = 取消操作  
        self.bind("<Escape>", lambda e: self._on_cancel())  
  
    def _build_ui(self, message, confirm_text, cancel_text, btn_color, btn_hover):  
        self.grid_columnconfigure(0, weight=1)  
        self.grid_rowconfigure(0, weight=1)  
  
        # 消息区域  
        msg_label = ctk.CTkLabel(  
            self,  
            text=message,  
            font=ctk.CTkFont(size=14),  
            wraplength=360,  
            justify="center",  
        )  
        msg_label.grid(row=0, column=0, columnspan=2, padx=30, pady=(30, 20), sticky="ew")  
  
        # 取消按钮（左侧，默认焦点）  
        cancel_btn = ctk.CTkButton(  
            self,  
            text=cancel_text,  
            width=140,  
            fg_color="transparent",  
            border_width=1,  
            text_color=("gray10", "gray90"),  
            command=self._on_cancel,  
        )  
        cancel_btn.grid(row=1, column=0, padx=(30, 10), pady=(0, 25), sticky="e")  
        cancel_btn.focus_set()  # 默认聚焦取消，防手滑  
  
        # 确认按钮（右侧，危险色）  
        confirm_btn = ctk.CTkButton(  
            self,  
            text=confirm_text,  
            width=140,  
            fg_color=btn_color,  
            hover_color=btn_hover,  
            command=self._on_confirm,  
        )  
        confirm_btn.grid(row=1, column=1, padx=(10, 30), pady=(0, 25), sticky="w")  
  
    def _center_on_parent(self, parent):  
        self.update_idletasks()  
        pw = parent.winfo_width()  
        ph = parent.winfo_height()  
        px = parent.winfo_x()  
        py = parent.winfo_y()  
        dw = self.winfo_width()  
        dh = self.winfo_height()  
        x = px + (pw - dw) // 2  
        y = py + (ph - dh) // 2  
        self.geometry(f"+{x}+{y}")  
  
    def _on_confirm(self):  
        self.result = True  
        if self.on_confirm:  
            self.on_confirm()  
        self.destroy()  
  
    def _on_cancel(self):  
        self.result = False  
        self.destroy()  
  
# 示例用法  
if __name__ == "__main__":  
    def on_confirm_action():  
        print("用户确认了操作！")  
  
    root = ctk.CTk()  
    root.geometry("600x400")  
  
    def open_dialog():  
        dialog = ConfirmDialog(  
            root,  
            title="删除文件",  
            message="您确定要删除这个文件吗？此操作无法撤销！",  
            confirm_text="删除",  
            cancel_text="取消",  
            danger_level="danger",  
            on_confirm=on_confirm_action,  
        )  
        root.wait_window(dialog)  # 等待对话框关闭  
        print(f"对话框结果: {dialog.result}")  
  
    open_btn = ctk.CTkButton(root, text="打开确认对话框", command=open_dialog)  
    open_btn.pack(pady=20)  
  
    root.mainloop()

这个类有几个细节值得说一下。grab_set()是做模态弹窗的关键——它会把所有鼠标键盘事件"抢"到当前窗口，用户必须处理完弹窗才能操作父窗口，避免了在弹窗还开着的时候又触发其他操作的混乱情况。另外，取消按钮默认获取焦点，这是个很重要的交互细节，用户如果下意识按回车，触发的是取消而不是确认。

最近在帮一个做点胶机的老铁解决Modbus通讯问题。他苦着脸跟我说："兄弟，我们这套系统连了12个从站设备，天天出问题！有时候读不到数据，有时候直接卡死，现场工程师都快疯了..."

这话听着熟悉吗？统计显示，工业项目中有47%的时间都在处理通讯异常。而Modbus RTU作为工业界的"老兵"，虽然简单可靠，但在多从站环境下却容易"翻车"。

今天咱们就来聊聊如何设计一套真正稳定的Modbus多从站轮询系统。别急着关掉页面——这套方案已经在3个工厂稳定运行半年多，零故障！

🎯 多从站通讯的三大"坑"

第一坑：串行通讯的"交通堵塞"

Modbus RTU是典型的主从模式，同一时刻只能有一个设备发言。想象一下12个人排队打电话，前面那位如果"占线"，后面全得干等着。

第二坑：超时处理的"连锁反应"

传统做法是设置一个全局超时时间，比如500ms。问题来了——如果第3号从站网络不好，卡了2秒，那后面9个从站都要跟着等。一个设备出问题，全线遭殃。

第三坑：错误恢复的"死循环"

更要命的是，很多系统对故障设备没有"隔离机制"。坏了的设备会一直尝试连接，把整个轮询拖垮。就像队伍里有个"话痨"，永远轮不到后面的人。

💡 核心设计思路：独立超时 + 错误隔离

咱们的解决方案核心就8个字：独立超时，错误隔离。

简单说就是：

• 每个从站有自己的"容错额度"
• 出错太多次的设备会被"暂时冷处理"
• 保证好设备不受坏设备影响

🔧 架构设计深度解析

📊 从站配置类：给每个设备建档案

csharp
using System;

namespace AppLoopMasterRtu
{
    /// <summary>
    /// 单个从站的轮询配置与运行时状态
    /// </summary>
    public class SlaveConfig
    {
        public byte SlaveId { get; set; }
        public ushort StartAddr { get; set; }
        public ushort Count { get; set; }
        public int ErrorCount { get; set; }
        public string Status { get; set; } = "待机";
        public string LastData { get; set; } = "--";
        public DateTime LastPoll { get; set; } = DateTime.MinValue;

        public Action<ushort[]>? OnData { get; set; }
    }
}

🔧 开篇

产线上新增了5台焊接机器人，领导要求把每台设备的实时温度都显示在监控界面上。

你打开 VS，写了一个 float[] temps = new float[5]，心想完事了。

结果第二周又加了3台，你只能回去改代码，把 5 改成 8……

第三周又加了2台。

「这数组到底要写多大才够用？」

如果你有这个困惑，今天这篇文章正好帮你解决它。

---

📌 上节回顾

「上一节我们学了数组，掌握了一维、多维与交错数组的声明和使用方法。今天在这个基础上，我们进一步学习 List<T> 泛型集合——一种比数组更灵活、更适合工业动态数据的容器。」

---

💡 核心知识讲解

数组的问题出在哪？

数组（Array）有一个硬伤：长度一旦定好，就不能改变。

你在程序启动时声明了 int[] alarmCodes = new int[10]，最多只能存10条报警记录。第11条进来，直接越界崩溃。

在工厂环境里，设备数量、报警条数、生产记录——这些数据天生就是动态的，数组应付起来很吃力。

List<T>（泛型列表） 就是为了解决这个问题而生的。

---

List<T> 是什么？

List<T> 是 C# 提供的一种 动态数组（可以自动扩容的集合容器）。

这里的 T 是一个占位符，代表你要存什么类型的数据。

• 存设备温度（小数）：List<float>
• 存报警代码（整数）：List<int>
• 存设备名称（文字）：List<string>

「把 T 理解成一个模具，你告诉它用什么材料，它就帮你做出对应的容器。」

---

和数组的核心区别

对比项	数组 Array	列表 List<T>
长度是否固定	✅ 固定，声明时确定	❌ 动态，随时增删
添加元素	❌ 不支持直接添加	✅ .Add() 一行搞定
适合场景	数量确定的静态数据	数量变化的动态数据
性能	略高（内存连续）	略低（但工业场景够用）

大多数工厂应用场景，List<T> 是首选，数组反而用得少。

---

List<T> 的核心操作

掌握以下6个操作，日常开发够用了：

① 创建列表

csharp
var alarmList = new List<int>();        // 空列表
var deviceNames = new List<string> { "焊接机1号", "焊接机2号" }; // 带初始值

② 添加元素 .Add()

csharp
alarmList.Add(1001);   // 添加一条报警码
alarmList.Add(1002);

③ 删除元素 .Remove() / .RemoveAt()

csharp
alarmList.Remove(1001);    // 按值删除
alarmList.RemoveAt(0);     // 按位置删除（第1个）

④ 查找元素 .Contains() / .Find()

csharp
bool exists = alarmList.Contains(1002);   // 是否存在某个值

⑤ 获取数量 .Count

csharp
int total = alarmList.Count;   // 当前有多少条记录

⑥ 遍历列表

csharp
foreach (var code in alarmList)
{
    Console.WriteLine($"报警码：{code}");
}

「记住这6个操作，List<T> 的80%使用场景都覆盖了。」

---

泛型（Generic）是什么意思？

第一次看到 <T> 可能会懵。

泛型 的意思是：这个容器的"规格"由你来定，而不是写死的。

类比工厂里的周转箱：同一款箱子，装螺丝就是"螺丝箱"，装轴承就是"轴承箱"，箱子本身的结构没变，只是装的东西不同。

List<T> 就是这个"通用箱子"，T 就是你要装的"货物类型"。

---

💻 VS2026 操作步骤

Step 1：新建控制台项目

打开 VS2026，选择 文件 > 新建 > 项目，搜索「控制台应用」，选择 .NET 10 框架，项目名填 ListDemo，点击创建。

Step 2：编写 List<T> 代码

打开 Program.cs，清空默认内容，按照下方代码示例输入。

输入 var alarmList = new List 时，VS2026 的 IntelliSense（智能代码补全）会自动弹出 List<T> 的类型提示，按 Tab 键快速补全。

Step 3：运行并查看输出

按 F5 启动调试，或点击顶部工具栏的 ▶ 按钮。

输出结果会显示在底部的「终端」窗口中。

VS2026 Copilot 辅助：如果运行报错，Copilot 会在错误行旁边显示 💡 图标，点击可获得"一键修复"建议，非常适合初学阶段快速排错。

---

Vibe Coding Prompt 写法

如果你想用 Vibe Coding 方式让 Copilot 帮你生成代码，可以在 VS2026 的 Copilot 对话框中输入以下 Prompt：

用 C# 14 和 .NET 10 写一个控制台程序，
使用 List<string> 存储5台注塑机的设备名称，
演示添加、删除、遍历操作，
变量名使用工业语义命名，每行关键代码加中文注释。

Copilot 会直接生成可运行的完整代码，你只需要检查逻辑是否符合需求即可。

---

📋 完整代码示例

这段代码演示了用 List<string> 管理注塑车间的设备列表，包含添加、删除、查找和遍历的完整操作流程。

csharp
// =============================================
// 示例：注塑车间设备列表管理
// 平台：VS2026 + .NET 10 + C# 14
// =============================================

using System;
using System.Collections.Generic;

// 【1】创建设备名称列表（初始包含3台设备）
var deviceNameList = new List<string>
{
    "注塑机1号",
    "注塑机2号",
    "注塑机3号"
};

Console.WriteLine("===== 当前设备列表 =====");

// 【2】遍历并输出所有设备名称
foreach (var deviceName in deviceNameList)
{
    Console.WriteLine($"  设备：{deviceName}");
}

Console.WriteLine($"\n当前设备总数：{deviceNameList.Count} 台");

// 【3】新增设备（模拟产线扩产）
deviceNameList.Add("注塑机4号");
deviceNameList.Add("注塑机5号");

Console.WriteLine("\n===== 新增2台设备后 =====");
Console.WriteLine($"当前设备总数：{deviceNameList.Count} 台");

// 【4】检查某台设备是否在列表中
string targetDevice = "注塑机3号";
bool isOnline = deviceNameList.Contains(targetDevice);
Console.WriteLine($"\n{targetDevice} 是否在线：{isOnline}");

// 【5】移除一台设备（模拟设备下线）
deviceNameList.Remove("注塑机2号");
Console.WriteLine("\n注塑机2号已下线，从列表移除。");

// 【6】按索引访问（获取第1台设备，索引从0开始）
string firstDevice = deviceNameList[0];
Console.WriteLine($"当前列表第一台设备：{firstDevice}");

// 【7】输出最终设备列表
Console.WriteLine("\n===== 最终设备列表 =====");
for (int i = 0; i < deviceNameList.Count; i++)
{
    Console.WriteLine($"  [{i + 1}] {deviceNameList[i]}");
}

运行后，你会在终端窗口看到设备列表的动态变化过程：从3台到5台，再到移除1台后的4台，每次操作结果都清晰打印出来。整个过程不需要改一行长度定义，List 自动帮你管好了。