运用VC# 创作简单的多线程组件

来源： 2017-08-20 19:54中

可以编写能同时执行多个任务的应用程序。此能力（称为“多线程处理”或“自由线程处理”）是设计处理器密集型且要求用户输入的组件的强大方法。计算工资表信息的组件就是一个可能利用多线程处理的组件示例。该组件可以在一个线程上处理用户输入到数据库的数据，而在另一个线程上执行频繁使用处理器的工资表计算。通过在不同的线程上运行这些进程，用户不必等到计算机完成计算，就可以输入其他数据。在本演练中，将创建一个简单的多线程组件，该组件可以同时执行若干个复杂计算。

创建项目

　　应用程序将包括单个窗体和一个组件。用户将输入值并指示该组件开始计算。然后，窗体将接收来自该组件的值，将其显示在标签控件中。该组件将执行频繁使用处理器的计算，并在完成后通知窗体。您将在组件中创建公共变量，用以保存从用户界面收到的值。同时，您还将在组件中实现一些方法，根据这些变量的值执行计算。

　　注意尽管对于计算值的方法来说，函数通常更为可取，但不能在线程之间传递参数，也不能返回值。有很多向线程提供值和从线程接收值的简单方法。在本演示中，将通过更新公共变量将值返回到用户界面，当线程执行完毕后，使用事件来通知主程序。

创建窗体

　　创建新的“Windows 应用程序”项目。

　　将应用程序命名为 Calculations，并将 Form1.cs 重命名为 frmCalculations.cs。

　　该窗体将用作应用程序的主用户界面。

　　双击设计器上的窗体以打开代码编辑器。在“编辑”菜单中，选择“查找和替换”，然后选择“替换”。使用“全部替换”将 Form1 替换为 frmCalculations。

　　在“解决方案资源管理器”中，右击“frmCalculations.cs”并选择“视图设计器”。设计器打开。
向窗体中添加 5 个 Label 控件、4 个 Button 控件和 1 个 TextBox 控件。

　　为这些控件设置属性，如下所示：

控件名称文本 Label1 lblFactorial1 （空白） Label2 lblFactorial2 （空白） Label3 lblAddTwo （空白） Label4 lblRunLoops （空白） Label5 lblTotalCalculations （空白） Button1 btnFactorial1 Factorial Button2 btnFactorial2 Factorial - 1 Button3 btnAddTwo Add Two Button4 btnRunLoops Run a Loop Textbox1 txtValue （空白）
创建 Calculator 组件

　　从“项目”菜单中选择“添加组件”。

　　将组件命名为 Calculator。

　　向 Calculator 组件添加公共变量

　　为 Calculator 打开代码编辑器。

　　添加创建公共变量的语句，这些变量用于将值从 frmCalculations 传递给每个线程。

　　变量 varTotalCalculations 将保留该组件执行的计算总数的累计值，而其他变量将接收来自窗体的值。

public int varAddTwo;
public int varFact1;
public int varFact2;
public int varLoopValue;
public double varTotalCalculations = 0;
向 Calculator 组件添加方法和事件

　　为事件声明委托，组件将使用这些事件向窗体传递值。

　　注意尽管您将声明 4 个事件，但由于其中的两个事件将具有相同的签名，因此只需要创建 3 个委托。

　　紧接着上一步输入的变量声明的下方，键入下列代码：

// This delegate will be invoked with two of your events.
public delegate void FactorialCompleteHandler(double Factorial, double TotalCalculations);
public delegate void AddTwoCompleteHandler(int Result, double TotalCalculations);
public delegate void LoopCompleteHandler(double TotalCalculations, int Counter);
　　声明组件将用来与应用程序进行通信的事件。为实现此目的，紧接着上一步输入的代码的下方，添加下列代码。

public event FactorialCompleteHandler FactorialComplete;
public event FactorialCompleteHandler FactorialMinusOneComplete;
public event AddTwoCompleteHandler AddTwoComplete;
public event LoopCompleteHandler LoopComplete;
　　紧接着上一步键入的代码的下方，键入下列代码：

