WinForms on 纪伟的个人博客

WinForms 学习笔记（八）：WinForms vs WPF——选型与迁移

Sat, 01 Aug 2026 10:00:00 +0800

写在前面

系列收官篇。前面 7 篇学了 WinForms 本身，本篇把它和兄弟框架 WPF 摆一起，做全维度对照、选型决策、迁移路径。

两个框架是"两条路"不是"新旧迭代"。读完这篇你知道什么项目选哪个，以及现有代码要不要迁。

一、本质差异回顾

1
2
3
4
5
6
7


WinForms（2002）：
 Win32 思维 —— 控件 = HWND，GDI+ 绘制，命令式代码 + 设计器
 "简单、稳定、土"

WPF（2006）：
 现代图形思维 —— DirectX 保留模式，XAML 声明式，数据驱动
 "强大、现代、陡"

两者都还活着（.NET 8 支持），不是迭代关系，是两条并行的路。理解这点，选型才不纠结。

二、全维度对照

维度	WinForms	WPF	谁赢
渲染	GDI+（CPU，无硬件加速）	DirectX（GPU，矢量）	WPF
窗口模型	每控件一个 HWND	一窗一 HWND，内部自绘	WPF（缩放/动画好）
UI 描述	C# 代码 + 设计器	XAML（声明式）	看团队
属性系统	普通 CLR 属性	依赖属性（绑定/动画/样式）	WPF
事件	老式 event	路由事件（冒泡/隧道）	WPF
数据绑定	弱（BindingSource/DataGridView）	强（任意属性/Converter/集合视图）	WPF
自定义外观	GDI+ 自绘 / 继承	ControlTemplate（彻底换皮）	WPF
动画	手写 OnPaint + Timer	Storyboard 声明式	WPF
MVVM	可用但不顺	原生支持（社区惯例）	WPF
设计器	VS 拖拽，最强	VS 设计器，可以但不如 WinForms	WinForms
上手速度	快（拖控件挂事件）	慢（XAML + 绑定 + 模板）	WinForms
学习曲线	平缓	陡	WinForms
老代码维护	海量遗留	中等量	平
现代 UI 视觉	难（土）	能（模板/动画/现代控件库）	WPF

一句话：要现代/复杂 UI/数据驱动 → WPF；要快/简单/老代码 → WinForms。

三、各自的主场

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


选 WinForms 的场景：
 ✓ 企业内部工具（ERP/CRM 客户端、数据录入）
 ✓ 工业软件（设备控制、监控面板）
 ✓ 金融终端（行情/交易）
 ✓ 快速原型 / 内部小工具
 ✓ 维护海量遗留代码
 ✓ 团队没 XAML/MVVM 经验，要快速出活

选 WPF 的场景：
 ✓ 需要复杂自定义 UI / 动画 / 现代视觉
 ✓ 数据驱动重（大量绑定、表单、图表）
 ✓ 想用 MVVM 做可测试的工程化架构
 ✓ 需要 DPI 缩放/触控更好的体验
 ✓ 新项目、能接受学习曲线

四、选型决策表

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


你的情况 选
─────────────────────────────────────────────────────
维护老 WinForms 项目 WinForms（别为重构而重构）
快速做个内部小工具（一两天上线） WinForms（拖拽就完事）
复杂自定义 UI / 动画 / 现代 Material WPF
数据密集（大量表单/表格/图表） WPF（绑定强）或 WinForms（DataGridView 够用）
团队熟悉 .NET 但没桌面经验 WinForms 上手快
要 MVVM / 单元测试 ViewModel WPF
要触控 / 高 DPI 精致 WPF
要进 Microsoft Store 都行（MSIX 打包）
跨平台桌面 都不行 → 看 MAUI / Avalonia

没有绝对赢家，看项目周期、团队、UI 复杂度、维护预期。

五、迁移路径

WinForms → WPF

不建议盲目迁。迁移成本高（整套 UI 重写 + XAML + 绑定）。只有这些情况值得迁：

UI 要大幅现代化（原 WinForms 已撑不住视觉需求）
要 MVVM 化提升可测试性 / 团队规模扩大
跨平台考虑（后续可走 MAUI，WPF 和 MAUI 共享 XAML 思路）

迁移要点：

业务逻辑（Model/Service）基本可复用（纯 C#）。
UI 层全部重写（Form → Window，事件 → 命令，DataGridView → DataGrid）。
渐进式：WPF 窗口可 hosted 在 WinForms 里（ElementHost）或反过来（WindowsFormsHost），混合过渡。

WPF → WinForms

极少见。除非：接手的项目 WPF 用得很糟（全 code-behind、没绑定），不如退回 WinForms 简化。一般不迁。

共存

WindowsFormsHost（WPF 里嵌 WinForms 控件）和 ElementHost（WinForms 里嵌 WPF 控件）让两者能混合——迁移过渡期或"核心 WPF + 个别老 WinForms 控件"复用。

六、还要不要学桌面？现代选项

2026 年，纯桌面新项目少（很多上 Web/Electron）。但 .NET 桌面仍有市场：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


.NET 桌面技术谱系：
 WinForms 老、简单、维护多（本系列）
 WPF 现代 XAML、强（姊妹系列 12 篇）
 UWP 退场中（被 WinUI 取代）
 WinUI 3 Windows App SDK，UWP 的继任（现代 Fluent）
 MAUI 跨平台（Win/Mac/iOS/Android），XAML
 Avalonia 第三方跨平台 XAML（类 WPF，社区活跃）

 选型：
 只 Windows + 现代 UI → WinUI 3 / WPF
 跨平台桌面 → MAUI / Avalonia
 老项目维护 / 快速工具 → WinForms / WPF

但别焦虑：WinForms/WPF 在企业/工业/金融仍是主力，几十年不会消失。学会这两个，加上理解了"Win32 思维 vs 现代图形思维"，迁移到 MAUI/WinUI 思路一致（都是 XAML + 绑定系）。

七、系列收官

1
2
3
4
5
6
7
8
9


WinForms 学习笔记 8 篇走完：
 1. WinForms 是什么（Win32 包装、vs WPF）
 2. Form 与控件体系（设计器、partial、控件树）
 3. 事件模型（event、订阅退订、内存泄漏）
 4. GDI+ 绘制（Graphics、OnPaint、双缓冲、自定义控件）
 5. 数据绑定（BindingSource、DataGridView、INPC）
 6. 线程与 async（UI 线程、Invoke、死锁）
 7. 部署（ClickOnce、单文件、签名）
 8. WinForms vs WPF（本篇，选型迁移）

1
2
3
4
5
6


核心收获：
 ✓ WinForms = Win32 包装 + 命令式代码 + 设计器，简单稳
 ✓ 理解 partial class / 控件树 / GDI+ Dispose / 事件退订
 ✓ 单 UI 线程 + Invoke/async + 死锁禁忌（呼应高并发篇）
 ✓ 数据绑定够用（BindingSource/DataGridView）
 ✓ 选型看场景：现代 UI → WPF；快/老项目 → WinForms

和「WPF 学习笔记」12 篇配起来，.NET 桌面两大框架就齐了——选哪个、为什么、怎么迁移，你心里有数。再往新走，MAUI/WinUI 的 XAML 思路一脉相承。

WinForms 学习笔记（七）：部署——ClickOnce、单文件发布与自动更新

Tue, 28 Jul 2026 10:00:00 +0800

写在前面

承接篇6。本篇讲 WinForms 应用怎么打包交付给用户：单文件发布、ClickOnce、自动更新、签名。

WinForms 部署比 Web 复杂：你要把 exe + 依赖装到用户机器、管更新、过 SmartScreen。.NET 8 时代，单文件发布 + ClickOnce 是主力，MSIX 是新选择。

一、dotnet publish：单文件发布

.NET SDK 的 dotnet publish 把应用打包成可分发的产物。最实用的是单文件（self-contained exe，用户机器不用装 .NET）：

1
2
3


dotnet publish -c Release -r win-x64 --self-contained true \
 -p:PublishSingleFile=true \
 -p:IncludeNativeLibrariesForSelfExtract=true

参数：

