委托与事件（2）

最新推荐文章于 2024-07-15 00:20:44 发布

宁大爷的博客

最新推荐文章于 2024-07-15 00:20:44 发布

阅读量387

点赞数

分类专栏： C#基础文章标签：委托事件

C#基础专栏收录该内容

4 篇文章 0 订阅

订阅专栏

原创链接

网上讲C#委托和事件的博文已经非常多了，其中也不乏一些深入浅出、条理清晰的文章。我之所以还是继续写，主要是借机整理学习笔记、归纳总结从而理解更透彻，当然能够以自己的理解和思路给其他人讲明白更好。
另外，太长的文章会让很多读者失去兴趣，所以我决定把这篇分成四个部分来介绍。分别是委托的基础、委托的进阶、事件的基础和事件的进阶。对使用委托与事件要求不高的同学可以跳过进阶部分。

本文接着讲委托的高级知识，上一节请参见C#委托与事件(1)。

4. 委托的高级知识

(1) 委托的类组成

前面我们介绍过了，委托实际上也是一个类，只不过它的对象不是一个普通的变量，而是一个方法。但是我们实际使用时并不需要定义这个类，而只是声明一下委托即可。这是因为当C#编译器处理委托类型时，会自动产生一个派生自System.MulticastDelegate的密封类，这个类与它的基类System.Delegate一起为委托提供必要的基础设施。
下面我们就以上一节中声明的委托delegate void GreetingDelegate(string s);来看看该类的组成。

public sealed class GreetingDelegate : System.MulticastDelegate
{
    public void Invoke(string s);
    public IAsyncResult BeginInvoke(string s, AsyncCallback cb, object state);
    public void EndInvoke(IAsyncResult result);
}```
可以看到，该类中定义了三个公共方法：
(a) `Invoke()`，它被用来以同步方式调用委托对象维护的每个方法。所谓同步是指调用者必须等待调用完成才能继续执行。`Invoke()`方法定义的参数和返回值完全匹配我们要定义的类`GreetingDelegate`。另外，`Invoke()`不能直接调用，而是在后台调用。
(b) `BeginInvoke()`，用于异步调用，它最前面的参数列表是`GreetingDelegate`定义的方法类的参数列表，此外，还有两个参数`AsyncCallback`和`object`用于异步方法调用。
(c) `EndInvoke()`，与`BeginInoke()`联合用于异步调用，它的返回值与委托声明的返回值一致，而它的唯一参数则是`BeginInvoke()`返回的类型`IAsyncResult`接口。

另外，上面我们定义的委托没有返回值，也可以定义返回值类型，这样`Invoke()`和`EndInvoke()`对应的返回值就不是`void`了。委托还可以指向包含任意数量`out`或者`ref`参数的方法，按道理只有`Invoke()`和`BeginInvoke()`方法与委托的参数列表有关，需要加上相应的`out`或者`ref`参数，但是由于异步调用时需要通过`EndInvoke()`来返回结果，所以`EndInvoke()`的参数列表中需要加上`out`或者`ref`参数。

下面简单介绍一下委托类的父类`System.MulticastDelegate`。

public abstract class MulticastDelegate : Delegate
{
// 返回所指向的方法列表
public sealed override Delegate[] GetInvocationList();
// 重载等于和不等于操作符
public static bool operator ==(MulticastDelegate d1, MulticastDelegate d2);
public static bool operator !=(MulticastDelegate d1, MulticastDelegate d2);

// 用来在内部管理委托所维护的方法列表
private IntPtr _invocationCount;
private object _invocationList;

}

public abstract class Delegate : IConeable, ISerializable
{
// 与函数列表交互的方法
// 给委托维护的列表添加一个方法，在C#中使用重载+=操作符调用此方法
public static Delegate Combine(params Delegate[] delegates);
public static Delegate Combine(Delegate a, Delegate b);
// 从调用列表中移除一个或所有的方法，在C#中使用-=操作符调用此方法
public static Delegate Remove(Delegate source, Delegate value);
public static Delegate RemoveAll(Delegate source, Delegate value);

// 重载操作符
public static bool operator ==(Delegate d1, Delegate d2);
public static bool operator !=(Delegate d1, Delegate d2);

// 扩展委托目标的属性
public MethodInfo Method { get; } //用以表示委托维护的静态方法的详细信息
public object Target { get; } // 如果方法调用是定义在对象级别的，
                              // Target返回表示委托维护的方法的对象；
                              // 如果调用的方法时一个静态成员，
                              // Target返回null

}

#####(2) 泛型委托
`C#`允许我们定义泛型委托，即当我们定义的委托接受的参数可能会不同时，我们可以通过类型参数来构建。下面我们来改写一下上一节中定义的那个委托，使得它不仅支持传入`string`，还支持传入整型。

