C#上位机开发：使用委托与Invoke安全跨线程更新UI日志

在开发C#上位机软件时，你是否遇到过这样的场景：一个耗时的数据采集或处理任务在后台线程中运行，当需要将进度、状态或结果实时显示到UI界面的日志框中时，程序却直接崩溃，抛出“无效的跨线程操作”异常？这几乎是每一位C# WinForms或WPF开发者入门多线程编程时必踩的“坑”。其核心原因在于Windows窗体控件的线程安全性限制——UI元素只能由创建它的主线程（通常是UI线程）进行修改。

本文将深入剖析这一经典问题，并提供一个完整、可复用的解决方案： 使用委托（Delegate）与控件的 Invoke 或 BeginInvoke 方法，安全地从后台线程更新UI界面日志 。无论你是正在开发工业数据监控、设备测试、自动化控制等典型的上位机系统，还是任何涉及后台任务与前台交互的C#桌面应用，掌握这套模式都是提升软件稳定性和用户体验的关键。我们将从问题重现、原理拆解，到逐步构建一个带日志功能的实战案例，最后分享工程化最佳实践，带你彻底弄懂并应用这一技术。

1. 背景与核心概念：为什么需要委托更新UI？

在深入代码之前，我们首先要理解问题的根源和涉及的核心概念。

1.1 上位机与UI线程模型

上位机（Host Computer） 通常指在工业控制、测试测量等领域中，用于发送指令、监控状态、处理和分析数据的计算机。其软件（上位机软件）需要提供友好的人机界面（HMI），实时显示设备状态、数据曲线、操作日志等。

在C# WinForms或WPF应用程序中，存在一个特殊的线程，称为 UI线程（或主线程） 。它负责创建并管理所有的窗口、控件，并运行一个消息循环（Message Loop），用于处理用户的输入（如点击、键盘事件）和系统的绘制请求。所有控件的属性修改（如 TextBox.Text 、 Label.Content 、 ListBox.Items ）都应当在这个线程上执行，以确保界面响应的正确性和一致性。

1.2 跨线程操作异常的产生

为了保持界面流畅，任何可能阻塞UI线程的耗时操作（如文件读写、网络通信、复杂计算、设备轮询）都应该放在 后台线程 （如 Thread 、 Task 、 BackgroundWorker ）中执行。

然而，当后台线程尝试直接修改UI控件的属性时，就会触发 InvalidOperationException ，并伴随错误信息：“ 跨线程操作无效: 从不是创建控件的线程访问它。 ”

// 错误示例：在后台线程中直接更新UI
private void buttonStart_Click(object sender, EventArgs e)
{
    Task.Run(() =>
    {
        // 模拟耗时工作
        Thread.Sleep(1000);
        // 尝试在后台线程直接更新文本框 - 这将引发异常！
        textBoxLog.Text = "任务完成！"; // ❌ 跨线程操作异常
    });
}

1.3 委托与控件的Invoke机制

C#的 委托（Delegate） 是一种类型安全的函数指针，它允许将方法作为参数传递或赋值给变量。在解决跨线程UI更新问题时，我们利用委托来“包裹”那个真正想要更新UI的方法。

WinForms控件提供了 Invoke 和 BeginInvoke 方法，它们的作用是将一个委托排队到创建该控件的线程（即UI线程）的消息队列中。当UI线程处理到该消息时，就会执行这个委托所指向的方法，从而安全地更新控件。

• Control.Invoke(Delegate method) : 同步调用。后台线程会阻塞，直到UI线程执行完该委托方法。
• Control.BeginInvoke(Delegate method) : 异步调用。后台线程将委托排队后立即继续执行，不等待UI线程执行完毕。这是更新日志、进度条等非阻塞操作的更常用选择。

核心思路 ：后台线程不直接操作控件，而是通过委托“告诉”UI线程：“请帮我在你的地盘上执行这个更新操作”。

2. 环境准备与项目创建

在开始实战前，请确保你的开发环境就绪。

2.1 开发环境要求