参数	含义
`-c Release`	Release 编译
`-r win-x64`	目标运行时（WinForms 只能 win-x64/x86）
`--self-contained true`	自包含（带 .NET 运行时，用户免装）
`PublishSingleFile`	打成单个 exe
`IncludeNativeLibrariesForSelfExtract`	原生库也塞进单文件

1
2
3


产物：bin/Release/net8.0-windows/win-x64/publish/MyApp.exe
 → 一个文件（运行时解压到临时目录），双击即跑
 → 拷给用户、放共享盘、U 盘分发都行

自包含单文件约 150MB+（含 .NET 运行时）。要更小用 --self-contained false（框架依赖，~1MB，但用户机器要装 .NET Desktop Runtime）。

二、ReadyToRun / Trim

ReadyToRun（R2R）：预编译成原生机器码，启动更快，体积大些：

1
2


dotnet publish -c Release -r win-x64 --self-contained true \
 -p:PublishSingleFile=true -p:PublishReadyToRun=true

1
2
3
4


ReadyToRun：
 预 JIT 成原生码，启动快 ~20-30%
 体积大 ~30%
 → 启动敏感的工具类应用值得开

Trim（裁剪）：移除没用到的代码，减小体积。WinForms 对 Trim 支持差（大量反射 + 设计器），别开：

1
2


# WinForms 别开 Trim（会运行时缺类型崩）
-p:PublishTrimmed=true # ✗ WinForms 不推荐

WinForms 还不能完全 AOT（NativeAOT），反射 / 设计器 / 资源加载不兼容。要做原生编译，考虑迁 MAUI/WinUI。

三、ClickOnce：老牌自动更新

ClickOnce（.NET Framework 2.0 起）是 WinForms/WPF 的"零摩擦安装 + 自动更新"方案：用户点网页链接 → 装到用户目录（不需管理员）→ 每次启动检查更新。

.NET 8 下 ClickOnce 仍支持（VS 项目属性 → Publish，或 publish 配置），流程：

1
2
3
4


1. dotnet publish 生成 ClickOnce 清单（.application / .manifest）
2. 放到 Web 服务器 / 共享盘 / Azure Blob
3. 用户访问 install.htm → 下载安装
4. 程序每次启动检查更新 → 有新版自动下载替换

VS 里：项目属性 → Publish → ClickOnce 发布向导，设发布位置、更新策略（启动时检查 / 间隔 N 天）、签名。

1
2
3
4
5


ClickOnce 适合：
 ✓ 企业内部工具（用户点链接即装，自动更新，不需管理员权限）
 ✓ 频繁更新的小工具
 ✗ 需要系统服务 / 驱动 / 深度注册表的（ClickOnce 沙箱限制）
 ✗ 需要"商店分发"的现代场景（用 MSIX）

ClickOnce 的更新是"替换整个应用"，大应用更新慢；但它仍是 WinForms 内网分发的最省心方案。

四、MSIX：现代打包

MSIX（Windows 10+）是微软主推的现代应用包格式：干净安装/卸载、沙箱、商店分发、自动更新。

1
2
3
4
5
6


MSIX vs ClickOnce：
 MSIX 现代包格式，干净安装，商店分发，需打包工程
 ClickOnce 老牌，零摩擦，内网/网页分发，更新简单

 → 想进 Microsoft Store / 企业私店 → MSIX
 → 内网快速分发 + 自动更新 → ClickOnce 够用

打包用 Visual Studio 的"Windows 应用程序打包项目"（WAP）或 MakeAppx 工具。MSIX 要签名（证书），企业分发用内部 CA，商店分发用 MS Store 关联。

五、自动更新实现

不用 ClickOnce/MSIX，自己实现"启动时检查 + 下载 + 替换"：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


// 简化版自动更新
private async void Form1_Load(object sender, EventArgs e)
{
 var latest = await CheckLatestVersionAsync();
 if (latest.Version > CurrentVersion)
 {
 if (MessageBox.Show($"发现新版本 {latest.Version}，更新?",
 "更新", MessageBoxButtons.YesNo) == DialogResult.Yes)
 {
 await DownloadAndUpdateAsync(latest.Url);
 Application.Restart(); // 重启加载新版本
 }
 }
}

要点：

版本号放一个可访问的地方（API/文件），启动时拉取对比。
下载新 exe 到临时目录，替换主程序（可能需 bat 脚本辅助，运行中的 exe 不能直接覆盖）。
用 ClickOnce/MSIX 省事；自实现适合特殊场景。

开源方案：Velopack、Squirrel.Windows，封装了检查/下载/替换/快捷方式全套。

六、代码签名

Windows SmartScreen 对未签名 exe 会弹警告（蓝屏"Windows 已保护你的电脑"）。企业/正式分发必须签名：

1
2
3
4


签名方式：
 代码签名证书（EV / OV）+ signtool.exe
 EV 证书 立即过 SmartScreen（贵，要硬件 token）
 OV 证书 需积累信誉，初期仍弹 SmartScreen

1
2


signtool sign /fd sha256 /a /tr http://timestamp.sectigo.com /td sha256 \
 /n "Your Company Name" MyApp.exe

内部分发用自签名证书（企业 CA 推到用户机器的根证书）；公网分发用商业代码签名证书。

七、部署选型

1
2
3
4
5
6
7
8


你的场景 推荐
──────────────────────────────────────────────────────
个人/小工具，拷给朋友 单文件 exe（U 盘/网盘）
企业内部，频繁更新 ClickOnce（网页/共享盘 + 自动更新）
进 Microsoft Store / 企业私店 MSIX
要启动快 单文件 + ReadyToRun
要正式分发，过 SmartScreen 商业代码签名 + 单文件/MSIX
自动更新不想自己造 Velopack / Squirrel

八、小结

1
2
3
4
5
6
7


WinForms 部署核心：
 ✓ dotnet publish --self-contained + PublishSingleFile = 单 exe 分发
 ✓ ReadyToRun 加速启动（体积换启动）；Trim 别开
 ✓ ClickOnce：内网零摩擦安装 + 自动更新（最省心）
 ✓ MSIX：现代包，适合商店/企业私店
 ✓ 自动更新：ClickOnce/MSIX 自带；或 Velopack/Squirrel
 ✓ 正式分发必须代码签名（过 SmartScreen）

下一篇：WinForms vs WPF——两个框架对照、选型决策、迁移路径，系列收官。

WinForms 学习笔记（六）：线程与 async——UI 线程、Invoke 与死锁

Fri, 24 Jul 2026 10:00:00 +0800

写在前面

承接篇5。本篇讲 WinForms 的线程模型：UI 线程、跨线程访问的坑、Control.Invoke、async/await，以及经典死锁。

WinForms 是单 UI 线程架构：所有控件操作必须在创建它们的那个线程（UI 线程）。后台线程碰控件会抛 InvalidOperationException。理解线程模型 + async，才能做"后台加载不卡 UI"和"不被死锁咬到"。

本篇的死锁部分，和本站「.NET 高并发编程全景」的 async 死锁节是同一套机制——WinForms 的 WindowsFormsSynchronizationContext 正是死锁三宿主之一。

一、单 UI 线程模型

1
2
3
4
5


WinForms 线程模型：
 - 主线程 = UI 线程，跑消息循环（Application.Run）
 - 所有控件由 UI 线程创建，只能由 UI 线程访问
 - 耗时操作放 UI 线程 → 界面卡死（消息循环阻塞）
 - 后台线程碰控件 → InvalidOperationException

1
2
3
4
5
6


// 错：后台线程直接改控件
Task.Run(() =>
{
 Thread.Sleep(2000);
 button1.Text = "Done"; // 💥 InvalidOperationException：跨线程访问
});

异常信息：“跨线程操作无效：控件 ‘button1’ 从不是创建它的线程访问它。”

这是 WinForms 的线程亲和：控件绑定创建线程。和 WPF 的 Dispatcher 同理，只是 WPF 报错更友好、WinForms 默认在 Debug 抛 / Release 可能不抛（行为不可预期，别赌）。

二、Control.Invoke / BeginInvoke：回到 UI 线程

后台线程要改控件，把操作投递回 UI 线程执行：Control.Invoke（同步）/ BeginInvoke（异步）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 后台线程把 UI 更新投递回 UI 线程
Task.Run(() =>
{
 var data = DownloadSlowly(); // 后台跑
 button1.BeginInvoke(() => // 投递回 UI 线程
 {
 button1.Text = "Done";
 textBox1.Text = data; // 在 UI 线程访问控件，安全
 });
});

