🎯 场景还原

凌晨2点，生产线突然停机。现场工程师焦急地盯着串口调试工具，数据包时有时无，连接状态不稳定。"又是串口通信的问题！"这是我在工业自动化项目中最常听到的抱怨。

我见过太多因为串口通信不稳定导致的生产事故。串口看似简单，实则暗藏玄机：线程安全、异常处理、数据完整性、UI响应，每一个环节都可能成为系统崩溃的导火索。

今天，我将用一个完整的工业级案例，带你掌握C# WinForms串口通信的核心技术，让你的应用从"能用"升级到"好用"、"稳用"。

🔍 串口通信开发的五大痛点分析

痛点1：UI线程冻结问题

传统的同步串口操作会阻塞UI线程，造成界面卡死，用户体验极差。

痛点2：数据接收不完整

串口数据是流式传输，一次接收可能只是完整数据的一部分，如何保证数据完整性？

痛点3：异常处理不当

设备断电、拔插串口线等异常情况处理不当，程序直接崩溃。

痛点4：多串口管理混乱

工业现场往往需要同时管理多个串口，传统方式代码冗余，维护困难。

痛点5：调试困难

数据收发过程不可视，问题排查如大海捞针。

💡 工业级串口通信解决方案

🚀 核心架构设计

我们采用分层架构设计，将串口操作封装成独立的管理器：

markdown
┌─────────────────────┐
│    UI层 (WinForms)   │  ← 用户界面，数据展示
├─────────────────────┤
│  业务逻辑层(Manager) │  ← 串口管理，事件处理  
├─────────────────────┤
│  封装层(Wrapper)     │  ← 串口封装，异常处理
└─────────────────────┘

🎯 解决方案一：线程安全的串口封装类

核心思路：使用SemaphoreSlim确保写操作的线程安全，Timer实现智能重连。

c#
using System;
using System.Collections.Generic;
using System.IO.Ports;
using System.Linq;
using System.Text;
using System.Threading;
using System.Threading.Tasks;

namespace AppMultiSerialPortManager
{
    public class SerialPortWrapper : IDisposable
    {
        private readonly SerialPort _serialPort;
        private readonly SemaphoreSlim _writeSemaphore;
        private readonly Timer _reconnectTimer;
        private bool _disposed = false;
        private volatile bool _isReconnecting = false;

        public event EventHandler<SerialDataReceivedEventArgs> DataReceived;
        public event EventHandler<SerialErrorEventArgs> ErrorOccurred;

        public string PortName => _serialPort.PortName;
        public bool IsOpen => _serialPort?.IsOpen ?? false;

        public SerialPortWrapper(string portName, int baudRate, Parity parity, int dataBits, StopBits stopBits)
        {
            _serialPort = new SerialPort(portName, baudRate, parity, dataBits, stopBits)
            {
                ReadTimeout = 1000,
                WriteTimeout = 1000,
                ReceivedBytesThreshold = 1
            };

            _serialPort.DataReceived += _serialPort_DataReceived;
            _serialPort.ErrorReceived += SerialPort_ErrorReceived;

            _writeSemaphore = new SemaphoreSlim(1, 1);
            _reconnectTimer = new Timer(ReconnectCallback, null, Timeout.Infinite, Timeout.Infinite);
        }

        private void _serialPort_DataReceived(object sender, System.IO.Ports.SerialDataReceivedEventArgs e)
        {
            try
            {
                var serialPort = sender as SerialPort;
                if (serialPort != null && serialPort.IsOpen)
                {
                    var bytesToRead = serialPort.BytesToRead;
                    if (bytesToRead > 0)
                    {
                        var buffer = new byte[bytesToRead];
                        var bytesRead = serialPort.Read(buffer, 0, bytesToRead);

                        if (bytesRead > 0)
                        {
                            var actualData = new byte[bytesRead];
                            Array.Copy(buffer, actualData, bytesRead);

                            OnDataReceived(new SerialDataReceivedEventArgs(PortName, actualData));
                        }
                    }
                }
            }
            catch (Exception ex)
            {
                OnErrorOccurred(new SerialErrorEventArgs(PortName, ex));
            }
        }

        public bool Open()
        {
            try
            {
                if (!_serialPort.IsOpen)
                {
                    _serialPort.Open();
                    _serialPort.DiscardInBuffer();
                    _serialPort.DiscardOutBuffer();
                }
                return true;
            }
            catch (Exception ex)
            {
                OnErrorOccurred(new SerialErrorEventArgs(PortName, ex));
                return false;
            }
        }