namespace TestDelegate
{
delegate void GreetingDelegate<T>(T arg);
class Program
{
public static void Hello(string s)
{
Console.WriteLine(” Hello, {0}!”, s);
// do something (hug or shake hand…)
}

    public static void Goodbye(string s)
    {
        Console.WriteLine("  Goodbye, {0}!", s);
        // do something (hug or wave hand...)
    }

    public static void GreetingTimes(int n)
    {
        Console.WriteLine("  Greeting {0} times!", n); 
    }

    static void MakeGreeting<T>(T name, GreetingDelegate<T> greeting)
    {
        greeting(name);
    }

    static void Main(string[] args)
    {
        GreetingDelegate<string> d1 = Hello;        //定义委托的一个对象（将方法绑定到委托）
        d1 += Goodbye;                              // 在d1上再绑定一个委托
        GreetingDelegate<int> d2 = GreetingTimes;   //定义委托的另一个对象
        MakeGreeting("April", d1);
        MakeGreeting(99, d2);
    }
}

}

输出内容：

Hello, April!
Goodbye, April!
Greeting 99 times!

有了泛型委托，很多方法都可以用一个委托模板表示出来，因此`C#`中提供了两个常用的泛型委托`Action<T>`和`Func<T>`来避免用户手工构建自定义委托的麻烦。
######Action<T>
`Action<T>`泛型委托定义的方法，参数列表可以多至16个（使用时需要指定各个参数的类型），返回值为`void`。
例如，我们有一个方法为`static void DisplayMessage(string msg, ConsoleColor txtColor, int printCount)`，若把它作为`Action<T>`委托的一个目标，则委托的实例化时需要这样写：
`Action<string, ConsoleColor, int) actionTarget = new Action<string, ConsoleColor, int>(DisplayMessage);`
调用委托方法时：
`actionTarget("your input string", ConsoleColor.Green, 2);`

######Func<T>
`Func<T>`泛型委托也可以指向多至16个参数的方法，但与`Action<T>`不同的是，它具有自定义的返回值，具体用法类似，不再赘述。

#####(3) 委托的异步调用
在说委托的异步调用之前，我们先对第一节最早的`delegate`例子做一个简单的改进，看看它的工作流程。首先，`MakeGreeting()`方法中除了调用`greeting()`之外，需要再调用一个额外的方法`FuncAfterGreeting()`。然后，我们定义了`GreetingDelegate`的一个对象`d1`，并在`d1`上绑定了`Hello()`和`Goodbye()`方法。最后我们调用`MakeGreeting()`方法来看看输出结果。

namespace AsyncDelegateTest
{
delegate void GreetingDelegate(string arg);
class Program
{
public static void Hello(string s)
{
Console.WriteLine(” Hello, {0}!”, s);
Console.WriteLine(” Waiting for 1 second”);
Thread.Sleep(1000);
Console.WriteLine(” Finished Hello”);
}

    public static void Goodbye(string s)
    {
        Console.WriteLine("  Goodbye, {0}!", s);
        Console.WriteLine("  Waiting for 2 second");
        Thread.Sleep(2000);
        Console.WriteLine("  Finished Goodbye");
    }

    public static void FuncAfterGreeting()
    {
        Console.WriteLine("  Do some other things...");
        Console.WriteLine("  Waiting for 3 second");
        Thread.Sleep(3000);
        Console.WriteLine("  Finished FuncAfterGreeting");
    }

