将方法绑定到委托

将方法绑定到委托

      GreetingDelegate delegate1, delegate2;
　　delegate1 = EnglishGreeting;
　　delegate2 = ChineseGreeting;
　　GreetPeople("Jimmy Zhang", delegate1);
　　GreetPeople("张子阳", delegate2);
    →
　　GreetingDelegate delegate1;
　　delegate1 = EnglishGreeting;  //赋值
　　delegate1 += ChineseGreeting; //再绑定
　　GreetPeople("Jimmy Zhang", delegate1);  // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
or
    GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
　　delegate1 += ChineseGreeting;
　　GreetPeople("Jimmy Zhang", delegate1);

前面的例子中，我不一定要直接在GreetPeople()方法中给 name参数赋值，我可以像这样使用变量：
　　static void Main(string[] args) {
　　string name1, name2;
　　name1 = "Jimmy Zhang";
　　name2 = "张子阳";
　　GreetPeople(name1, EnglishGreeting);
　　GreetPeople(name2, ChineseGreeting);
　　Console.ReadKey();
　　}
　　而既然委托GreetingDelegate 和 类型 string 的地位一样，都是定义了一种参数类型，那么，我是不是也可以这么使用委托？
　　static void Main(string[] args) {
　　GreetingDelegate delegate1, delegate2;
　　delegate1 = EnglishGreeting;
　　delegate2 = ChineseGreeting;
　　GreetPeople("Jimmy Zhang", delegate1);
　　GreetPeople("张子阳", delegate2);
　　Console.ReadKey();
　　}
　　如你所料，这样是没有问题的，程序一如预料的那样输出。这里，我想说的是委托不同于string的一个特性：可以将多个方法赋给同一个委托，或者叫将多个方法绑定到同一个委托，当调用这个委托的时候，将依次调用其所绑定的方法。在这个例子中，语法如下：
　　static void Main(string[] args) {
　　GreetingDelegate delegate1;
　　delegate1 = EnglishGreeting; // 先给委托类型的变量赋值
　　delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法
　　// 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
　　GreetPeople("Jimmy Zhang", delegate1);
　　Console.ReadKey();
　　}
　　输出为：
　　Morning, Jimmy Zhang
　　早上好, Jimmy Zhang

 实际上，我们可以也可以绕过GreetPeople方法，通过委托来直接调用EnglishGreeting和ChineseGreeting：
　　static void Main(string[] args) {
　　GreetingDelegate delegate1;
　　delegate1 = EnglishGreeting; // 先给委托类型的变量赋值
　　delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法
　　// 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
　　delegate1 ("Jimmy Zhang");
　　Console.ReadKey();
　　}
　　NOTE：这在本例中是没有问题的，但回头看下上面GreetPeople()的定义，在它之中可以做一些对于EnglshihGreeting和ChineseGreeting来说都需要进行的工作，为了简便我做了省略。
　　注意这里，第一次用的“=”，是赋值的语法；第二次，用的是“+=”，是绑定的语法。如果第一次就使用“+=”，将出现“使用了未赋值的局部变量”的编译错误。

 我们也可以使用下面的代码来这样简化这一过程：
　　GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
　　delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法
　　看到这里，应该注意到，这段代码第一条语句与实例化一个类是何其的相似，你不禁想到：上面第一次绑定委托时不可以使用“+=”的编译错误，或许可以用这样的方法来避免：
　　GreetingDelegate delegate1 = new GreetingDelegate();
　　delegate1 += EnglishGreeting; // 这次用的是 “+=”，绑定语法。
　　delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法
　　但实际上，这样会出现编译错误： “GreetingDelegate”方法没有采用“0”个参数的重载。尽管这样的结果让我们觉得有点沮丧，但是编译的提示：“没有0个参数的重载”再次让我们联想到了类的构造函数。我知道你一定按捺不住想探个究竟，但再此之前，我们需要先把基础知识和应用介绍完。

既然给委托可以绑定一个方法，那么也应该有办法取消对方法的绑定，很容易想到，这个语法是“-=”：

static void Main(string[] args) {
　　GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);
　　delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法
　　// 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
　　GreetPeople("Jimmy Zhang", delegate1);
　　Console.WriteLine();
　　delegate1 -= EnglishGreeting; //取消对EnglishGreeting方法的绑定
　　// 将仅调用 ChineseGreeting
　　GreetPeople("张子阳", delegate1);
　　Console.ReadKey();
　　}
　　输出为：
　　Morning, Jimmy Zhang
　　早上好, Jimmy Zhang
　　早上好, 张子阳

让我们再次对委托作个总结：

使用委托可以将多个方法绑定到同一个委托变量，当调用此变量时(这里用“调用”这个词，是因为此变量代表一个方法)，可以依次调用所有绑定的方法。

using System;
using System.Collections.Generic;
using System.Text;
namespace Delegate
{
    //定义委托，它定义了可以代表的方法的类型
    public delegate void GreetingDelegate(string name);

    class Program
    {
        private static void EnglishGreeting(string name)
        {
            Console.WriteLine("Morning, " + name);
        }
        private static void ChineseGreeting(string name)
        {
            Console.WriteLine("早上好, " + name);
        }

        //注意此方法，它接受一个GreetingDelegate类型的方法作为参数
        private static void GreetPeople(string name, GreetingDelegate MakeGreeting)
        {
            MakeGreeting(name);
        }

        static void Main(string[] args)
        {
            GreetingDelegate delegate1 = new GreetingDelegate(EnglishGreeting);

            delegate1 += ChineseGreeting; // 给此委托变量再绑定一个方法
            // 将先后调用 EnglishGreeting 与 ChineseGreeting 方法
            GreetPeople("Jimmy Zhang", delegate1);
            Console.WriteLine();

            delegate1 -= EnglishGreeting; //取消对EnglishGreeting方法的绑定
            // 将仅调用 ChineseGreeting
            GreetPeople("张子阳", delegate1);
            Console.WriteLine();

            Console.ReadKey();
        }
    }
}

 

 

 

----------------------------------------------------------------------------------

委托的加减

using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApp
{
    class Delegate_AddMinus
    {
        public static void Main()
        {
            BankCardSS card1 = new BankCardSS();
            card1.m_id = "001";
            CreditCardS card2 = new CreditCardS();
            card2.m_id = "002";
            MDelegateS d1 = new MDelegateS(card1.Desposit);
            MDelegateS d2 = new MDelegateS(card2.Desposit);
            MDelegateS d3 = d1 + d2; //合并委托
            d3(100);
            d3 = d3 - d1;//删除委托
            d3 = d3 + new MDelegateS(card2.Borrow); //合并委托
            d3(50);

            Console.Read();
        }
    }

    delegate void MDelegateS(uint i);

    class BankCardSS
    {
        public string m_id;
        public uint m_amount;

        public void Desposit(uint x)
        {
            m_amount = m_amount + x;
            Console.WriteLine("卡{0}:存入{1}元,余额{2}元",m_id ,x,m_amount);
        }

        public void withdraw(uint x)
        {
            m_amount = m_amount - x;
            Console.WriteLine("卡{0}:取出{1}元,余额{2}元", m_id, x, m_amount);
        }
    }

    class CreditCardS : BankCardSS
    {
        public uint m_debit;
        public void Borrow(uint x)
        {
            m_debit = m_debit - x;
            Console.WriteLine("信用卡{0}:贷款{1}元",m_id ,x);
        }
    }
}

卡001:存入100元,余额100元
卡002:存入100元,余额100元
卡002:存入50元,余额150元
信用卡002:贷款50元