        public void Close()
        {
            try
            {
                if (_serialPort.IsOpen)
                {
                    _serialPort.Close();
                }
            }
            catch (Exception ex)
            {
                OnErrorOccurred(new SerialErrorEventArgs(PortName, ex));
            }
        }

        public async Task<bool> WriteDataAsync(byte[] data)
        {
            if (data == null || data.Length == 0)
                return false;

            await _writeSemaphore.WaitAsync();
            try
            {
                if (!_serialPort.IsOpen)
                {
                    if (!Open())
                        return false;
                }

                await Task.Run(() => _serialPort.Write(data, 0, data.Length));
                return true;
            }
            catch (Exception ex)
            {
                OnErrorOccurred(new SerialErrorEventArgs(PortName, ex));
                StartReconnectTimer();
                return false;
            }
            finally
            {
                _writeSemaphore.Release();
            }
        }

        public async Task<bool> WriteStringAsync(string data)
        {
            if (string.IsNullOrEmpty(data))
                return false;

            var bytes = System.Text.Encoding.UTF8.GetBytes(data);
            return await WriteDataAsync(bytes);
        }

  
        private void SerialPort_ErrorReceived(object sender, SerialErrorReceivedEventArgs e)
        {
            OnErrorOccurred(new SerialErrorEventArgs(PortName, new Exception($"串口错误: {e.EventType}")));
            StartReconnectTimer();
        }

        private void StartReconnectTimer()
        {
            if (!_isReconnecting && !_disposed)
            {
                _isReconnecting = true;
                _reconnectTimer.Change(TimeSpan.FromSeconds(5), TimeSpan.FromSeconds(5));
            }
        }

        private void ReconnectCallback(object state)
        {
            try
            {
                if (_disposed)
                    return;

                Close();
                Thread.Sleep(1000); // 等待端口释放

                if (Open())
                {
                    _isReconnecting = false;
                    _reconnectTimer.Change(Timeout.Infinite, Timeout.Infinite);
                }
            }
            catch (Exception ex)
            {
                OnErrorOccurred(new SerialErrorEventArgs(PortName, ex));
            }
        }

        private void OnDataReceived(SerialDataReceivedEventArgs e)
        {
            DataReceived?.Invoke(this, e);
        }

        private void OnErrorOccurred(SerialErrorEventArgs e)
        {
            ErrorOccurred?.Invoke(this, e);
        }

        public void Dispose()
        {
            if (!_disposed)
            {
                _disposed = true;
                _reconnectTimer?.Dispose();
                _writeSemaphore?.Dispose();

                try
                {
                    if (_serialPort != null)
                    {
                        if (_serialPort.IsOpen)
                            _serialPort.Close();
                        _serialPort.Dispose();
                    }
                }
                catch { }
            }
        }
    }
}

实战应用：适用于需要高稳定性的工业控制系统，如PLC通信、传感器数据采集。

避坑指南：⚠️ 必须设置合理的读写超时时间，避免无限等待导致程序假死。

写给每一位想用 C# 写出跨平台桌面应用的开发者

---

🤔 你是否也有这样的困惑？

刚接触 Avalonia 的时候，不少开发者卡在了"第一步"——环境搭建。

明明照着网上的教程一步步操作，结果 dotnet new 跑出来没有 Avalonia 模板；或者 SDK 版本对不上，编译直接报错；再或者 NuGet 源没配好，包死活下不下来。一顿折腾两三个小时，Hello World 都没跑起来，挫败感拉满。

这篇文章就是为了解决这个问题。

读完之后，你将掌握：从零到一完整搭建 Avalonia 开发环境的标准流程，包括 .NET SDK 的版本选择与验证、Avalonia 模板的安装与更新、常见报错的排查思路，以及创建并运行第一个项目的完整步骤。整个过程控制在 30 分钟以内，可直接落地到实际项目中。

---

🧩 先搞清楚：Avalonia 到底是什么？

在动手之前，咱们先花两分钟把概念摸清楚，后面操作起来才不会懵。

Avalonia 是一个基于 .NET 的开源跨平台 UI 框架，设计理念上和 WPF 非常接近——同样用 XAML 描述界面，同样支持数据绑定和 MVVM 模式。但它最大的不同在于：一套代码，能跑在 Windows、macOS、Linux，甚至 iOS、Android 和 WebAssembly 上。