1
2
3
4
5
6


Invoke vs BeginInvoke：
 Invoke 同步：投递 + 等 UI 线程执行完才返回（后台线程阻塞）
 BeginInvoke 异步：投递 + 立即返回（后台线程继续）

 → 绝大多数场景用 BeginInvoke（不阻塞后台线程）
 → Invoke 慎用：后台线程等 UI 线程，UI 线程若也卡 → 死锁

InvokeRequired 属性判断当前是否不在 UI 线程（线程安全的控件更新套路：if InvokeRequired → BeginInvoke 转发）。

三、async/await：现代写法

.NET 4.5+ 的 async/await 大幅简化：await 后的代码自动回到 UI 线程（因为 WindowsFormsSynchronizationContext），不用手写 Invoke。

1
2
3
4
5
6
7
8


private async void btnLoad_Click(object sender, EventArgs e)
{
 btnLoad.Enabled = false;
 var data = await Task.Run(() => DownloadSlowly()); // 后台跑
 // await 之后自动回到 UI 线程：
 textBox1.Text = data; // 安全，不用 Invoke
 btnLoad.Enabled = true;
}

1
2
3
4
5


async/await 的妙处：
 - 写起来像同步（顺序代码），实际异步
 - await 处释放 UI 线程（不卡）
 - await 之后由 SyncContext 自动续接到 UI 线程
 - 不用手写 Invoke/BeginInvoke

async void 仅用于事件处理器（btnLoad_Click）。其他地方用 async Task。async void 的坑：异常无法被调用方 await、不可控。

四、WindowsFormsSynchronizationContext：为什么 await 回 UI 线程

WinForms 在 Application.Run 时安装 WindowsFormsSynchronizationContext，它把 Post（投递延续）实现为"塞进 UI 消息队列"。await 默认捕获当前 SyncContext，延续 Post 回它 → 回到 UI 线程。

1
2
3
4
5
6
7
8


await 的内部：
 1. UI 线程跑到 await Task.Run(...)
 2. 捕获当前 SynchronizationContext = WindowsFormsSynchronizationContext
 3. Task.Run 在线程池跑 DownloadSlowly
 4. UI 线程从 await 处返回，继续跑消息循环（不卡）
 5. DownloadSlowly 完成，延续要跑
 6. SyncContext.Post 把延续塞进 UI 消息队列
 7. UI 线程消息循环取出，执行延续（textBox1.Text = data）

关键：UI 线程从 await 处"释放"了（回去跑消息循环），不是阻塞等。这是 async 不卡 UI 的根本。和 WPF 的 DispatcherSynchronizationContext、老 ASP.NET 的 AspNetSynchronizationContext 同构。

五、.Result 死锁：经典坑

最经典、咬人最狠的坑：UI 线程上 await 一个未完成的 Task 时，用 .Result/.Wait() 同步阻塞 → 死锁。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


// 💥 死锁代码
private void button1_Click(object sender, EventArgs e) // UI 线程
{
 var data = GetDataAsync().Result; // 同步阻塞 UI 线程
 textBox1.Text = data;
}

private async Task<string> GetDataAsync()
{
 var json = await httpClient.GetStringAsync(url); // 默认 ConfigureAwait(true)
 return Parse(json);
}

死锁过程：

1
2
3
4
5


1. UI 线程调 GetDataAsync().Result → 阻塞自己等 Task 完成
2. GetDataAsync 跑到 await，返回，延续注册"完成后回 UI 线程"
3. HTTP 数据回来，延续想在 UI 线程上跑（SyncContext 要求）
4. 但 UI 线程被 .Result 堵着，腾不出手
5. 延续等 UI 线程 → Task 永远完不成 → .Result 永远等 → 死锁

两种解法：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// 解法一：一路 async 到顶（推荐）
private async void button1_Click(object sender, EventArgs e)
{
 var data = await GetDataAsync(); // 不阻塞 UI 线程
 textBox1.Text = data;
}

// 解法二：库代码一律 ConfigureAwait(false)
private async Task<string> GetDataAsync()
{
 var json = await httpClient.GetStringAsync(url).ConfigureAwait(false); // 不回 UI 线程
 return Parse(json);
}

详见本站「.NET 高并发编程全景 · async 死锁节」——同一套 SynchronizationContext 阻塞机制，WPF / 老 ASP.NET / WinForms 都中招，ASP.NET Core 不中招（无 SyncContext）。

六、Task.Run 的正确姿势

后台跑耗时操作用 Task.Run，但要分清"I/O 绑定"和"CPU 绑定"：

1
2
3
4
5
6


CPU 绑定（计算密集）：用 Task.Run
 await Task.Run(() => HeavyCompute());

I/O 绑定（网络/文件/数据库）：用原生异步 API，不要 Task.Run 包
 await httpClient.GetStringAsync(url); // ✓ 底层 IOCP 异步
 await Task.Run(() => httpClient.GetString(url)); // ✗ 多此一举，还占线程池

误用 Task.Run 包 I/O：等于"在线程池线程里阻塞等网络"，浪费一个线程。I/O 用原生 async API 才是真异步。

七、进度与取消

后台任务要报告进度 + 可取消，用 IProgress<T> + CancellationToken：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


private async void btnStart_Click(object sender, EventArgs e)
{
 var cts = new CancellationTokenSource();
 var progress = new Progress<int>(p => progressBar1.Value = p); // 回调自动在 UI 线程

 try
 {
 await Task.Run(() => DoWork(progress, cts.Token));
 MessageBox.Show("完成");
 }
 catch (OperationCanceledException) { MessageBox.Show("已取消"); }
}

private void DoWork(IProgress<int> progress, CancellationToken ct)
{
 for (int i = 0; i <= 100; i++)
 {
 ct.ThrowIfCancellationRequested();
 Thread.Sleep(50); // 模拟干活
 progress.Report(i); // 报告进度（IProgress 自动转到 UI 线程）
 }
}

要点：

Progress<T> 的回调在创建它的线程（UI 线程）触发——不用手 Invoke。
CancellationToken 一路传到底，取消时 ThrowIfCancellationRequested 抛异常，冒泡到调用方。
这两套取代了老的 BackgroundWorker（下面提）。

八、BackgroundWorker（老的，了解即可）

.NET 2.0 时代的后台任务组件，封装了"后台跑 + 进度 + 取消 + 回 UI 线程"，在 async/await 之前是主流：

1
2
3
4
5


var worker = new BackgroundWorker { WorkerReportsProgress = true, WorkerSupportsCancellation = true };
worker.DoWork += (s, e) => { /* 后台跑 */ e.Result = Compute(); };
worker.ProgressChanged += (s, e) => progressBar1.Value = e.ProgressPercentage; // 自动 UI 线程
worker.RunWorkerCompleted += (s, e) => textBox1.Text = e.Result.ToString(); // 自动 UI 线程
worker.RunWorkerAsync();

新代码用 async/await + Progress + CancellationToken，别再用 BackgroundWorker。维护老代码能看懂即可。

九、小结

1
2
3
4
5
6
7
8


WinForms 线程核心：
 ✓ 单 UI 线程，控件只能由 UI 线程访问
 ✓ 后台碰控件 → InvalidOperationException
 ✓ 回 UI 线程：Invoke（同步）/ BeginInvoke（异步）/ async-await（自动）
 ✓ await 默认回 UI 线程（WindowsFormsSynchronizationContext）
 ✓ 死锁禁忌：UI 线程上 .Result/.Wait() 阻塞 async 方法
 ✓ 解法：async all the way 或库代码 ConfigureAwait(false)
 ✓ 进度用 IProgress<T>，取消用 CancellationToken（取代 BackgroundWorker）

下一篇：部署——ClickOnce、单文件发布、ReadyToRun、自动更新。

WinForms 学习笔记（五）：数据绑定——BindingSource、DataGridView 与 INPC

Mon, 20 Jul 2026 10:00:00 +0800

写在前面

承接篇4。本篇讲 WinForms 的数据绑定：BindingSource、BindingList、INotifyPropertyChanged、DataGridView。

