C#基础与Windows Forms应用开发实战

最新推荐文章于 2025-04-01 09:47:31 发布

南城游子

最新推荐文章于 2025-04-01 09:47:31 发布

阅读量2.1k

点赞数 19

本文链接：https://blog.csdn.net/weixin_36474001/article/details/141756874

版权

本文还有配套的精品资源，点击获取

简介：Windows窗体应用是基于Windows Forms框架的桌面应用程序，使用C#等编程语言进行开发。本项目通过创建动物和工作人员的管理界面，深入介绍了面向对象编程（OOP）基础、类与对象的实例化、事件驱动编程、数据绑定等关键概念。开发者将学会使用各种控件如按钮、文本框等，处理文件操作和异常，以及利用Visual Studio进行程序调试。该课程设计项目有助于初学者深入理解C#语言和Windows应用开发，强化编程技能和问题解决能力。 windows窗体应用

1. Windows Forms框架介绍

Windows Forms是一个用于构建Windows桌面应用程序的图形用户界面(GUI)库，它是.NET Framework的一部分，允许开发者快速创建丰富的交互式界面。本章将为读者概述Windows Forms的基本概念、特点以及如何开始使用这一框架。

Windows Forms提供了一组预定义的控件，如按钮、文本框、列表框等，这些都是构建Windows桌面应用程序不可或缺的组成部分。通过使用这些控件，开发者可以轻松地为用户提供直观的界面元素，提高应用程序的用户体验。除此之外，Windows Forms还支持拖放式设计，开发者可以在Visual Studio中通过图形界面拖动控件到窗体上，快速构建界面布局。

Windows Forms框架的一个关键优势是它的事件驱动模型。在这种模型下，用户与界面的交互动态触发事件，这些事件随后由相应的事件处理程序处理。这种模式让Windows Forms应用程序响应用户的操作变得十分简单。接下来的章节将深入探讨如何在Windows Forms中使用C#语言以及面向对象编程的实践。

2. C#编程语言应用

2.1 C#语言基础

2.1.1 C#语言的特点与优势

C#是一种由微软公司开发的现代、类型安全的面向对象的编程语言。它继承了C和C++的强大功能，同时通过自动内存管理、垃圾收集和类型安全来简化开发过程。C#的设计目标是结合Visual Basic的易用性和C++的强大功能。

C#语言的一些关键特点包括：

简单易学 ：对于有C/C++或Java背景的开发者来说，C#的语法相对直观易懂。
面向对象 ：支持封装、继承和多态等面向对象的原则。
类型安全 ：编译器会在编译时检查类型错误，有助于防止运行时错误。
自动垃圾回收 ：减少了内存泄漏的可能性，降低了手动内存管理的复杂性。
安全性 ：支持安全代码和不可信代码之间的隔离。
版本兼容 ：通过版本控制，能够保持应用程序在新版本的C#和.NET框架中的兼容性。
丰富的库支持 ：.NET Framework提供了大量预构建的类库，用于处理各种常见的编程任务。

2.1.2 C#语言基本语法

C#的基本语法包括变量声明、控制流语句、异常处理和预处理器指令等。以下是一些基本的语法结构：

// 变量声明
int number = 10;
string text = "Hello, C#!";

// 控制流语句：if-else
if(number > 0)
{
    Console.WriteLine("Number is positive.");
}
else
{
    Console.WriteLine("Number is non-positive.");
}

// 循环语句：for loop
for(int i = 0; i < 5; i++)
{
    Console.WriteLine($"This is loop iteration number {i}.");
}

// 异常处理：try-catch-finally
try
{
    // 可能引发异常的代码
}
catch(Exception ex)
{
    // 处理异常
    Console.WriteLine($"Exception caught: {ex.Message}");
}
finally
{
    // 无论是否捕获到异常都将执行的代码
}

2.1.3 C#语言核心概念解析

核心概念中，我们首先要讨论的是 委托和事件 。委托是一种类型，表示对具有特定参数列表和返回类型的方法的引用。事件是一种特殊类型的多播委托，它允许多个方法订阅和发布通知。

委托（Delegates） ：委托类似于其他一些语言中的函数指针概念，但是更加安全，类型更安全。
事件（Events） ：事件是一种特殊的委托，它用于声明类或对象何时发生某些事情，例如，按钮点击或数据加载完成。

