static void Main(string[] args)
{
/*
* Deletages Tasks
*/
DelegateContainer.del();
Console.WriteLine(DelegateContainer.floatDel());
DelegateContainer.intakeDel("yeetus", "deletus", "the fetus");
//Bonus task:
AddDel addDel = MathClass.Add;
AddFloatDel addFloatDel = MathClass.Add;
Console.WriteLine(addDel(1, 4));
Console.WriteLine(addFloatDel(1.5f, 4.2f));
/*
* Lambda Tasks
*/
LambdaTwoTimes lambdaTwoTimes = (a) => a * 2;
Console.WriteLine(lambdaTwoTimes(4));
LambdaFloatSum lambdaFloatSum = (a, b, c) => a + b + c;
Console.WriteLine(lambdaFloatSum(2.4f, 2.6f, 7.3f));
LambdaString lambdaString = () => "Hello world";
Console.WriteLine(lambdaString());
}
public void Invoke()
{
Console.WriteLine("主线程{0} 正在执行中....", Thread.CurrentThread.ManagedThreadId);
#region 异步委托
AddDel addDemo = AddFun;
var ascResult = addDemo.BeginInvoke(1, 2, null, null);
while (!ascResult.IsCompleted)
{
//主线程再干一些事情
}
// //此EndInvoke方法会阻塞当前线程。 直到 委托方法执行完毕后，并将返回值交给 result后，继续执行后面的代码
int result = addDemo.EndInvoke(ascResult);
//第二种： 使用 回调函数
IAsyncResult ascResult2 = addDemo.BeginInvoke(1, 2, MyDelCallBakc, 3);
Console.WriteLine("执行的结果是：{0}", result);
Console.ReadKey();
#endregion 异步委托
#region 并行计算
int[] sum = { 0 };
object lck = new object();
Parallel.For(1, 1000000, i =>
{
lock (lck)
{
sum[0] += i;
}
Console.WriteLine("当前执行到 ：" + i + "@" + Thread.CurrentThread.ManagedThreadId);
Thread.Sleep(1000);
});
Console.WriteLine(sum[0]);
sum[0] = 0;
for (int i = 1; i < 1000000; i++)
{
sum[0] += i;
}
Console.WriteLine(sum[0] + "---");
#endregion 并行计算
Console.WriteLine("主线程执行完毕。。。");
}
static void Main(string[] args)
{
AddDel del = new AddDel(AddStaticFunc);
Program p = new Program();
del += p.AddInstanceFunc;
int result = del(3, 4);
Console.WriteLine(result);
Console.ReadKey();
}
//异步委托执行的顺序是：主线程创建一个委托对象，往下执行发现是异步调用这个委托方法，就开启一个线程来执行这个委托方法，主线程继续在往下执行，这个委托方法执行完成之后在进入到回调函数通过回调函数来获得他的执行结果
private static void callback(IAsyncResult ar)
{
Console.WriteLine("回调函数被执行了");
Thread.Sleep(1000);
Console.WriteLine(Thread.CurrentThread.ManagedThreadId);
AsyncResult demo = ar as AsyncResult;
AddDel del = (AddDel)demo.AsyncDelegate; //就是当前的异步委托对象
int result = del.EndInvoke(ar);
Console.WriteLine(result);
Console.WriteLine(demo.AsyncState);
}
public ProgramDelegate()
{
HelloMsgDel objHelloeMsg = new HelloMsgDel(HelloMsg);
objHelloeMsg();
AddDel objAddDel = new AddDel(Add);
int result = objAddDel(10, 20);
Console.WriteLine("Result= " + result);
}
static void Main(string[] args)
{
AddDel del = new AddDel(AddStaticMethod);
//int result = del(3, 4);//同步调用
IAsyncResult result = del.BeginInvoke(3, 4, new AsyncCallback(callback), "传给回调函数的信息");
//如果想拿到异步委托的结果
//result.IsCompleted //标志是否完成
//这样就能拿到结果，但是写在这里主线程会等待子线程的结果，阻塞线程，所以写到回调函数里面
//int addResult = del.EndInvoke(result);
Console.WriteLine("主线程执行了：" + Thread.CurrentThread.ManagedThreadId);
Console.ReadKey();
}
//异步委托 执行完成了的回调函数
public static void MyDelCallBakc(IAsyncResult result)
{
//Thread.CurrentThread;
//把接口类型转换成实例类型
AsyncResult asyncResult = (AsyncResult)result;
//转换成我们自己的委托类型
AddDel del = (AddDel)asyncResult.AsyncDelegate;
//执行完成获取 执行的结果
int addResult = del.EndInvoke(result);
int state = (int)asyncResult.AsyncState;
Console.WriteLine("异步完成的回调方法执行的结果是：{0} @{1}", addResult, Thread.CurrentThread.ManagedThreadId);
}
static void Main(string[] args)
{
#region MyRegion 委托
AddDel del = new AddDel(Addfuc);
del += new Program().Add2;
int res = del(3, 4);
Console.WriteLine(res);
#endregion
#region 泛型委托
Func <int, int, int> funcDemo = new Func <int, int, int>(Addfuc);//Addfuc;
int rs = funcDemo(1, 2);
Console.WriteLine(rs);
#endregion
#region 匿名方法
Func <int, int, int> anonymityfunc =
delegate(int a, int b) { return(a + b); };
#endregion
#region lambda语句
Func <int, int, int> lambdafunc = (a, b) => { return(a + b); };
#endregion
#region lambda表达式
Func <int, int, int> lambdaexpressionfunc = (a, b) => a + b;
#endregion
#region 案列
List <string> strlist = new List <string> {
"1", "2", "3"
};
IEnumerable <string> ls = strlist.Where((string a) => a == "1");
foreach (var item in ls)
{
Console.WriteLine(item.ToString());
}
Console.ReadKey();
#endregion
}
static void Main(string[] args)
{
//一、Lambda表达式的演变
#region 1.基本的委托
//缺点：既要定义委托类型，又要定义委托指向的方法
//构造一个委托变量
AddDel del = new AddDel(AddStaticFunc);
Program p = new Program();
//将委托指向方法
del += p.AddInstanceFunc;
//如果是多播委托，则拿到的委托返回值是最后一个委托指向的方法的执行结果
int result = del(3, 4);
Console.WriteLine(result);
#endregion
#region 2.泛型委托
//缺点：还要定义一个委托指向的方法
Func<int, int, int> funcDemo = new Func<int, int, int>(AddStaticFunc);
int result1 = funcDemo(3, 4);
Console.WriteLine(result1);
#endregion
#region 3.匿名委托
//缺点：形式上有点繁琐
Func<int, int, int> funcDemo2 = delegate(int a, int b) { return a + b; };
int result2 = funcDemo2(3, 4);
Console.WriteLine(result2);
#endregion
#region 4.Lambda语句
//缺点：形式上还有点繁琐
Func<int, int, int> funcDemo3 = (int a, int b) => { return a + b; };
int result3 = funcDemo3(3, 4);
Console.WriteLine(result3);
#endregion
#region 5.Lambda表达式
//缺点：传入参数还要手动指定类型
Func<int, int, int> funcDemo4 = (int a, int b) => a + b;
int result4 = funcDemo4(3, 4);
Console.WriteLine(result4);
#endregion
#region 6.Lambda表达式
//如果只有一个传入参数就还可以省略小括号
//比如Fun<int, int> funcDemo6 = a => a + a;
Func<int, int, int> funcDemo5 = (a, b) => a + b;
int result5 = funcDemo5(3, 4);
Console.WriteLine(result5);
#endregion
//Action没有返回值
//Func最后一个参数是返回值
//为什么微软要提供这两种方法？
//答:因为指向相同方法签名（方法名 + 参数）的不同委托类型是不能相互转化的，在实际使用中可能为相同功能定义了多个不同的委托类型，而调用的时候不知道该用哪个，所以可能会产生很多重复和混乱，所以微软预定义了这两种委托类型，使得编码标准化，减少了重复了混乱
Console.WriteLine("=====================================================================");
#region Where以及自定义扩展方法
List<string> strList = new List<string>()
{
"3","9","32","7"
};
//把集合中字符串小于"6"，查询出来然后打印
//Where方法内部：遍历strList集合，把strList中的每个元素传到后面那个匿名委托去执行，如果结果为true，就把这个元素选择出来，最终的结果，把所有选择出来的元素返回给temp
//var temp = strList.Where(delegate(string a) { return a.CompareTo("6") < 0; });
//自定义的扩展方法
//var temp = strList.MyWhere(delegate(string a) { return a.CompareTo("6") < 0; });
//简化为Lambda表达式
//方法泛型的约束（传入参数类型）可以省略，但是如果你是显式的约束，就必须满足约束，比如可以写成
//var temp = strList.MyWhere((string a) => a.CompareTo("6") < 0);
var temp = strList.MyWhere(a => a.CompareTo("6") < 0);
foreach (var item in temp)
{
Console.WriteLine(item);
}
#endregion
Console.Read();
}
delegate int AddDel(int a, int b);//定义一个委托
public void LambdaTest()
{
List <string> list = new List <string>()
{
"1", "2", "3", "4"
};
List <string> temp = list.FindAll(s => int.Parse(s) > 1);
List <int> list2 = new List <int>()
{
1, 2, 3, 4, 5, 6
};
list2.FindAll(GetEvenNum);
MessageBox.Show(temp[1]);
//lambda实际就是一个匿名函数
Func <int, int, int> func = (a, b) => a + b;
func(1, 2);
AddDel funLambda = delegate(int a, int b) { return(a + b); };//匿名函数
funLambda(1, 3);
//标准查询运算（SQO） SQO缺点：语句太庞大 复杂
//筛选、投影、聚合、排序等功能
List <Uesr> userList = new List <Uesr>()
{
new Uesr {
Id = 1, Name = "张三", Age = 21
},
new Uesr {
Id = 2, Name = "张三", Age = 22
},
new Uesr {
Id = 3, Name = "张三", Age = 23
},
new Uesr {
Id = 4, Name = "张三", Age = 24
},
new Uesr {
Id = 5, Name = "张三", Age = 25
},
new Uesr {
Id = 6, Name = "张三", Age = 26
},
new Uesr {
Id = 7, Name = "张三", Age = 27
},
new Uesr {
Id = 8, Name = "张三", Age = 28
}
};
//集合筛选
userList = userList.Where(x => x.Age > 25).OrderBy(x => x.Name).ToList <Uesr>();
userList.ForEach(r => Update(r.Id));//更新
//查询单个实体
userList.FirstOrDefault <Uesr>(s => s.Age > 25);
//查询投射Select
userList.Where(x => x.Age > 25).Select(a => a.Name.Contains("b")).ToList();
userList.Where(x => x.Age > 25).Select(a => new { a.Name, a.Id }).ToList();
//集合连接Join（）
//新建一个Student集合，并初始化数据
List <Student> lstStudent = new List <Student>()
{
new Student {
Id = 1, UserId = 1, ClassName = "电信一班"
},
new Student {
Id = 2, UserId = 2, ClassName = "电信二班"
},
new Student {
Id = 3, UserId = 3, ClassName = "电信三班"
}
};
var result = userList.Join(lstStudent, u => u.Id, p => p.UserId, (u, p) => new { UserId = u.Id, Name = u.Name, ClassName = p.ClassName });
}
static void InitInfo()
{
//隐式推断类型
var customer = new User();
//对象集合初始化器
User user = new User {
Id = 1, Name = "Zouqj", Age = 27
};
List <Dog> dogs = new List <Dog>()
{
new Dog()
{
Name = "Tom", Age = 1
}, new Dog()
{
Name = "Lucy", Age = 3
}
};
//创建并初始化数组：
string[] array = { "西施", "貂蝉" };
//匿名类
var p = new { Id = 1, Name = " Zouqj ", Age = 26 };//属性名字和顺序不同会生成不同类
//匿名方法测试
ConsoleWrite delCW1 = new ConsoleWrite(WriteMsg);
delCW1("天下第一");
ConsoleWrite delCW2 = delegate(string strMsg)
{
Console.WriteLine(strMsg);
};
delCW2("天下第二");
//扩展方法
string str = "冷水江";
str.WriteSelf(2016);
#region lambda
AddDel fun = delegate(int a, int b) { return(a + b); }; //匿名函数
//Console.WriteLine(fun(1, 3));
//lambda 参数类型可以进行隐式推断，可以省略类型 lambda本质就是匿名函数
AddDel funLambda = (a, b) => a + b;
List <string> strs = new List <string>()
{
"1", "2", "3"
};
var temp = strs.FindAll(s => int.Parse(s) > 1);
foreach (var item in temp)
{
Console.WriteLine(item);
}
//Console.WriteLine(funLambda(1,3));
#endregion
//LINQ
IEnumerable <Dog> listDogs = from dog in dogs
where dog.Age > 5
//let d=new{Name=dog.Name}
orderby dog.Age descending
select dog;
//select new{Name=dog.Name}
//LINQ分组：
IEnumerable <IGrouping <int, Dog> > listGroup = from dog in listDogs where dog.Age > 5 group dog by dog.Age;
//遍历分组：
foreach (IGrouping <int, Dog> group in listGroup)
{
Console.WriteLine(group.Key + "岁数：");
foreach (Dog d in group)
{
Console.WriteLine(d.Name + ",age=" + d.Age);
}
}
//params
ParamsMethod(25, 24, 21, 15);
ParamsMethod(25, 24, 21, 15);
//Dynamic
dynamic Customer = new ExpandoObject();
Customer.Name = "Zouqj";
Customer.Age = 27;
Customer.Male = true;
Console.WriteLine(Customer.Name + Customer.Age + Customer.Male);
Console.ReadKey();
}
public int sumItUp(int x, int y)
{
AddDel add = sum;
return(sum(x, y));
}