C#秘密武器之委托

概述

在C#的世界里,委托是无处不在,尤其在.NET自己封装的框架里到处都有其身影,所以掌握委托就很有必要了!那什么是委托呢?其实委托就是一种数据类型,跟int等东东差不多,只不过在使用时要自己先去构建一个委托数据类型(不像int微软已为你准备好),然后声明一个委托类型的变量,并为其赋值,赋值的对象只能是方法,最后通过委托变量就可以进行方法调用了!

委托的简单使用

如下定义了一个委托类型 - Calculator:

delegate int Calculator (int x);

此委托适用于任何有着int返回类型和一个int类型参数的方法,如:

static int Double (int x) { return x * 2; }

创建一个委托实例,将该此方法赋值给该委托实例:

Calculator c = new Calculator(Double);

也可以简写成:

Calculator c = Double;

这个方法可以通过委托调用:

int result = c(2);

下面是完整代码:

delegate int Calculator(int x);

class Program {

    static int Double(int x) { return x * 2; }
    static void Main(string[] args) {
        Calculator c = Double;
        int result = c(2);

        Console.Write(result);
        Console.ReadKey();
    }
}

一、多路委托

委托类实际继承于MulticastDelegate,这使委托对象支持多路委托,即委托对象可以绑定多个方法。当输入参数后,每个方法会“按顺序”执行!这里不建议委托方法有返回值,即使有返回值,多路委托中的方法也只能返回最后一个方法的返回值!

例如:

MyDelegate d = MyMethod1;
// “+=” 用来添加,同理“-=”用来移除。
d += MyMethod2;
// d -= MyMethod2 

调用时,按照方法被添加的顺序依次执行。注意,对于委托,+= (实质是调用的Delegate的Combine方法)和 -= (实质是调用的Delegate的Remove方法)

MyDelegate d;
d += MyMethod1;// 相当于MyDelegate d = MyMethod1;

我们先定义一个委托(ProgressReporter),然后定义一个匹配方法(Match)来执行该委托中的所有方法。如下:

public delegate void ProgressReporter(int percentComplete);

public class Utility {
    public static void Match(ProgressReporter p) {
        if (p != null) {
            for (int i = 0; i <= 10; i++) {
                p(i * 10);
                System.Threading.Thread.Sleep(100);
            }
        }
    }
}

然后我们需要两个监视进度的方法,一个把进度写到Console,另一个把进度写到文件。如下:

class Program {
    static void Main(string[] args) {
        ProgressReporter p = WriteProgressToConsole;
        p += WriteProgressToFile;
        Utility.Match(p);
        Console.WriteLine("Done.");
        Console.ReadKey();
    }

    static void WriteProgressToConsole(int percentComplete) {
        Console.WriteLine(percentComplete+"%");
    }
    static void WriteProgressToFile(int percentComplete) {
        System.IO.File.AppendAllText("progress.txt", percentComplete + "%");
    }
}

运行结果:

C#秘密武器之委托

注意:同一类型的委托变量可以相加减!

二、委托体现的插件式编程思想

其实就是把委托(方法)作为一种方法的参数来进行传递,由于同一委托可以接收多种不同实现的方法(插件),从而实现了一种插件式编程,实现动态的扩展。

例如,我们有一个Utility类,这个类实现一个通用方法(Calculate),用来执行任何有一个整型参数和整型返回值的方法。这样说有点抽象,下面来看一个例子:

delegate int Calculator(int x);

class Program {

    static int Double(int x) { return x * 2; }
    static void Main(string[] args) {
        int[] values = { 1,2,3,4};
        Utility.Calculate(values, Double);

        foreach (int i in values)
            Console.Write(i + " "); // 2 4 6 8

        Console.ReadKey();
    }
}

class Utility {
    public static void Calculate(int[] values, Calculator c) {
        for (int i = 0; i < values.Length; i++)
            values[i] = c(values[i]);
    }
}

这个例子中的Utility是固定不变的,程序实现了整数的Double功能。我们可以把这个Double方法看作是一个插件,如果将来还要实现诸如求平方、求立方的计算,我们只需向程序中不断添加插件就可以了。

如果Double方法是临时的,只调用一次,若在整个程序中不会有第二次调用,那么我们可以在Main方法中更简洁更灵活的使用这种插件式编程,无需先定义方法,使用λ表达式即可,如:

...
Utility.Calculate(values, x => x * 2);
...

三、静态方法和实例方法对于委托的区别

当一个类的实例的方法被赋给一个委托对象时,在上下文中不仅要维护这个方法,还要维护这个方法所在的实例。System.Delegate 类的Target属性指向的就是这个实例。举个例子:

class Program {
    static void Main(string[] args) {
        X x = new X();
        ProgressReporter p = x.InstanceProgress;
        p(1);
        Console.WriteLine(p.Target == x); // True
        Console.WriteLine(p.Method); // Void InstanceProgress(Int32)
    }