    static void MakeGreeting(string name, GreetingDelegate greeting)
    {
        greeting(name); // 这里相当于是greeting.Invoke(name);
        FuncAfterGreeting();
    }

    static void Main(string[] args)
    {
        GreetingDelegate d1 = Hello;     //定义委托的一个对象（将方法绑定到委托）
        d1 += Goodbye;                  //定义委托的另一个对象
        MakeGreeting("April", d1);
    }
}

}“`

输出结果：

  Hello, April!
  Waiting for 1 second
  Finished Hello
  Goodbye, April!
  Waiting for 2 second
  Finished Goodbye
  Do some other things...
  Waiting for 3 second
  Finished FuncAfterGreeting

从输出我们可以看到MakeGreeting()方法中，首先调用了Hello()方法，并运行完毕；然后调用了Goodbye()方法，并运行完毕；最后调用FuncAfterGreeting()，并运行完毕；至此，整个MakeGreeting()方法运行完毕。
这就是采用同步的方式调用委托，这样委托对象绑定的每个方法要依次执行，而且后者必须等前者执行完毕之后才能开始执行。另外，只有把委托对象绑定的所有方法执行完毕后才能回到MakeGreeting()方法中继续往下执行。

而在(1)中我们介绍的BeginInvoke()和EndInvoke()函数能使委托实现异步调用，所谓异步调用，就是在上例中MakeGreeting()方法中的线程去执行greeting方法时利用线程池中的线程去实现调用，自己则继续往下执行。有了BeginInvoke()和EndInvoke()这两个函数后，异步调用就很简单了，直接先用greeting调用BeginInvoke()函数，然后就可以做其他的事情，结束之间再调用EndInvoke()即可。

namespace AsyncDelegateTest2
{
    delegate void GreetingDelegate(string arg);
    class Program
    {
        public static void Hello(string s)
        {
            Console.WriteLine("  Hello, {0}!", s);
            Console.WriteLine("  Waiting for 3 second");
            Thread.Sleep(3000);
            Console.WriteLine("  Finished Hello");
        }

        public static void FuncAfterGreeting()
        {
            Console.WriteLine("  Do some other things...");
            Console.WriteLine("  Waiting for 3 second");
            Thread.Sleep(3000);
            Console.WriteLine("  Finished FuncAfterGreeting");
        }

        static void MakeGreeting(string name, GreetingDelegate greeting)
        {
            IAsyncResult result = greeting.BeginInvoke(name, null, null);
            FuncAfterGreeting();
            greeting.EndInvoke(result);
        }

        static void Main(string[] args)
        {
            GreetingDelegate d1 = Hello;     //定义委托的一个对象（将方法绑定到委托）
            MakeGreeting("April", d1);
        }
    }
}

输出结果：

  Do some other things...
  Hello, April!
  Waiting for 3 second
  Waiting for 3 second
  Finished Hello
  Finished FuncAfterGreeting

为什么我这里把Goodbye方法去掉了，这是因为BeginInvoke()只能在绑定了单个方法的delegate上调用，如果我们在d1上还绑定了其他方法，那么去调用BeginInvoke()的时候会出现下面的异常：

Unhandled Exception: System.ArgumentException: The delegate must have only one target.```

当然如果你一定要绑定多个方法这样用的话，可以先通过`GetInvocationList()`获得绑定的方法列表，然后依次调用`BeginInvoke()`方法。

namespace AsyncDelegateTest3
{
delegate void GreetingDelegate(string arg);
class Program
{
public static void Hello(string s)
{
Console.WriteLine(” Hello, {0}!”, s);
Console.WriteLine(” Waiting for 3 second”);
Thread.Sleep(3000);
Console.WriteLine(” Finished Hello”);
}

    public static void Goodbye(string s)
    {
        Console.WriteLine("  Goodbye, {0}!", s);
        Console.WriteLine("  Waiting for 2 second");
        Thread.Sleep(2000);
        Console.WriteLine("  Finished Goodbye");
    }