WinForms 的数据绑定比 WPF 弱很多（没有 XAML 那套强大绑定系统），但做"表单 ↔ 对象"“列表 ↔ DataGridView"这种典型场景完全够用。理解它的模型，你能在 WinForms 里把数据驱动 UI 做得不错——只是不如 WPF 优雅。

一、WinForms 数据绑定模型

两类绑定：

1
2
3
4
5
6
7
8
9


简单绑定（Simple Binding）：
 控件的某属性 ↔ 数据对象的某属性（一对一）
 textBox1.DataBindings.Add("Text", obj, "Name"); // textBox.Text ↔ obj.Name

复杂绑定（Complex Binding）：
 控件 ↔ 数据集合（一对多）
 dataGridView1.DataSource = list; // 整个表 ↔ 列表
 comboBox1.DataSource = list;
 comboBox1.DisplayMember = "Name";

数据流向（DataSourceUpdateMode）：

1
2
3


OnValidation 默认，控件失焦校验后回写源
OnPropertyChanged 源属性变就回写
Never 只单向（源→控件），不回写

二、INotifyPropertyChanged：让对象"可观察”

数据源要通知 UI"我变了"，实现 INotifyPropertyChanged：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class User : INotifyPropertyChanged
{
 private string _name;
 public string Name
 {
 get => _name;
 set { if (_name != value) { _name = value; OnPropertyChanged(nameof(Name)); } }
 }

 public event PropertyChangedEventHandler PropertyChanged;
 protected void OnPropertyChanged(string n) =>
 PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(n));
}

1
2
3
4


没实现 INPC：
 obj.Name 改了，绑定的 textBox 不刷新（UI 还是旧值）
实现了 INPC：
 obj.Name 改 → 触发 PropertyChanged → 绑定系统听到 → 刷新 textBox

WPF 里 INPC 是主角；WinForms 里同样要 INPC 才能让"对象 → 控件"方向自动刷新。C# 现代写法用 CommunityToolkit.Mvvm 的 [ObservableProperty] 源生成器省样板（第 6 篇会提）。

三、BindingList：可观察集合

列表场景，改集合（增删元素）要通知 UI 刷新，用 BindingList<T>（WinForms 专用）：

1
2
3
4
5
6


var users = new BindingList<User> { new() { Name = "张三" }, new() { Name = "李四" } };
dataGridView1.DataSource = users;

// 增删自动反映到 DataGridView
users.Add(new User { Name = "王五" }); // 表格立即多一行
users.RemoveAt(0); // 表格立即少一行

1
2
3
4
5
6


ObservableCollection<T>（WPF 用）vs BindingList<T>（WinForms 用）：
 ObservableCollection 集合变更通知（Add/Remove）→ UI 刷新
 BindingList 集合变更通知 + 元素属性变更（INPC）→ UI 刷新 + 可编辑

 WinForms 的 DataGridView 对 BindingList 支持最好（行编辑、排序）
 两者都实现了 IList/IBindingList，互转不难

WinForms 优先用 BindingList<T>；要和 WPF 共享代码用 ObservableCollection<T> 再包装。

四、BindingSource：绑定中枢

BindingSource 是 WinForms 绑定的中间层——你把集合给它，控件绑它。它统一了列表/对象/DataTable 的绑定接口，并提供导航（Position/Current）、排序、过滤。

1
2
3
4
5
6
7


var bs = new BindingSource { DataSource = users };
dataGridView1.DataSource = bs; // 控件绑 BindingSource（不是直接绑 list）

bs.PositionChanged += (s, e) => // 当前选中行变化
 Text = $"选中: {((User)bs.Current).Name}";

bs.Add(new User { Name = "赵六" }); // 通过 bs 增删

1
2
3
4
5


为什么用 BindingSource：
 ✓ 统一接口（list/object/DataTable 都能 DataSource）
 ✓ 导航（Position/Current/MoveNext）
 ✓ 排序/过滤（Sort/Filter，绑 DataTable 时）
 ✓ 解耦：控件绑 bs，bs 绑数据；换数据源只动 bs

复杂表单/主从表（两个 DataGridView 联动）几乎必用 BindingSource。简单单控件绑定可以跳过它直接 DataBindings.Add。

五、DataGridView：数据绑定主力

DataGridView 是 WinForms 表格控件，绑集合/DataTable 后自动生成列，支持编辑、排序、选择：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// 简单绑定
dataGridView1.DataSource = users;

// 控制：自动生成列关掉，手定义
dataGridView1.AutoGenerateColumns = false;
dataGridView1.Columns.Add(new DataGridViewTextBoxColumn
{
 DataPropertyName = "Name", // 绑定到 User.Name
 HeaderText = "姓名",
 Width = 150
});
dataGridView1.Columns.Add(new DataGridViewCheckBoxColumn
{
 DataPropertyName = "IsActive",
 HeaderText = "启用"
});
dataGridView1.DataSource = users;

常用能力：

能力	怎么用
编辑	`ReadOnly = false`（默认可编辑，改完回写源）
排序	点列头自动排序（绑 DataTable/BindingList 支持）
选择	`SelectionMode`（FullRowSelect 等）
主从表	两个 DataGridView，主表的 BindingSource 作为从表 DataSource
单元格样式	`RowsDefaultCellStyle` / `CellFormatting` 事件

1
2
3
4
5
6


// 按条件着色：Active=false 的行标红
private void grid_CellFormatting(object s, DataGridViewCellFormattingEventArgs e)
{
 if (dataGridView1.Rows[e.RowIndex].DataBoundItem is User u && !u.IsActive)
 e.CellStyle.BackColor = Color.MistyRose;
}

DataGridView 是 WinForms 表格场景的瑞士军刀，大数据量时考虑 VirtualMode（虚拟模式，只渲染可见行）。

六、主从表（主从绑定）

两个表联动：选主表一行，从表显示对应明细。BindingSource 让这很简单：

1
2
3
4
5
6
7
8
9


// 主：订单列表
var orders = new BindingList<Order> { /* ... */ };
var bsOrders = new BindingSource { DataSource = orders };

// 从：通过 DataMember 指定"订单的明细集合属性"
var bsDetails = new BindingSource { DataSource = bsOrders, DataMember = "Details" };

gridOrders.DataSource = bsOrders; // 主表
gridDetails.DataSource = bsDetails; // 从表（随主表选中自动联动）

选 gridOrders 一行 → bsOrders.Current 变 → bsDetails 自动显示该订单的 Details。

七、WinForms vs WPF 绑定对比

维度	WinForms	WPF
绑定声明	代码 `DataBindings.Add` / 设计器	XAML `{Binding}` 声明式
绑定目标	控件属性 ↔ 对象属性（有限）	任意 DP ↔ 任意属性
Converter	`Format`/`Parse` 事件（简陋）	`IValueConverter`（强大）
集合控件	DataGridView + BindingList	ItemsControl + ObservableCollection + DataTemplate
验证	`Validating` 事件 / ErrorProvider	ValidationRule / INotifyDataErrorInfo
模板	DataGridView 列样式（有限）	DataTemplate（任意外观）

1
2
3


一句话：
 WinForms 绑定 = 够用的表单/表格双向
 WPF 绑定 = 任意 UI 任意数据的声明式绑定，配合模板无敌

八、小结

1
2
3
4
5
6
7


WinForms 数据绑定核心：
 ✓ 简单绑定：DataBindings.Add("控件属性", 源, "源属性")
 ✓ 复杂绑定：DataSource = 集合（DataGridView/ComboBox）
 ✓ 数据源实现 INotifyPropertyChanged → 控件自动刷新
 ✓ 列表用 BindingList<T>（增删 + 元素属性变更都通知）
 ✓ BindingSource 是绑定中枢（导航/排序/过滤/主从）
 ✓ DataGridView 是表格主力（编辑/排序/主从/CellFormatting）

下一篇：线程与 async——UI 线程模型、Control.Invoke、async/await，以及 WinForms 经典的 .Result 死锁（呼应本站高并发篇）。

WinForms 学习笔记（四）：GDI+ 绘制——Graphics、OnPaint 与自定义控件

Thu, 16 Jul 2026 10:00:00 +0800

写在前面

承接篇3。本篇讲 WinForms 自定义绘制的核心：GDI+、Graphics、OnPaint、双缓冲、自定义控件。

