浅谈C#中常见的委托

水深无声 2022-08-24 11:45 205阅读 0赞

[点击打开链接][Link 1]

一提到委托，浮现在我们脑海中的大概是听的最多的就是类似C++的函数指针吧，呵呵，至少我的第一个反应是这样的。

关于委托的定义和使用，已经有诸多的人讲解过，并且讲解细致入微，尤其是张子阳的那一篇。我就不用多废话了。

今天我要说的是C\#中的三种委托方式:Func委托，Action委托，Predicate委托以及这三种委托的常见使用场景。

# Func,Action,Predicate全面解析 #

首先来说明Func委托，通过MSDN我们可以了解到，Func委托有如下的5种类型：

![复制代码][copycode.gif]

（1） *delegate TResult Func<TResult>(); 
    
                （2）*delegate TResult Func<T1,TResult>(T1 arg1);
    
                （3） *delegate TResult Func<T1,T2,TResult>(T1 arg1, T2 arg2);
    
                （4）*delegate TResult Func<T1,T2,T3,TResult>(T1 arg1, T2 arg2, T3 arg3);
    
                （5）*delegate TResult Func<T1,T2,T3,T4,TResult>T1 arg1, T2 arg2, T3 arg3, T4 arg4);

![复制代码][copycode.gif]

其中（1）只能委托无参但是有返回值的函数，TResult就是其返回类型。

而（2）只能委托具有一个传入参数，有返回值的函数，T1为一个传入参数，TResult为返回类型。

（3）只能委托具有二个传入参数，有返回值的函数，T1和T2为两个传入参数，TResult为返回类型，（4）和（5）以此类推。

那么如何来使用呢？ 下面给出一个简单的几个例子：

![复制代码][copycode.gif]

#region Func委托
                
                ///Func<TResult>的用法
                ///这里TResult代表函数的返回值类型
                ///只能代理返回值为TResult类型的无参函数
                Func<string> func = delegate()
                {
                    return "我是Func<TResult>委托出来的结果";
                };
                Console.WriteLine(func());
                Console.ReadKey();
    
                ///Func<T,TResult>的用法
                ///这里的T为代理的函数的传入类型,TResult代表函数的返回值类型
                ///只能代理参数为T类型,返回值为TResult类型的函数
                Func<string, string> funcOne = delegate(string s)
                {
                    return s.ToUpper();
                };
                Console.WriteLine(funcOne("我是Func<T,TResult>委托出来的结果"));
                Console.ReadKey();
    
                ///Func<T1,T2,TResult>的用法
                ///这里T1,T2为代理的函数的传入类型,TResult代表函数的返回值类型
                ///只能代理参数为T1,T2类型,返回值为TResult类型的函数
                Func<string, string, string> funcTwo = delegate(string value1, string value2)
                {
                    return value1 + " " + value2;
                };
                Console.WriteLine(funcTwo("我是", "Func<T1,T2,TResult>委托出来的结果"));
                Console.ReadKey();
    
                #endregion

![复制代码][copycode.gif]

上面代码中，我用了匿名方法来代替函数，其中delegate()代表无参函数，delegate(string s)代表有一个传入参数的函数，以下的以此类推。

然后需要说明的就是Action委托，这个委托也是非常常用的，尤其是在涉及到线程和界面交互的时候，配合着lamada表达式使用，非常方便的实现二者的交互。后面我会提到用法。

来看看Action委托的几种表现形式：

![复制代码][copycode.gif]

（1） * delegate void Action(); 无参,无返回值
    
                  （2）* delegate void Action<T>(T1 arg1);
    
                （3）* delegate void Action<T1,T2>(T1 arg1, T2 arg2);
    
                （4）* delegate void Action<T1,T2,T3>T1 arg1, T2 arg2, T3 arg3);
    
                （5）* delegate void Action<T1,T2,T3,T4>T1 arg1, T2 arg2, T3 arg3, T4 arg4);

![复制代码][copycode.gif]

从上面可以看出，总共有5中表现形式，其中（1）既没有传入参数，也没有返回值，那么它适合代理那些无参，无返回值的函数；（2）有一个传入参数，无返回值，适合代理有参，无返回值的函数，（3）（4）（5）以此类推。最都容纳四个传入参数。

那么如何使用呢？下面有一些简单的例子：

![复制代码][copycode.gif]