其他核心概念还包括 LINQ（Language Integrated Query） ，它是一种用于以声明方式操作数据的查询技术。它允许开发者直接在C#语言中编写查询，而无需担心底层数据源的具体实现。

我们将在后续的章节中，继续深入学习和探讨这些核心概念以及它们在实际应用中的细节。

2.2 C#在Windows Forms中的应用

2.2.1 C#与WinForms的整合

Windows Forms是.NET Framework的一部分，它提供了一种创建Windows桌面应用程序的手段。通过C#与Windows Forms的整合，开发者可以利用C#的强大编程能力，实现用户界面的快速设计与事件驱动编程。

一个简单的WinForms应用程序通常包含以下核心组件：

窗体（Form） ：这是应用程序的主容器，每个Windows Forms应用程序至少包含一个窗体。
控件（Controls） ：如按钮（Button）、文本框（TextBox）、列表（ListBox）等，用于创建用户界面。
事件（Events） ：如点击按钮（Click event），用于响应用户的操作。

在Visual Studio IDE中创建一个WinForms应用时，开发者会用到C#编写事件处理程序，例如：

private void button1_Click(object sender, EventArgs e)
{
    MessageBox.Show("Hello, Windows Forms!");
}

这段代码展示了当用户点击一个按钮时，应用程序将会弹出一个消息框显示一条欢迎信息。

2.2.2 C#事件处理模型

在WinForms应用中，事件处理是核心交互机制之一。当用户与界面交互时（如点击按钮、输入文本等），应用程序会触发相应的事件，并调用注册到该事件的处理方法。

事件处理模型主要涉及以下几个部分：

事件源（Event source） ：触发事件的对象，比如按钮。
事件（Event） ：一个由事件源触发的信号。
事件处理器（Event handler） ：当事件发生时被调用的方法。
委托（Delegate） ：作为事件和事件处理器之间的桥梁，定义了事件处理方法的签名。

在WinForms中，C#允许你为特定的事件编写处理代码：

// 声明事件处理器
private void button1_Click(object sender, EventArgs e)
{
    // 当按钮1被点击时执行的代码
}

// 在窗体初始化代码中订阅事件
this.button1.Click += new System.EventHandler(this.button1_Click);

以上代码演示了如何为按钮点击事件编写处理函数，并将其与具体的事件关联起来。

2.2.3 C#与.NET Framework的关系

C#是一种面向.NET Framework设计的编程语言。.NET Framework提供了一个丰富的运行时环境，其中包括公共语言运行时（CLR）和基础类库（BCL）。C#编写的源代码在编译时会被转换成中间语言（IL），CLR负责执行IL代码，并提供内存管理、线程管理、异常处理等服务。

公共语言运行时（CLR） ：是.NET Framework的执行引擎，它负责加载程序集、执行IL代码、进行垃圾回收和提供类型安全等。
基础类库（BCL） ：提供了一组丰富的预构建类库，用于处理各种常见的编程任务，比如文件操作、网络通信、数据访问等。

C#语言与.NET Framework的紧密集成，使得开发人员可以使用C#编写代码，然后在CLR上运行，享受.NET Framework提供的各种服务和功能。

为了更好地理解和应用C#与.NET Framework的关系，开发者需要对.NET的类库有一定的了解，并熟悉如何使用C#编写与这些类库交互的代码。

在下一章，我们将深入探讨面向对象编程（OOP）的基础知识，以及如何在C#中利用这些基础知识构建更加强大和灵活的应用程序。

3. 面向对象编程（OOP）基础

面向对象编程（OOP）是现代软件开发中不可或缺的一部分。它为复杂的应用提供了一种组织和架构方式，使开发者能够构建出模块化、可维护和可扩展的代码库。本章将深入探讨OOP的核心概念，类与对象的定义和实例化，以及面向对象设计原则。

3.1 OOP核心概念

3.1.1 类与对象

在面向对象编程中，类可以被视为一种蓝图或模板，用于定义对象的状态和行为。对象则是从这个蓝图中实例化出的具体实体。类可以包含数据（以属性的形式）以及操作这些数据的方法。一个类的实例，即对象，拥有类中定义的所有属性和方法。

// 示例代码：C#中类的定义和对象的实例化
public class Person
{
    public string Name { get; set; }
    public int Age { get; set; }