WinForms 的"外观"分两类：控件自带外观（Button 长啥样系统定）和自绘外观（你在 OnPaint 里画）。后者就是 GDI+ 的地盘——画文字、线条、矩形、图片，做仪表盘、图表、自定义按钮。理解 GDI+，你才能做 WinForms 里任何"非标准"的视觉。

一、GDI+ 是什么

GDI+ 是 Windows 的 2D 图形库（Win32 GDI 的升级），System.Drawing 命名空间封装它。核心是 Graphics 对象——你的"画布"，所有绘制都通过它。

1
2
3
4
5
6
7


GDI+ 三件套：
 Graphics 画布（绑定到某控件/位图的 HDC）
 Pen 画线/边框（颜色、粗细、虚线）
 Brush 填充（纯色/渐变/纹理）
 + Font/Color/Image 等辅助

 绘制 = Graphics.用 Pen/Brush 画形状 + 用 Font 写字

二、OnPaint：绘制入口

控件每次需要重绘时（首次显示、被遮挡后露出、手动 Invalidate()），触发 Paint 事件，你重写 OnPaint 或挂 Paint 事件来画：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


public class MyPanel : Panel
{
 protected override void OnPaint(PaintEventArgs e)
 {
 base.OnPaint(e);
 var g = e.Graphics; // 这次绘制的 Graphics
 g.Clear(Color.White);
 g.DrawString("Hello", Font, Brushes.Black, 10, 10);
 g.DrawRectangle(Pens.Red, 50, 50, 100, 60);
 }
}

PaintEventArgs 给你 Graphics 和 ClipRectangle（需要重绘的区域，优化用）。

别缓存 Graphics——每次 Paint 的 Graphics 是新的，用完即弃。CreateGraphics() 能拿到一个，但别用它做持续绘制（不随重绘刷新，会被擦掉），只在响应鼠标实时画（橡皮线）时用。

三、Graphics 常用方法

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27


var g = e.Graphics;

// 文字
g.DrawString("文本", font, brush, x, y);
g.DrawString("文本", font, brush, rect, format); // 带布局

// 线
g.DrawLine(pen, x1, y1, x2, y2);
g.DrawLines(pen, points); // 折线
g.DrawCurve(pen, points); // 平滑曲线

// 形状（描边用 Pen，填充用 Brush）
g.DrawRectangle(pen, x, y, w, h);
g.FillRectangle(brush, x, y, w, h);
g.DrawEllipse(pen, x, y, w, h); // 圆/椭圆
g.FillEllipse(brush, x, y, w, h);
g.DrawPolygon(pen, points);
g.DrawArc(pen, x, y, w, h, startAngle, sweepAngle); // 弧/饼图

// 图片
g.DrawImage(image, x, y);
g.DrawImage(image, destRect, srcRect, GraphicsUnit.Pixel); // 缩放/裁剪

// 变换
g.TranslateTransform(dx, dy); // 平移
g.ScaleTransform(sx, sy); // 缩放
g.RotateTransform(angle); // 旋转

四、Pen/Brush/Font：GDI+ 对象必须 Dispose

Pen、Brush、Font、Bitmap 都是非托管资源（包装 GDI 句柄），不用了必须 Dispose，否则句柄泄漏。

1
2
3
4
5
6
7


// 正确：using 包裹
using var pen = new Pen(Color.Red, 2);
using var brush = new SolidBrush(Color.Blue);
using var font = new Font("Arial", 12);
e.Graphics.DrawRectangle(pen, 10, 10, 100, 60);
e.Graphics.FillRectangle(brush, 10, 10, 100, 60);
// using 结束自动 Dispose

1
2
3
4


哪些要 Dispose：
 ✓ Pen / Brush / Font / Bitmap / Graphics（自己 CreateGraphics 创建的）
 ✗ Brushes.Red / Pens.Black 等系统内置（共享，别 Dispose）
 ✗ Paint 事件里的 e.Graphics（系统管，别 Dispose）

经验：用了 new 创建的 GDI+ 对象，都要 Dispose。系统内置（Brushes.Xxx/Pens.Xxx/SystemFonts.Xxx）是共享单例，别动。

五、双缓冲：解决闪烁

WinForms 默认直接画到屏幕，复杂绘制会闪烁（先擦白再画，肉眼可见）。解决：双缓冲——先画到内存位图，完成后一次性贴到屏幕。

1
2
3
4
5
6
7
8


public class MyPanel : Panel
{
 public MyPanel()
 {
 DoubleBuffered = true; // 开双缓冲（最简单）
 // 或 SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
 }
}

1
2
3


为什么闪烁：
 无双缓冲：擦白 → 画 A → 画 B → ... 每步都上屏，肉眼见过程 → 闪烁
 双缓冲： 在内存位图画完整帧 → 一次贴屏 → 看不到过程

自定义控件绘制（尤其动画/重绘频繁），默认开双缓冲。

六、自定义控件：重写 OnPaint

做个"圆形按钮"演示自绘：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31


public class RoundButton : Control
{
 public Color FillColor { get; set; } = Color.SteelBlue;

 public RoundButton()
 {
 DoubleBuffered = true;
 ResizeRedraw = true; // 尺寸变就重绘
 Size = new Size(80, 80);
 }

 protected override void OnPaint(PaintEventArgs e)
 {
 var g = e.Graphics;
 g.SmoothingMode = SmoothingMode.AntiAlias; // 抗锯齿

 var rect = new Rectangle(0, 0, Width - 1, Height - 1);

 using var brush = new SolidBrush(FillColor);
 g.FillEllipse(brush, rect); // 填充圆

 using var pen = new Pen(Color.DarkBlue, 2);
 g.DrawEllipse(pen, rect); // 描边

 // 居中文字
 var sf = new StringFormat { Alignment = StringAlignment.Center,
 LineAlignment = StringAlignment.Center };
 using var font = new Font("Arial", 10, FontStyle.Bold);
 g.DrawString(Text, font, Brushes.White, rect, sf);
 }
}

要点：

继承 Control（或 Panel/Button），重写 OnPaint。
SmoothingMode.AntiAlias 开抗锯齿，边缘平滑。
ResizeRedraw = true 让尺寸变化时重绘。
所有 new 的 GDI+ 对象 Dispose。

七、触发重绘：Invalidate

OnPaint 只在系统认为需要重绘时调用。你改了数据想让画面更新，要主动触发：

1
2
3
4
5


// 改了某属性后让控件重绘
this.Invalidate(); // 整个区域
this.Invalidate(dirtyRect); // 只重绘某区域（性能优）

// 不要直接调 OnPaint / CreateGraphics 画

Invalidate 是异步的（标记脏，等下次 WM_PAINT 消息处理）。要立即刷新用 Update()（立即处理重绘），但通常不必。

八、DPI 感知

高 DPI 屏幕（4K 笔记本），WinForms 默认会模糊或错位。.NET 8 + WinForms 改进：app.manifest 设 DPI 感知。

1
2
3
4
5
6


<!-- app.manifest -->
<application xmlns="urn:schemas-microsoft-com:asm.v3">
 <windowsSettings>
 <dpiAwareness xmlns="http://schemas.microsoft.com/SMI/2016/WindowsSettings">PerMonitorV2</dpiAwareness>
 </windowsSettings>
</application>

PerMonitorV2 是现代标准（每个显示器独立 DPI）。.NET 8 下 WinForms 对 PerMonitorV2 支持大幅改善。绘制时用 DeviceDpi 缩放坐标/字号，别写死像素。

九、GDI+ vs 其他

1
2
3
4
5
6


GDI+（WinForms） CPU 绘制，简单，性能一般，无硬件加速
Direct2D（UWP/Win2D） GPU 加速，快，但 API 复杂
DirectX（WPF） GPU 保留模式，矢量，动画友好

 → WinForms 想要 GPU 加速的复杂图形：嵌 Win2C 或直接上 WPF
 → 简单仪表/图表/自绘控件：GDI+ 够用

十、踩坑速记

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


坑 1：GDI+ 对象不 Dispose → 句柄泄漏，久了崩或画错
 → new 的 Pen/Brush/Font/Bitmap 全 Dispose（using）

坑 2：闪烁
 → DoubleBuffered = true

坑 3：CreateGraphics 画的图被擦掉
 → 持续内容画在 OnPaint；CreateGraphics 只用于实时交互（橡皮线）