#region Action的用法
                ///Action<T>的用法
                ///这里的T为代理函数的传入类型,无返回值
                Action<string[]> action = delegate(string[] x)
                {
                    var result = from p in x
                                 where p.Contains("s")
                                 select p;
                    foreach (string s in result.ToList())
                    {
                        Console.WriteLine(s);
                    }
                };
                string[] str={ "charlies","nancy","alex","jimmy","selina"};
                action(str);
                Console.ReadKey();
    
                #endregion

![复制代码][copycode.gif]

上面的例子是通过传入的String类型的数组，找出其中包含有字符s的项，然后输出到控制台。

最后一个就是Predicate委托，这个的形式比较少一些，就是一个传入参数，返回值为bool类型，具体示例如下：

![复制代码][copycode.gif]

#region Predicate
              ///bool Predicate<T>的用法
                ///输入一个T类型的参数,返回值为bool类型
                Predicate<string[]> predicate = delegate(string[] x)
                {
                    var result = from p in x
                                 where p.Contains("s")
                                 select p;
                    if (result.ToList().Count > 0)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                };
                string[] _value = { "charlies", "nancy", "alex", "jimmy", "selina" };
                if (predicate(_value))
                {
                    Console.WriteLine("They contain.");
                }
                else
                {
                    Console.WriteLine("They don't contain.");
                }
                Console.ReadKey();
    
                #endregion

![复制代码][copycode.gif]

上面的代码其实也是判断String数组中有没有包含s的项，有的话就在控制台打印出  They contain.没有的话就打印出They don't contain.

总结一下这三个的特点就是：

Func可以接受0个至4个传入参数，必须具有返回值
    
    Action可以接受0个至4个传入参数，无返回值
    
    Predicate只能接受一个传入参数，返回值为bool类型

下面附上全部实现代码：

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace DelegateIntegrateConsoleApp
    {
        class Program
        {
            static void Main(string[] args)
            {
                #region Func委托
                
                ///Func<TResult>的用法
                ///这里TResult代表函数的返回值类型
                ///只能代理返回值为TResult类型的无参函数
                Func<string> func = delegate()
                {
                    return "我是Func<TResult>委托出来的结果";
                };
                Console.WriteLine(func());
                Console.ReadKey();
    
                ///Func<T,TResult>的用法
                ///这里的T为代理的函数的传入类型,TResult代表函数的返回值类型
                ///只能代理参数为T类型,返回值为TResult类型的函数
                Func<string, string> funcOne = delegate(string s)
                {
                    return s.ToUpper();
                };
                Console.WriteLine(funcOne("我是Func<T,TResult>委托出来的结果"));
                Console.ReadKey();
    
                ///Func<T1,T2,TResult>的用法
                ///这里T1,T2为代理的函数的传入类型,TResult代表函数的返回值类型
                ///只能代理参数为T1,T2类型,返回值为TResult类型的函数
                Func<string, string, string> funcTwo = delegate(string value1, string value2)
                {
                    return value1 + " " + value2;
                };
                Console.WriteLine(funcTwo("我是", "Func<T1,T2,TResult>委托出来的结果"));
                Console.ReadKey();
    
                /*************余下的类似上面的这种操作,最多可以接受四个传入参数***************
                 *delegate TResult Func<TResult>();  
                 *delegate TResult Func<T1,TResult>(T1 arg1);
                 *delegate TResult Func<T1,T2,TResult>(T1 arg1, T2 arg2);
                 *delegate TResult Func<T1,T2,T3,TResult>(T1 arg1, T2 arg2, T3 arg3);
                 *delegate TResult Func<T1,T2,T3,T4,TResult>T1 arg1, T2 arg2, T3 arg3, T4 arg4);
                 */
    
                #endregion
    
                #region Action的用法
                ///Action<T>的用法
                ///这里的T为代理函数的传入类型,无返回值
                Action<string[]> action = delegate(string[] x)
                {
                    var result = from p in x
                                 where p.Contains("s")
                                 select p;
                    foreach (string s in result.ToList())
                    {
                        Console.WriteLine(s);
                    }
                };
                string[] str={ "charlies","nancy","alex","jimmy","selina"};
                action(str);
                Console.ReadKey();
    
                /***************余下的类似上面的这种操作,最多可以接受四个传入参数**********
                 * delegate void Action(); 无参,无返回值
                 * delegate void Action<T>(T1 arg1);
                 * delegate void Action<T1,T2>(T1 arg1, T2 arg2);
                 * delegate void Action<T1,T2,T3>T1 arg1, T2 arg2, T3 arg3);
                 * delegate void Action<T1,T2,T3,T4>T1 arg1, T2 arg2, T3 arg3, T4 arg4);
                 */
    
                #endregion
    
                #region Predicate
                ///bool Predicate<T>的用法
                ///输入一个T类型的参数,返回值为bool类型
                Predicate<string[]> predicate = delegate(string[] x)
                {
                    var result = from p in x
                                 where p.Contains("s")
                                 select p;
                    if (result.ToList().Count > 0)
                    {
                        return true;
                    }
                    else
                    {
                        return false;
                    }
                };
                string[] _value = { "charlies", "nancy", "alex", "jimmy", "selina" };
                if (predicate(_value))
                {
                    Console.WriteLine("They contain.");
                }
                else
                {
                    Console.WriteLine("They don't contain.");
                }
                Console.ReadKey();
    
                #endregion
    
    
            }
        }
    }

