C# WinForm窗体间参数传递的实践方法

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

简介：在C# WinForm开发中，正确地在窗体间传递参数是必要的技能。文章将指导如何使用构造函数、ShowDialog方法和事件委托来实现基本类型数据和复杂对象的传递。

1. C# WinForm窗体间传参概述

在C# WinForm应用中，窗体间传递参数是实现交互和数据交换的基础。开发者需要掌握多种传递参数的方法，以便在不同的需求场景下选择最合适的实现方式。本章节将简要概述WinForm窗体间传参的目的、意义及主要技术手段。我们将从基本构造函数传递开始，逐步探讨使用ShowDialog方法、公共属性、对象传递以及事件和委托等复杂技术。

窗体间传参的主要目标是为了在应用程序的不同部分共享和更新数据。例如，当用户在一个窗体中输入数据后，可能需要将这些数据传递到另一个窗体中去进行进一步处理。通过参数传递，各个窗体间能够维持数据的一致性，并且能够实现逻辑上的松耦合。

接下来的章节中，我们将详细解析各种窗体间传递参数的技术，包括构造函数传递、ShowDialog方法、公共属性、对象传递、以及事件和委托等。每种技术都有其特定的使用场景和优缺点，理解并掌握这些知识对于开发高效、可维护的WinForm应用至关重要。

2. 构造函数传递基本类型数据

2.1 基本类型参数的定义

2.1.1 引入构造函数参数

在C# WinForm应用程序中，构造函数（Constructor）是类的一个特殊方法，用于在创建类的实例时初始化对象。构造函数传递是将基本类型数据从一个窗体传递到另一个窗体的直接且简单的方法。通过在目标窗体的构造函数中定义参数，可以在实例化窗体时直接将数据传递给该窗体。

2.1.2 构造函数参数的数据类型

构造函数可以接受任何类型的数据作为参数，包括但不限于整型（int）、浮点型（float）、字符串（string）等基本数据类型。还可以是更复杂的数据类型，例如自定义的类类型。参数类型的选择取决于需要传递的数据内容。

2.2 构造函数传递的实现步骤

2.2.1 创建源窗体实例

在源窗体中，创建目标窗体的实例时，需要在构造函数中传递参数。例如，如果目标窗体需要一个字符串参数，那么实例化该窗体的代码可能如下：

TargetForm targetForm = new TargetForm("传递的字符串");

2.2.2 在构造函数中接收参数

接下来，在目标窗体的构造函数中，需要声明一个参数来接收从源窗体传递过来的数据。这个参数应当与源窗体实例化该窗体时提供的参数类型相匹配。

public class TargetForm : Form
{
    private string dataReceived;

    public TargetForm(string data)
    {
        InitializeComponent();
        this.dataReceived = data;
    }
}

2.2.3 使用参数数据

一旦参数被接收，就可以在目标窗体的任何地方使用这个数据了。可以在窗体加载事件中使用，也可以在窗体中任何需要使用该数据的地方通过私有字段访问。

2.3 构造函数传递的优势与局限

2.3.1 易用性和安全性分析

构造函数传递的优点在于简单易用，代码清晰且易于维护。当窗体构造时，所需的所有数据都可以直接通过构造函数传递，无需额外的设置步骤。然而，对于一些安全性要求较高的数据，直接在构造函数中传递可能不是最佳选择，因为构造函数本质上是公开的，容易被其他代码访问。

2.3.2 对构造函数限制的考虑

构造函数的限制之一是它不支持可选参数和命名参数，这意味着必须为所有参数提供值，并且必须按照参数的顺序提供这些值。当窗体需要多个数据项时，可能会导致参数列表变得很长，这会降低代码的可读性和可维护性。此外，构造函数参数一旦定义，若需修改，可能会影响到所有使用该构造函数的地方。

// 代码示例：构造函数传递的实例
public class SourceForm : Form
{
    public void ShowTargetForm()
    {
        // 将基本类型数据通过构造函数传递给TargetForm
        TargetForm targetForm = new TargetForm("Hello, WinForm!");
        targetForm.ShowDialog();
    }
}

public class TargetForm : Form
{
    private string message;

    // TargetForm构造函数接收一个字符串参数
    public TargetForm(string message)
    {
        InitializeComponent();
        this.message = message;
    }

