c#中匿名函数lamb表达式

c#中匿名函数lamb表达式

实例一:(其实,这样都是些语法糖)

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks; namespace ConsoleApplication2
{
//c#中的匿名函数
//申明一委托
delegate void Del();
class Program
{ static void show()
{
Console.WriteLine("show ......");
} static void Test()
{
Del d = new Del(show);
d();
}
static void Test2()
{
//你可以这么写....
Del d = delegate()
{
Console.WriteLine("show......");
};
d(); //你也可以这么写
Del d1 = delegate
{
Console.WriteLine("show.....");
}; d1();
//你还可以这么写;这就是lamb表达式;
Del d2 = () =>
{
Console.WriteLine("show.....");
};
d2(); }
static void Main(string[] args)
{ Test2();
Console.ReadLine(); }
}
}

有参数的lamb表达式:

 static void Test()
{
//你可以这么写
Dele d = delegate(int j)
{
Console.WriteLine(j);
};
d(); Dele d1 = (j) => { Console.WriteLine(j); };
d1();
//这个就是有参参的lamb表达式;
} static void Main(string[] args)
{
Test();
Console.ReadLine(); }

顺便提一下c#中的Action Func Predicate;

Delegate至少0个参数,至多32个参数,可以无返回值,也可以指定返回值类型。

Action是无返回值的泛型委托。

Action 表示无参,无返回值的委托

Action<int,string> 表示有传入参数int,string无返回值的委托

Action<int,string,bool> 表示有传入参数int,string,bool无返回值的委托

Action<int,int,int,int> 表示有传入4个int型参数,无返回值的委托

Action至少0个参数,至多16个参数,无返回值。

Func是有返回值的泛型委托

   Func<int> 表示无参,返回值为int的委托

   Func<object,string,int> 表示传入参数为object, string 返回值为int的委托

   Func<object,string,int> 表示传入参数为object, string 返回值为int的委托

   Func<T1,T2,,T3,int> 表示传入参数为T1,T2,,T3(泛型)返回值为int的委托

   Func至少0个参数,至多16个参数,根据返回值泛型返回。必须有返回值,不可void

 (4) predicate

   predicate 是返回bool型的泛型委托

   predicate<int> 表示传入参数为int 返回bool的委托

   Predicate有且只有一个参数,返回值固定为bool

实例:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Threading; namespace ConsoleApplication2
{ delegate void Dele(int i);
class Program
{
static void add(int i,int j)
{
Console.WriteLine(i+j);
}
static int sub(int i, int j)
{
return i - j;
} static bool isTrue(int i)
{
if (i > )
return true;
else
return false;
} static void Test()
{ List<Action<int,int>> list = new List<Action<int,int>>();
list.Add(add);
//调用方式一
list[](,);
//最后一个参数是返回值;
Func<int,int,int> func=sub;
int result=func(,);
Console.WriteLine(result); Predicate<int> p = isTrue;
bool re = p();
Console.WriteLine(re); }
static void Test2()
{
//当然我们可以换一种方式写滴呀
Action<int, int> action = delegate(int i, int j)
{
Console.WriteLine(i+j);
};
action(,); Func<int, int, int> func = delegate(int i, int j)
{
return i - j;
};
int result = func(,); Predicate<int> pre = delegate(int i)
{
bool re=
i==?true: false;
return re;
}; }
static void Test3()
{
//当然我们也可以这样写滴呀
Action<int, int> action = (i, j) => { Console.WriteLine(i + j); };
action(,); Func<int,int,int> func=(i,j)=>{return i-j;};
int result=func(,); Predicate<int> pre = (i) => { if (i == )return true; else return false; };
bool val = pre(); } static void Test4()
{
Thread thread = new Thread(delegate()
{
Console.WriteLine("hahhahah....");
});
thread.Start(); Thread thread2 = new Thread(() =>
{
Console.WriteLine("hahah......");
});
thread2.Start(); } static void Main(string[] args)
{
//其实,就相当于这样滴呀: public delegate void Action<T>(T arg);
Test();
Console.ReadLine(); }
}
}
上一篇:nfs存储服务实时同步


下一篇:Linux(10):期中架构(2)--- NFS存储服务 & 实时同步