• 操作系统 : Windows 10 或更高版本（WinForms/WPF对Windows支持最佳）。
• 开发工具 : Visual Studio 2022 或 Visual Studio Code（需安装C#扩展）。本文以 Visual Studio 2022 Community 版本为例。
• .NET框架 : .NET 6.0、.NET 8.0 或 .NET Framework 4.7.2 及以上。本文示例使用 .NET 6.0 Windows 窗体应用 ，它兼容性好且是未来趋势。
• 基础知识 : 具备C#基础语法、事件处理以及简单的多线程（ Task ）概念。

2.2 创建示例项目

1. 打开 Visual Studio 2022，选择“创建新项目”。
2. 搜索并选择“ Windows 窗体应用 ”，模板说明中通常标明“.NET”或“.NET Core”，点击“下一步”。
3. 配置你的项目：
   • 项目名称 : DelegateUiUpdateDemo
   • 位置 : 按需选择
   • 解决方案名称 : 默认同项目名即可
   • 框架 : 选择 .NET 6.0 (长期支持) 。如果你的VS版本只显示.NET Framework，选择4.7.2或更高版本亦可，核心代码一致。
4. 点击“创建”。项目创建成功后，你会看到一个默认的窗体 Form1 。

2.3 设计简易日志界面

我们将设计一个典型的上位机日志界面，包含启动按钮、日志列表框和清空按钮。

在解决方案资源管理器中，双击 Form1.cs 打开窗体设计器。从工具箱中拖放以下控件到窗体上，并按下表设置属性：

调整窗体大小至合适，最终设计界面大致如下：

[ 开始模拟任务 ] [ 清空日志 ]
-----------------------------------
|                                  |
|         (ListBoxLog区域)          |
|                                  |
|                                  |
-----------------------------------

3. 核心原理与语法拆解

在编写事件处理代码前，我们需要深入理解将要用到的几个关键语法。

3.1 委托的定义与使用

在C#中，我们可以使用内置的 Action 或 Func 泛型委托，也可以自定义委托。对于更新日志这种没有返回值且参数可能变化的方法， Action<string> 非常合适，它代表一个接受一个 string 参数且无返回值的方法。

// 使用内置Action委托定义一个“更新日志”的委托类型
Action<string> updateLogDelegate;

// 将一个符合签名的方法赋值给委托
updateLogDelegate = AppendLogText; // AppendLogText是我们将要写的方法

// 调用委托，等同于调用 AppendLogText("一些消息")
updateLogDelegate("一些消息");

3.2 Control.InvokeRequired 属性

这是一个非常重要的布尔属性。它用于判断当前执行代码的线程 是否 是创建该控件的线程（即UI线程）。

• true : 当前是 非UI线程 ，必须使用 Invoke/BeginInvoke 。
• false : 当前是 UI线程 ，可以直接操作控件。

最佳实践 ：在任何可能被多线程调用的更新UI的方法中，首先检查 InvokeRequired 。

3.3 Invoke 与 BeginInvoke 的使用模式

标准的、线程安全的UI更新模式如下：

// 假设这是一个更新ListBox的方法
private void SafeAppendLog(string message)
{
    // 检查当前线程是否是创建listBoxLog的线程
    if (listBoxLog.InvokeRequired)
    {
        // 如果不是UI线程，则通过BeginInvoke将调用封送到UI线程
        // 使用Lambda表达式简洁地传递参数
        listBoxLog.BeginInvoke(new Action<string>(SafeAppendLog), message);
    }
    else
    {
        // 这里已经确保在UI线程上执行，可以安全操作控件
        // 添加日志条目，并附带时间戳
        listBoxLog.Items.Add($"{DateTime.Now:HH:mm:ss.fff} - {message}");
        // 滚动到最新项
        listBoxLog.TopIndex = listBoxLog.Items.Count - 1;
    }
}

模式解读 ：

1. if (listBoxLog.InvokeRequired) : 进行线程安全检查。
2. listBoxLog.BeginInvoke(...) : 如果不在UI线程，则重新调用自己（但通过 BeginInvoke 排队），并将参数 message 传递过去。
3. 当执行流再次进入 else 分支时，它一定运行在UI线程上，此时可以安全地修改 listBoxLog.Items 。

4. 完整实战案例：模拟数据采集与日志更新

现在，我们将把上述理论应用到 Form1 中，创建一个完整的、可运行的示例。

4.1 编写线程安全的日志追加方法

