C# 异步委托实例概述

最新推荐文章于 2023-09-23 13:32:58 发布

shiweijian1986

最新推荐文章于 2023-09-23 13:32:58 发布

阅读量747

点赞数

分类专栏：技术杂论文章标签： c# 多线程 thread constructor class null

技术杂论专栏收录该内容

10 篇文章 0 订阅

订阅专栏

C#异步委托实例概述

1 引言

曾经我做过一个项目，这个项目里面有一个计费功能，计费功能要对当月所有的费用进行计算，由于数据量很大，计算过程也有点复杂，所以用户在执行计费程序时，整个计算机就会出现“假死”的情况。在面对这种情况时，如果客户在单击“计费”按钮后，“计费”在“后台”进行，而软件的其他功能不受影响，当计费完毕，程序弹出提示窗口告知用户计费完毕，就能让软件有良好的使用效果。

因此，我们可以想到是多线程处理，也就是把耗时久的操作用另外的线程放在“后台”处理，主功能不受影响。在这里，我想还是先介绍一下什么是多线程吧。线程是执行程序的实际单位，而进程是组织线程的一个数据结构，它并没有执行程序的能力，一般来说，我们会把单线程或者主要执行的线程称为主线程，其他的处理线程称为线程。Windows操作系统是多任务多线程的操作系统，并且VC++和VC#都支持多线程开发。

但是线程存在同步和异步的问题，关于同步和异步，网上有一个经典的说法，我也曾经转载在我的博客上，在这里还是重新提一下吧。例子如下：

离你很远的地方有个很漂亮的女网友，你想知道她到底对你如何，你通过邮政礼仪，寄给她一支玫瑰（相当于异步调用）。因为回执要等很多天，所以，你这些天不必整天傻等回执，可以照样吃饭工作（处理些简单的事务），当然，如果你这些天又泡到个MM,这时你就要选择，如果也用异步的方法，当然没问题，因为哪个回执先回来，先处理那个，但如果你对后面这个MM采用同步方式，那你只能解决掉这个同步的MM后，才能处理前面那个回执，不管那个回执何时到达。

这和多线程也有点不同，多线程是两个色狼泡两个MM,自己泡自己的。

2 异步委托和多线程

关于这个问题，我想很多初学者跟我一样有很多疑问吧。下面我说的内容也许不正确，我在这里真的很希望大家能够指正，因为我讲的只是我自己的理解。

其实异步委托跟多线程在C#编程上是没有关系的。我做了一个Sample，我实在没看到任何地方写上了CreateThread这样的语句，但是却能达到异步的效果，也许，系统将处理的线程隐藏了，由操作系统管理，而不希望用户太多地介入，从而导致混乱。

2.1 委托

在这里我想重新提一下什么是委托，msdn上说得似乎有点晦涩，这个也不怪他们。我有一个同学是在微软做翻译的，呵呵。很多翻译工作其实并不是由长期从事开发的人写的，而是一些大学毕业生或者英语比较好的人（小笑一下，本人在vs 2005 beta的时候曾经帮导师翻译msdn，自我感觉翻译的比后来的微软翻译的好）。Ok，言归正传，委托其实就等于C++里面的函数指针，是指向函数地址的变量。我想，也许是为了更加面向对象，并且避免指针的滥用而导致系统错误，C#引用了委托这个概念。其实不管是事件，还是委托，大家都可以把它们看成跟类一样的东西，都需要声明，都需要进行实例化，并且其实例可以看成引用类型的对象。这样的话，更加容易理解很多觉得很神秘的东西。

委托就是声明一个“函数指针”，但这个“指针”必须要声明其指向函数的形式，也就是说，我如果声明委托为：

public delegate void BinaryDelegate(int startIndex, int count);

那么，这个委托只能指向“返回值是void，参数分别为int startIndex, int count”的函数。

Ok，是否这样就可以使用委托了呢？当然不可以啦，前面已经说过，C#是纯面向对象的语言，它一定不能有指针，并且，我也说过了在C#中，像委托或者事件什么的，我们其实都可以看成是引用类型的变量，所以，在使用之前要实例化，只有实例化才能被称为对象，否则只是提出了一个概念，不能实际应用。例如，我们提出“人类”（human）这个概念，但是只有实例化了“人类”->“张三”，这个“张三”才能被驱使，比如我叫张三去端水。我不能叫“人类”去端水。

我们还是以前面的例子为基础，我们来实例化这个委托。

BinaryDelegate addingDelegate = new BinaryDelegate(AddingFunction);

请注意，实例化的参数（相当于构造函数的参数）只能是函数名称，这个函数名称是不能带参数的（是不是跟C++的函数指针一样呢？）。所以，如果一旦实例化委托，那么就必须在其作用域（类内部或者外部）内有其委托指明的函数存在，否则在编译时报错。

2.2 委托使用的时机

在我的印象里，委托经常出现在三个场合（也许更多，我水平有限）。1、事件调用（最常用）。2、线程调用。3、同步异步调用。