    public static void FuncAfterGreeting()
    {
        Console.WriteLine("  Do some other things...");
        Console.WriteLine("  Waiting for 3 second");
        Thread.Sleep(3000);
        Console.WriteLine("  Finished FuncAfterGreeting");
    }

    static void MakeGreeting(string name, GreetingDelegate greeting)
    {
        Delegate[] delArray = greeting.GetInvocationList();
        foreach (var d in delArray)
        {
            var del = (GreetingDelegate)d;
            IAsyncResult result = del.BeginInvoke(name, null, null);
        }
        FuncAfterGreeting();
    }

    static void Main(string[] args)
    {
        GreetingDelegate d1 = Hello;     // 定义委托的一个对象（将方法绑定到委托）
        d1 += Goodbye;                  // 定义委托的另一个对象
        MakeGreeting("April", d1);
        Console.ReadLine(); // 如果不加这行的话，很可能Hello方法还没执行完程序就退出了，
                            // 因为我们没有调用EndInvoke()去检查它们的状态
    }
}

}

输出结果：

Do some other things…
Hello, April!
Goodbye, April!
Waiting for 2 second
Waiting for 3 second
Waiting for 3 second
Finished Goodbye
Finished FuncAfterGreeting
Finished Hello

回到`AsyncDelegateTest2`，这里其实还存在一个问题。那就是`MakeGreeting()`方法中的这句话`greeting.EndInvoke(result);`，如果`Hello()`方法需要执行30s，那么3s后`FuncAfterGreeting()`方法就执行完毕了，主线程执行到`EndInvoke()`这句话。而这句话就相当于让主线程一直去查询`Hello()`方法是否执行完毕。那么问题来了，能不能不要这么麻烦主线程，而是让`Hello()`方法执行完毕后自动告诉主线程呢？这就是异步回调。

namespace AsyncDelegateTest4
{
delegate void GreetingDelegate(string arg);
class Program
{
public static void Hello(string s)
{
Console.WriteLine(” Hello, {0}!”, s);
Console.WriteLine(” Waiting for 5 second”);
Thread.Sleep(5000);
Console.WriteLine(” Finished Hello”);
}

    public static void FuncAfterGreeting()
    {
        Console.WriteLine("  Do some other things...");
        Console.WriteLine("  Waiting for 3 second");
        Thread.Sleep(3000);
        Console.WriteLine("  Finished FuncAfterGreeting");
    }

    static void MakeGreeting(string name, GreetingDelegate greeting)
    {
        IAsyncResult result = greeting.BeginInvoke(name, new AsyncCallback(FuncForCallBack), "AsycState:OK");
        FuncAfterGreeting();
    }

    static void FuncForCallBack(IAsyncResult result)
    {
        // AsyncResult should using System.Runtime.Remoting.Messaging
        GreetingDelegate handler = (GreetingDelegate)((AsyncResult)result).AsyncDelegate;
        handler.EndInvoke(result);
        Console.WriteLine(result.AsyncState);
    }

    static void Main(string[] args)
    {
        GreetingDelegate d1 = Hello;
        MakeGreeting("April", d1);
        Console.ReadLine();
    }
}

}

输出结果：

Do some other things…
Hello, April!
Waiting for 5 second
Waiting for 3 second
Finished FuncAfterGreeting
Finished Hello
AsycState:OK

这里我们定义了一个回调函数`FuncForCallBack()`，这样就不需要在`MakeGreeting()`方法的最后显示地去调用`EndInvoke()`去检查委托方法的执行状态了。

参考文献：
《精通C#》
[张子阳的《C# 中的委托和事件》](http://www.cnblogs.com/JimmyZhang/archive/2007/09/23/903360.html)
[Delegates Tutorial](https://msdn.microsoft.com/en-us/library/aa288436(v=vs.71).aspx)
[也来说说C#异步委托](http://www.cnblogs.com/lxblog/archive/2012/12/11/2813893.html)
[C#委托的异步调用](http://www.csharpwin.com/csharpspace/12393r3151.shtml)