    static void WriteProgressToConsole(int percentComplete) {
        Console.WriteLine(percentComplete+"%");
    }
    static void WriteProgressToFile(int percentComplete) {
        System.IO.File.AppendAllText("progress.txt", percentComplete + "%");
    }
}

class X {
    public void InstanceProgress(int percentComplete) {
        // do something
    }
}

但对于静态方法,System.Delegate 类的Target属性是Null,所以将静态方法赋值给委托时性能更优。

四、泛型委托

如果你知道泛型,那么就很容易理解泛型委托,说白了就是含有泛型参数的委托,例如:

public delegate T Calculator<T> (T arg);

我们可以把前面的例子改成泛型的例子,如下:

public delegate T Calculator<T>(T arg);

class Program {

    static int Double(int x) { return x * 2; }
    static void Main(string[] args) {
        int[] values = { 1, 2, 3, 4 };
        Utility.Calculate(values, Double);

        foreach (int i in values)
            Console.Write(i + " "); // 2 4 6 8

        Console.ReadKey();
    }
}

class Utility {
    public static void Calculate<T>(T[] values, Calculator<T> c) {
        for (int i = 0; i < values.Length; i++)
            values[i] = c(values[i]);
    }
}

Func委托

委托 Func 支持 0~16 个参数,Func 必须具有返回值

public delegate TResult Func<TResult>()
public delegate TResult Func<T1,TResult>(T1 obj1)
public delegate TResult Func<T1,T2,TResult>(T1 obj1,T2 obj2)
public delegate TResult Func<T1,T2,T3,TResult>(T1 obj1,T2 obj2,T3 obj3)
............
public delegate TResult Func<T1,T2,T3,......,T16,TResult>(T1 obj1,T2 obj2,T3 obj3,......,T16 obj16)

static void Main(string[] args)
        {
            Func<double, bool, double> func = Account;
            double result=func(1000, true);
            Console.WriteLine("Result is : "+result);
            Console.ReadKey();
        }

        static double Account(double a,bool condition)
        {
            if (condition)
                return a * 1.5;
            else
                return a * 2;
        }

Action委托

Action<T> 的返回值为 void,也就是没有返回值!
Action 支持0~16个参数,可以按需求任意使用。

public delegate void Action()
public delegate void Action<T1>(T1 obj1)
public delegate void Action<T1,T2> (T1 obj1, T2 obj2)
public delegate void Action<T1,T2,T3> (T1 obj1, T2 obj2,T3 obj3)
............
public delegate void Action<T1,T2,T3,......,T16> (T1 obj1, T2 obj2,T3 obj3,......,T16 obj16)

static void Main(string[] args)
        {
            Action<string> action=ShowMessage;
            action("Hello World");
            Console.ReadKey();
        }

        static void ShowMessage(string message)
        {
            MessageBox.Show(message);
        }

Predicate<T>委托

Predicate只有一个参数,且返回值总是为bool类型!

public delegate bool Predicate<T>(T obj)

internal class PredicateDelegate
    {
        public bool PredicateMethod(int x )
        {
            return x > 50;
        }
    }
     PredicateDelegate predicateDelegate = new PredicateDelegate();
      // 只有一个参数 并返回bool 值
     Predicate<int> predicate = predicateDelegate.PredicateMethod;
     bool results =predicate(60);
     Console.WriteLine(results);

Comparison委托


public delegate int Comparison<in T>(T x, T y)

为返回int类型的内置委托。T是要比较的对象的类型,而返回值是一个有符号整数,指示 x 与 y 的相对值,如下表所示:

含义

小于 0

x 小于 y。

0

x 等于 y。

大于 0

x 大于 y。

  此委托由 Array 类的 Sort<T>(T[], Comparison<T>) 方法重载和 List<T> 类的 Sort(Comparison<T>) 方法重载使用,用于对数组或列表中的元素进行排序

五、匿名方法和Lambda表达式

匿名方法

如果某个委托变量需要绑定的方法只用一次的话,其实是没有必要为方法起名的,直接用匿名方法会比较好!我们总是使用 delegate(){......} 的方式建立匿名方法!

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

namespace DelegateSamples
{
    //声明一个委托,参数为string,无返回值
    delegate void DelSamples(string msg);
    class Program
    {
        static void Main(string[] args)
        {
          //匿名委托
          DelSamples delSample4 = delegate(string msg)
          {
              Console.WriteLine("你好,我是{0}", msg);
          };
          delSample4("KoalaStudio");

          //利用Lambda表达式实现匿名委托
          DelSamples delSample5 = (string msg) => {
             Console.WriteLine("你好,我是{0}", msg);
          };
          delSample5("KoalaStudio");

          Console.ReadKey();
        }

    }
}