![复制代码][copycode.gif]

# 在WinForm和WPF中,利用Func,Action,Predicate进行线程UI交互 #

下面这部分主要讲解如何在WinForm中利用这些委托进行线程和界面的交互。

首先对于Func来说，由于其必须具有返回值，所以我们可以利用如下代码来实现线程和界面的交互：

![复制代码][copycode.gif]

#region 利用Func实现线程和界面交互
            private void AlternationUsingFunc(object text)
            {
                //无参数,但是返回值为bool类型
                this.Invoke(new Func<bool>(delegate()
                {
                    button1.Text = text.ToString();
                    return true; //返回值
                }));
            }
    
            private void AlternationUsingFuncThread()
            {
                WaitCallback waitCallBack = new WaitCallback(this.AlternationUsingFunc);
                ThreadPool.QueueUserWorkItem(waitCallBack, "Func的使用");
            }
    
            private void button1_Click(object sender, EventArgs e)
            {
                AlternationUsingFuncThread();
            }
            #endregion

![复制代码][copycode.gif]

其中

this.Invoke(new Func<bool>(delegate()
                {
                    button1.Text = text.ToString();
                    return true; //返回值
                }));

这段代码中利用了Func<TResult>这种类型，也就是没有传入参数，但是有一个bool类型的返回值，然后将这个函数利用加入到线程池中，最后运行，这里我们成功的设置了button1的text为“Func的使用”。

然后，对于Action来说，由于其可以无参，无返回值，那么它的交互方式最为简便，同时也是使用最多的,先看有参的调用方式：

![复制代码][copycode.gif]

#region 利用Action实现线程和界面交互
            private void AlternationUsingAction(object text)
            {
                //需要一个T类型的参数,无返回值
                this.Invoke(new Action<object>(delegate(object myText)
                {
                    myText = text;
                    button2.Text = text.ToString();
                }),text);
            }
    
            private void AlternationUsingActionThread()
            {
                WaitCallback waitCallBack = new WaitCallback(this.AlternationUsingAction);
                ThreadPool.QueueUserWorkItem(waitCallBack,"Action的使用");
            }
    
            private void button2_Click(object sender, EventArgs e)
            {
                AlternationUsingActionThread();
            }
            #endregion

![复制代码][copycode.gif]

在上面的代码示例中，我们使用了带有一个传入参数的Action委托，当然了，匿名类型delegate(object myText)匿名代理了具有一个传入参数的函数。

其实简单点来说，可以像如下方式使用：

this.Invoke((Action)(()=>
                {
                    button2.Text = text.ToString();
                }));

这样就显得非常的方便。

最后一个当然是Predicate委托，和上面类似，只是写起来麻烦一些，它需要一个传入参数，并且返回一个bool类型：

![复制代码][copycode.gif]

#region 利用Predicate实现线程和界面的交互
            private void AlternationUsingPrecidate(object text)
            {
                //需要一个T类型的参数,返回bool类型
                this.Invoke(new Predicate<object>(delegate(object myText)  
                {
                    myText = text;
                    button3.Text = myText.ToString();
                    return true;   //返回值
                }),text);
            }
    
            private void AlternationUsingPrecidateThread()
            {
                WaitCallback waitCallBack = new WaitCallback(this.AlternationUsingPrecidate);
                ThreadPool.QueueUserWorkItem(waitCallBack,"Predicate的使用");
            }
    
            private void button3_Click(object sender, EventArgs e)
            {
                AlternationUsingPrecidateThread();
            }
            #endregion