打开 Form1.cs 的代码视图（右键窗体 -> 查看代码，或按F7）。在 Form1 类中，添加我们刚刚设计的 SafeAppendLog 方法。

using System;
using System.Windows.Forms;

namespace DelegateUiUpdateDemo
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        /// <summary>
        /// 线程安全地向列表框中追加日志
        /// </summary>
        /// <param name="message">日志消息</param>
        private void SafeAppendLog(string message)
        {
            // 检查调用此方法的线程是否为创建listBoxLog的UI线程
            if (listBoxLog.InvokeRequired)
            {
                // 非UI线程，使用BeginInvoke异步委托回UI线程执行
                // 注意：这里传递的是当前方法本身 (SafeAppendLog) 和参数 message
                listBoxLog.BeginInvoke(new Action<string>(SafeAppendLog), message);
            }
            else
            {
                // 此时已处于UI线程，安全操作控件
                string logEntry = $"{DateTime.Now:HH:mm:ss.fff} - {message}";
                listBoxLog.Items.Add(logEntry);
                // 自动滚动到最新一条日志
                listBoxLog.TopIndex = listBoxLog.Items.Count - 1;
            }
        }
    }
}

4.2 实现后台模拟任务

我们将模拟一个耗时任务，比如从虚拟设备循环读取数据。在 Form1 类中添加一个模拟任务方法，并在其中调用我们的安全日志方法。

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace DelegateUiUpdateDemo
{
    public partial class Form1 : Form
    {
        // 添加一个取消令牌源，用于优雅地停止任务
        private CancellationTokenSource _cancellationTokenSource;

        public Form1()
        {
            InitializeComponent();
        }

        // ... SafeAppendLog 方法在这里 ...

        /// <summary>
        /// 模拟一个耗时的数据采集任务
        /// </summary>
        private async Task SimulateDataAcquisitionAsync(CancellationToken cancellationToken)
        {
            try
            {
                SafeAppendLog("后台数据采集任务开始...");
                int dataPoint = 0;

                for (int i = 0; i < 10; i++)
                {
                    // 每次循环检查是否被请求取消
                    if (cancellationToken.IsCancellationRequested)
                    {
                        SafeAppendLog("任务被用户取消。");
                        return;
                    }

                    // 模拟每次采集耗时200-500毫秒
                    await Task.Delay(new Random().Next(200, 500), cancellationToken);
                    dataPoint = new Random().Next(100, 1000); // 模拟采集到一个数据

                    // 使用线程安全的方法更新UI日志
                    SafeAppendLog($"采集到数据点 #{i + 1}: 值 = {dataPoint}");

                    // 这里可以同时更新进度条等其他UI控件（需另外写安全更新方法）
                }

                SafeAppendLog("数据采集任务完成！");
            }
            catch (TaskCanceledException)
            {
                // 任务被正常取消，不记录为错误
                SafeAppendLog("任务已取消。");
            }
            catch (Exception ex)
            {
                // 捕获其他异常，并安全地更新到UI
                SafeAppendLog($"任务发生异常: {ex.Message}");
            }
        }
    }
}

关键点说明 ：

1. 异步与取消 ：我们使用 async/await 和 CancellationToken 来编写友好的异步任务，支持用户中途取消。
2. 异常处理 ：在 try-catch 块中调用 SafeAppendLog ，确保任何异常信息也能安全地显示在UI上。
3. UI更新点 ：在任务开始、每次循环、任务完成或出错时，都通过 SafeAppendLog 更新界面。

4.3 连接按钮事件与任务控制

现在，我们需要为“开始模拟任务”和“清空日志”按钮编写事件处理程序。

首先，双击设计器中的 buttonStart 和 buttonClear 按钮，VS会自动生成点击事件处理方法框架。然后，修改代码如下：

using System;
using System.Threading;
using System.Threading.Tasks;
using System.Windows.Forms;

namespace DelegateUiUpdateDemo
{
    public partial class Form1 : Form
    {
        private CancellationTokenSource _cancellationTokenSource;

        public Form1()
        {
            InitializeComponent();
            // 初始化按钮状态
            UpdateStartButtonState(isRunning: false);
        }

        // ... SafeAppendLog 和 SimulateDataAcquisitionAsync 方法在这里 ...

