一.委托和异步调用：
先上代码：
public class AsyncClass
{
private List<string> output=new List<string>();
public List<string> OutPut { get { return output; } }
public AsyncClass()
{
Timer solwTimer = new Timer(new TimerCallback(OnTimerCallBack), "slow", 2500, 2500);
Timer fastTimer = new Timer(new TimerCallback(OnTimerCallBack), "fast", 2000, 2000);
output.Add("mid");
}
private void OnTimerCallBack(object state)
{
output.Add(state.ToString());
}
}
static void Main(string[] args)
{
AsyncClass asyncClass=new AsyncClass();
System.Threading.Thread.Sleep(3000);
Console.WriteLine(asyncClass.OutPut[0]);
Console.WriteLine(asyncClass.OutPut[1]);
Console.WriteLine(asyncClass.OutPut[2]);
Console.Read();
//Assert.AreEqual("slow", asyncClass.OutPut[0]);
//Assert.AreEqual("fast", asyncClass.OutPut[1]);
//Assert.AreEqual("mid", asyncClass.OutPut[1]);
}
按理应该先执行slow->fast->mid
实际上不是这样。
slow和fast都是异步调用，应该先走主流程mid，最后才是slow,然后fast。
有图为证：
二.委托的本质，委托的抽象级别，委托和接口关系
委托是一种引用方法的类型，委托本质是一个类，定义委托实际上就是定义一个行为接口。只要符合该行为接口的方法，都可以赋给委托。从这个角度来说，委托是方法级别的抽象。
接口和委托均完成了对行为的抽象，但是二者实现的本质，却有面向对象和面向过程之分。
异：
(1)前者是直接将方法封装为对象，后者则是直接对方法的操作。
(2)前者可以被任何类实现，但是只能实现为公开的方法。对于后者，只要某一个方法符合委托的方法签名，不管是静态方法，还是匿名函数或者Lambda表达式，都可以传递给委托。参考委托让冒泡排序的扩展更加优雅--开闭原则的使用。
(3)从抽象的程度看，委托更彻底。在.NET种，委托更多的是被用于事件，异步调用，回调方法当中，尤其是观察者模式中，使用委托更是事半功倍。
(4)接口是对象级别的抽象，委托没有接口那样的强制要求实现，且针对静态方法。因此相对于接口，委托是一种更加开放的抽象。委托可以看成是方法的模板，有点类似类的模板-泛型(对类的抽象)，而接口没有那层味道。
同：委托和接口类似之处，都是对方法的抽象。
三.委托和接口在策略模式中的使用
第三部分是对第二部分的实例验证。直接上代码：
此处例子参考<大话设计模式>这本书
//业务简述：税收分国税，企业税，个人税等等，不同税算法不同。策略模式本质就是面向接口编程，不同的算法可以理解为不同的策略
//抽象税收算法
public interface ITaxStrategy
{
double Calculate(double income)
}
//个税
public class ITaxPerson:ITaxStrategy
{
public double Calculate(double income)
{
return income*0.1;
}
}
//企税
public class ITaxEnterprice:ITaxStrategy
{
public double Calculate(double income)
{
return income*0.3;
}
}
//…… 其他未来不确定的税收算法
public class TaxManager
{
public ITaxStrategy _itax
//接口作为参数，降低耦合，保证了不管未来是出现何种算法，保证这里的模块是稳定的；利用构造函数执行注入。
public Taxmanager(ITaxStrategy itax)
{
_itax=itax;
}
public double GetTex(double income)
{
_itax.Calculate(income);
}
}
public class Program
{
public static void Main(string[] args)
{
TaxManager taxManager=new TaxManager();
taxManager.GetTax(20000);
}
}
接下来，我们用委托来实现税收策略。
//委托方法签名public delegate double TaxCalculateHandler(double income);public class Tax{
//个税
public double TaxPersonCalculate(double income) { return income*0.1; }
//企税
publice double TaxEnterpriceCalculate(double income) { return income*0.3; }
//…… 其他未来不确定的税收算法
}
public class TaxManager{
private TaxCalculateHandler _delegateCal
//委托作为参数，降低耦合，保证了不管未来是出现何种算法，保证这里的模块是稳定的；利用构造函数执行注入。
public Taxmanager(TaxCalculateHandler itax)
{
this._delegateCal=itax;
}
public double GetTex(double income)
{
_delegateCal(income);
}
}
public class Program{
public static void Main(string[] args) {
TaxManager taxManager=new TaxManager(Tax.TaxPersonCalculate);
taxManager.GetTax(1000);
}
}
对比以上两种方式，思路差不多，都有很好的可扩展性，至于选择哪一种，就看具体情况了。
四.匿名方法对委托的代码优化
注释掉的部分，是冗长部分，优化后代码量减少不少。
//1.抽象出的操作方法，个人感觉有点像类的模板即泛型，所以从某一方面，不妨称委托为抽象出来的方法模板。
public delegate void StrHelloHandler();
//委托是对具体方法的抽象，他隔离了调用者和实际执行方法的关联
public class AsyncDelegate {
private List<string> output = new List<string>();
public List<string> OutPut { get { return output; } }
public AsyncDelegate() {
//2.委托的异步调用，这里主流程先执行，后才从Hello执行到World;
StrHelloHandler handler=null;
//handler += new StrHelloHandler(Hello);
//handler += new StrHelloHandler(Split);
//handler += new StrHelloHandler(World);
//采用匿名方法对以上代码进行优化
handler += delegate { output.Add("Hello"); };
handler += delegate { output.Add(","); };
handler += delegate { output.Add("World"); };
output.Add("你好，世界.");
handler.Invoke();
}
//private void Hello()
//{
// message[0]= "Hello";
//}
//private void Split()
//{
// message[1] = ",";
//}
//private void World()
//{
// message[2] = "World";
//}
}
public class Program
{
static void Main(string[] args)
{
//AsyncClass asyncClass=new AsyncClass();
//System.Threading.Thread.Sleep(3000);
AsyncDelegate asyncClass = new AsyncDelegate();
Console.WriteLine(asyncClass.OutPut[0]);
Console.WriteLine(asyncClass.OutPut[1]);
Console.WriteLine(asyncClass.OutPut[2]);
Console.WriteLine(asyncClass.OutPut[3]);
Console.Read();
//Assert.AreEqual("slow", asyncClass.OutPut[0]);
//Assert.AreEqual("fast", asyncClass.OutPut[1]);
//Assert.AreEqual("mid", asyncClass.OutPut[1]);
}
}