坑 4：高 DPI 模糊/错位
 → app.manifest 开 PerMonitorV2 + 绘制按 DeviceDpi 缩放

坑 5：OnPaint 里每次 new Font
 → 字体复用（字段缓存），别每帧 new

十一、小结

1
2
3
4
5
6
7


GDI+ 绘制核心：
 ✓ Graphics 是画布；OnPaint 是绘制入口；Invalidate 触发重绘
 ✓ Pen/Brush/Font/Bitmap 是非托管，new 了必 Dispose
 ✓ 系统内置 Brushes.Xxx/Pens.Xxx 共享，别 Dispose
 ✓ 双缓冲（DoubleBuffered）防闪烁
 ✓ 自定义控件 = 继承 Control + 重写 OnPaint
 ✓ 高 DPI 用 PerMonitorV2 + 按 DeviceDpi 缩放

下一篇：数据绑定——BindingSource、BindingList<T>、DataGridView、INotifyPropertyChanged，WinForms 比 WPF 弱但仍能用的绑定体系。

WinForms 学习笔记（三）：事件模型——老式 event 与内存泄漏陷阱

Sun, 12 Jul 2026 10:00:00 +0800

写在前面

承接篇2。本篇讲 WinForms 的事件驱动模型：老式 .NET event、订阅退订的讲究，以及最经典的坑——没退订导致的内存泄漏。

WinForms 是事件驱动的：用户点按钮 → 触发 Click 事件 → 你的处理函数跑。整个 UI 编程就是"挂事件、写处理函数"。但 .NET 的 event 模型有个反直觉的特性：订阅了不退订，会内存泄漏。这一篇把这个坑讲透。

一、.NET event 基础回顾

1
2
3
4
5
6
7
8
9


// 声明
public event EventHandler<EventArgs> SomethingHappened;

// 触发
SomethingHappened?.Invoke(this, EventArgs.Empty);

// 订阅 / 退订
obj.SomethingHappened += Handler;
obj.SomethingHappened -= Handler;

event 本质是封装的委托（只能 +=/-=，不能外部直接赋值或触发）。EventHandler 标准签名：(object sender, EventArgs e)。

WinForms 控件的事件都是这个模型：Button.Click、TextBox.TextChanged、Form.FormClosing……

二、WinForms 里怎么挂事件

方式一：设计器挂接（最常用）

在 VS 属性面板的"事件"页，双击事件 → 生成处理函数 + 在 .Designer.cs 里 +=：

1
2
3
4
5


// .Designer.cs
this.button1.Click += button1_Click;

// Form1.cs
private void button1_Click(object sender, EventArgs e) { ... }

方式二：代码挂接

1
2
3


button1.Click += Button1_Click;
// 或 lambda
button1.Click += (s, e) => MessageBox.Show("clicked");

lambda 挂接的坑：lambda 没名字，无法 -= 退订（后面内存泄漏会讲）。要退订的事件，别用 lambda。

三、订阅与退订：为什么要退订

关键认知：事件订阅是引用链——事件源（被 += 的对象）持有订阅者（处理函数的 target）的引用。

1
2
3
4


事件源.button1.Click (委托链)
 → 持有 → Form 处理函数的 target（通常 this / Form 实例）

 即：button1 活着，就持有 Form，Form 不能被 GC

这在 Form 内部通常没事（Form 和 button1 同寿）。但跨对象订阅时，泄漏就来了：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 泄漏场景：短寿命的 DetailForm 订阅长寿命的 EventBus 事件
public class DetailForm : Form
{
 public DetailForm(EventBus bus)
 {
 bus.DataChanged += OnDataChanged; // 订阅
 }
 void OnDataChanged(object s, EventArgs e) { ... }
 // DetailForm 关闭时，忘了 bus.DataChanged -= OnDataChanged
}

1
2
3
4
5
6
7
8


泄漏链：
 EventBus（长寿命，singleton）
 .DataChanged (委托链)
 → 持有 → DetailForm 实例（闭包 target）

 DetailForm 关闭后，本该被 GC
 但 EventBus 的事件链还持有它 → 永远活着 → 泄漏
 每开一次 DetailForm 泄漏一个，内存蹭蹭涨

修复：DetailForm 关闭时退订：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


public class DetailForm : Form
{
 private readonly EventBus _bus;
 public DetailForm(EventBus bus) { _bus = bus; _bus.DataChanged += OnDataChanged; }

 void OnDataChanged(object s, EventArgs e) { ... }

 protected override void OnFormClosed(FormClosedEventArgs e)
 {
 _bus.DataChanged -= OnDataChanged; // 关键：退订
 base.OnFormClosed(e);
 }
}

规则：谁订阅谁退订。订阅的逆操作必须在订阅者生命周期结束时执行（Dispose / FormClosed）。

四、内存泄漏的三种典型场景

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


场景 1：短寿命对象订阅长寿命对象事件（最常见）
 → 上面 DetailForm + EventBus 例子
 → 修复：短寿命对象销毁时退订

场景 2：lambda 捕获 this
 longLived.Event += () => this.DoSomething();
 → lambda 闭包持有 this，longLived 活着就持有 this
 → 修复：别用 lambda 捕获 this 订阅长寿命事件；用方法 + 显式 -=

场景 3：忘了退订的事件处理函数持有大对象
 → 处理函数 target 持有大 Bitmap/Form，不退订就一直不释放
 → 修复：同上，规则退订

五、弱事件：让事件源不持有订阅者

如果订阅者生命周期不可控（插件、动态加载的 Form），手动退订麻烦，弱事件模式让事件源不阻止订阅者被 GC：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


// 用 WeakReference 包装订阅者（简化版弱事件）
public class WeakEvent<TArgs> where TArgs : EventArgs
{
 private readonly List<WeakReference> _handlers = new();
 public void Add(EventHandler<TArgs> h) => _handlers.Add(new WeakReference(h));

 public void Raise(object sender, TArgs args)
 {
 for (int i = _handlers.Count - 1; i >= 0; i--)
 {
 if (_handlers[i].Target is EventHandler<TArgs> h)
 h(sender, args);
 else
 _handlers.RemoveAt(i); // 已被 GC 的清理掉
 }
 }
}

生产别自己造：WPF 有内置 WeakEventManager，WinForms 没原生弱事件，但可用 WeakReference 封装或第三方库。原则：长寿命事件源 + 不可控订阅者用弱事件。

六、Form 与 Application 级事件

WinForms 几个常用生命周期事件：

事件	触发时机	典型用途
`Form.Load`	窗体首次显示前	初始化数据、读配置
`Form.FormClosing`	关闭前（可取消）	“确定退出?“弹窗、`e.Cancel = true`
`Form.FormClosed`	关闭后	退订事件、释放资源
`Application.Idle`	消息队列空时	偶尔做的后台轻任务（已少用）
`Application.ApplicationExit`	进程退出	全局清理

1
2
3
4
5


private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
 if (MessageBox.Show("确定退出?", "确认", MessageBoxButtons.YesNo) == DialogResult.No)
 e.Cancel = true; // 阻止关闭
}

FormClosing（ing，可取消）vs FormClosed（ed，已关闭，不可逆）——命名一致：ing 在前可干预，ed 在后已发生。

七、自定义事件

写自己的控件/组件时，常要发自定义事件：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


public class MyTimer : Component
{
 // 1. 声明事件
 public event EventHandler<TickEventArgs> Tick;

 // 2. 触发（受保护的虚方法，子类可重写）
 protected virtual void OnTick(TickEventArgs e) => Tick?.Invoke(this, e);

 internal void Fire() => OnTick(new TickEventArgs { Count = ++_count });
 private int _count;
}

public class TickEventArgs : EventArgs
{
 public int Count { get; set; }
}

要点：

事件用 EventHandler<TArgs> 标准签名（(object sender, TArgs e)）。
EventArgs 子类装事件数据；无数据的用 EventArgs.Empty。
触发用受保护虚方法 OnXxx，子类可重写拦截。

八、小结

1
2
3
4
5
6
7