    public void SayHello()
    {
        Console.WriteLine("Hello, my name is " + Name + "!");
    }
}

// 使用Person类创建对象
Person john = new Person();
john.Name = "John";
john.Age = 30;
john.SayHello(); // 输出: Hello, my name is John!

3.1.2 继承、封装与多态

继承（Inheritance）允许我们创建一个类（称为子类或派生类）来继承另一个类（称为基类或父类）的属性和方法。封装（Encapsulation）则是将数据（属性）和操作数据的方法绑定在一起，并对外隐藏实现细节，只提供接口。多态（Polymorphism）是指同一操作作用于不同的对象时，可以有不同的解释和不同的执行结果。

// 继承示例
public class Employee : Person // Employee 继承自 Person
{
    public string Department { get; set; }

    // 重写SayHello方法以实现多态
    public override void SayHello()
    {
        Console.WriteLine("Hello, I am " + Name + ", working in " + Department + ".");
    }
}

Employee jane = new Employee();
jane.Name = "Jane";
jane.Age = 28;
jane.Department = "Research";
jane.SayHello(); // 输出: Hello, I am Jane, working in Research.

3.2 类与对象的定义和实例化

3.2.1 类的定义与属性

类的定义包括访问修饰符、类名、基类、接口实现以及类体。属性是类中用于封装数据的成员。它们通常包括一个私有字段和两个公共访问器方法：get和set。这些方法提供了对私有字段的读写控制。

public class Rectangle
{
    // 私有字段
    private int width;
    private int height;

    // 属性
    public int Width
    {
        get { return width; }
        set { width = value; }
    }

    public int Height
    {
        get { return height; }
        set { height = value; }
    }

    // 构造函数
    public Rectangle(int width, int height)
    {
        this.Width = width;
        this.Height = height;
    }
}

3.2.2 对象的创建与使用

在C#中，对象通过使用 new 关键字进行实例化，该关键字会调用类的构造函数。创建对象后，可以访问其公开的属性和方法。

// 创建Rectangle类的对象
Rectangle myRectangle = new Rectangle(10, 20);

// 使用对象的属性和方法
myRectangle.Width = 15; // 修改宽度属性
myRectangle.Height = 25; // 修改高度属性
Console.WriteLine(myRectangle.Width); // 输出宽度：15
Console.WriteLine(myRectangle.Height); // 输出高度：25

3.2.3 构造函数与析构函数

构造函数用于初始化对象状态，而析构函数则用于在对象被销毁前执行清理工作。在C#中，析构函数通过 ~ClassName() 来表示。

public class Example
{
    // 构造函数
    public Example()
    {
        // 构造代码
    }

    // 析构函数
    ~Example()
    {
        // 清理代码
    }
}

3.3 面向对象设计原则

3.3.1 SOLID原则简述

SOLID原则是一组面向对象设计的最佳实践，旨在提高代码的可维护性和灵活性。SOLID原则包括五个部分：

单一职责原则（Single Responsibility Principle）
开闭原则（Open/Closed Principle）
里氏替换原则（Liskov Substitution Principle）
接口隔离原则（Interface Segregation Principle）
依赖倒置原则（Dependency Inversion Principle）

3.3.2 设计模式在WinForms中的应用

设计模式是针对特定问题的通用解决方案模板。在Windows Forms应用程序开发中，可以利用多种设计模式来优化代码结构。例如，使用MVVM模式可以帮助分离UI逻辑与业务逻辑。

3.3.3 面向对象分析与设计实践

面向对象分析（OOA）和面向对象设计（OOD）是一系列方法和工具，它们指导我们如何将现实世界的问题抽象成软件模型。在实践中，分析阶段涉及理解问题域，而设计阶段则涉及构建系统的蓝图，这两个阶段是紧密相连的。良好的OOA和OOD可以帮助团队在开发过程中保持一致性和清晰性。

4. 事件驱动编程实践

事件驱动编程是Windows Forms应用程序中不可或缺的部分。在本章节中，我们将深入探讨事件驱动模型的基础知识，包括事件和委托的概念。接着，我们将通过实例演示如何创建和触发自定义事件，以及如何处理多个事件并进行状态管理。

4.1 事件驱动模型基础