    protected override void OnLoad(EventArgs e)
    {
        base.OnLoad(e);
        // 在窗体加载时使用传递来的数据
        MessageBox.Show(message);
    }
}

通过上述示例代码，我们可以清晰地看到如何在WinForm应用程序中通过构造函数传递基本类型数据。这种方法适用于简单的数据传递场景，尤其是在窗体初始化阶段就需要这些数据的场景。然而，开发者需要考虑构造函数传递带来的局限性，并评估是否适用于需要传递复杂数据或高安全性的场景。

3. 使用ShowDialog方法传递参数

3.1 ShowDialog方法的作用机制

3.1.1 ShowDialog方法介绍

在WinForms应用程序中， ShowDialog() 方法是模态对话框中传递参数的一个非常常用的方法。模态对话框在执行完毕之前会阻止用户访问父窗体中的其他控件。这种方式非常适合于执行需要用户确认或提供输入的任务，如登录窗体、设置窗体等。

ShowDialog() 方法不仅能够显示窗体，还能返回一个 DialogResult 枚举值，表示窗体的关闭状态，如用户点击“确定”还是“取消”。这就允许调用代码根据用户的选择执行不同的逻辑。

3.1.2 窗体间数据传递的流程

当使用 ShowDialog() 方法时，首先需要创建目标窗体的实例，然后调用该实例的 ShowDialog() 方法。该方法会阻塞当前线程直到模态窗体关闭。关闭窗体时，可以返回一个 DialogResult 的值，同时也可以设置窗体的公共属性，以便在父窗体中访问通过 ShowDialog() 方法获取的数据。

3.2 ShowDialog方法传递参数的实现

3.2.1 调用ShowDialog方法前的准备

在使用 ShowDialog() 方法之前，需要确保窗体中的控件和事件处理器已经正确设置，并且窗体类中定义了可以用来传递数据的公共属性或事件。例如：

public partial class Form1 : Form
{
    // 公共属性用于传递数据
    public string ReturnData { get; set; }

    // 构造函数接受一个参数用于初始化
    public Form1(string data)
    {
        InitializeComponent();
        // 使用传入的数据初始化窗体
        this.Text = data;
    }

    // 窗体关闭时触发的事件，设置返回数据
    private void Form1_FormClosing(object sender, FormClosingEventArgs e)
    {
        // 设置父窗体能够访问的数据
        ReturnData = this.Text;
    }
}

3.2.2 ShowDialog返回后获取数据

当调用 ShowDialog() 后，可以在返回后立即从目标窗体的公共属性中获取需要的数据。例如：

Form1 form = new Form1("示例数据");
DialogResult result = form.ShowDialog();

if (result == DialogResult.OK)
{
    // 根据需要处理从Form1获取的数据
    string data = form.ReturnData;
    // ... 使用数据执行其他操作
}

3.3 ShowDialog方法的适用场景

3.3.1 模态窗体数据传递的特征

使用 ShowDialog() 方法创建的模态窗体会阻止父窗体的操作，直到模态窗体关闭。这种行为确保了数据传递的顺序性和同步性，因为父窗体在收到返回的数据之前不会执行后续的代码。这是处理需要确保用户输入或确认信息的场景的理想选择。

3.3.2 非模态窗体数据传递的考虑

如果应用程序需要在保持父窗体操作性的同时进行数据传递，非模态窗体是一个更好的选择。使用 Show() 方法而不是 ShowDialog() 方法会创建一个可以与其他窗体同时交互的非模态窗体。在这种情况下，数据传递可以通过其他方法实现，例如使用事件、委托、共享对象等。

通过使用 ShowDialog() 方法，开发者可以以一种简单直接的方式在模态窗体和父窗体之间传递数据。这种方法适用于那些需要集中处理用户输入的场景，使得数据回传的过程清晰且易于管理。

4. 通过公共属性传递数据

4.1 公共属性传递数据的概念

4.1.1 公共属性作为数据载体

在软件开发中，公共属性是类中的一种重要成员，它允许外部访问和修改类的内部状态。在C# WinForm应用程序中，公共属性常被用于在窗体之间传递数据。属性可以是简单的数据类型，也可以是复杂对象，这取决于传递数据的需求。