WinForms 事件核心：
 ✓ event 是封装的委托；+= 订阅、-= 退订
 ✓ 事件订阅是引用链：源持有订阅者 → 阻止 GC
 ✓ 规则：谁订阅谁退订（FormClosed/Dispose 里 -=）
 ✓ lambda 订阅无法退订 → 慎用于长寿命事件
 ✓ Form.Load/FormClosing/FormClosed 是常用生命周期事件
 ✓ 自定义事件用 EventHandler<TArgs> + OnXxx 虚方法

下一篇：GDI+ 绘制——Graphics、OnPaint、双缓冲、自定义控件，以及 GDI+ 对象的 Dispose。

WinForms 学习笔记（二）：Form 与控件体系——设计器与控件树

Wed, 08 Jul 2026 10:00:00 +0800

写在前面

承接篇1。本篇拆解 WinForms 的代码组织核心：设计器生成的 .Designer.cs、partial class 机制、控件树、.resx 资源，以及常用控件和容器布局。

WinForms 开发的 80% 是"在 VS 里拖控件、设属性、挂事件"，但这背后设计器替你生成了什么？理解它，你才能脱离设计器手写、排查布局 bug、做自定义控件。

一、partial class：设计器和你的代码各管一半

VS 设计器拖一个 Button 到 Form，生成两个文件：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


// Form1.Designer.cs —— 设计器生成，你别手改（改了下次设计器覆盖）
partial class Form1
{
 private System.Windows.Forms.Button button1;

 private void InitializeComponent()
 {
 this.button1 = new System.Windows.Forms.Button();
 this.button1.Location = new System.Drawing.Point(100, 80);
 this.button1.Name = "button1";
 this.button1.Size = new System.Drawing.Size(75, 23);
 this.button1.Text = "点我";
 this.button1.Click += button1_Click; // 事件挂接也在设计器里
 this.ClientSize = new System.Drawing.Size(300, 200);
 this.Controls.Add(this.button1);
 this.Name = "Form1";
 this.Text = "Form1";
 }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


// Form1.cs —— 你写的业务逻辑
public partial class Form1 : Form
{
 public Form1()
 {
 InitializeComponent(); // 设计器生成的方法，必须调
 }

 private void button1_Click(object sender, EventArgs e)
 {
 MessageBox.Show("Clicked");
 }
}

要点：

两个文件同一个类（partial）——编译器合并。设计器管布局（.Designer.cs），你管逻辑（Form1.cs）。
InitializeComponent() 必须在构造函数里第一个调——它创建控件实例、设属性、挂事件、建控件树。不调，窗体一片空白。
.Designer.cs 不要手改——下次在设计器里改动会覆盖。要改控件树，在设计器里改，或写到 Form1.cs。

记忆法：.Designer.cs = 设计器的"手稿"，Form1.cs = 你的工位。两半拼成 Form1。

二、控件树：Controls 集合

每个 Control（包括 Form）有一个 Controls 集合，装它的子控件。整个界面是一棵树：

1
2
3
4
5
6
7
8


Form (根)
├── MenuStrip (菜单)
├── ToolStrip (工具栏)
├── TableLayoutPanel (中间容器)
│ ├── Label
│ ├── TextBox
│ └── Button
└── StatusStrip (状态栏)

1
2
3
4
5


// 代码里操作控件树
var panel = new TableLayoutPanel { Dock = DockStyle.Fill, ColumnCount = 2 };
panel.Controls.Add(new Label { Text = "姓名" }, 0, 0); // (col, row)
panel.Controls.Add(new TextBox(), 1, 0);
this.Controls.Add(panel); // 加到 Form

Controls.Add/Remove/Clear 改树结构。
Dock（停靠）和 Anchor（锚定）决定控件随窗体缩放的行为——WinForms 布局的两大基石（第 4 篇会再讲）。
父控件 Dispose 时会级联 Dispose 子控件（自动）。

三、常用控件一览

WinForms 内置控件丰富，覆盖典型桌面需求：

控件	用途	关键属性/事件
`Form`	窗口	`Text`/`Size`/`DialogResult`/`FormClosing`
`Button`	按钮	`Text`/`Click`
`TextBox`	文本输入	`Text`/`ReadOnly`/`Multiline`/`TextChanged`
`Label`	标签	`Text`
`CheckBox` / `RadioButton`	选择	`Checked`/`CheckedChanged`
`ComboBox`	下拉	`Items`/`SelectedIndex`/`SelectedValueChanged`
`ListBox` / `CheckedListBox`	列表	`Items`/`SelectedIndexChanged`
`DataGridView`	表格（数据绑定主力）	`DataSource`（第 5 篇详讲）
`PictureBox`	图片	`Image`
`DateTimePicker`	日期	`Value`
`TabControl`	选项卡	`TabPages`
`ProgressBar`	进度	`Value`/`Maximum`
`TreeView` / `ListView`	树/列表视图	`Nodes`/`Items`

四、容器与布局控件

WinForms 的布局靠容器 + Dock/Anchor，不像 WPF 那样有专门的布局系统（Panel 体系）：

容器	布局方式
`Panel`	空容器，子控件绝对坐标或 Dock
`GroupBox`	带标题的 Panel（分组）
`TabControl`	选项卡页
`SplitContainer`	可拖动的分隔条，两块区域
`TableLayoutPanel`	表格布局（行/列，百分比/绝对）
`FlowLayoutPanel`	流式布局（从左到右/从上到下自动排）

1
2
3
4
5


布局两大基石：
 Dock 停靠（Top/Bottom/Left/Right/Fill），子控件占满父的某侧
 Anchor 锚定（Top/Bottom/Left/Right 组合），窗体缩放时控件边距固定