事件调用（最常用）是委托用的最多的地方。我们为了使窗口之间的数据可以进行传递，经常会使用窗体定义事件。最常见的情况是这样的，用户为了查询一个客户，在窗体B中单击“查询”按钮后，弹出一个客户查询窗体（这里定义为A），在A中查询出指定的结果后，单击“选择”按钮，A关闭，窗体B上就获得了查询的客户信息。基于这种情况，我们一般会在A中定义一个事件，然后会在B中写一个当这个事件发生后调用的方法（函数）。那么怎么把A的事件和B的方法结合起来呢，这个时候就需要用到委托了。实际上，委托就是事件和方法之间的桥梁。如果大家不明白，可以看看class.designer.cs这个文件，当我们在按钮上选择click按钮事件时，就会自动创建一个与之相关的委托，以及事件函数，例如。

this.btnStart.Click += new System.EventHandler(this.btnStart_Click);

< classid="clsid:38481807-CA0E-42D2-BF39-B33AF135CC4D" id=ieooui>

线程调用时也需要使用委托。为什么呢？我们这么来考虑一下，线程主要表达模块中的程序代码的“执行事实”（深入浅出MFC）。那么线程要调用执行的函数代码，怎么调用函数呢？这么一说，我们就知道了，委托（即函数指针）就是搭起函数和其他东西（事件、线程）之间的桥梁。所以，在线程调用时也要使用委托，通过委托连接要执行的函数。例如：

class Test

{

static void Main()

{

Thread newThread = new Thread(new ThreadStart(Work.DoWork));

newThread.Start();

}

class Work

{

Work() {}

public static void DoWork() {}

}

红体字的部分就是委托的部分。ThreadStart 委托，它表示此线程开始执行时要调用的方法。所以，在线程调用时需要委托。

先不说其他的，先看看代码。

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Threading;
using System.Runtime.Remoting.Messaging;

namespace AddingAndMultipliction
{

    public partial class Form1 : Form
    {
        #region public constructor
        public Form1()
        {
            InitializeComponent();
        }
        #endregion


        private delegate void BinaryCaculationHandle(int startIndex, int count, out long result);
        private BinaryCaculationHandle bcAdding;
        private BinaryCaculationHandle bcMinuing;
        private BinaryCaculationHandle bcMulting;

        #region private control's method
        private void btnStart_Click(object sender, EventArgs e)
        {
            try
            {
                bcAdding = new BinaryCaculationHandle(AddingResult);
                bcMinuing = new BinaryCaculationHandle(MinuingResult);
                bcMulting = new BinaryCaculationHandle(MultingResult);
                long addingResult = 0, minuingResult = 0, multingResult = 0;
                bcAdding.BeginInvoke(1,100, out addingResult, new AsyncCallback(AddingCallBackMethod), null);
                bcMinuing.BeginInvoke(1, 100, out minuingResult, new AsyncCallback(MinuingCallBackMethod), null);
                bcMulting.BeginInvoke(1, 100, out multingResult, new AsyncCallback(MultingCallBackMethod), null);

                //Thread tAdding = new Thread;
                //Thread tMultipliction = new Thread(new ThreadStart(GetMultiResult));
                //tAdding.Start();
                //tMultipliction.Start();
            }
            catch (System.Exception ex)
            {

            }
        }
        #endregion

#region private method

        private void AddingResult(int startIndex, int count, out long result)
        {
            int s = startIndex;
            for (int i = 0; i < count; i++)
            {
                s = s + i;
            }
            result = s;
        }
        private void AddingCallBackMethod(IAsyncResult iar)
        {
            AsyncResult ar = (AsyncResult)iar;
            bcAdding = (BinaryCaculationHandle)ar.AsyncDelegate;
            long result = 0;
            bcAdding.EndInvoke(out result, iar);

            MessageBox.Show("加法结果：" + result.ToString());
        }

        private void MultingResult(int startIndex, int count, out long result)
        {
            long s = startIndex;
            for (int i = 1; i < count; i++)
            {
                s = s * i;
            }
            result = s;
        }

        private void MultingCallBackMethod(IAsyncResult iar)
        {
            AsyncResult ar = (AsyncResult)iar;
            bcAdding = (BinaryCaculationHandle)ar.AsyncDelegate;
            long result = 0;
            bcAdding.EndInvoke(out result, iar);
            MessageBox.Show("乘法结果：" + result.ToString());
        }

        private void MinuingResult(int startIndex, int count, out long result)
        {
            long s = startIndex;
            for(int i = 0; i< count ; i++)
            {
                s = s - i;
            }
            result = s;
        }

        private void MinuingCallBackMethod(IAsyncResult iar)
        {
            AsyncResult ar = (AsyncResult)iar;
            bcAdding = (BinaryCaculationHandle)ar.AsyncDelegate;
            long result = 0;
            bcAdding.EndInvoke(out result, iar);
            Thread.Sleep(1000);
            MessageBox.Show("减法结果：" + result.ToString());
        }
        #endregion
    }
}

最后执行的结果是：加法先算出来，乘法其次，减法最后。