公共属性提供了一种直观和灵活的方式来进行数据共享。通过设置和获取属性值，可以轻松实现数据的传递和接收。这种方式在处理需要频繁更新或读取的数据时非常有效，例如配置信息、用户输入的数据等。

4.1.2 属性访问修饰符的选择

在定义公共属性时，选择合适的访问修饰符至关重要。常用的访问修饰符包括 public 和 private 。其中， public 修饰符允许属性在类的外部被访问和修改，而 private 修饰符则限制访问范围，只允许在类的内部访问属性。

选择访问修饰符时需要考虑数据的安全性和封装性。对于需要跨窗体共享的数据，应使用 public 属性。但为了防止数据被不当修改或访问，应在可能的情况下使用 private 属性，并通过公共属性的 get 和 set 访问器来控制数据的访问和修改。

4.2 公共属性传递数据的实践

4.2.1 设计数据属性

为了在窗体间传递数据，首先需要在源窗体中设计合适的公共属性。这些属性的类型可以是基本数据类型，也可以是自定义的复杂对象类型。在设计属性时，应当遵循良好的面向对象设计原则，如单一职责原则和开闭原则。

以下是一个简单的示例，展示如何在源窗体中定义一个字符串类型的公共属性：

public partial class SourceForm : Form
{
    // 定义一个公共属性
    public string DataToPass { get; set; }

    public SourceForm()
    {
        InitializeComponent();
    }

    // 其他方法和事件
}

4.2.2 在窗体间读取和设置属性值

一旦定义了公共属性，我们就可以在目标窗体中读取或设置这些属性的值。例如，当源窗体关闭时，可以将需要传递的数据赋值给目标窗体的属性。

// 在源窗体中
SourceForm sourceForm = new SourceForm();
sourceForm.DataToPass = "需要传递的数据";
sourceForm.ShowDialog(); // 显示窗体并等待其关闭

// 在目标窗体中
private void Form_Load(object sender, EventArgs e)
{
    // 检查属性值是否已由源窗体设置
    if (sourceForm.DataToPass != null)
    {
        // 使用接收到的数据
    }
}

4.3 属性传递与数据封装

4.3.1 封装对数据安全性的意义

封装是面向对象编程的四大基本原则之一，它要求将数据（或状态）和处理数据的方法捆绑在一起，并对外隐藏对象的实现细节。通过封装，可以增加数据的安全性，防止外部代码直接访问和修改对象的内部状态。

在使用公共属性传递数据时，应当注意不要过度暴露数据。过多的公共属性可能会导致类的内部实现过于透明，从而带来安全风险。此时，合理的访问器（ get 和 set ）使用，可以在控制数据访问的同时，提供适当的灵活性。

4.3.2 属性的封装原则和技巧

为了实现良好的数据封装，我们可以使用以下一些原则和技巧：

• 属性命名规范 ：为属性使用合适的命名，清晰地表达属性的功能和用途。
• 使用访问器控制 ：通过 get 和 set 访问器控制属性的读取和修改权限。
• 属性验证 ：在 set 访问器中加入数据验证逻辑，确保设置的值符合预期。
• 私有字段 ：将存储实际数据的字段设为私有，通过公共属性对外提供访问接口。
• 属性和事件结合 ：对于需要响应属性值变化的场景，可以结合事件机制，通知其他对象属性值已改变。

// 使用私有字段和公共属性结合的示例
public partial class DataForm : Form
{
    // 私有字段
    private string privateData;

    // 公共属性
    public string PublicData
    {
        get { return privateData; }
        set
        {
            // 在设置之前进行数据验证
            if (value != privateData) // 防止自我赋值
            {
                privateData = value;
                // 可以在此处触发一个事件，通知其他对象数据已改变
            }
        }
    }

    public DataForm()
    {
        InitializeComponent();
    }

    // 其他方法和事件
}

通过上述章节的深入探讨，我们已经了解了公共属性在窗体间传递数据的作用、设计方法和实现技巧。接下来的章节，我们将探讨使用事件和委托传递数据的机制和应用。

5. 对象传递示例（使用Person类）

在WinForm应用程序中，对象传递是窗体间通信的一种强大而灵活的方法。在本章节中，我们将介绍如何通过创建一个简单的Person类及其属性来实现对象传递，并分析其技术细节以及如何保持对象状态。此外，我们还将探讨面向对象传递的优势以及如何应对管理复杂对象状态的挑战。