        /// <summary>
        /// 更新开始按钮的文本和状态
        /// </summary>
        private void UpdateStartButtonState(bool isRunning)
        {
            // 此方法也可能被后台线程调用，需要线程安全
            if (buttonStart.InvokeRequired)
            {
                buttonStart.BeginInvoke(new Action<bool>(UpdateStartButtonState), isRunning);
                return;
            }

            buttonStart.Text = isRunning ? “停止任务” : “开始模拟任务”;
            buttonStart.Enabled = true; // 确保按钮可用
        }

        // “开始模拟任务”按钮点击事件
        private async void buttonStart_Click(object sender, EventArgs e)
        {
            // 防止重复启动任务
            buttonStart.Enabled = false;

            if (_cancellationTokenSource == null)
            {
                // 第一次点击，启动任务
                _cancellationTokenSource = new CancellationTokenSource();
                UpdateStartButtonState(isRunning: true);
                SafeAppendLog("用户启动了数据采集任务。");

                try
                {
                    // 启动异步任务，但不await，避免阻塞UI。
                    // 使用Task.Run将任务推入线程池，防止复杂计算阻塞UI（尽管本例主要是Delay）。
                    var task = Task.Run(() => SimulateDataAcquisitionAsync(_cancellationTokenSource.Token));
                    // 可以在这里添加一个超时机制或等待任务完成的其他逻辑
                    // 例如：await task; // 如果需要在任务完成后做某事
                }
                catch (Exception ex)
                {
                    SafeAppendLog($"启动任务时出错: {ex.Message}");
                    _cancellationTokenSource?.Dispose();
                    _cancellationTokenSource = null;
                    UpdateStartButtonState(isRunning: false);
                }
            }
            else
            {
                // 第二次点击，取消任务
                SafeAppendLog("用户请求取消任务...");
                _cancellationTokenSource?.Cancel();
                _cancellationTokenSource?.Dispose();
                _cancellationTokenSource = null;
                UpdateStartButtonState(isRunning: false);
            }
            // 按钮状态在UpdateStartButtonState中更新，此处无需重复
        }

        // “清空日志”按钮点击事件
        private void buttonClear_Click(object sender, EventArgs e)
        {
            // 清空操作直接在UI线程（按钮点击事件即在UI线程）执行即可
            listBoxLog.Items.Clear();
            SafeAppendLog("日志已清空。");
        }
    }
}

4.4 运行与验证

1. 按下 F5 或点击“开始调试”运行程序。
2. 点击“开始模拟任务”按钮。你将看到列表框中开始按时间顺序出现日志，例如：

   14:25:31.456 - 用户启动了数据采集任务。
   14:25:31.457 - 后台数据采集任务开始...
   14:25:31.723 - 采集到数据点 #1: 值 = 567
   14:25:32.012 - 采集到数据点 #2: 值 = 890
   ...
   

3. 观察按钮文本变为“停止任务”。在任务运行期间，你仍然可以拖动窗体、点击其他区域，UI不会卡顿，这证明了后台线程在正常工作。
4. 点击“停止任务”按钮，任务会优雅停止，并记录取消日志。
5. 点击“清空日志”按钮，日志被清空并添加一条清空记录。

恭喜！ 你已经成功实现了一个使用委托安全跨线程更新UI日志的上位机程序核心机制。

5. 常见问题与排查思路

在实际开发中，你可能会遇到一些变体或问题。下面是一些常见场景及解决方案。

6. 最佳实践与工程化建议

掌握了基础模式后，我们可以进一步优化代码，使其更健壮、更易于维护，适用于真实的上位机项目。

6.1 封装通用的UI线程调用助手

在每个需要更新UI的地方都写一遍 if (control.InvokeRequired)... 是重复的。我们可以创建一个静态工具类。

using System;
using System.Windows.Forms;

namespace DelegateUiUpdateDemo.Utilities
{
    public static class UiThreadHelper
    {
        /// <summary>
        /// 在控件的创建线程上安全地执行一个Action
        /// </summary>
        public static void SafeInvoke(this Control control, Action action)
        {
            if (control == null) throw new ArgumentNullException(nameof(control));
            if (control.InvokeRequired)
            {
                control.Invoke(action);
            }
            else
            {
                action();
            }
        }

