C# 匿名方法

delegate int calculator(int x, int y); //委托类型
static void Main(string[] args)
{
//创建委托对象（确定与哪些方法进行绑定）,委托实例名=new 委托名（某个类的方法，本例与加法向绑定
calculator MYAdd = new calculator(Adding);
//创建委托对象（确定与哪些方法进行绑定）,委托实例名=new 委托名（某个类的方法，本例与减法向绑定
calculator MYMove = new calculator(Moveing);
//创建委托对象（确定与哪些方法进行绑定）,委托实例名=new 委托名（某个类的方法，本例与乘法向绑定
calculator MYMultiply = new calculator(Multiply);
//创建委托对象（确定与哪些方法进行绑定）,委托实例名=new 委托名（某个类的方法，本例与除法向绑定
calculator MYDivide = new calculator(Divide);
//通过委托执行方法
int A = MYAdd(, );//
int B = MYMove(, );//
int C = MYMultiply(, );//
int D = MYDivide(, );//
} /// <summary>
/// 加法
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public static int Adding(int x,int y)
{
return x + y;
}
/// <summary>
/// 减法
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public static int Moveing(int x, int y)
{
return x - y;
}
/// <summary>
/// 乘法
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public static int Multiply(int x, int y)
{
return x * y;
}
/// <summary>
/// 除法
/// </summary>
/// <param name="x"></param>
/// <param name="y"></param>
/// <returns></returns>
public static int Divide(int x, int y)
{
return x / y;
}

static void Main(string[] args)
{
//Predicate 泛型委托代表一类具有 一个T类型(通用类型)作为参数并返回BOOL类型的方法
var B = new Predicate<int>(isbol);
 bool BB=isbol(1);//true
} /// <summary>
/// Predicate 泛型委托
/// </summary>
/// <typeparam name="?"></typeparam>
/// <param name="x"></param>
/// <returns></returns>
public static bool isbol(int x)
{
return x > ;
}

static void Main(string[] args)
{
//Action 他代表了一类方法，可以有0个到16个输入参数，输入参数的类型是不确定的。此类方法不能有返回值，也就是返回VOID类型的方法。
var B = new Action<int,string,string>(Action_d);
B(-,"true","flase");
Console.ReadKey();
} /// <summary>
/// Action 泛型委托
/// </summary>
/// <typeparam name="?"></typeparam>
/// <param name="x"></param>
/// <returns></returns>
public static void Action_d(int x,string y,string z)
{
if (x > )
{
Console.WriteLine(y);
}
else
{
Console.WriteLine(z);
}
}

static void Main(string[] args)
{
//Func 他代表了一类方法，可以有0个到16个输入参数，输入参数的类型是不确定的。此类方法有返回值。
var B = new Func<int, string,string,string>(Func_d);//注意：<>中最后一个string代表输出类型
Console.WriteLine(B(,"True","False"));
Console.ReadKey();
} /// <summary>
/// Predicate 泛型委托
/// </summary>
/// <typeparam name="?"></typeparam>
/// <param name="x"></param>
/// <returns></returns>
public static string Func_d(int x,string y,string z)
{
if (x > )
{
return y;
}
else
{
return z;
}
}

delegate int calculator(int x, int y); //委托类型
static void Main(string[] args)
{
//创建委托对象（确定与哪些方法进行绑定）,委托实例名=new 委托名（某个类的方法，本例与加法向绑定
calculator Adding =delegate( int x, int y)
{
return x+y;
}; calculator Moveing = delegate(int x, int y)
{
return x - y;
}; calculator Multiply = delegate(int x, int y)
{
return x * y;
}; calculator Divide = delegate(int x, int y)
{
return x / y;
};
Adding(, );//
Moveing(, );//
Multiply(, );//
Divide(, );//
}

通过使用匿名方法，由于您不必创建单独的方法，因此减少了实例化委托所需的编码系统开销。

例如，如果创建方法所需的系统开销是不必要的，则指定代码块（而不是委托）可能非常有用。  启动新线程即是一个很好的示例。  无需为委托创建更多方法，线程类即可创建一个线程并且包含该线程执行的代码。