首页 > 代码库 > C#委托
C#委托
委托的定义与方法的定义类似，只是返回值类型的前面多了个delegate。如：public delegate void PrientDelegate(string content)，其实委托就是一个能够将方法封装成一个引用类型，能和普通对象一样传递。
一、委托声明的注意点
1、和类一样，委托的声明可以再类的外部声明，委托也可以再类的内部声明。
2、委托的声明虽然形式上与方法很像，但是它没有方法主体，而是直接以分号结尾。
3、修饰符可以是new、public、protected、internal、private。
4、delegate关键字后是本委托类型可以匹配的方法签名，尤其需要注意的是，它还包括方法的返回类型，但并非与方法名完全匹配。
二、给委托绑定方法时，要符合的两点要求
1、方法的签名要与委托一样，方法参数的个数和类型。
2、方法的返回值类型要与委托一样。
调用委托就相当于调用委托所绑定的方法， 一个委托可以绑定多个方法。委托是引用类型，因此它就可以到处传递，没有它，C#能够将方法到处传递吗？
先附上一个基础的例子
public delegate void Print(string str); //声明一个委托 class Program { public static void PrintString(string str) { Console.WriteLine(str); } static void Main(string[] args) { //创建一个委托对象，并将方法PrintString赋给该委托 Print p = new Print(Program.PrintString); //Print p = Program.PrintString; //直接用=号也可以让委托绑定方法。 p("调用委托实际等于调用了委托所绑定的方法!"); //输出调用委托实际等于调用了委托所绑定的方法! Console.ReadKey(); } }三、委托的组合(多个委托之间的关系)
"+"可以将两个委托组合起来，"-"可以从一个委托组合中删除其中一个成员。
public delegate void Print(); class Program { public static void PrintString1() { Console.WriteLine("我是第一个方法"); } public static void PrintString2() { Console.WriteLine("我是第二个方法"); } static void Main(string[] args) { //创建一个委托对象并绑定方法 Print p1 = Program.PrintString1; //委托p1绑定方法1 Print p2 = Program.PrintString2; //委托p2绑定方法2 Print p3 = p1 + p2; //将p1委托和p2委托组合成一个新委托p3 p3(); //调用委托p3,相当于调用p3所有已经绑定的方法，此时是方法1与方法2,此时输出 我是第一个方法 "换行" 我是第二个方法 Print p4 = p3 - p1; //创建一个新的委托对象，其绑定的方法为p3委托组合去除委托p1，实际就只剩下p2 p4(); //调用委托p4，相当于调用所有p4绑定的方法 输出 我是第二个方法 Console.ReadKey(); } }四、委托的添加方法与删除方法(一个委托的事情)
通过"+="符可以像已有委托新添加绑定一个方法，通过"-="可以从委托中删除一个已绑定的方法。
public delegate void Print(); class Program { public static void PrintString1() { Console.WriteLine("我是第一个方法"); } public static void PrintString2() { Console.WriteLine("我是第二个方法"); } static void Main(string[] args) { Print p = PrintString1; //声明一个委托并绑定第一个方法 p(); //调用委托p 输出 我是第一个方法 p += PrintString2; //再为p多绑定一个方法 p(); //调用委托p 输出我是第一个方法 "换行" 我是第二个方法，看到现在p委托一经是绑定两个方法的了 p -= PrintString1; //从委托p中删除一个已经绑定的方法p1; p(); //调用委托p 输出 我是第二个方法 看到p现在已经是只绑定第二个方法了 Console.ReadKey(); } }
五、委托在回调中的应用
委托在回调函数中的调用：
public delegate void PrintCompleteCallback(string message); class Program { public static void PrintMessage(string message) { Console.WriteLine(message); } static void Main(string[] args) { PrintCompleteCallback CompleteCallback = Program.PrintMessage; //创建一个委托，并绑定PrintMessage方法 Printer printer = new Printer("我是一个打印机"); printer.Print(CompleteCallback); //调用p对象的Print方法，要求传入一个委托作为参数，相当于传入一个方法作为参数 Console.ReadKey(); } } public class Printer { private string _name; public Printer(string name) { _name = name; } public void Print(PrintCompleteCallback callback) //委托对象作为方法参数 { callback(_name + "打印完毕"); //调用委托，相当于调用callback委托所绑定的对象 } }
六、匿名方法
匿名方法最大的优势在于其减少了系统开销，方法仅在委托使用时才定义。直接给委托传递一段代码比先创建一个方法再绑定到委托要简单。
匿名方法的使用规则：
1、匿名方法中不能使用跳转语句跳至此匿名方法的外部，反之亦然；匿名方法外部的跳转语句也不能跳到此匿名方法的内部。
2、在匿名方法内部不能访问不安全的代码。另外，也不能访问在匿名方法外部定义的ref与out参数。但可以使用在匿名方法外部定义的其它变量。
public delegate void Print(); //定义一个委托 public delegate int GetLength(string str); //定义一个带参数的委托 class Program { static void Main(string[] args) { Print p = delegate //不带参数的匿名方法 { Console.WriteLine("你在他乡还好吗？"); }; p(); GetLength g = delegate(string str) //带参数的匿名方法，注意方法的参数要与委托一致 { return str.Length; }; int length = g("你还好吗？"); //调用委托，注意要传入参数 Console.WriteLine(length); Console.ReadKey(); } }
七、Lambda表达式
Lambda表达式和匿名方法基本相同，只是语法不同而已，可以说，Lambda表达式就是匿名方法。必须要记住，Lambda就是一个匿名方法，是给委托赋值用的，也就是说，使用Lambda的场景只有给委托赋值。
Lambda表达式的语法更加简洁：
(param)=>expr //其中param是一个输出参数列表,说白了就是给委托的参数，expr是一个表达式或一系列语句，说白了就是输出或执行的操作
Lambda表达式具有以下特性：
1、在一个具有唯一的显式类型参数的Lambda表达式中，圆括号可以从参数列表中删除。例如：param=>expr
2、当输入参数不唯一时，括号不能省略。
3、输入参数列表中的各参数可以显式指定类型，也可以省略掉参数类型，具体类型通过类型推断机制判断。
4、expr可以只包含一个计算表达式，也可以包含一系列语句，只是如果是一系列语句必须包括在大括号内。
一个委托参数的Lambda表达式
public delegate string Print(string content); //定义一个委托，该委托接受一个字符串输入，用于Lambda的左边 class Program { static void Main(string[] args) { Print p = (str) => str += "-输出参数"; //(str) 输入参数，也就是委托参数中的content，箭头后的是输出，最简单的理解就是，箭头左边是输入，箭头左边是输出，当然语句就不同了。 string outstr = p("输入参数"); Console.WriteLine(outstr); //输出 输入参数-输出参数 Console.ReadKey(); } }两个委托参数的Lambda表达式的调用:
public delegate string Print(string content1,string content2); //定义一个委托 class Program { static void Main(string[] args) { Print p = (str1,str2) => str1 += "左边-右边" + str2; //多个输入参数，括号不能省略 string outstr = p("张飞","关羽"); //输出 张飞左边-右边关羽 Console.WriteLine(outstr); //输出 输入参数-输出参数 Console.ReadKey(); } }带语句的Lambda表达式
public delegate void Print(string content); //定义一个委托 class Program { static void Main(string[] args) { Print p = str => //带语句的Lambda表达式，由于只有一个参数，所以小括号可以省略 { Console.WriteLine(str); }; p("你好"); //你好 Console.ReadKey(); } }2014-04-08-----------------------------
现在学完了Lambda表达式了，可以结合扩展方法来瞧瞧Linq是怎么实现的了。下面写个模仿Linq的Where实现的示例：
namespace ConsoleApplication3{ public delegate bool Compare(int i); class Program { static void Main(string[] args) { //.Net的Linq扩展的是IEnumerable<TSource>(底层，范围广)，而我是Calculate类 Calculate c = new Calculate(); int[] intArr = new int[] { 10, 20 }; int[] intArrReturn = c.Where(m => m > 18, intArr); foreach (int i in intArrReturn) { Console.WriteLine(i); } Console.ReadKey(); } } public static class Exten { //技术点1：扩展方法，扩展的是Calculate类(第一个参数) //技术点2：以委托作为参数，在方法内部会调用(第二个参数) public static int[] Where(this Calculate c, Compare compare, int[] intArr) { int[] returnArr = new int[2]; //示例定长数组 int count = 0; foreach (int i in intArr) { if (compare(i)) { returnArr[count] = i; count++; } } return returnArr; } } //计算类 public class Calculate { }}有那么点像了，Linq是泛型+Lambda，所以它的名字比较帅，如果我们把委托(参数名)改一下：Compare改为Func<T>
public delegate bool Func<T>(int i);
看下代码提示，是不是更像Linq了？
很遗憾，到目前为止，我们扩展的Calculate类不支持链式操作，因为返回的结果是一个int[]数组。而链式操作的原理是，返回的结果又能继续，如IEnumerable<int>的Where(m => m.xx)之后返回的又是IEnumerable<int>，所以能够无限下去。
2014-04-08-----------------------------------
八、委托中的协变与逆变
协变：委托方法的返回值类型直接或间接地继承自委托签名的返回值类型，称为协变。
逆变：委托签名中的参数类型继承自委托方法的参数类型，称为逆变。
注意:协变强调的是返回类型，逆变强调的则是方法参数。
协变Demo：
delegate People getSon(string name); class Program { static void Main(string[] args) { getSon g = sons; People p = g("张飞"); //注意虽然委托方法返回的是Son，但是委托本身返回的是父类People Console.WriteLine(p.Name); //输出 张飞 Console.ReadKey(); } public static Son sons(string name) //委托方法的返回值类型继承自委托签名的返回值类型 逆变 { Son m = new Son(); m.Name = name; return m; } } public class People { public People() { } public int Id { get; set; } public string Name { get; set; } } public class Son : People { public int Age { get; set; } }逆变Demo:
delegate string getSonName(Son s); class Program { static void Main(string[] args) { getSonName g = sons; Son s = new Son(); s.Name = "关羽"; string str = g(s); Console.WriteLine(str); //输出 关羽 Console.ReadKey(); } public static string sons(People p) //委托签名的参数类型继承自委托方法的参数类型 此People为委托签名参数Son的父类 { return p.Name; } } public class People { public People() { } public int Id { get; set; } public string Name { get; set; } } public class Son : People { public int Age { get; set; } }