Lambda表达式

匿名方法的优雅写法就是Lambda表达式!

注意事项:

①Lambda表达式中的参数列表(参数数量、类型和位置)必须与委托相匹配

②表达式中的参数列表不一定需要包含类型,除非委托有ref或out关键字(此时必须显示声明);

如果没有参数,必须使用一组空的圆括号

static void Main(string[] args)
        {
            Action<int> action = (x) =>
            {
                x = x + 500;
                Console.WriteLine("Result is : " + x);
            };
            action.Invoke(1000);
            Console.ReadKey();
        }

六、异步委托

public delegate int Ad(int x,int y);
        static void Main(string[] args)
        {
            xu xus = new xu();
            Ad a = new Ad(Add);
            Console.WriteLine(a(3, 3));
            Console.WriteLine("start");
            Console.ReadLine();
        }
static int Add(int x, int y)
        {
            Thread.Sleep(2000);
            return x + y;
        }

运行这段代码 会先停顿2秒钟之后再显示6 和start 因为我使用了sleep这个方法 它使该线程休眠2秒钟,所以会在2秒之后显示信息,但是这对用户体验来说是非常糟糕的,那我们怎么改善呢?看看如下代码

public delegate int Ad(int x,int y);
        static void Main(string[] args)
        {
            xu xus = new xu();
            Ad a = new Ad(Add);
            Console.WriteLine(a(3, 3));
           // Console.WriteLine("start");
           IAsyncResult isa= a.BeginInvoke(3, 3, null, null);
           while (!isa.IsCompleted)
           { 
            Console.WriteLine("未完成");
           }
          int s= a.EndInvoke(isa);
          Console.WriteLine(s.ToString());
             Console.ReadLine();
        }
         static int Add(int x, int y)
        {
            Thread.Sleep(2000);
            return x + y;
        }
        static int ex(int x, int y)
        {
            //Thread.Sleep(5000);
            return x - y;
        }

这里我们使用了begininvoke方法来异步执行 委托方法返回一个IAsyncResult 类型的值 代表委托执行的状态,使用一个while循环 来判断IsCompleted 如果没有完成异步调用则不断显示“未完成” 如果完成endinvoke 则返回结果。但是这里需要不断的询问操作完成状态 那么我们怎样让委托异步调用完成之后主动通知我们呢? 看看如下代码

public delegate int Ad(int x,int y);
        static void Main(string[] args)
        {
            xu xus = new xu();
            Ad a = new Ad(Add);
            Console.WriteLine(a(3, 3));
            IAsyncResult isa= a.BeginInvoke(3, 3, new AsyncCallback(call), "edit by xyl");
            //执行你想执行的代码 这里我们还是用IsCompleted来代替
           while (!isa.IsCompleted)
           { 
            Console.WriteLine("未完成");
           }
            Console.ReadLine();
        }
        static void call(IAsyncResult isa)
        {
            AsyncResult ar = (AsyncResult)isa;
            Ad a = (Ad)ar.AsyncDelegate;
            Console.WriteLine("this is {0},{1}",a.EndInvoke(isa),ar.AsyncState);
        }

        static int Add(int x, int y)
        {
            Thread.Sleep(2000);
            return x + y;
        }
        static int ex(int x, int y)
        {
            //Thread.Sleep(5000);
            return x - y;
        }
    }

这里我们使用了一个call方法 注意它是没有返回值的。把IAsyncResult转换成AsyncResult注意少了个I然后转换成AD 类型的委托 最后endinvoke 来返回值 这样在委托异步执行完成之后会自动通知方法。

注意:回调函数是在 ThreadPool线程上进行的,因此主线程将继续执行。ThreadPool线程是后台线程,这些线程不会在主线程结束后保持应用程序的运行,因此主线程必须休眠足够长的时间以便回调完成。我们也可以在主线程完成操作后调用IsCompleted属性判断委托函数是否完成。

七、事件

事件其实就是某种类型的委托,在给事件赋值时,用符合该委托的方法就行!

public delegate void PriceChangedHandler (decimal oldPrice, decimal newPrice);
public class IPhone6
{
    public event PriceChangedHandler PriceChanged;
}

事件的使用和委托完全一样,只是多了些约束。下面是一个简单的事件使用例子:

public delegate void PriceChangedHandler(decimal oldPrice, decimal newPrice);

public class IPhone6 {
    decimal price;
    public event PriceChangedHandler PriceChanged;
    public decimal Price {
        get { return price; }
        set {
            if (price == value) return;
            decimal oldPrice = price;
            price = value;
            // 如果调用列表不为空,则触发。
            if (PriceChanged != null)
                PriceChanged(oldPrice, price);
        }
    }
}