        /// <summary>
        /// 在控件的创建线程上安全地执行一个Action（异步）
        /// </summary>
        public static void SafeBeginInvoke(this Control control, Action action)
        {
            if (control == null) throw new ArgumentNullException(nameof(control));
            if (control.InvokeRequired)
            {
                control.BeginInvoke(action);
            }
            else
            {
                action();
            }
        }

        /// <summary>
        /// 安全地更新控件的属性（泛型版本，更直观）
        /// </summary>
        public static void SafeSetProperty<TControl>(this TControl control, Action<TControl> propertySetter) where TControl : Control
        {
            if (control == null) throw new ArgumentNullException(nameof(control));
            if (control.InvokeRequired)
            {
                control.Invoke(new Action(() => propertySetter(control)));
            }
            else
            {
                propertySetter(control);
            }
        }
    }
}

使用这个助手类，我们的 SafeAppendLog 方法可以简化为：

private void SafeAppendLog(string message)
{
    // 使用扩展方法，代码更简洁
    listBoxLog.SafeInvoke(() =>
    {
        string logEntry = $"{DateTime.Now:HH:mm:ss.fff} - {message}";
        listBoxLog.Items.Add(logEntry);
        listBoxLog.TopIndex = listBoxLog.Items.Count - 1;
    });
}
// 或者使用更具体的属性设置器
private void SafeAppendLog2(string message)
{
    listBoxLog.SafeSetProperty(lb =>
    {
        string logEntry = $"{DateTime.Now:HH:mm:ss.fff} - {message}";
        lb.Items.Add(logEntry);
        lb.TopIndex = lb.Items.Count - 1;
    });
}

6.2 实现带日志级别的日志系统

真实的上位机需要区分信息、警告、错误等不同级别的日志。

public enum LogLevel
{
    Info,
    Warning,
    Error,
    Debug
}

public static class Logger
{
    private static ListBox _logListBox; // 假设绑定到ListBox
    private static readonly object _lockObj = new object();

    public static void Initialize(ListBox listBox)
    {
        _logListBox = listBox;
    }

    public static void Log(string message, LogLevel level = LogLevel.Info)
    {
        if (_logListBox == null) return;

        string prefix = level switch
        {
            LogLevel.Info => "[INFO]",
            LogLevel.Warning => "[WARN]",
            LogLevel.Error => "[ERROR]",
            LogLevel.Debug => "[DEBUG]",
            _ => "[UNKN]"
        };
        string fullMessage = $"{DateTime.Now:HH:mm:ss} {prefix} {message}";

        _logListBox.SafeBeginInvoke(() =>
        {
            // 这里可以添加颜色区分（如果使用RichTextBox）
            _logListBox.Items.Add(fullMessage);
            _logListBox.TopIndex = _logListBox.Items.Count - 1;

            // 可选：将错误日志写入文件
            if (level == LogLevel.Error)
            {
                WriteToFile(fullMessage);
            }
        });
    }

    private static void WriteToFile(string message)
    {
        lock (_lockObj)
        {
            // 简单的文件写入逻辑
            string logPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "app.log");
            File.AppendAllText(logPath, message + Environment.NewLine);
        }
    }
}

在窗体初始化时调用 Logger.Initialize(listBoxLog); ，之后在任何线程都可以使用 Logger.Log("设备连接成功", LogLevel.Info); 。

6.3 窗体生命周期与资源管理

这是上位机项目稳定性的关键。务必妥善管理后台任务的生命周期。

public partial class Form1 : Form
{
    private CancellationTokenSource _globalCts;

    public Form1()
    {
        InitializeComponent();
        // 初始化日志系统
        Logger.Initialize(listBoxLog);
    }

    private void Form1_Load(object sender, EventArgs e)
    {
        _globalCts = new CancellationTokenSource();
    }

    private async void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        // 阻止窗体立即关闭，先执行清理
        e.Cancel = true; // 暂时取消关闭事件

        Logger.Log("应用程序正在关闭，清理资源...", LogLevel.Info);
        buttonStart.Enabled = false;

        // 请求所有后台任务取消
        _globalCts?.Cancel();

        // 这里可以添加一个短暂的等待，让任务有机会结束
        // 注意：对于无法响应的任务，可能需要更复杂的超时处理
        await Task.Delay(500);