5.1 创建Person类及其属性

5.1.1 类的定义和属性实现

在C#中，定义一个类来表示Person信息，包括但不限于姓名、年龄和职业等属性，可以如下进行：

public class Person
{
    // Person类的属性
    public string Name { get; set; }
    public int Age { get; set; }
    public string Occupation { get; set; }

    // 构造函数初始化Person对象
    public Person(string name, int age, string occupation)
    {
        this.Name = name;
        this.Age = age;
        this.Occupation = occupation;
    }
}

5.1.2 Person类作为数据载体

创建Person类后，该类的实例可以作为数据载体在不同窗体间传递。类的属性可以根据需要进行设置和获取，从而实现数据的共享和状态的传递。

5.2 Person类对象在窗体间传递

5.2.1 对象传递的技术细节

在WinForm应用程序中，传递对象通常涉及创建对象实例并在窗体间传递该实例的引用。在源窗体中创建Person对象，并通过方法参数或属性将其传递给目标窗体。

// 在源窗体中创建Person对象并传递
public void ShowDetailsForm(Person person)
{
    var detailForm = new DetailsForm();
    detailForm.PersonInfo = person; // 将Person对象传递给详情窗体
    detailForm.ShowDialog();
}

在目标窗体（如DetailsForm）中，接收Person对象，并使用其属性：

public partial class DetailsForm : Form
{
    public Person PersonInfo { get; set; }

    // 在构造函数或其他合适的地方接收Person对象
    public DetailsForm(Person person)
    {
        InitializeComponent();
        this.PersonInfo = person;
        // 使用Person对象的属性更新UI
    }
}

5.2.2 对象状态保持的考虑

在窗体间传递对象时，需要确保对象的状态在传递过程中保持一致。例如，当从一个窗体传递Person对象到另一个窗体时，需要考虑到对象的可变性和生命周期管理。

// 从详情窗体返回时，可以获取更新后的对象状态
var resultPerson = detailForm.PersonInfo;

5.3 对象传递的优势与挑战

5.3.1 面向对象传递的优势

使用面向对象的方法传递数据有许多优势，包括封装性和可维护性的提升。对象封装了相关的数据和行为，可以更容易地在窗体间传递和使用。

5.3.2 管理复杂对象状态的策略

管理复杂对象的状态可能会带来挑战，特别是当对象被多个窗体共享和修改时。为了管理这些状态，可能需要采用一些策略，比如：

• 使用深拷贝或浅拷贝来复制对象。
• 在对象的setter方法中加入逻辑以控制属性值的变更。
• 实现监听器或事件订阅机制，以确保当对象状态变化时，所有相关的窗体都能得到通知。

// Person类的深拷贝实现示例
public Person DeepCopy()
{
    return new Person(this.Name, this.Age, this.Occupation);
}

通过本章节的介绍，我们可以看到对象传递不仅提供了一种灵活且强大的数据共享方式，同时它也是设计复杂WinForm应用程序时需要认真考虑的问题。理解如何有效地管理对象状态和生命周期对于开发健壮的WinForm应用至关重要。

6. 定义和使用事件和委托传递数据

6.1 事件和委托的基础概念

6.1.1 事件和委托的作用

在WinForm应用程序中，事件是一种非常强大的通信机制，允许用户定义在特定条件下被调用的方法。事件通常与用户交互有关，如按钮点击、文本更改等。委托则是一种特殊类型的引用类型，它引用具有特定参数列表和返回类型的方法。委托本身并不知道它所引用的方法，直到它被赋予一个实现了这些参数和返回类型的方法。

事件和委托的结合使用允许开发者创建松散耦合的应用程序。事件的发布者不需要了解谁将处理这些事件，而事件的订阅者不需要知道这些事件是由谁发布的。这种设计模式使得代码更加模块化，易于维护和扩展。

6.1.2 事件和委托在WinForm中的应用

在WinForm中，事件和委托被用于多个场景。例如，点击一个按钮会触发一个事件，该事件处理程序可以包含处理点击事件所需执行的代码。委托经常被用作事件的类型，它们定义了事件处理程序的签名，确保任何订阅事件的方法都符合预期的形式。

// 委托定义
public delegate void EventHandler(object sender, EventArgs e);

