C#这十种语法糖你都用过吗？
|
admin
2026年2月4日 16:44
本文热度 93
|
作者： .NET开发菜鸟
链接：cnblogs.com/dotnet261010/p/6055092.html
语法糖
指计算机语言中添加的某种语法，这种语法对语言的功能并没有影响，但是更方便程序员使用。通常来说使用语法糖能够增加程序的可读性，从而减少程序代码出错的机会。
需要声明的是“语法糖”这个词绝非贬义词，它可以给我们带来方便，是一种便捷的写法，编译器会帮我们做转换，而且可以提高开发编码的效率，在性能上也不会带来损失。
一、自动属性
以前：手写私有变量+公有属性
现在：声明空属性，编译器自动生成对应私有成员字段。
写法：输入prop ,连续按两次tab键，自动生成属性。 publicstring Name { get; set; }
privatestring _LoginName;
publicstring LoginName {get { return _LoginName; }set { _LoginName = value; } }
二、隐式类型（var）
var定义变量有以下四个特点：
程序员在声明变量时可以不指定类型，由编译器根据值来指定类型
1、必须在定义时初始化
2、一旦初始化完成，就不能再给变量赋与初始值不同类型的值了
3、var要求是局部变量
4、使用var定义变量和object不同，它在效率上和使用强类型方式定义变量完全一样
注意：
a.隐式类型在定义时必须初始化
例如：var name; 错 var name="Tom";正确
b.可以用同类型的其他隐式类型变量来初始化新的隐式类型变量
例如：var v=1;
var v2=v;
c.也可以用同类型的字面量来初始化隐式类型变量
例如: var v3="hello";
v3="world";
d.隐式类型局部变量还可以初始化数组而不指定类型
例如: var array=new int[]{1,2,3,4,5}; (注意：赋值运算符左边没有方括号)
e.编译器可以根据变量的初始值“推断”变量的类型
例如：var number=0; 编译后就变成了 int number =0;
三、参数默认值和命名参数
C#方法的可选参数是.net 4.0最新提出的新的功能，对应简单的重载可以使用可选参数和命名参数混合的形式来定义方法，这样就可以很高效的提高代码的运行效率
设计一个方法的参数时，可以部分或全部参数分配默认值。调用其方法时，可以重新指定分配了默认值的参数，也可以使用默认值。重新指定分配默认值的参数时，可以显式地为指定参数名称赋值；隐式指定的时候，是根据方法参数的顺序，靠C#编译器的推断。
使用的指导原则：
1、可以为方法和有参属性指定默认值
2、有默认值的参数，必须定义在没有默认值的参数之后
3、默认参数必须是常量
4、ref和out参数不能指定默认值 publicclassUser {publicstring Name { get; set; }
publicstring LoginName { get; set; }
publicint Age { get; set; }
publicstring Address { get; set; }
publicstring Password { get; set; }
publicUser(string name) {this.Name = name; }
publicUser(string name,string loginName) {this.Name = name;this.LoginName = loginName; }
publicUser(string name,string loginName,int age,string address="上海",string password="1234") {this.Name = name;this.LoginName = loginName;this.Age = age;this.Address = address;this.Password = password; } }
使用默认值参数和命名参数classProgram {staticvoidMain(string[] args) { User user = new User("小明","xiaoming",27); Console.WriteLine(user.Address);
User user2 = new User("小红", "xiaohong", 28,"北京"); Console.WriteLine(user2.Address);
User user3 = new User("小红", "xiaohong", 28,password:"5678"); Console.WriteLine(user3.Password);
Console.ReadKey(); } }
输出结果：
四、对象初始化器和集合初始化器 classProgram {staticvoidMain(string[] args) {
User zjl = new User(); zjl.Name = "周杰伦"; zjl.phone = "12345678956";
User xiaohong = new User() { Name = "小红", phone = "1232154566", Address = "上海" };
Console.WriteLine("姓名:"+xiaohong.Name);
List<User> listUser = new List<User>() { xiaohong,new User(){Name="张三",Password="1234",Age=12,DeptId="0001"},new User(){Name="张四",Password="1234",Age=16,DeptId="0002"},new User(){Name="张五",Password="1234",Age=29,DeptId="0003"},new User(){Name="张六",Password="1234",Age=18,DeptId="0001"},new User(){Name="张七",Password="1234",Age=12,DeptId="0001"} }; Console.ReadKey(); } }
五、匿名类和匿名方法
匿名类型
有时候你定义的类只是用来封装一些相关的数据，但并不需要相关联的方法、事件和其他自定义的功能。同时，这个类仅仅在当前的应用程序中使用，而不需要在项目间重用。你所需要的只是一个“临时的”类型，现在来看看这个类的定义
internal class oneClass
{
//定义若干私有数据成员
//通过属性来封装每个数据成员
}
构建上面的类虽然说不上有多难，但是如果这个类有很多数据成员的话，那么还是要消耗相当时间的。C#3.0提供了匿名类型来轻松完成这个工作。
现在定义一个匿名对象来表示一个人
var aPeople=new {pName="张三",pAge=26,pSex="男"};
现在我们就可以使用属性语法获取和设置对象的各个变量
aPeople.pAge=29;
Console.WriteLine("{0} is {1}years old",aPeople.pName,aPeople.pAge);
匿名类型的嵌套
刚刚我们定义了表示一个人的匿名类型，现在我们定义一个表示雇员的嵌套匿名类型：
var Aemployee=new {
JoinDate="2012-09-23",
aPeople=new {pName="张三",pAge=26,pSex="男"},
title=Manager
};
匿名类型的限制：
1、匿名类型不支持事件、自定义方法和自定义重写
2、匿名类型是隐式封闭的
3、匿名类型的实例创建只使用默认构造函数
4、匿名类型没有提供可供控制的类名称（使用var定义的）
匿名方法
普通方法定义方式，因为方法的存在是为了复用一段代码，所以一般会给方法取个名字，这个方法的引用就可以通过“方法名”调用
匿名方法：
但是有的方法，不需要复用，仅仅是使用一次就够了，所以不需要方法名，这种方法就叫做匿名方法。
匿名方法必须结合委托使用。（潜在的意思就是：尽管没有方法名了，但方法的指针还是存放了某个委托对象中）
注意：
1、在编译后，会为每个匿名方法创建一个私有的静态方法，然后将此静态方法传给委托对象使用
2、匿名方法编译后会生成委托对象，生成方法，然后把方法装入委托对象，最后赋值给声明的委托变量
3、匿名方法可以省略参数，编译的时候会自动为这个方法按照委托签名的参数添加参数 publicclassTest {publicstaticvoidTestFive() {var aPeople = new { pName = "张三", pAge = 26, pAddress = "美国" };var aEmployee = new { JionDate = DateTime.Now, Salary = 8000, aPeople = new { pName = "张三", pAge = 26, pAddress = "美国" } };
Console.WriteLine(aEmployee.aPeople.pName);
Console.ReadKey(); }
publicstaticvoidTest() { Console.WriteLine(aPeople.pName); } }
匿名方法 classProgram {delegatevoidPrinter(string s);publicdelegatevoidPrintEmployee(User u);
staticvoidMain(string[] args) { Printer p = delegate(string s) { Console.WriteLine(s); }; p("Hello World");
List<User> listUser = new List<User>() {new User(){Name="张三",Password="1234",Age=12,DeptId="0001"},new User(){Name="张四",Password="1234",Age=16,DeptId="0002"},new User(){Name="张五",Password="1234",Age=29,DeptId="0003"},new User(){Name="张六",Password="1234",Age=18,DeptId="0001"},new User(){Name="张七",Password="1234",Age=12,DeptId="0001"} };
ChangeUserPwd(listUser, delegate(User u) {
Console.WriteLine(u.Name+"的新密码是:"+u.Password); }); ChangeUserPwd(listUser, u=> { Console.WriteLine(u.Name + "的新密码是:" + u.Password); }); Console.ReadKey(); }
publicstaticvoidChangeUserPwd(List<User> list, PrintEmployee callback) {int i = 0;foreach (User u in list) { u.Password = u.Password + i.ToString(); i += 2; callback(u); } } }
六、扩展方法
为什么要有扩展方法，就是为了在不修改源码的情况下，为某个类增加新的方法。
语法：
定义静态类，并添加public的静态方法，第一个参数代表扩展方法的扩展类。它必须放在一个非嵌套、非泛型的静态类中（的静态方法）；它至少有一个参数；第一个参数必须附加this关键字；第一个参数不能有任何其他修饰符（out/ref）.第一个参数不能是指针类型。
注意：
1、C#只支持扩展方法，不支持扩展属性、扩展事件等；
2、方法名无限制，第一个参数必须带this，表示要扩展的类型；
3、扩展方法的命名空间可以使用namespace System,但不推荐；
4、定义扩展方法的类必须是静态类；
5、扩展方法虽然是public的静态方法，但是生成以后是实例方法，使用时需要先实例化对象，通过对象.方法名进行调用扩展方法； publicstaticclassConvertExtension {publicstaticintConvertToInt(this Convert convert,string s) {int i;if (int.TryParse(s, out i)) {return i; }else {return0; } } }
classProgram {staticvoidMain(string[] args) { Convert convert = new Convert();int i= convert.ConvertToInt("abc");
Console.WriteLine(i);
int j= ConvertExtension.ConvertToInt(convert, "2"); Console.WriteLine(j);
Console.ReadKey(); } }
七、内置泛型委托
Action<T>
可以使用Action<T>委托以参数形式传递方法，而不用显示声明自定义的委托。封装的方法必须与此委托定义的方法签名相对应，也就是说，封装的方法必须具有一个通过值传递给它的参数，并且不能有返回值。
通常，这种方法用于执行某个操作。 publicstaticclassListExtend {publicdelegatevoid PrintT<T>(T t);
publicstaticvoid TEach<T>(this List<T> list, PrintT<T> pt) {foreach (T t in list) { pt(t); } } }
classProgram {
staticvoidMain(string[] args) { List<User> listUser = new List<User>() {new User(){Name="张三",Password="1234",Age=12,DeptId="0001"},new User(){Name="张四",Password="1234",Age=16,DeptId="0002"},new User(){Name="张五",Password="1234",Age=29,DeptId="0003"},new User(){Name="张六",Password="1234",Age=18,DeptId="0001"},new User(){Name="张七",Password="1234",Age=12,DeptId="0001"} };
List<Dept> listDept = new List<Dept>() {new Dept(){DeptId="0001",DeptName="人事部",PepNum=10},new Dept(){DeptId="0002",DeptName="财务部",PepNum=7},new Dept(){DeptId="0003",DeptName="行政部",PepNum=15} };
#region 使用自定义委托
listUser.TEach(PrintUser);
listDept.TEach(PrintDept);
#endregion
#region 使用内置泛型委托
listUser.ForEach(PrintUser); listUser.ForEach(delegate(User u) { Console.WriteLine(u.Name + " " + u.Password + " " + u.phone); });
listUser.ForEach(p=>Console.WriteLine(p.Name+" "+p.Password+" "+p.phone));
listDept.ForEach(new Action<Dept> (delegate(Dept d) { Console.WriteLine(d.DeptId + " " + d.DeptName + " " + d.PepNum); }));
#endregion
Console.ReadKey(); }
publicstaticvoidPrintUser(User u) { Console.WriteLine(u.Name+" "+u.Password+" "+u.phone); }
publicstaticvoidPrintDept(Dept d) { Console.WriteLine(d.DeptId+" "+d.DeptName+" "+d.PepNum); } }
Predicate<T>
表示定义一组条件并确定指定对象是否符合这些条件的方法。
此委托由Array和List<T>类的几种方法使用，用于在集合中搜索元素。返回值为Bool类型 publicstaticclassExtend{public delegate bool CheckDelegate<T>(T t);publicstaticList<T> MyFind<T>(this List<T> list, CheckDelegate<T> match) {List<T> newList = newList<T>();foreach (T item in list) {if (match(item)) { newList.Add(item); } }return newList; } }
classProgram{static void Main(string[] args) {List<User> listUser = newList<User>() {new User(){Name="张三",Password="1234",Age=12,DeptId="0001"},new User(){Name="张四",Password="1234",Age=16,DeptId="0002"},new User(){Name="张五",Password="1234",Age=29,DeptId="0003"},new User(){Name="张六",Password="1234",Age=18,DeptId="0001"},new User(){Name="张七",Password="1234",Age=12,DeptId="0001"} };
List<Dept> listDept = newList<Dept>() {new Dept(){DeptId="0001",DeptName="人事部",PepNum=10},new Dept(){DeptId="0002",DeptName="财务部",PepNum=7},new Dept(){DeptId="0003",DeptName="行政部",PepNum=15} };
List<User> newListUser= listUser.FindAll(new Predicate<User>(delegate(User u){return u.Age>40;}));
List<User> list = listUser.MyFind(Match);foreach (User u in list) { Console.WriteLine(u.Name + " " + u.Password + " " + u.phone); } Console.ReadKey(); }
static bool Match(User u) {if (u.Age > 15) {
returntrue; }returnfalse; } }
Func 返回值类型可以自定义 classProgram{static void Main(string[] args) {List<User> listUser = newList<User>() {new User(){Name="张三",Password="1234",Age=12,DeptId="0001"},new User(){Name="张四",Password="1234",Age=16,DeptId="0002"},new User(){Name="张五",Password="1234",Age=29,DeptId="0003"},new User(){Name="张六",Password="1234",Age=18,DeptId="0001"},new User(){Name="张七",Password="1234",Age=12,DeptId="0001"} };
List<Dept> listDept = newList<Dept>() {new Dept(){DeptId="0001",DeptName="人事部",PepNum=10},new Dept(){DeptId="0002",DeptName="财务部",PepNum=7},new Dept(){DeptId="0003",DeptName="行政部",PepNum=15} };
List<int> newList= listUser.Select(new Func<User, int>(delegate(User u) { return u.Age; })).ToList();List<int> list = listUser.Select(p => { return p.Age; }).ToList(); newList.ForEach(p => Console.WriteLine(p));
List<Employee> listEmploy= listUser.Select(new Func<User, Employee>(delegate(User u) { Employee e = new Employee();if (u.Age > 15) { e.Name = u.Name; e.Phone = u.phone; e.Salary = 5000;return e; }else {returnnull; }
})).ToList(); listEmploy.ForEach(p => {if (p != null) { Console.WriteLine(p.Name+" "+p.Salary); }
});
Console.ReadKey(); } }
八、Lambda表达式
Lambda表达式是比匿名方法更简洁的一种匿名方法语法
最基本的Lambda表达式语法:
{参数列表}=>{方法体}
例如：
(int x)=>{returm x+1}
说明：
1、参数列表中的参数类型可以是明确类型或推断类型
2、如果是推断类型，则参数的数据类型将由编译器根据上下文自动推断出来
如果参数列表只包含一个推断类型参数时：
参数列表=>{方法体}
前提：x的数据类型可以根据上下文推断出来
x =>{returm x+1}
如果方法体只包含一条语句时：
{参数列表}=>表达式
{int x} => x+1;
Lambda表达式示例：
1、多参数，推断类型参数列表，表达式方法体
(x,y) => x*y
2、无参数，表达式方法体
() => Console.WriteLine()
3、多参数，推断类型参数列表，多语句方法体，需要使用{}
(x,y) => {Console.WriteLine(x);Console.WriteLine(y)}
Lambda表达式缩写推演
new Func<string,int>(delegate(string str){return str.Length;});//内置委托
delegate(string str){return str.Length;}//匿名方法
(string str)=>{return str.Length};//Lambda表达式
(str)=>str.Length;//让编译器推断类型
str=>str>Length;//去掉不必要的括弧 #region Lambda表达式
MyDelegate my1 = (string name) => { return"Lambda表达式:hello" + name; }; Console.WriteLine(my1("tom"));
MyDelegate my2 = name => { return"Lambda表达式:hello" + name; }; Console.WriteLine(my2("tom"));
MyDelegate my3 = name =>"Lambda表达式:hello" + name; Console.WriteLine(my3("tom"));
#endregion
九、标准查询运算符
标准查询运算符：定义在System.Linq.Enumerable类中的50多个为IEnumerable<T>准备的扩展方法，这些方法用来对它操作的集合进行查询筛选。
筛选集合where:需要提供一个带bool返回值的“筛选器”，从而标明集合中某个元素是否应该被返回。
查询投射：返回新对象集合IEnumerable<TSource> Select()
统计数量int Count()
多条件排序 OrderBy().ThenBy().ThenBy()
集合连接 Join() classProgram{static void Main(string[] args) {List<User> listUser = newList<User>() {new User(){Name="张三",Password="1234",Age=12,DeptId="0001"},new User(){Name="张四",Password="1234",Age=16,DeptId="0002"},new User(){Name="张五",Password="1234",Age=29,DeptId="0003"},new User(){Name="张六",Password="1234",Age=18,DeptId="0001"},new User(){Name="张七",Password="1234",Age=12,DeptId="0001"} };
List<Dept> listDept = newList<Dept>() {new Dept(){DeptId="0001",DeptName="人事部",PageNum=10},new Dept(){DeptId="0002",DeptName="财务部",PageNum=10},new Dept(){DeptId="0003",DeptName="行政部",PageNum=10} };
List<User> newListUser = listUser.Where(p => p.Age>12).ToList(); Console.WriteLine("所有用户姓名"); listUser.ForEach(p=>Console.WriteLine(p.Name)); Console.WriteLine("年龄大于12的用户姓名"); newListUser.ForEach(p=>Console.WriteLine(p.Name));
List<User> list1 = listUser.OrderByDescending(p => p.Age).ThenByDescending(p => p.phone).ThenBy(p => p.LoginName).ToList();
List<UserDept> uds = listUser.Join(listDept, u => u.DeptId, d => d.DeptId, (u, d) => new UserDept() { UserName = u.Name, LoginName = u.LoginName, DeptName = d.DeptName }).ToList(); uds.ForEach(p=>Console.WriteLine(p.UserName));
var udVar = listUser.Join(listDept, u => u.DeptId, d => d.DeptId, (u, d) => new { UserName = u.Name, LoginName = u.LoginName, DeptName = d.DeptName }).ToList(); udVar.ForEach(p => Console.WriteLine(p.UserName));
#region 4.0 group by 分组
IEnumerable<IGrouping<string, User>> userGroup = listUser.GroupBy(p => p.DeptId);
foreach (IGrouping<string, User> group in userGroup) { Console.WriteLine("部门编号:" + group.Key);foreach (User user in group) { Console.WriteLine(user.Name + "-" + user.phone + "-" + user.LoginName); }
Console.WriteLine("--------------------------------"); }#endregion
#region 5.0 分页：Skip+Take Skip:跳过 Take:取
List<User> listSource = listUser.OrderBy(p => p.Name).ToList();foreach (User user in listSource) { Console.WriteLine(user.Name); }
Console.WriteLine("--------------");List<User> list = GetPageListByIndex(listUser, 1, 2);foreach (User user in list) { Console.WriteLine(user.Name); }
#endregion
Console.ReadKey(); }
staticList<User> GetPageListByIndex(List<User> listSource, int pageIndex, int pageSize) {return listSource.Skip((pageIndex - 1) * pageSize).Take(pageSize).ToList(); } }
十、Linq
Linq:语言集成查询
Linq是一组语言特性和API，使得你可以使用统一的方式编写各种查询。查询的对象包括XML、对象集合、SQL Server数据库等等。
Linq to Objects：主要负责对象的查询
Linq to XML:主要负责XML的查询
Linq to ADO.NET：主要负责数据库的查询
Linq to SQL
Linq to DataSet
Linq to Entities
Linq查询的两种方式：
1、查询方法方式：主要利用System.Linq.Enumerable类中定义的扩展方法和Lambda表达式进行查询
2、查询语句方式：一种更接近SQL语法的查询方式
查询语句VS查询方法
1、CLR本身并不理解查询语句，它只理解查询方法
2、编译器负责在编译时将查询语句翻译成查询方法
3、大部分查询方法都有对应的查询语句形式：Select（）对应select、OrderBy（）对应orderby
4、部分查询方法目前在C#中还没有对应的查询语句，如：Count()和Max()这时只能采用以下替代方案:
查询方法
查询语句+查询方法的混合方式 classProgram{publicdelegate string MyDelegate(string name);
staticvoid Main(string[] args){int[]arrays = { 5, 2, 0, 66, 4, 32, 7, 1 };
#region 使用循环实现
List<int>list = new List<int>();foreach(int i in arrays){if(i % 2 == 0){list.Add(i);}}list.Sort();list.Reverse();
Console.WriteLine(string.Join(",",list));
#endregion
#region 使用Linq实现varintNew = arrays.Where(p => p % 2 == 0).Select(p => p).OrderByDescending(p => p).ToList();
Console.WriteLine(string.Join(",",intNew));
vareven = from number in arrayswherenumber % 2 == 0orderbynumber descendingselectnumber; #endregion
#region 类型推断varb = true;if(b){Console.WriteLine("True");} #endregion
#region 扩展方法strings = "abc";inta = s.ToInt();Console.WriteLine(a);
objectobj = "sdsf";doubled= obj.ToDouble();
Console.WriteLine(d); #endregion
#region 对象初始化器Contactcon = new Contact(){FirstName="Tom",LastName="Jerry",Email="tom@163.com" };
Console.WriteLine(con.Email); #endregion
#region 集合初始化器
List<Contact>listContact = new List<Contact>(){newContact(){FirstName="Tom",LastName="Tack",Email="aaa"},newContact(){FirstName="Tom",LastName="jerry",Email="bbb"}};
Console.WriteLine(listContact[0].Email); #endregion
#region 匿名类型
varitem = new {ProductName="Iphone",Price=4000 };stringinfo = item.ProductName + "..." + item.Price;Console.WriteLine(info);
#endregion
MyDelegatemy = new MyDelegate(Hello);stringstrName = my("tom");Console.WriteLine(strName);
#region 匿名方法(只用一次)MyDelegatemy2 = delegate(string str){return"匿名方法:hello" + str;};
stringname= my2("tom");Console.WriteLine(name); #endregion
#region Lambda表达式
MyDelegatemy1 = (string str) => { return "Lambda表达式:hello" + str; };Console.WriteLine(my1("tom"));
MyDelegatemyDel = p => { return "Lambda表达式:hello" + p; };Console.WriteLine(my2("tom"));
MyDelegatemy3 = p => "Lambda表达式:hello" + p;Console.WriteLine(my3("tom"));
#endregion
int[]intArray = { 1,2,3,6,4,90,65,44,9};
varvar1 = intArray.Select(p => p + 1);Console.WriteLine(string.Join(",",var1));
varvar2 = from p in intArray select p + 1;Console.WriteLine(string.Join(",",var1));
varvar3 = intArray.Where(p => p % 2 == 0);var3 = from number in intArraywherenumber % 2 == 0selectnumber;
var3 = intArray.Where(p => p % 2 == 0 && p > 10);var3 = intArray.Where(p => GetCondition(p));
var3 = from number in intArraywherenumber % 2 == 0 && number > 10selectnumber;var3 = from number in intArraywhereGetCondition(number)selectnumber;Console.WriteLine(string.Join(",",var3));
List<Contact>MyContact = new List<Contact>(){newContact(){FirstName="tom",LastName="jorry",Email="Tom@163.com"},newContact(){FirstName="tom",LastName="jack",Email="jack@163.com"},newContact(){FirstName="tom",LastName="jerry",Email="jerry@163.com"}};
varvar4 = MyContact.Where(p => p.FirstName == "tom" && p.Email == "Tom@163.com");var4 = MyContact.Where(p => GetContact(p));
var4 = from p in MyContact where p.FirstName == "tom" && p.Email == "Tom@163.com" select p;var4 = from p in MyContact where GetContact(p) select p;foreach(Contactcontact in var4){Console.WriteLine(contact.LastName);}
int[]ints = { 1,1,2,3,4,0};varvar5 = ints.Distinct();Console.WriteLine(string.Join(",",var5));
int[]intArrays = { 1,2,4,3,7,8,0};varvar6 = intArrays.OrderBy(i => i);var6 = intArrays.OrderByDescending(i => i);var6 = intArrays.Where(i => i % 2 == 0).OrderBy(i => i);var6 = from i in intArrays where i % 2 == 0orderbyi select i;var6 = from i in intArrays where i % 2 == 0orderbyi descending select i;var6 = (from i in intArrays where i % 2 == 0 select i).OrderBy(i => i);Console.WriteLine(string.Join(",",var6));
List<Employee>listEmployee = new List<Employee>(){newEmployee(){FirstName="唐僧",LastName="玄奘",Sex="男",Age=30,Country="大唐"},newEmployee(){FirstName="白骨精",LastName="晶晶",Sex="女",Age=200,Country="古墓"},newEmployee(){FirstName="孙悟空",LastName="行者",Sex="男",Age=500,Country="傲来国"},newEmployee(){FirstName="紫霞",LastName="仙子",Sex="女",Age=100,Country="天界"}};
varvar7 = from p in listEmployee group p by p.Sex;var7 = listEmployee.GroupBy(p => p.Sex);foreach(var group in var7){Console.WriteLine("分组:"+group.Key);foreach(var v in group){Console.WriteLine(v.FirstName);}}Console.ReadKey();}
staticbool GetContact(Contact item){if(item.FirstName == "tom" && item.Email == "Tom@163.com")returntrue;elsereturnfalse;}
staticbool GetCondition(int i){if(i % 2 == 0 && i > 10)returntrue;elsereturnfalse;}
staticstring Hello(string name){return"hello" + name;}}
classProgram{staticvoid Main(string[] args){List<User>listUser = new List<User>(){newUser(){Name="张三",Password="1234",Age=12,DeptId="0001"},newUser(){Name="张四",Password="1234",Age=16,DeptId="0002"},newUser(){Name="张五",Password="1234",Age=29,DeptId="0003"},newUser(){Name="张六",Password="1234",Age=18,DeptId="0001"},newUser(){Name="张七",Password="1234",Age=12,DeptId="0001"}};
List<Dept>listDept = new List<Dept>(){newDept(){DeptId="0001",DeptName="人事部",PageNum=10},newDept(){DeptId="0002",DeptName="财务部",PageNum=10},newDept(){DeptId="0003",DeptName="行政部",PageNum=10}};
varnewList = from p in listUser select p;
varlist = from p in listUser where p.Age > 12 && p.Address == "上海" select p;
varnewListUser = from p in listUser orderby p.Name orderby p.Age ascending select p;
varjoinResult = from u in listUserjoind in listDeptonu.DeptId equals d.DeptIdselectnew {UserName = u.Name, LoginName = u.LoginName, DeptName = d.DeptName };foreach(var item in joinResult){Console.WriteLine(item.DeptName);}
vargroupList = from u in listUser group u by u.DeptId;foreach(var group in groupList){Console.WriteLine(group.Key);foreach(var item in group){Console.WriteLine(item.ToString());}}
Console.ReadKey();}}
该文章在 2026/2/4 16:46:07 编辑过
|
|
400 186 1886