        _globalCts?.Dispose();
        Logger.Log("资源清理完成。", LogLevel.Info);

        // 真正关闭窗体
        e.Cancel = false;
        this.Close();
    }

    // 启动任务时，使用全局的CancellationToken
    private async void buttonStart_Click(object sender, EventArgs e)
    {
        await StartDataAcquisitionAsync(_globalCts.Token);
    }
}

6.4 性能考量：高频日志的优化

对于每秒更新数百上千次的数据流，频繁调用 BeginInvoke 会带来性能压力。可以采用缓冲队列。

using System.Collections.Concurrent;
using System.Threading;
using System.Windows.Forms;

public class BufferedLogger
{
    private readonly ListBox _listBox;
    private readonly ConcurrentQueue<string> _logQueue = new ConcurrentQueue<string>();
    private readonly System.Windows.Forms.Timer _uiTimer;
    private const int FLUSH_INTERVAL_MS = 100; // 每100ms刷新一次UI

    public BufferedLogger(ListBox listBox)
    {
        _listBox = listBox;
        _uiTimer = new System.Windows.Forms.Timer { Interval = FLUSH_INTERVAL_MS };
        _uiTimer.Tick += FlushLogsToUi;
        _uiTimer.Start();
    }

    public void Log(string message)
    {
        _logQueue.Enqueue($"{DateTime.Now:HH:mm:ss.fff} - {message}");
    }

    private void FlushLogsToUi(object sender, EventArgs e)
    {
        if (_logQueue.IsEmpty) return;

        // 一次性取出队列中的所有日志
        var logsToAdd = new List<string>();
        while (_logQueue.TryDequeue(out var log))
        {
            logsToAdd.Add(log);
        }

        if (logsToAdd.Count > 0)
        {
            _listBox.SafeBeginInvoke(() =>
            {
                // 批量添加，减少UI刷新次数
                _listBox.Items.AddRange(logsToAdd.ToArray());
                _listBox.TopIndex = _listBox.Items.Count - 1;
            });
        }
    }

    public void Stop()
    {
        _uiTimer.Stop();
        FlushLogsToUi(null, EventArgs.Empty); // 最后刷新一次
    }
}

7. 总结与扩展方向

通过本文的逐步拆解与实战，你应该已经掌握了在C#上位机项目中，使用委托安全更新UI日志的核心技能。我们从最令人头疼的跨线程异常出发，理解了UI线程模型，学会了 InvokeRequired 、 Invoke / BeginInvoke 的标准使用模式，并构建了一个完整的、可应对实际开发的日志更新模块。

关键要点回顾 ：

1. 永远不要 在后台线程中直接操作UI控件。
2. 使用 Control.InvokeRequired 进行线程安全检查。
3. 使用 Control.Invoke （同步）或 Control.BeginInvoke （异步）将UI更新操作“封送”到UI线程执行。
4. 利用 async/await 和 CancellationToken 管理后台任务的生命周期，实现优雅的启动与停止。
5. 通过封装工具类、实现日志级别、管理窗体生命周期和优化高频更新，可以将基础模式工程化，构建出健壮的上位机应用。

下一步可以探索 ：

• 结合更多UI控件 ：将同样的模式应用到 ProgressBar （进度条）、 Chart （图表）、 DataGridView （数据表格）的实时更新上。
• 使用事件聚合器 ：在更复杂的项目中，考虑使用 EventAggregator 或 MediatR 等模式进行松耦合的跨线程消息通信，让UI更新逻辑更清晰。
• 学习WPF的Dispatcher ：如果你转向WPF开发，其 Dispatcher.BeginInvoke 是等效机制，并且WPF的数据绑定 ( INotifyPropertyChanged ) 本身能在一定程度上处理线程切换，但理解 Dispatcher 仍是必备技能。
• 探索 SynchronizationContext ：这是 .NET 中更通用的线程上下文同步机制， WinFormsSynchronizationContext 和 DispatcherSynchronizationContext 是其具体实现，理解它有助于编写更通用的异步代码。

跨线程UI更新是桌面开发的基础，也是面试中的高频考点。理解其原理并熟练运用，不仅能让你写出更稳定的软件，也能让你在面对更复杂的异步编程模型时游刃有余。