![复制代码][copycode.gif]

具体的注释我已经写在代码中了，最后运行，能成功的将button3的Text置为“Predicate的使用.”

下面是全部实现代码：

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

using System;
    using System.Collections.Generic;
    using System.ComponentModel;
    using System.Data;
    using System.Drawing;
    using System.Linq;
    using System.Text;
    using System.Windows.Forms;
    using System.Threading;
    
    namespace DelegateIntegrateWinFormApp
    {
        public partial class mainFrm : Form
        {
            public mainFrm()
            {
                InitializeComponent();
            }
    
            private void mainFrm_Load(object sender, EventArgs e)
            {
                /****************************注意例子中的使用方法****************
                 * delegate TResult Func<TResult>();  无参,但是返回值为TResult类型
                 * delegate void Action<T>(T1 arg1);  有一个参数arg1,但是无返回值
                 * delegate bool Predicate<T>(T arg);  有一个参数arg,返回bool类型
                 * **************************************************************/
            }
    
            #region 利用Func实现线程和界面交互
            private void AlternationUsingFunc(object text)
            {
                //无参数,但是返回值为bool类型
                this.Invoke(new Func<bool>(delegate()
                {
                    button1.Text = text.ToString();
                    return true; //返回值
                }));
            }
    
            private void AlternationUsingFuncThread()
            {
                WaitCallback waitCallBack = new WaitCallback(this.AlternationUsingFunc);
                ThreadPool.QueueUserWorkItem(waitCallBack, "Func的使用");
            }
    
            private void button1_Click(object sender, EventArgs e)
            {
                AlternationUsingFuncThread();
            }
            #endregion
    
                
    
    
            #region 利用Action实现线程和界面交互
            private void AlternationUsingAction(object text)
            {
                //需要一个T类型的参数,无返回值
                this.Invoke(new Action<object>(delegate(object myText)
                {
                    myText = text;
                    button2.Text = text.ToString();
                }),text);
            }
    
            private void AlternationUsingActionThread()
            {
                WaitCallback waitCallBack = new WaitCallback(this.AlternationUsingAction);
                ThreadPool.QueueUserWorkItem(waitCallBack,"Action的使用");
            }
    
            private void button2_Click(object sender, EventArgs e)
            {
                AlternationUsingActionThread();
            }
            #endregion
    
            #region 利用Predicate实现线程和界面的交互
            private void AlternationUsingPrecidate(object text)
            {
                //需要一个T类型的参数,返回bool类型
                this.Invoke(new Predicate<object>(delegate(object myText)  
                {
                    myText = text;
                    button3.Text = myText.ToString();
                    return true;   //返回值
                }),text);
            }
    
            private void AlternationUsingPrecidateThread()
            {
                WaitCallback waitCallBack = new WaitCallback(this.AlternationUsingPrecidate);
                ThreadPool.QueueUserWorkItem(waitCallBack,"Predicate的使用");
            }
    
            private void button3_Click(object sender, EventArgs e)
            {
                AlternationUsingPrecidateThread();
            }
            #endregion
    
            
    
    
        }
    }

![复制代码][copycode.gif]