对于长期做 Windows 桌面开发的 C# 开发者来说，Avalonia 的学习曲线相当平缓。如果你熟悉 WPF，上手 Avalonia 基本不需要太多额外学习成本。而对于想从 Windows 走向全平台的团队，Avalonia 是目前 .NET 生态里最成熟的选择之一。

---

🛠️ 第一步：安装 .NET SDK

版本要求

Avalonia 目前要求 .NET 8.0 或更高版本。这一点需要特别注意——很多老项目可能还跑在 .NET 6 甚至 .NET Framework 上，但 Avalonia 的模板和工具链已经全面迁移到 .NET 8+。

当然，.NET 支持多版本共存，你完全可以在同一台机器上同时装着 .NET 6、.NET 8、.NET 9，它们互不干扰。

下载与安装

前往 dotnet.microsoft.com 下载对应操作系统的 SDK 安装包。

• Windows：下载 .exe 安装程序，一路 Next 即可
• macOS：下载 .pkg 安装包，或者通过 Homebrew 安装：

bash
brew install --cask dotnet-sdk

• Linux（Ubuntu/Debian 系）：

bash
sudo apt-get update
sudo apt-get install -y dotnet-sdk-8.0

验证安装是否成功

安装完成后，打开终端（Windows 用 PowerShell 或 CMD），执行：

bash
dotnet --version

如果输出类似 8.0.xxx 或 10.0.xxx 的版本号，说明安装成功。

想查看当前机器上装了哪些版本的 SDK，执行：

bash
dotnet --list-sdks

输出示例：

---

📦 第二步：安装 Avalonia 项目模板

.NET SDK 本身并不自带 Avalonia 的项目模板，需要单独安装。这一步是很多新手卡壳的地方。

安装命令

bash
dotnet new install Avalonia.Templates

Avalonia 要求 .NET 8+，正常情况下直接用 install 子命令就行。

安装成功后，终端会输出一张模板清单，大概长这样：