事件驱动模型是基于事件的应用程序设计方式。在事件驱动模型中，程序不是通过顺序执行代码来运行的，而是响应各种事件。这些事件可以是由用户操作引发的（如鼠标点击、按键等），也可以是系统内部机制（如定时器到期）生成的。

4.1.1 事件与委托的概念

在C#中，委托（Delegate）是一种可以持有对具有特定参数列表和返回类型的方法的引用的类型。它类似于C或C++中的函数指针，但更安全，更具有面向对象的特性。事件（Event）是.NET Framework中委托的一个特例，它提供了一种声明方式，用于表示某个动作或发生的事情已经发生了。

// 示例代码：委托的声明和使用
public delegate void MyDelegate(string message);

public void SayHello(string message)
{
    Console.WriteLine(message);
}

public void TriggerEvent()
{
    MyDelegate del = new MyDelegate(SayHello);
    del("Hello, World!");
}

在上面的代码示例中，我们声明了一个委托 MyDelegate ，然后创建了一个方法 SayHello ，这个方法符合委托所定义的签名。我们创建了一个委托实例 del ，将 SayHello 方法与委托实例关联，并通过委托实例调用方法。

事件的声明通常伴随着两个部分：委托类型的声明和事件本身的声明。在.NET中，事件通常以 On 开头，后跟事件名，再跟一个 EventArgs 类型的参数。例如：

public class MyClass
{
    public delegate void MyEventArgs(string message);
    public event MyEventArgs MyEvent;

    public void OnMyEvent()
    {
        if (MyEvent != null)
        {
            MyEvent("Event triggered!");
        }
    }
}

在这里，我们定义了一个事件 MyEvent ，以及触发事件的方法 OnMyEvent 。在 OnMyEvent 中，我们首先检查事件是否有订阅者，如果有，则触发事件。

4.1.2 常见事件处理方式

在Windows Forms应用程序中，事件处理通常涉及订阅和响应UI控件（如按钮点击、文本框输入等）引发的事件。常见的事件处理方式有以下几种：

直接在设计视图中添加事件处理器 ：这是最简单直接的方法，在Visual Studio的设计视图中，直接双击控件的事件，然后编写事件处理代码。
使用 += 操作符在代码中订阅事件 ：可以在代码的任何地方找到事件订阅的控件，并使用 += 操作符添加事件处理方法。

// 示例代码：事件订阅
private void Form1_Load(object sender, EventArgs e)
{
    button1.Click += new EventHandler(button1_Click);
}

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

使用lambda表达式作为事件处理器 ：这适用于事件处理逻辑非常简单的情况。

button1.Click += (sender, e) => MessageBox.Show("Button clicked using lambda!");

4.2 事件处理技巧与实例

本小节将介绍如何创建和触发自定义事件，处理多个事件以及与状态管理相关的高级技术。

4.2.1 自定义事件的创建与触发

创建自定义事件首先需要定义一个委托类型，然后声明事件，并实现触发事件的方法。以下是自定义事件的创建和触发过程的示例：

// 定义委托和事件
public delegate void CustomEventHandler(object sender, CustomEventArgs e);
public event CustomEventHandler CustomEvent;

// 触发事件的方法
public void RaiseCustomEvent()
{
    CustomEventArgs args = new CustomEventArgs("Custom event raised!");
    CustomEvent?.Invoke(this, args);
}

// 自定义事件参数类
public class CustomEventArgs : EventArgs
{
    public string Message { get; set; }

    public CustomEventArgs(string message)
    {
        Message = message;
    }
}

在实际应用中，您可以在需要触发事件的任何地方调用 RaiseCustomEvent 方法，而任何订阅了 CustomEvent 的事件处理方法都会被执行。

4.2.2 多事件处理与事件链

在处理多个事件时，可能会需要在一个事件处理方法中调用另一个事件处理方法，形成事件链。例如，完成一个表单的验证，可能需要在提交前触发验证事件，并在验证通过后触发提交事件。

public class FormWithEvents
{
    public event EventHandler<EventArgs> FormSubmitting;

    public void OnFormSubmitting(EventArgs e)
    {
        FormSubmitting?.Invoke(this, e);
    }