那么，现在对于WPF来说，该如何来使用呢？其实在WPF中，和winform中类似，只是在WPF中要实现线程和界面的交互，我们需要用Dispatcher来实现，也就是形如Control.Dispatcher.Invoke()的方式，由于与Winform实现方式无多大差别，这里我就直接附上全部代码：

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    using System.Windows;
    using System.Windows.Controls;
    using System.Windows.Data;
    using System.Windows.Documents;
    using System.Windows.Input;
    using System.Windows.Media;
    using System.Windows.Media.Imaging;
    using System.Windows.Navigation;
    using System.Windows.Shapes;
    using System.Threading;
    
    namespace WpfApplication1
    {
        /// <summary>
        /// Interaction logic for Window1.xaml
        /// </summary>
        public partial class Window1 : Window
        {
            public Window1()
            {
                InitializeComponent();
            }
    
            private void Window_Loaded(object sender, RoutedEventArgs e)
            {
                /****************************注意例子中的使用方法****************
                * delegate TResult Func<TResult>();  无参,但是返回值为TResult类型
                * delegate void Action();  无参,无返回值
                * delegate bool Predicate<T>(T arg);  有一个参数arg,返回bool类型
                * 需要注意,与WinForm中不同的是,WPF中需要利用Control.Dispatcher.Invoke来实现,其他类似.
                * **************************************************************/
            }
    
            #region 利用Func实现线程和界面交互
            private void AlternationUsingFunc(object text)
            {
                //无参数,但是返回值为bool类型
                button1.Dispatcher.Invoke(new Func<bool>(delegate()
                {
                    button1.Content = text.ToString();
                    return true; //返回值
                }));
            }
    
            private void AlternationUsingFuncThread()
            {
                WaitCallback waitCallBack = new WaitCallback(this.AlternationUsingFunc);
                ThreadPool.QueueUserWorkItem(waitCallBack, "Func的使用");
            }
    
            private void button1_Click(object sender, RoutedEventArgs e)
            {
                AlternationUsingFuncThread();
            }
            #endregion
    
            #region 利用Action实现线程和界面交互
            private void AlternationUsingAction(object text)
            {
                //无参数,无返回值
                //button2.Dispatcher.Invoke(new Action(delegate()
                //{
                //    button2.Content = text.ToString();
                //}));
                //或者
                button2.Dispatcher.Invoke((Action)(()=>
                {
                    button2.Content = text.ToString();
                }));
            }
    
            private void AlternationUsingActionThread()
            {
                WaitCallback waitCallBack = new WaitCallback(this.AlternationUsingAction);
                ThreadPool.QueueUserWorkItem(waitCallBack, "Action的使用");
            }
    
            private void button2_Click(object sender, RoutedEventArgs e)
            {
                AlternationUsingActionThread();
            }
            #endregion
    
            #region 利用Predicate实现线程和界面的交互
            private void AlternationUsingPrecidate(object text)
            {
                //需要一个T类型的参数,返回bool类型
                this.button3.Dispatcher.Invoke(new Predicate<object>(delegate(object myText)
                {
                    myText = text;
                    button3.Content = myText.ToString();
                    return true;   //返回值
                }), text);
            }
    
            private void AlternationUsingPrecidateThread()
            {
                WaitCallback waitCallBack = new WaitCallback(this.AlternationUsingPrecidate);
                ThreadPool.QueueUserWorkItem(waitCallBack, "Predicate的使用");
            }
    
            private void button3_Click(object sender, RoutedEventArgs e)
            {
                AlternationUsingPrecidateThread();
            }
            #endregion
    
            
        }
    }

![复制代码][copycode.gif]

逐个点击界面上的按钮,我们可以看到成功实现了线程和UI的交互:

![2012010608252255.jpg][]

当然，上面我们只是说到了在WinForm中和WPF中如何来使用的情况，代码比较简单，也没有具体的应用场景，下面我们将结合中WPF来模拟一个具体的应用场景：

# 实现异步和线程同步 #

现在假设我有一个txt文档，名称为newEXO.txt，里面大概有5w行记录，文件大小为30MB左右;同时我手边还有一个oldEXO.txt里面也有5w数据，但是其中有一些记录和newEXO.txt中的不同，我现在需要对比两个txt文档，找出不同的记录，并对不同的记录进行上色操作。

那么现在这里很明确了，我们需要两个函数，一个是读取记录的函数ChangeText(),一个是上色的函数ChangeColor()。

但是在实际操作中，发现如果我直接利用wpf读取数据的话，逐行读取，耗时10s左右，也就是用户界面会被阻塞10s，然后才会显示给用户，这个体验性是相当不好的，所以拟采用异步方式来导入数据。

同时，考虑到差异比较也会比较耗时，所以也准备采用异步方式来进行对比。

那么问题来了，两个均采用异步方式进行，难免会发生数据未导入完成就开始进行差异比较的可能，所以这里还涉及到一个线程同步的问题。

现在，这里有三个操作，异步的数据导入，异步的差异比较并上色，线程同步。

首先我们看异步导入，你也可以自己实现一个异步类，通过委托的BeginInvoke方法和EndInvoke方法来实现