// This method will calculate the value of a number minus 1 factorial
// (varFact2-1!).
public void FactorialMinusOne()
{
double varTotalAsOfNow = 0;
double varResult = 1;
// Performs a factorial calculation on varFact2 - 1.
for (int varX = 1; varX <= varFact2 - 1; varX++)
{
varResult *= varX;
// Increments varTotalCalculations and keeps track of the current
// total as of this instant.
varTotalCalculatio

[1] [2] [3] [4] [5] [6] 下一页

ns += 1;
varTotalAsOfNow = varTotalCalculations;
}
// Signals that the method has completed, and communicates the
// result and a value of total calculations performed up to this
// point.
FactorialMinusOneComplete(varResult, varTotalAsOfNow);
}

// This method will calculate the value of a number factorial.
// (varFact1!)
public void Factorial()
{
double varResult = 1;
double varTotalAsOfNow = 0;
for (int varX = 1; varX <= varFact1; varX++)
{
varResult *= varX;
varTotalCalculations += 1;
varTotalAsOfNow = varTotalCalculations;
}
FactorialComplete(varResult, varTotalAsOfNow);
}

// This method will add two to a number (varAddTwo+2).
public void AddTwo()
{
double varTotalAsOfNow = 0;
int varResult = varAddTwo + 2;
varTotalCalculations += 1;
varTotalAsOfNow = varTotalCalculations;
AddTwoComplete(varResult, varTotalAsOfNow);
}

// This method will run a loop with a nested loop varLoopValue times.
public void RunALoop()
{
int varX;
double varTotalAsOfNow = 0;
for (varX = 1; varX <= varLoopValue; varX++)
{
// This nested loop is added solely for the purpose of slowing down
// the program and creating a processor-intensive application.
for (int varY = 1; varY <= 500; varY++)
{
varTotalCalculations += 1;
varTotalAsOfNow = varTotalCalculations;
}
}
LoopComplete(varTotalAsOfNow, varLoopValue);
}
将用户输入传输到组件

　　下一步是向 frmCalculations 添加代码，以接收用户输入，以及从 Calculator 组件接收值和向它传输值。

　　实现 frmCalculations 的前端功能

　　在代码编辑器中打开 frmCalculations。

　　找到 public class frmCalculations 语句。紧接着 { 的下方键入：

Calculator Calculator1;
　　找到构造函数。紧接着 } 之前，添加以下行：

// Creates a new instance of Calculator.
Calculator1 = new Calculator();
　　在设计器中单击每个按钮，为每个控件的单击事件处理程序生成代码大纲，并添加代码以创建这些处理程序。

　　完成后，单击事件处理程序应该类似于以下形式：

private void btnFactorial1_Click(object sender, System.EventArgs e)
// Passes the value typed in the txtValue to Calculator.varFact1.
{
Calculator1.varFact1 = int.Parse(txtValue.Text);
// Disables the btnFactorial1 until this calculation is complete.
btnFactorial1.Enabled = false;
Calculator1.Factorial();
}

private void btnFactorial2_Click(object sender, System.EventArgs e)
{
Calculator1.varFact2 = int.Parse(txtValue.Text);
btnFactorial2.Enabled = false;
Calculator1.FactorialMinusOne();
}
private void btnAddTwo_Click(object sender, System.EventArgs e)
{
Calculator1.varAddTwo = int.Parse(txtValue.Text);
btnAddTwo.Enabled = false;
Calculator1.AddTwo();
}
private void btnRunLoops_Click(object sender, System.EventArgs e)
{
Calculator1.varLoopValue = int.Parse(txtValue.Text);
btnRunLoops.Enabled = false;
// Lets the user know that a loop is running
lblRunLoops.Text

上一页 [1] [2] [3] [4] [5] [6] 下一页

= "Looping";
Calculator1.RunALoop();
}
　　在上一步添加的代码的下方，键入以下代码以处理窗体将从 Calculator1 接收的事件：