class Program {
    static void Main() {
        IPhone6 iphone6 = new IPhone6() { Price = 5288 };
        // 订阅事件
        iphone6.PriceChanged += iphone6_PriceChanged;

        // 调整价格(事件发生)
        iphone6.Price = 3999;

        Console.ReadKey();
    }

    static void iphone6_PriceChanged(decimal oldPrice, decimal price) {
        Console.WriteLine("年终大促销,iPhone 6 只卖 " + price + " 元, 原价 " + oldPrice + " 元,快来抢!");
    }
}

运行结果:

C#秘密武器之委托

有人可能会问,如果把上面的event关键字拿掉,结果不是一样的吗,到底有何不同?

没错可以用事件的地方就一定可以用委托代替。

但事件有一系列规则和约束用以保证程序的安全可控,事件只有 += 和 -= 操作,这样订阅者只能有订阅或取消订阅操作,没有权限执行其它操作。如果是委托,那么订阅者就可以使用 = 来对委托对象重新赋值(其它订阅者全部被取消订阅),甚至将其设置为null,甚至订阅者还可以直接调用委托,这些都是很危险的操作,广播者就失去了独享控制权。

事件保证了程序的安全性和健壮性。

事件的标准模式

.NET 框架为事件编程定义了一个标准模式。设定这个标准是为了让.NET框架和用户代码保持一致。System.EventArgs是标准模式的核心,它是一个没有任何成员,用于传递事件参数的基类。
按照标准模式,我们对于上面的iPhone6示例进行重写。首先定义EventArgs:

public class PriceChangedEventArgs : EventArgs {
    public readonly decimal OldPrice;
    public readonly decimal NewPrice;
    public PriceChangedEventArgs(decimal oldPrice, decimal newPrice) {
        OldPrice = oldPrice;
        NewPrice = newPrice;
    }
}

然后为事件定义委托,必须满足以下条件:

  • 必须是 void 返回类型;
  • 必须有两个参数,且第一个是object类型,第二个是EventArgs类型(的子类);
  • 它的名称必须以EventHandler结尾。

由于考虑到每个事件都要定义自己的委托很麻烦,.NET 框架为我们预定义好一个通用委托System.EventHandler<TEventArgs>:

public delegate void EventHandler<TEventArgs> (object source, TEventArgs e) where TEventArgs : EventArgs;

如果不使用框架的EventHandler<TEventArgs>,我们需要自己定义一个:

public delegate void PriceChangedEventHandler (object sender, PriceChangedEventArgs e);

如果不需要参数,可以直接使用EventHandler(不需要<TEventArgs>)。有了EventHandler<TEventArgs>,我们就可以这样定义示例中的事件:

public class IPhone6 {
    ...
    public event EventHandler<PriceChangedEventArgs> PriceChanged;
    ...
}

最后,事件标准模式还需要写一个受保护的虚方法来触发事件,这个方法必须以On为前缀,加上事件名(PriceChanged),还要接受一个EventArgs参数,如下:

public class IPhone6 {
    ...
    public event EventHandler<PriceChangedEventArgs> PriceChanged;
    protected virtual void OnPriceChanged(PriceChangedEventArgs e) {
        if (PriceChanged != null) PriceChanged(this, e);
    }
    ...
}

下面给出完整示例:

public class PriceChangedEventArgs : System.EventArgs {
    public readonly decimal OldPrice;
    public readonly decimal NewPrice;
    public PriceChangedEventArgs(decimal oldPrice, decimal newPrice) {
        OldPrice = oldPrice;
        NewPrice = newPrice;
    }
}

public class IPhone6 {
    decimal price;
    public event EventHandler<PriceChangedEventArgs> PriceChanged;

    protected virtual void OnPriceChanged(PriceChangedEventArgs e) {
        if (PriceChanged != null) PriceChanged(this, e);
    }

    public decimal Price {
        get { return price; }
        set {
            if (price == value) return;
            decimal oldPrice = price;
            price = value;
            // 如果调用列表不为空,则触发。
            if (PriceChanged != null)
                OnPriceChanged(new PriceChangedEventArgs(oldPrice, price));
        }
    }
}

class Program {
    static void Main() {
        IPhone6 iphone6 = new IPhone6() { Price = 5288M };
        // 订阅事件
        iphone6.PriceChanged +=iphone6_PriceChanged;

        // 调整价格(事件发生)
        iphone6.Price = 3999;
        Console.ReadKey();
    }

    static void iphone6_PriceChanged(object sender, PriceChangedEventArgs e) {
        Console.WriteLine("年终大促销,iPhone 6 只卖 " + e.NewPrice + " 元, 原价 " + e.OldPrice + " 元,快来抢!");
    }
}

运行结果:

C#秘密武器之委托 

C#秘密武器之委托

上一篇:8、云数据库


下一篇:mysql数据迁移至浪潮数据库