[C#] 委托与事件(2)

526 查看

网上讲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定义的方法类的参数列表,此外,还有两个参数AsyncCallbackobject用于异步方法调用。
(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# 中的委托和事件》
Delegates Tutorial
也来说说C#异步委托
C#委托的异步调用


2018 - 知识虫 - 我的知识库 渝ICP备16002641号-2

渝公网安备 50010702501581号