protected void FactorialHandler(double Value, double Calculations)
// Displays the returned value in the appropriate label.
{
lblFactorial1.Text = Value.ToString();
// Re-enables the button so it can be used again.
btnFactorial1.Enabled = true;
// Updates the label that displays the total calculations performed
lblTotalCalculations.Text = "TotalCalculations are " +
Calculations.ToString();
}

protected void FactorialMinusHandler(double Value, double Calculations)
{
lblFactorial2.Text = Value.ToString();
btnFactorial2.Enabled = true;
lblTotalCalculations.Text = "TotalCalculations are " +
Calculations.ToString();
}

protected void AddTwoHandler(int Value, double Calculations)
{
lblAddTwo.Text = Value.ToString();
btnAddTwo.Enabled = true;
lblTotalCalculations.Text = "TotalCalculations are " +
Calculations.ToString();
}

protected void LoopDoneHandler(double Calculations, int Count)
{
btnRunLoops.Enabled = true;
lblRunLoops.Text = Count.ToString();
lblTotalCalculations.Text = "TotalCalculations are " +
Calculations.ToString();
}
　　在 frmCalculations 的构造函数中，紧挨在 } 之前添加下列代码，以处理窗体将从 Calculator1 接收的自定义事件：

Calculator1.FactorialComplete += new
Calculator.FactorialCompleteHandler(this.FactorialHandler);
Calculator1.FactorialMinusOneComplete += new
Calculator.FactorialCompleteHandler(this.FactorialMinusHandler);
Calculator1.AddTwoComplete += new
Calculator.AddTwoCompleteHandler(this.AddTwoHandler);
Calculator1.LoopComplete += new
Calculator.LoopCompleteHandler(this.LoopDoneHandler);
测试应用程序

　　现在项目已经创建完毕，该项目将能够执行若干个复杂计算的组件与窗体结合在一起。尽管尚未实现多线程处理功能，但在继续之前应该对项目进行测试，以验证它的功能。

测试项目

　　从“调试”菜单中选择“启动”。

　　应用程序启动并显示 frmCalculations。

　　在文本框中键入 4，然后单击标记为“添加两个”的按钮。

　　在按钮下方的标签中应该显示数字“6”，在 lblTotalCalculations 中应该显示“Total Calculations are 1”。

　　现在单击标记为“阶乘 - 1”的按钮。

　　该按钮的下方应显示数字“6”，而 lblTotalCalculations 中现在应显示“Total Calculations are 4”。

　　将文本框中的值更改为 20，然后单击标记为“阶乘”的按钮。

　　该按钮的下方显示数字“2.43290200817664E+18”，而 lblTotalCalculations 中现在显示为“Total Calculations are 24”。

　　将文本框中的值更改为 50000，然后单击标记为“运行循环”的按钮。

　　注意，在此按钮重新启用前有一个短暂然而明显的间隔。此按钮下的标签应显示“50000”，而总的计算次数显示为“25000024”。

　　将文本框中的值更改为 5000000 并单击标记为“运行循环”的按钮，紧接着单击标记为“添加两个”的按钮。再次单击它。

　　直到循环已经完成，该按钮以及窗体上的任何控件才有响应。

　　如果程序只运行单个执行线程，则类似上述示例的频繁使用处理器的计算倾向于占用该程序，直到计算已经完成。在下一节中，您将向应用程序添加多线程处理功能，以便一次可以运行多个线程。
添加多线程处理功能

　　上面的示例演示了只运行单个执行线程的应用程序的限制。在下一节，您将使用 Thread 类对象向组件添加多个执行线程。

添加 Threads 子例程

　　在代码编辑器中打开 Calculator.cs。

　　在代码顶部附近，找到类声明，紧接着 { 的下方，键入下列代码：

// Declares the variables you will use to hold your thread objects.
public System.Threading.Thread FactorialThread;
public System.Threading.Thread FactorialMinusOneThread;
public System.Threading.Thread AddTwoThread;
public System.Threading.Thread LoopThread;