![复制代码][copycode.gif]

using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Text;
    
    namespace ThreadSynchorous
    {
        public  class AsyncInvoke
        {
            public void BeginAsync(Func<bool> MyFunction)
            {
                Func<bool> func = new Func<bool>(MyFunction);
                IAsyncResult iar = func.BeginInvoke(new AsyncCallback(EndAsync), func);
            }
    
            public void EndAsync(IAsyncResult iar)
            {
                Func<bool> func = (Func<bool>)iar.AsyncState;
                func.EndInvoke(iar);
            }
        }
    }

![复制代码][copycode.gif]

由于Action委托的使用方式最为便捷，这里我采用Action委托方式来进行,当然了，：

![复制代码][copycode.gif]

private void ChangeText()
            {
                this.button1.Dispatcher.Invoke((Action)(()=>
                {
                    string filename = @"C:\newEXO.txt";
                    using (StreamReader sr = new StreamReader(filename, Encoding.Default))
                    {
                        string result;
                        while ((result = sr.ReadLine()) != null)
                        {
                            //here perform action
                        }
                    }
                    //label1.Dispatcher.Invoke((new Action(delegate()
                    label1.Dispatcher.Invoke((Action)(()=>
                    {
                        label1.Content += "Loading finish!(Thread.CurrentThreadName=" + Thread.CurrentThread.ManagedThreadId.ToString() + ") ";
                    }));
                }));
            }

![复制代码][copycode.gif]

首先是当点击button1按钮的时候，就启动ChangeText（）函数，也即数据导入函数，然后label1会在加载完毕的时候，给出提示信息。

下面再看看ChangeColor()函数：

![复制代码][copycode.gif]

private void ChangeColor()
            {
                this.button1.Dispatcher.Invoke((Action)(()=>
                {
                    this.button1.Background = Brushes.Red;
    
                    //here perform large amount of data action and color the result
    
                    label1.Dispatcher.Invoke((Action)(()=>
                    {
                        label1.Content += "Coloring finish!(Thread.CurrentThreadName=" + Thread.CurrentThread.ManagedThreadId + ") ";
                    }));
    
                }));
            }

![复制代码][copycode.gif]

可以看到也是当button1点击的时候，会触发ChangeColor函数。由于二者操作比较耗时，为了防止用户界面阻塞，我们放到线程池中：

ThreadPool.QueueUserWorkItem(o => ChangeText());
    
      ThreadPool.QueueUserWorkItem(o => ChangeColor());

从上面可以看出，当点击按钮button1的时候，两个函数同时被引发，也就是点击按钮的时候进行如下操作：

private void button1_Click(object sender, RoutedEventArgs e)
            {
                ThreadPool.QueueUserWorkItem(o => ChangeText());
                ThreadPool.QueueUserWorkItem(o => ChangeColor());
                label1.Content += " \r\n-------------------------\r\n";
            }

看到了什么？

![2012010608255330.jpg][]

看到了线程运行的混乱,我们本想让数据先加载,然后比较得出差异着色,可惜上面的结果中却与想象中的相差甚远.

这里的ChangeText（）函数和ChangeColor（）函数肯定不会像想象的那样顺序执行，那么代码就有问题了，所以为了避免这个问题，我们必须进行线程同步，如何来进行呢？ 方法很多，这里我采用EventWaitHandle方式来进行。

EventWaitHandle的Reset方式用来重置信号量，告诉其他运行的进程，你们需要被阻塞；Set方式用来释放信号量，告诉其他运行的进程，你们的阻塞已经被解除，可以继续运行了。

但是其他进行通过什么来知道自己是否可以解除阻塞状态呢？ 那就是利用WaitOne方式来判断:

也就是按照如下的代码模式来:

![复制代码][copycode.gif]

EventWaitHandle waitMeHandle = new EventWaitHandle(false,EventResetMode.ManualReset);
    private void ChangeText()
    {
         waitMeHandle.Reset();  //即将进入下列执行过程，其他需要阻塞
    　　//....
         waitMeHandle.Set(); //释放
    }
    private void ChangeColor()
    {
          waitMeHandle.WaitOne(); //等待，直到接收到Set信号，才能运行
         //  ...
    }

![复制代码][copycode.gif]

当然上面我举出的例子只是一个Sample,我写过这个软件,利用的是BeginInvoke和EndInvoke方式实现的异步调用,有兴趣可以参见我的这篇文章中提到的软件:

# [我的作品：PlainTextCompare][PlainTextCompare] #

下面是软件截图:

![2012010608380890.jpg][]

另外在写这篇文章的时候,我在StackOverFlow上面有过提问,就是关于当前的Thread的ThreadId为什么一致的问题, 应该说两个函数放到了ThreadPool中,结果出来的ThreadId应该不一样才对呀.

其实,正确的答案是我的打印出ThreadId的信息都放在了label1.Dispatcher.Invoke这句话中,而这个Lable1属于界面UI,也就是前台线程,所以ThreadId会是一样的,如果你直接在进入函数的时候,输出ThreadId,你就会发现两个函数运行在不同的线程上了.

[StackOverFlow的问答,请点击这里][StackOverFlow]

下面是全部代码：

![ExpandedBlockStart.gif][]

![复制代码][copycode.gif]

using System;
    using System.Text;
    using System.Windows;
    using System.Windows.Media;
    using System.Threading;
    using System.IO;
    
    namespace ThreadSynchorous
    {
        public partial class Window1 : Window
        {
            public Window1()
            {
                InitializeComponent();
                asyncInvoke = new AsyncInvoke();
            }
            AsyncInvoke asyncInvoke;
            EventWaitHandle waitMeHandle = new EventWaitHandle(false,EventResetMode.ManualReset);
    
            private void button1_Click(object sender, RoutedEventArgs e)
            {
                ThreadPool.QueueUserWorkItem(o => ChangeText());
                ThreadPool.QueueUserWorkItem(o => ChangeColor());
    
                label1.Content += " \r\n-------------------------\r\n";
            }
    
            
            private void ChangeText()
            {
                waitMeHandle.Reset();  //即将进入下列执行过程，其他需要阻塞
                this.button1.Dispatcher.Invoke((Action)(()=>
                {
                    string filename = @"C:\MyLearn\eqrms_hk_20111219_listedposn_ff\EQRMS_HK_20111219_EXO.txt";
                    using (StreamReader sr = new StreamReader(filename, Encoding.Default))
                    {
                        string result;
                        while ((result = sr.ReadLine()) != null)
                        {
                            //here perform action
                        }
                    }
                    label1.Dispatcher.Invoke((Action)(()=>
                    {
                        label1.Content += "Loading finish!(Thread.CurrentThreadName=" + Thread.CurrentThread.ManagedThreadId.ToString() + ") ";
                        waitMeHandle.Set(); //释放
                    }));
                }));
            }
    
            
            private void ChangeColor()
            {
                waitMeHandle.WaitOne(); //等待，直到接收到Set信号，才能运行
                this.button1.Dispatcher.Invoke((Action)(()=>
                {
                    this.button1.Background = Brushes.Red;
    
                    //here perform large amount of data action and color the result
    
                    label1.Dispatcher.Invoke((Action)(()=>
                    {
                        label1.Content += "Coloring finish!(Thread.CurrentThreadName=" + Thread.CurrentThread.ManagedThreadId + ") ";
                    }));
    
                }));
            }
        }
    }

![复制代码][copycode.gif]

本文中涉及到的源码,可以从[点击打开链接][Link 2]

如果你感觉这篇文章对你有帮助,帮我点一下\[推荐\]哦,谢谢!

[Link 1]: http://www.cnblogs.com/scy251147/archive/2012/01/05/2313805.html
[copycode.gif]: /images/20220823/24339737b1a449d097b9fe51e8ebeb09.png
[ExpandedBlockStart.gif]: /images/20220823/01c9f70b2c1d441fb3992bdbe0ad2409.png
[2012010608252255.jpg]: /images/20220823/b02c625732b14da5ac55638697f93f87.png
[2012010608255330.jpg]: /images/20220823/83157427ff0f4fefb1db858cd8c4d18c.png
[PlainTextCompare]: http://www.cnblogs.com/scy251147/archive/2011/12/27/2304057.html
[2012010608380890.jpg]: /images/20220823/4ce58518f01a44548b59711e48c6b92d.png
[StackOverFlow]: http://stackoverflow.com/questions/8651194/why-cant-i-use-powershell-to-create-a-network-directory
[Link 2]: http://files.cnblogs.com/scy251147/DelegateIntegrate.zip