 复杂布局组合：TableLayoutPanel/FlowLayoutPanel 做网格/流式，其余靠 Dock/Anchor

1
2
3
4
5


// 典型布局：顶部菜单 + 工具栏 + 中间内容(Fill) + 底部状态栏
menuStrip.Dock = DockStyle.Top;
toolStrip.Dock = DockStyle.Top;
statusStrip.Dock = DockStyle.Bottom;
contentPanel.Dock = DockStyle.Fill; // Fill 要最后加（Z-order 规则）

Dock 的 Z-order 顺序很关键：先加的 Dock 控件占外层，Fill 要最后加，否则被其他 Dock 控件挤掉。设计器里"置于底层/顶层"或代码里 Controls.Add 顺序控制。

五、.resx 资源文件

Form1.resx 装窗体的资源：图标、本地化字符串、二进制（图片）等。XML 格式。

1
2
3
4
5
6
7


<!-- Form1.resx 片段 -->
<data name="$this.Text" xml:space="preserve">
 <value>我的窗体</value>
</data>
<data name="button1.Text" xml:space="preserve">
 <value>点我</value>
</data>

本地化：为不同语言建 Form1.zh-CN.resx/Form1.en.resx，编译成卫星程序集，运行时按文化自动切换。
设计器属性：很多属性（Text/Font/Image）实际存在 .resx 里，.Designer.cs 引用它。

1
2


// 代码里访问项目级资源
var text = Properties.Resources.MyString;

六、控件生命周期与 Dispose

1
2
3
4
5
6


控件生命周期：
 new Control() 构造（托管对象，还没 HWND）
 Controls.Add 加入树
 HandleCreated 第一次需要时创建 HWND（懒）
 ... 显示/交互 ...
 Dispose() 释放（HWND + 托管资源）

关键点：

HWND 懒创建：控件实际窗口句柄在第一次显示或访问 Handle 时才建。
必须 Dispose：控件持有非托管资源（HWND、GDI 对象），Dispose 释放它们。Form 关闭时自动 Dispose 其控件树；手动创建的控件（没加到树）要自己 Dispose。
Pen/Brush/Bitmap/Font 这些 GDI+ 对象也非托管，用完要 Dispose（第 4 篇详讲）。

1
2
3
4
5
6


// 典型坑：动态创建的控件忘了 Dispose → GDI 句柄泄漏
for (int i = 0; i < 100; i++)
{
 var btn = new Button(); // 没加到 Controls，没人替它 Dispose
 // ... 用完没 Dispose → 泄漏
}

七、设计时 vs 运行时

设计器在你的控件上跑 ComponentDesigner，会触发控件的某些代码。所以：

构造函数别干重活（设计器会 new 你的 Form，重活会拖慢设计器甚至让它崩）。
DesignMode 属性：控件在设计器里跑时为 true，可用来跳过运行时才该做的逻辑（查数据库、连网络）。

1
2
3
4
5
6


public MyControl()
{
 InitializeComponent();
 if (!DesignMode) // 只在真正运行时才加载配置
 LoadConfig();
}

注意：DesignMode 在构造函数里还不可靠（句柄未建），最稳的是在 Load 事件里查。

八、小结

1
2
3
4
5
6
7


WinForms 代码组织核心：
 ✓ partial class：.Designer.cs（设计器管布局）+ Form1.cs（你管逻辑）
 ✓ InitializeComponent() 构造函数必调
 ✓ 控件树 = Controls 集合的嵌套
 ✓ 布局靠容器 + Dock/Anchor
 ✓ .resx 装资源和本地化
 ✓ 控件持有 HWND，必须 Dispose

下一篇：事件模型——WinForms 的老式 event、订阅/退订的讲究、没退订导致的内存泄漏陷阱。

WinForms 学习笔记（一）：WinForms 是什么——Win32 包装与现代定位

Sat, 04 Jul 2026 10:00:00 +0800

写在前面

版本说明：.NET 8 LTS + Visual Studio 2022，代码在 Windows 10/11 验证。

这个系列和「WPF 学习笔记」12 篇是兄弟篇——两者都是 .NET 桌面 UI 框架，但走了两条截然不同的路：

WinForms（2002，Framework 1.0）：封装 Win32 API，控件是 HWND 的包装，GDI+ 绘制。简单、稳定、设计器好用。
WPF（2006，Framework 3.0）：全新设计，XAML + DirectX + 依赖属性 + 数据绑定 + MVVM。强大、现代，但复杂。

为什么 2026 年还学 WinForms？因为它没死：企业内部工具、工业软件、金融终端、快速原型，WinForms 仍是主力——简单、开发快、运行稳、机器老也能跑。很多公司有几十年积累的 WinForms 代码要维护。而且理解 WinForms 的"Win32 思维"，反过来更能理解 WPF 为什么那样设计。

本系列 8 篇，定位和 WPF 系列一致：全景式（基础 + 原理 + 实战），面向 .NET 后端转桌面的读者。读完你能：上手 WinForms 开发、理解它和 WPF 的本质差异、知道什么时候该选哪个。

一、WinForms 是什么：Win32 的托管包装

WinForms 的本质一句话：把 Win32 的窗口（HWND）和 GDI+ 绘图，包装成 .NET 托管对象。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


Win32 层（C/C++）：
 - CreateWindow → 返回 HWND（窗口句柄）
 - WM_PAINT 消息 → 用 GDI 绘制
 - 消息循环（GetMessage/DispatchMessage）
 - 每个控件一个 HWND

WinForms 层（.NET 托管）：
 - Form / Control 类 → 内部持有 HWND
 - OnPaint 虚方法 → 包装 WM_PAINT，用 Graphics（GDI+）画
 - Application.Run → 跑消息循环
 - Button / TextBox / ... 都是 Control 子类，各持 HWND

所以 WinForms 的每个控件都是真实的操作系统窗口（有 HWND），这和 WPF 截然不同（WPF 一个窗口通常只有一个 HWND，内部全自绘）。

1
2
3
4
5
6
7
8


// 最小 WinForms 程序：一个窗体 + 一个按钮
using System.Windows.Forms;

var form = new Form { Text = "Hello", Width = 300, Height = 200 };
var button = new Button { Text = "点我", Left = 100, Top = 80 };
button.Click += (s, e) => MessageBox.Show("Hello WinForms!");
form.Controls.Add(button);
Application.Run(form); // 跑消息循环，直到窗体关闭

这就是 WinForms 的"味道"：直接、命令式、像写脚本。设置属性、挂事件、加到 Controls，完事。没有 XAML、没有绑定、没有标记扩展。

二、WinForms vs WPF：两条路的核心差异

这是本系列最重要的对照（也是第 8 篇的主题）：

维度	WinForms	WPF
渲染	GDI+（立即模式近亲，每个控件自绘到自己的 HWND）	DirectX（保留模式，整棵视觉树提交 GPU）
窗口模型	每控件一个 HWND	一窗口一 HWND，内部自绘
UI 描述	C# 代码 + 设计器（`.Designer.cs`）	XAML（声明式标记）
属性系统	普通 CLR 属性	依赖属性（支持绑定/动画/样式）
事件	老式 `event`（无路由）	路由事件（视觉树冒泡/隧道）
数据绑定	弱（BindingSource，主要表单/表格场景）	强（双向/Converter/CollectionView，任意属性）
自定义外观	GDI+ 自绘 / 继承控件	ControlTemplate（彻底换皮）
架构模式	习惯 code-behind 直写	MVVM（原生支持）
学习曲线	平缓（拖控件 + 写事件）	陡（XAML + 绑定 + 模板）
现代化	.NET 8 支持，但 API 老旧	.NET 8 支持，持续优化

1
2
3


一句话区分：
 WinForms = "用 Win32 思维写 UI"（命令式、控件即窗口）
 WPF = "用现代图形思维写 UI"（声明式、数据驱动）

如果你是后端，WinForms 上手更快（像写控制台程序，拖控件挂事件）；WPF 更"工程化"（MVVM、绑定、可测试），但入门门槛高。

三、WinForms 的现代定位（谁还在用）

2026 年，WinForms 不是主流新技术，但远没死：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


WinForms 的主场：
 ✓ 企业内部工具（ERP/CRM 客户端、数据录入、报表）
 ✓ 工业软件（设备控制、监控面板、SCADA）
 ✓ 金融终端（交易界面、行情显示）
 ✓ 快速原型 / 内部小工具（开发快、部署简单）
 ✓ 维护遗留系统（几十年积累的代码）

WinForms 不适合：
 ✗ 需要复杂自定义 UI / 动画 / 现代视觉
 ✗ 跨平台（WinForms 只跑 Windows）
 ✗ 触控 / 移动端

.NET 8/9 下 WinForms 是开源的（dotnet/winforms），仍持续修 bug、支持新 .NET。支持单文件发布、ReadyToRun、ClickOnce 部署。生命周期随 .NET LTS。

四、开发环境与项目结构

Visual Studio 2022（推荐）：设计器体验最好，拖控件、属性面板、事件挂接一站式。
VS Code + dotnet CLI：能写代码，但没有可视化设计器（WinForms 设计器依赖 VS）。
项目模板：dotnet new winforms（SDK 风格，.NET 8）。

1
2
3


dotnet new winforms -n HelloWinForms
cd HelloWinForms
dotnet run # 弹出 Form1

生成的项目结构：

1
2
3
4
5
6


HelloWinForms/
├── HelloWinForms.csproj
├── Program.cs # Main: Application.Run
├── Form1.cs # 业务代码（partial）
├── Form1.Designer.cs # 设计器生成的控件布局（partial）
└── Form1.resx # 资源（图标、本地化字符串等）

Form1.cs 和 Form1.Designer.cs 是同一个类的两半（partial），设计器管布局、你管逻辑——这是 WinForms 的核心代码组织方式，第 2 篇详讲。

五、本系列怎么跟

8 篇，全景式：

1
2
3
4
5
6
7
8


1. WinForms 是什么（本篇）
2. Form 与控件体系（设计器、控件树、.Designer.cs）
3. 事件模型（老式 event、订阅退订、内存泄漏）
4. GDI+ 绘制（Graphics、OnPaint、自定义控件）
5. 数据绑定（BindingSource、DataGridView、INPC）
6. 线程与 async（UI 线程、Invoke、死锁）
7. 部署（ClickOnce、单文件、自动更新）
8. WinForms vs WPF（选型与迁移）

每篇有可跑的代码示例，聚焦"为什么这样设计"而不只是 API 罗列。线程篇（6）会交叉链到本站「.NET 高并发编程」的 async 死锁节——WinForms 的 WindowsFormsSynchronizationContext 正是死锁三宿主之一。

六、小结

1
2
3
4


WinForms 的一句话画像：
 老（2002）、稳、简单、Win32 包装、设计器好用
 企业/工业/原型仍是主力，没死也不前卫
 和 WPF 是"两条路"，不是"新旧的迭代"

下一篇：Form 与控件体系——设计器怎么生成代码、控件树怎么组织、.Designer.cs 和 .resx 里装了什么。