    private void Form1_SubmitButton_Click(object sender, EventArgs e)
    {
        if (ValidateForm())
        {
            OnFormSubmitting(e);
            SubmitForm();
        }
        else
        {
            MessageBox.Show("Form validation failed.");
        }
    }

    private void Form1_ValidationError(object sender, EventArgs e)
    {
        // Display validation error to the user
    }
    // 其他方法定义
}

在这个例子中，表单提交按钮点击事件 Form1_SubmitButton_Click 触发时，首先进行表单验证，如果验证成功，则触发 FormSubmitting 事件；否则，显示验证失败的消息。

4.2.3 事件与状态管理

事件与状态管理紧密相关。应用程序的状态变化通常伴随着事件的发生，而事件又可能触发状态的改变。良好的状态管理策略可以避免事件处理中的竞争条件和状态不一致问题。

例如，在一个具有登录功能的应用程序中，登录成功事件应该更新应用程序状态，例如设置当前用户为已登录状态，并可能重定向用户到主界面。

public class LoginForm : Form
{
    // 登录成功事件
    public event EventHandler<LoginEventArgs> LoggedIn;

    // 登录验证后触发事件
    public void OnLoggedIn(LoginEventArgs e)
    {
        LoggedIn?.Invoke(this, e);
        if (e.Success)
        {
            // 更新用户状态，例如设置当前用户对象
            // 跳转到主界面逻辑...
        }
    }
    // 其他方法定义
}

public class LoginEventArgs : EventArgs
{
    public bool Success { get; set; }
    public string ErrorMessage { get; set; }
    // 可以根据需要添加更多属性
}

在这个登录示例中，登录验证成功后会触发 LoggedIn 事件，并在事件处理方法中根据成功标志更新应用程序的状态。这样的策略可以确保应用程序的不同部分（如用户界面、业务逻辑层）可以根据事件传递的状态信息作出相应的反应。

通过本章节的介绍，我们了解到事件驱动模型的基础概念，并通过实例深入理解了如何创建和处理自定义事件，以及如何在多事件处理和状态管理中运用这些知识。这些技巧为构建更加互动和动态的Windows Forms应用程序奠定了基础。

5. Windows Forms综合应用

5.1 常用控件使用方法

5.1.1 基本控件功能与属性

在Windows Forms中，基本控件是构建应用程序用户界面的基石。一些常用的控件包括按钮（Button）、文本框（TextBox）、标签（Label）等。这些控件不仅功能丰富，而且每个控件都具备多种属性，如 Text 、 Name 、 Size 、 Location 等，可以用来控制控件在界面上的显示和行为。

以 Button 控件为例， Text 属性可以定义按钮上的显示文字， Click 事件允许开发者指定按钮被点击时执行的操作。

// C# 示例代码：创建并配置一个按钮控件
Button myButton = new Button();
myButton.Text = "点击我";
myButton.Location = new Point(50, 50);
myButton.Click += new EventHandler(MyButton_Click); // 注册点击事件

private void MyButton_Click(object sender, EventArgs e)
{
    MessageBox.Show("按钮被点击了！");
}

5.1.2 控件的布局与响应式设计

在布局控件时，需要考虑到响应式设计，以确保界面在不同分辨率和设备上都能良好显示。控件的布局通常使用 TableLayoutPanel 或 FlowLayoutPanel 等容器控件管理，这些容器控件可以方便地对内部控件进行定位和布局。

// C# 示例代码：使用TableLayoutPanel布局控件
TableLayoutPanel table = new TableLayoutPanel();
table.ColumnCount = 2;
table.RowCount = 2;
table.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F));
table.ColumnStyles.Add(new ColumnStyle(SizeType.Percent, 50F));
table.RowStyles.Add(new RowStyle(SizeType.Percent, 50F));
table.RowStyles.Add(new RowStyle(SizeType.Percent, 50F));

// 添加控件到布局面板
table.Controls.Add(myButton, 0, 0);

5.1.3 高级控件使用与自定义

除了基础控件外，Windows Forms还提供了高级控件，例如 ListView 、 TreeView 和 DataGridView ，这些控件可以展示复杂数据并实现丰富的用户交互。此外，开发者还可以通过继承现有控件类来创建自定义控件，以满足特定的业务需求。

// C# 示例代码：自定义控件的基本步骤
public class CustomButton : Button
{
    // 可以添加自定义属性和方法
    public CustomButton()
    {
        // 自定义构造器逻辑
    }

