委托的定义与方法的定义类似，只是返回值类型的前面多了个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表达式的语法更加简洁：
(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; }
}
原文：http://www.cnblogs.com/mingxuantongxue/p/3805949.html