// 事件定义
public event EventHandler Click;

在上面的例子中， EventHandler 是一个委托，它定义了任何事件处理程序都必须接受的参数：一个 object sender （事件的发起者）和一个 EventArgs e （事件参数）。 Click 是一个事件，它使用 EventHandler 委托类型。

6.2 通过事件传递数据

6.2.1 事件发布和订阅机制

在WinForm中，事件的发布和订阅遵循特定的模式。发布者（通常是控件或窗体）定义事件并引发它们，而订阅者（其他控件或窗体）则连接到这些事件，并提供一个处理程序来响应事件。

// 事件发布
protected virtual void OnClick(EventArgs e) {
    Click?.Invoke(this, e);
}

// 事件订阅
button.Click += new EventHandler(button_Click);

在上述代码中， OnClick 方法在某些条件下被调用以引发 Click 事件。在其他地方，我们订阅这个事件，并提供一个事件处理程序 button_Click 。

6.2.2 实现自定义事件

要创建自定义事件，我们需要定义一个委托和一个事件。然后，我们编写一个方法来引发该事件，并在另一个方法中处理该事件。

// 定义委托
public delegate void CustomEventHandler(object sender, CustomEventArgs e);

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

// 定义事件
public event CustomEventHandler CustomEvent;

// 引发事件的方法
protected virtual void OnCustomEvent(CustomEventArgs e) {
    CustomEvent?.Invoke(this, e);
}

// 使用事件
public void Subscribe() {
    CustomForm.CustomEvent += HandleCustomEvent;
}

// 事件处理程序
private void HandleCustomEvent(object sender, CustomEventArgs e) {
    Console.WriteLine(e.Message);
}

在上面的代码中， CustomEvent 是一个自定义事件， CustomEventHandler 是它的委托， CustomEventArgs 是它的参数类。 Subscribe 方法订阅了 CustomEvent 事件，而 HandleCustomEvent 是事件的处理程序。

6.3 委托在数据传递中的应用

6.3.1 委托的数据传递模型

委托可以封装对方法的引用，这使得它们成为在WinForm应用程序中传递数据的理想选择。委托可以作为参数传递给其他方法，或者在方法间共享，并在需要的时候调用引用的方法。

// 定义委托
public delegate string MessageDelegate(string name);

// 使用委托
public string Greet(string name) {
    return $"Hello, {name}!";
}

// 调用委托
MessageDelegate del = new MessageDelegate(Greet);
string message = del("World");

在上述代码中，我们定义了一个委托 MessageDelegate ，它引用了 Greet 方法。然后我们创建了一个委托实例 del ，它引用了 Greet 方法，并传递了一个参数 "World" 。

6.3.2 委托和事件结合使用的高级技巧

通过结合使用委托和事件，我们可以实现复杂的通信机制。一个事件可以有一个或多个事件处理程序，它们都是使用委托引用的方法。当事件被触发时，所有订阅了该事件的方法都将被调用。

// 声明委托和事件
public delegate void CustomEventDelegate(object sender, CustomEventArgs e);
public event CustomEventDelegate CustomEvent;

// 事件发布者
protected virtual void OnCustomEvent(CustomEventArgs e) {
    CustomEvent?.Invoke(this, e);
}

// 事件订阅者
private void HandleCustomEvent(object sender, CustomEventArgs e) {
    // 处理事件
}

// 订阅和发布
CustomForm.CustomEvent += HandleCustomEvent;
CustomForm.OnCustomEvent(new CustomEventArgs { Message = "Event triggered" });

在上面的代码中，我们定义了一个自定义事件 CustomEvent ，并在 CustomForm 类中实现了触发该事件的 OnCustomEvent 方法。然后我们在另一个类中订阅了这个事件，并提供了 HandleCustomEvent 作为事件处理程序。当 OnCustomEvent 被调用时，所有订阅了 CustomEvent 的处理程序都将被执行。

通过使用事件和委托，我们能够构建出高度解耦的WinForm应用程序，它们能够有效地在窗体之间传递数据和状态。这种模式在许多应用程序中是常见的，特别是在需要实现用户界面交互和业务逻辑分离的场景中。

7. 订阅发送窗体事件以接收数据

7.1 理解事件订阅机制