    protected override void OnPaint(PaintEventArgs pevent)
    {
        base.OnPaint(pevent);
        // 自定义绘制逻辑
    }
}

5.2 数据绑定技术应用

5.2.1 数据绑定基础

数据绑定技术是连接UI控件和数据源的桥梁。通过数据绑定，开发者可以将控件的属性与数据源的字段相关联，实现数据和视图的同步更新。Windows Forms支持简单数据绑定和复杂数据绑定，其中简单绑定将单个控件属性与数据源字段绑定，而复杂绑定则涉及到数据表和数据列。

5.2.2 绑定源的选择与配置

选择合适的绑定源是实现数据绑定的关键。开发者可以选择数组、列表、数据集（DataSet）或数据视图（DataView）作为绑定源。在配置绑定源时，通常使用 BindingSource 组件作为中介，以简化绑定过程并提供额外的功能，如排序和筛选。

// C# 示例代码：配置数据源并绑定到控件
BindingSource bindingSource = new BindingSource();
bindingSource.DataSource = myDataTable; // myDataTable 是一个数据表实例
myDataGridView.DataSource = bindingSource; // 假设 myDataGridView 是一个 DataGridView 控件

5.2.3 绑定数据的展示与操作

当数据源与控件绑定成功后，数据会自动填充到控件中，用户可以查看和操作数据。如果需要对数据进行更新、添加或删除，可以利用控件的内置功能，如 DataGridView 的编辑和删除按钮，或者监听相关事件进行编程处理。

// C# 示例代码：处理数据变更事件
myDataGridView.CellValueChanged += new DataGridViewCellEventHandler(DataGrid_CellValueChanged);

private void DataGrid_CellValueChanged(object sender, DataGridViewCellEventArgs e)
{
    // 当单元格值变更时，更新数据源
    myDataTable.Rows[e.RowIndex][e.ColumnIndex] = myDataGridView.Rows[e.RowIndex].Cells[e.ColumnIndex].Value;
}

5.3 文件操作实现

5.3.1 文件读写基础

在Windows Forms应用程序中，经常需要进行文件的读写操作。例如，使用 File.ReadAllText() 和 File.WriteAllText() 方法可以方便地读取和写入文本文件。这些操作涉及到.NET Framework的 System.IO 命名空间。

// C# 示例代码：读取和写入文本文件
string filePath = @"C:\path\to\your\file.txt";
string content = File.ReadAllText(filePath);
File.WriteAllText(filePath, content);

5.3.2 文件对话框与操作

OpenFileDialog 和 SaveFileDialog 控件可以简化文件的打开和保存对话框的创建。用户可以借助这些对话框选择文件路径，而无需手动编写界面代码。

// C# 示例代码：使用文件保存对话框
SaveFileDialog saveFileDialog = new SaveFileDialog();
saveFileDialog.Filter = "文本文件|*.txt";
if (saveFileDialog.ShowDialog() == DialogResult.OK)
{
    string filePath = saveFileDialog.FileName;
    // 用户确认保存，执行文件写入操作
}

5.3.3 文件操作的高级技巧

高级文件操作包括随机访问文件、文件压缩解压以及监控文件系统变化等。这些操作通常需要更深层次的API调用和附加库的支持，如使用 FileStream 进行随机访问和使用第三方库进行文件压缩。

// C# 示例代码：使用FileStream进行文件随机访问
FileStream fs = new FileStream(filePath, FileMode.OpenOrCreate, FileAccess.ReadWrite);
fs.Seek(100, SeekOrigin.Begin); // 移动到文件的100字节位置
fs.WriteByte(97); // 写入字节 'a'
fs.Close();

5.4 异常处理技巧

5.4.1 异常处理机制

在编写Windows Forms应用程序时，良好的异常处理机制是必不可少的。通过 try-catch-finally 语句可以捕获运行时错误，并对异常进行分类处理。异常处理有助于防止程序因错误而崩溃，并为用户提供清晰的错误信息。

try
{
    // 尝试执行可能抛出异常的代码
}
catch (FileNotFoundException ex)
{
    // 捕获并处理特定类型的异常
    MessageBox.Show("文件未找到: " + ex.Message);
}
finally
{
    // 无论是否发生异常都会执行的代码
}