Template Name                                Short Name                   Language    Tags
-------------------------------------------- ---------------------------- ----------- ---------------------------------------------------------
Avalonia .NET App                            avalonia.app                 [C#],F#     Desktop/Xaml/Avalonia/Windows/Linux/macOS
Avalonia .NET MVVM App                       avalonia.mvvm                [C#],F#     Desktop/Xaml/Avalonia/Windows/Linux/macOS
Avalonia Cross Platform Application          avalonia.xplat               [C#],F#     Desktop/Xaml/Avalonia/Browser/Mobile
Avalonia Resource Dictionary                 avalonia.resource                        Desktop/Xaml/Avalonia/Windows/Linux/macOS
Avalonia Styles                              avalonia.styles                          Desktop/Xaml/Avalonia/Windows/Linux/macOS
Avalonia TemplatedControl                    avalonia.templatedcontrol    [C#],F#     Desktop/Xaml/Avalonia/Windows/Linux/macOS
Avalonia UserControl                         avalonia.usercontrol         [C#],F#     Desktop/Xaml/Avalonia/Windows/Linux/macOS
Avalonia Window                              avalonia.window              [C#],F#     Desktop/Xaml/Avalonia/Windows/Linux/macOS

🪟 一个让人抓狂的场景

用户点了"设置"按钮。新窗口弹出来了。

然后他没关设置窗口，又点了一次"设置"。又弹出来一个。再点，再弹。最后桌面上叠了五个一模一样的设置窗口，像俄罗斯套娃一样摞在那儿。

这不是假设。这是我在一个实际项目里遇到的真实 bug——用户反馈"软件有点怪"，我远程看了一眼，好家伙，七个设置窗口。

多窗口管理，听起来简单。做起来，坑多得很。

这篇文章咱们就把这件事彻底聊清楚：模态窗口怎么做、非模态怎么管、对话流程怎么设计，附完整可运行代码，不绕弯子。

---

🧠 先把概念捋一遍

很多人分不清模态和非模态，用的时候全凭感觉。其实区别很直接——

模态窗口（Modal）：弹出后，主窗口被"冻住"，用户必须先处理弹窗才能继续操作。确认删除、填写表单、输入密码——这些场景用模态。

非模态窗口（Non-Modal）：弹出后，主窗口照常可以操作，两个窗口互不干扰。日志查看器、悬浮工具栏、实时监控面板——这些适合非模态。

选错了，用户体验就会很奇怪。把一个"查看日志"做成模态，用户每次看日志都得先关掉它才能继续干活，那不是在帮用户，是在折磨用户。

---

🔒 模态窗口：grab_set() 才是关键

CTk里做模态窗口，很多人只知道用CTkToplevel，但少了一步——grab_set()。

python
import customtkinter as ctk  
  
  
class ConfirmDialog(ctk.CTkToplevel):  
    """通用确认对话框（模态）"""  
  
    def __init__(self, master, title="确认", message="确定要执行此操作吗？"):  
        super().__init__(master)  
  
        self.result = None  # 用来传递用户的选择  
  
        self.title(title)  
        self.geometry("360x180")  
        self.resizable(False, False)  
  
        # ⭐ 关键：设置模态，阻断主窗口输入  
        self.grab_set()  
        # 让弹窗居中于父窗口  
        self.transient(master)  
  
        self._build_ui(message)  
  
        # 等待窗口关闭再返回  
        self.wait_window()  
  
    def _build_ui(self, message):  
        ctk.CTkLabel(  
            self,  
            text=message,  
            font=ctk.CTkFont(family="Microsoft YaHei", size=14),  
            wraplength=300  
        ).pack(pady=(28, 20), padx=20)  
  
        btn_frame = ctk.CTkFrame(self, fg_color="transparent")  
        btn_frame.pack(pady=(0, 20))  
  
        ctk.CTkButton(  
            btn_frame, text="确认", width=100,  
            fg_color="#4F46E5",  
            command=self._on_confirm  
        ).pack(side="left", padx=8)  
  
        ctk.CTkButton(  
            btn_frame, text="取消", width=100,  
            fg_color="#6B7280",  
            command=self._on_cancel  
        ).pack(side="left", padx=8)  
  
    def _on_confirm(self):  
        self.result = True  
        self.destroy()  
  
    def _on_cancel(self):  
        self.result = False  
        self.destroy()  
  
class App(ctk.CTk):  
    def __init__(self):  
        super().__init__()  
        self.title("主窗口")  
        self.geometry("400x300")  
  
        # 按钮触发弹窗  
        ctk.CTkButton(  
            self, text="打开弹窗", command=self.open_confirm_dialog  
        ).pack(pady=20)  
  
    def open_confirm_dialog(self):  
        dialog = ConfirmDialog(self, title="确认操作", message="你确定要继续吗？")  
        if dialog.result:  
            print("用户选择了确认")  
        else:  
            print("用户选择了取消")  
  
  
if __name__ == "__main__":  
    app = App()  
    app.mainloop()

这里有三个细节值得注意：

• grab_set() 把所有鼠标键盘事件"抢"过来，主窗口就收不到了——这才是真正的模态效果
• transient(master) 让弹窗跟随主窗口，最小化主窗口时弹窗也跟着消失，行为更自然
• wait_window() 让调用方"卡"在那一行，等弹窗关闭后再继续执行——这样dialog.result才能拿到值

少了grab_set()，窗口虽然弹出来了，但主窗口照样能点，那叫"看起来像模态"，实际上不是。

🎯 你是不是也遇到过这种情况？

项目里有个需求——识别一批扫描件里的文字，或者给系统加个图片中的文本提取功能。调研一圈下来，大家都在说 PaddleOCR 好用、精度高、开源免费。

然后你打开文档，发现它是 Python 的。

作为一个日常写 C# 的开发者，这一刻的感受大概是："又要搭 Python 环境？又要维护一套 HTTP 接口？"

这种割裂感，我在好几个项目里都遇到过。要么是把 Python 推理服务单独部署，网络调用加延迟；要么是用一些精度有限的老旧 .NET OCR 库，效果差强人意；要么就是干脆放弃 AI 能力，用规则硬写。

直到接触到 PaddleSharp，这个局面才真正被打破。

读完这篇文章，你将了解：

• PaddleSharp 到底是什么、从哪来、能做什么
• 它和 Python 方案相比，各有什么优劣
• C# 开发者如何快速定位自己的使用场景

---

🧩 PaddleSharp 从哪来？

要说清楚 PaddleSharp，得先说说它背后的东西。

百度飞桨（PaddlePaddle） 是国内最主流的深度学习框架之一，自 2016 年开源以来，积累了大量工业级 AI 模型。其中最广为人知的是 PaddleOCR——一套支持 80+ 语言、兼顾检测与识别的完整 OCR 工具链，以及 PaddleDetection，覆盖目标检测、关键点检测等视觉任务。

飞桨本身提供了一个叫 Paddle Inference 的 C++ 推理引擎，专门用于模型部署。理论上，任何语言只要能调用 C++ 动态库，就能跑飞桨的模型。

而 PaddleSharp 就是这件事在 C# 世界的实现。它由 GitHub 用户 sdcb 开发维护，本质是 Paddle Inference C API 的 C# 封装，NuGet 包名统一以 Sdcb. 开头。

核心设计理念只有一句话：让 C# 开发者无需理解 Python，也能直接调用工业级 AI 模型。

---

🗺️ PaddleSharp 的整体生态地图

PaddleSharp 不是一个单一的包，而是一组按功能划分的 NuGet 模块，按需引入：

模块包名	功能定位
Sdcb.PaddleInference	核心推理引擎封装，底层基础
Sdcb.PaddleInference.runtime.win64.mkl	Windows x64 CPU 推理运行时（MKL-DNN）
Sdcb.PaddleInference.runtime.win64.cuda*	Windows GPU 推理运行时（CUDA）
Sdcb.PaddleOCR	OCR 功能封装（检测+方向+识别）
Sdcb.PaddleOCR.KnownModels	预置模型定义与自动下载管理
Sdcb.PaddleDetection	目标检测功能封装（PP-YOLO 等）
OpenCvSharp4	图像处理依赖（Mat 格式转换等）

这种分层解耦的设计很聪明——你只需要 OCR，就不必把检测模块也拉进来；你在 Linux 上部署，就换对应平台的运行时包。整个生态的依赖关系是清晰可控的。

支持的运行环境方面，PaddleSharp 覆盖了：

• Windows x64（CPU MKL-DNN / NVIDIA GPU CUDA）
• Linux x64（Ubuntu 20.04，CPU / GPU）
• .NET 版本：.NET 5、.NET 6、.NET 7、.NET 8 均可使用

🎯 你是不是也遇到过这些情况？

做 Winform 界面的时候，窗体上密密麻麻全是控件，用户一眼看过去完全不知道从哪里下手。或者表单里有十几个 TextBox，逻辑上分属不同业务模块，却混在一起，维护的时候自己都搞不清楚哪个是哪个。

这不是设计能力的问题，是没有用好分组控件。

GroupBox 是 Winform 里最被低估的控件之一。很多开发者只把它当个"画框"，套上去显示个标题就完事了，完全没发挥出它在逻辑分层、动态管理、状态联动方面的真正价值。

读完这篇文章，你将掌握：

• GroupBox 的核心机制与布局控制技巧
• 动态创建与批量管理控件的实战方法
• 基于 GroupBox 实现模块化启用/禁用的交互设计

这些技巧在实际项目里可以直接落地，不是纸上谈兵。

---

🔍 问题深度剖析：GroupBox 被误用在哪里？

表象问题：界面乱、逻辑散

在中大型 Winform 项目里，一个窗体承载 30~50 个控件是常有的事。如果不做分组，界面的可读性会急剧下降，用户操作错误率上升，开发者自己维护时也要花大量时间定位控件。

根本原因：只用了 GroupBox 的"壳"

很多人用 GroupBox 的方式是这样的：拖一个 GroupBox 到窗体，改个 Text 属性当标题，然后把控件堆进去。这没错，但只用到了 10% 的功能。

真正的问题在于：

• 没有利用 GroupBox 的容器特性进行批量操作（启用、禁用、隐藏一整组）
• 没有结合 Enabled 属性做模块级别的状态管理
• 没有动态生成，导致代码里到处是硬编码的控件名称，扩展性极差
• 忽略了 Dock 和 Anchor，导致窗体缩放时布局崩掉

这些问题在项目规模变大之后会集中爆发，维护成本直线上升。

---

💡 核心要点提炼

在深入方案之前，先把几个关键机制说清楚。

GroupBox 本质上是一个容器控件（ContainerControl），它的 Controls 集合包含所有子控件。这意味着你对 GroupBox 做的很多操作，可以自动传递给子控件，比如 Enabled = false 会让整组控件同时变灰不可用，Visible = false 会隐藏整组。

Dock 与 Anchor 的选择逻辑：如果 GroupBox 需要随窗体缩放自适应，优先用 Dock（填充方向固定）；如果需要保持与某条边的距离固定，用 Anchor。两者混用是布局混乱的常见来源，要避免。

TabIndex 管理：GroupBox 内部的控件 TabIndex 是独立的局部序列，不影响窗体全局的 Tab 顺序。这是一个经常被忽视的细节，在表单输入场景里很重要。

---

🛠️ 解决方案一：基础布局控制与样式规范化

应用场景

适用于大多数信息录入类窗体，比如用户信息填写、设备参数配置等，控件数量在 20 个以上时效果最明显。

实现思路

把相关控件按业务逻辑归组，利用 GroupBox 的 Padding 属性控制内边距，配合 Anchor 保证缩放时不变形。

csharp
using System;
using System.Drawing;
using System.Windows.Forms;

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

        /// <summary>
        /// 基础 GroupBox 规范化配置
        /// </summary>
        private void InitGroupBoxStyle(GroupBox groupBox, string title)
        {
            groupBox.Text = title;
            groupBox.Font = new Font("微软雅黑", 9F, FontStyle.Regular);
            groupBox.ForeColor = Color.FromArgb(64, 64, 64);

            // 内边距，避免子控件贴边
            groupBox.Padding = new Padding(10, 15, 10, 10);

            // 跟随父容器四边缩放
            groupBox.Anchor = AnchorStyles.Top | AnchorStyles.Left
                            | AnchorStyles.Right | AnchorStyles.Bottom;
        }

        /// <summary>
        /// 加载默认用户数据
        /// </summary>
        private void LoadUserData()
        {
            textBoxName.Text = "张三";
            numericUpDownAge.Value = 28;
            radioButtonMale.Checked = true;
            checkBoxAutoSave.Checked = true;
            comboBoxTheme.SelectedIndex = 0;
            comboBoxLanguage.SelectedIndex = 0;
        }

        /// <summary>
        /// 保存按钮事件
        /// </summary>
        private void ButtonSave_Click(object sender, EventArgs e)
        {
            if (ValidateInput())
            {
                string gender = radioButtonMale.Checked ? "男" : "女";
                string message = $"用户信息已保存：\n" +
                               $"姓名：{textBoxName.Text}\n" +
                               $"年龄：{numericUpDownAge.Value}\n" +
                               $"性别：{gender}\n" +
                               $"自动保存：{(checkBoxAutoSave.Checked ? "是" : "否")}\n" +
                               $"主题：{comboBoxTheme.Text}\n" +
                               $"语言：{comboBoxLanguage.Text}";

                MessageBox.Show(message, "保存成功", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }

        /// <summary>
        /// 重置按钮事件
        /// </summary>
        private void ButtonReset_Click(object sender, EventArgs e)
        {
            DialogResult result = MessageBox.Show("确定要重置所有设置吗？",
                                                "确认重置",
                                                MessageBoxButtons.YesNo,
                                                MessageBoxIcon.Question);
            if (result == DialogResult.Yes)
            {
                LoadUserData();
                MessageBox.Show("设置已重置", "重置完成", MessageBoxButtons.OK, MessageBoxIcon.Information);
            }
        }

        /// <summary>
        /// 退出按钮事件
        /// </summary>
        private void ButtonExit_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        /// <summary>
        /// 输入验证
        /// </summary>
        private bool ValidateInput()
        {
            if (string.IsNullOrWhiteSpace(textBoxName.Text))
            {
                MessageBox.Show("请输入姓名", "输入错误", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                textBoxName.Focus();
                return false;
            }

            if (numericUpDownAge.Value < 1)
            {
                MessageBox.Show("年龄必须大于0", "输入错误", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                numericUpDownAge.Focus();
                return false;
            }

            return true;
        }

        /// <summary>
        /// 窗体关闭前确认
        /// </summary>
        protected override void OnFormClosing(FormClosingEventArgs e)
        {
            DialogResult result = MessageBox.Show("确定要退出程序吗？",
                                                "退出确认",
                                                MessageBoxButtons.YesNo,
                                                MessageBoxIcon.Question);
            if (result == DialogResult.No)
            {
                e.Cancel = true;
            }
            base.OnFormClosing(e);
        }
    }
}

这段代码做了几件事：统一字体避免各处不一致，设置合理的内边距防止子控件贴边显示，Anchor 设置保证窗体拉伸时 GroupBox 跟着变化。