在C# WinForm应用程序中，事件订阅是一种强大的数据传递机制，它允许窗体响应来自其他窗体或对象的通知。理解事件订阅的工作流程对于设计响应式和交互式界面至关重要。

7.1.1 事件订阅的工作流程

事件订阅通常涉及以下步骤：

1. 定义事件 : 在发送窗体中定义一个事件，通常与委托类型关联。
2. 声明事件 : 在发送窗体的类中声明事件。
3. 触发事件 : 在特定的操作或条件下触发事件。
4. 订阅事件 : 在接收窗体中订阅事件，这通常通过添加事件处理器方法实现。
5. 事件触发时执行 : 当事件被触发时，所有订阅该事件的方法将被调用。

7.1.2 设计支持事件的窗体结构

为了有效地使用事件，窗体需要有一个明确的结构。通常这意味着：

• 使用委托定义事件的签名。
• 在窗体类中声明事件，并提供一个公开的方法来添加或移除事件处理器。
• 在适当的时候触发事件。

下面是一个简单的例子，展示了如何在C#中定义和使用事件。

// 声明一个委托类型，用于定义事件签名
public delegate void MyEventHandler(object sender, MyEventArgs e);

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

// 发送窗体类
public class SenderForm
{
    // 事件声明
    public event MyEventHandler MyEvent;

    // 触发事件的方法
    public void FireEvent()
    {
        if (MyEvent != null)
        {
            MyEvent(this, new MyEventArgs { Message = "Event triggered" });
        }
    }
}

// 接收窗体类
public class ReceiverForm
{
    private SenderForm senderForm;

    public ReceiverForm(SenderForm sender)
    {
        senderForm = sender;
        // 订阅事件
        senderForm.MyEvent += HandleMyEvent;
    }

    // 定义事件处理器
    private void HandleMyEvent(object sender, MyEventArgs e)
    {
        MessageBox.Show(e.Message);
    }
}

7.2 实现窗体间的数据订阅与接收

事件订阅不仅仅是一个理论概念，它需要在实际的窗体代码中实现。以下是实现窗体间事件订阅和数据接收的步骤。

7.2.1 创建事件处理器

在接收窗体中，你需要为发送窗体的事件创建一个事件处理器。这通常是一个方法，其签名与事件委托类型匹配。

7.2.2 在目标窗体中订阅和响应事件

目标窗体需要订阅发送窗体的事件，并定义一个方法来响应事件。在窗体的构造函数或其他初始化代码中添加订阅代码。

// 在接收窗体的构造函数中订阅事件
public ReceiverForm()
{
    InitializeComponent();
    this.Load += new EventHandler(ReceiverForm_Load);
}

// 事件订阅的具体实现
private void ReceiverForm_Load(object sender, EventArgs e)
{
    SenderForm senderForm = new SenderForm();
    senderForm.MyEvent += HandleMyEvent;
}

// 实现事件响应逻辑
private void HandleMyEvent(object sender, MyEventArgs e)
{
    // 在这里处理事件数据
    MessageBox.Show(e.Message);
}

7.3 探讨事件与委托的高效互动

事件和委托的高效互动能够提高程序的响应性和模块化。理解如何提升事件处理性能以及如何结合使用委托和事件，是提高WinForm应用程序性能和可维护性的关键。

7.3.1 提升事件处理性能的方法

• 使用 += 和 -= 操作符管理事件订阅 : 这样可以避免重复订阅同一个事件，从而减少不必要的事件处理器调用。
• 避免在事件处理器中执行耗时操作 : 如果必须执行复杂或耗时的任务，考虑使用后台线程或异步调用。

7.3.2 理解委托和事件的关联使用

委托是事件的基础，它们之间的关系紧密。在设计窗体交互时，合理使用委托和事件可以使代码更加清晰和可维护。例如，可以创建一个中心事件管理器类，管理所有窗体间的事件订阅和触发，这样可以减少各个窗体之间的耦合度，提升代码的复用性。

通过精心设计和实施事件订阅，你可以构建出具有高响应性和低耦合性的WinForm应用程序。这种强大的数据传递机制为现代桌面应用程序的设计提供了无限可能。

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

简介：在C# WinForm开发中，正确地在窗体间传递参数是必要的技能。文章将指导如何使用构造函数、ShowDialog方法和事件委托来实现基本类型数据和复杂对象的传递。

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