文章目录
- C#中Linq和Lambda表达式的使用整理
- 1. Linq和Lambda简介
- 2. Lambda表达式
- 3. Lambda常用的扩展方法
- 3-1 Where方法：筛选满足条件的数据
- 3-2 Count()方法：获取数据条数
- 3-3 Any()方法：是否至少有一条数据
- 3-4 排序：OrderBy()、OrderByDescending()、ThenBy()、ThenByDescending()
- 3-5 限制结果集，取部分数据： 去重--groupby/distinct、 截取--skip(n)、Task(n)
- 3-6 聚合函数: Max()、Min()、Average()、Sum()、Count()等
- 3-7 分组 GroupBy()
- 3-8 取首条记录 top(1)
- 3-9 投影 Select，类似Java中Steam的map/flatmap
- 3-10 链式调用
- 4. Linq和Lambda具体代码示例参考：
- 4-1 简单的查询语句
- 4-2 带where的查询
- 4-3 简单的函数计算（count，min，max，sum）
- 4-4 排序order by desc/asc
- 4-5 top(1)
- 4-6 跳过前N条取余下的数据 Skip
- 4-7 截取指定长度的数据 Take
- 4-8 分页查询： Skip、Take组合使用
- 4-9 包含Contains ， 类似like '%%'
- 4-10 分组group by
- 4-11 Sql中的In -- 通过Contains实现
- 4-12 内连接 Inner Join
- 4-13 Linq和Lambda实现 左链接、右链接、内链接参考：
- 4-14 扩展：交集、并集、差集的用法 [了解，使用不多]
- 4-15 一些使用的实例代码：
C#中Linq和Lambda表达式的使用整理
扩展：
可以使用 var 让编译器的“类型推断”来简化类型的声明，
在linq中常用 C#的var ， 和javaScript的var不一样，
它仍然是强类型的！！！
1. Linq和Lambda简介
Linq:
语言集成查询（ Language Integrated Query，缩写：Linq）,发音"link"，是微软的一项技术，新增一种自然查询的SQL语法到.NET Framework的编程语言中
Lambda:
Lambda 表达式，是一种简化的匿名函数，可用于创建委托或表达式目录树。其次，也可以将 Lambda 表达式作为参数进行传递，或者将它作用于函数调用值调用后返回的一个函数来使用。经常在 Linq 中使用 Lambda 表达式
2. Lambda表达式
1. 匿名方法可以写成Lambda表达式:
Func<int, int, string> f1 = (i1,i2) =>{
return $"{i1}+{i2}={i1 + i2}";
};
2. 可以省略参数数据类型，因为编译器根据委托类型推断出参数类型用=>引出来方法体
如果委托没有返回值，且方法体只有一行代码，可省略{}
Action<int, string> f1 = (age, name) => Console.WriteLine($"年龄{age},姓名{name}");
f1 (18, "yzk");
3. 如果=>之后的方法体中只有一行代码，且方法有返回值，那么可以省略方法体的{}以及return
Func<int, int, string> f1 = (i1, i2) => $"{i1}+{i2}={i1 + i2}";
4. 如果只有一个参数，参数的()可以省略
Action<string> f1 = s => Console.WriteLine(s);
Func<int, bool> f2 = i => i > 5;
5. 配合lambda能简化数据处理，如：Where
int[] nums = new int[]
{ 3,99,88,77,7,8,9,66,15,7};
IEnumerable<int> items = nums.Where(i=>i>10);//using System.Linq;
3. Lambda常用的扩展方法
3-1 Where方法：筛选满足条件的数据
where方法： 集合的每一项数据都会经过predicate的测试，
如果针对一个元素，predicate执行的返回值为true，
那么这个元素就会放到返回值中。
where参数是一个lambda表达式格式的匿名方法，
方法的参数e表示当前判断的元素对象。参数的名字可以自定义，如p,m等
// 使用实例：
//1 Linq
var ss = from r in db.Am_recProScheme
where r.rpId > 10
select r;
//2 Lamba
var ss1 = db.Am_recProScheme.Where(p => p.rpId > 10);
//3 等价的Sql
string sssql = "select * from Am_recProScheme where rpid>10";
3-2 Count()方法：获取数据条数
// 直接使用count
int count1 = list.Count(e => e.Salary > 5000 || e.Age < 30);
// 先使用where再调用count
int count2 = list.Where(e => e.Salary > 5000 || e.Age < 30).Count();
3-3 Any()方法：是否至少有一条数据
// 检查是否符存在符合条件的数据时，Any效率会高些 如：有可能比Count()实现效率高
// 直接使用Any
bool b1 = list.Any(e => e.Salary > 8000);
// 先使用where再调用Any
bool b2 = list.Where(e => e.Salary > 8000).Any();
3-4 排序：OrderBy()、OrderByDescending()、ThenBy()、ThenByDescending()
order()对数据正序排序
orderByDescending()倒序排序
对于简单类型排序，也许不用lambda表达式。
特殊案列：按照最后一个字符排序；
用Guid或者随机数进行排序 多规则排序：
可以在OrderBy()、OrderByDescending()后继续写ThenBy()、ThenByDescending()
案例：优先按照Age排序，如果Age相同再按照Salary排序
list.OrderBy(e => e.Age).ThenByDescending(e => e.Salary)
// 错误写法： 千万不要下方写法，会以最后一个进行排序的
list.OrderBy(e => e.Age). OrderByDescending (e => e.Salary)
3-5 限制结果集，取部分数据： 去重–groupby/distinct、 截取–skip(n)、Task(n)
【去重 groupby/distinct ==> 参考：】
// Linq语法：
// 使用group关键字进行表数据去重
var data= from a in db.orderInfo group p by new {a.orderTypeId} into _group select _group.FirstOrDefault();
// 使用group关键字对多个字段进行表数据去重
var data= from a in db.orderInfo group p by new {a.orderTypeId,...} into _group select _group.FirstOrDefault();
// Lamda语法：
// 单个去重： 使用GroupBy关键字进行表数据去重
var data=db.orderInfo.GroupBy(t=>t.orderTypeId).Select(r => r.First()).ToList();
// 使用DistinctBy关键字进行表数据去重
var data=db.orderInfo.DistinctBy(t=>t.orderTypeId).ToList();
// 多个字段去重： 使用GroupBy关键字对多个字段进行表数据去重
var data=db.orderInfo.GroupBy(t=>new{t.orderTypeId,...}).Select(r => r.First()).ToList();
// 使用DistinctBy关键字对多个字段进行表数据去重
var data=db.orderInfo.DistinctBy(t=>new{t.orderTypeId,...}).ToList();
// sql语法：
// 使用DISTINCT关键字进行表数据去重
string sqlStr="SELECT DISTINCT orderTypeId FROM orderInfo";
// 使用GROUP BY关键字进行表数据去重
string sqlStr="SELECT orderTypeId FROM orderInfo GROUP BY orderTypeId";
【截取 skip/Task ==> 参考：】
skip(n)跳过n条数据，
Task(n)获取n条数据
案例：获取从第2条开始获取3条数据
var items = list.Skip(2).Take(3);
3-6 聚合函数: Max()、Min()、Average()、Sum()、Count()等
// 如取最小值：年龄>30岁中薪水最小的数据
list.Where(e => e.Age > 30).Min(e=>e.Salary)
3-7 分组 GroupBy()
返回值为IGrouping<TKey,TSource>类型的泛型IEnumerable,
每一组以一个IGrouping对象的形式返回。
IGrouping是一个继承自IEnumerable的接口，
IGrouping中Key属性表示这一组的分组数据的值。
// 类似如下Sql的效果：
// string sql = "select recType,min(rpId) from Am_recProScheme group by recType";
var ss = db.Am_recProScheme.GroupBy(p => p.recType);
foreach (var t in ss )
{
// t.Key==分组的字段(p.recType) ,
Response.Write(t.Key + "--" + t.Min(p => p.rpId));
}
3-8 取首条记录 top(1)
// 如 取最后一个可以按倒叙排列再取值
// Linq写法
var ss = (from r in db.Am_recProScheme
select r).FirstOrDefault();
// Lambda写法
var ss1 = db.Am_recProScheme.FirstOrDefault();
3-9 投影 Select，类似Java中Steam的map/flatmap
效果： 把集合中的每一项转换为另外一种类型
// 实例：
IEnumerable<int> ages = list.Select(e => e.Age);
IEnumerable<string> names = list.Select(e=>e.Gender?"男":"女");
var dogs = list.Select(p=>new Dog{NickName=e.Name,Age=e.Age});
// 匿名类型：
var p = new {Name="tom",Id=1};
var p1 = new {name,Id=1,p.Age};
var items = list.Select(e=>new {e.Name,e.Age,XingBie= e.Gender ? "男" : "女"});
var items = list.GroupBy(e => e.Gender).Select(g=>new { Gender=g.Key,Count=g.Count(),AvgSalary= g.Average(e => e.Salary),MinAge= g.Min(e => e.Age)});
3-10 链式调用
集合转换：
有一些地方需要数组类型或者List类型的变量，
可以用ToArray()方法和ToList()， 分别把IEnumerable<T>，转换为Array和List<T>
链式调用：
Where、Select、OrderBy、GroupBy、Task、Skip等返回值都是IEnumerable<T>类型，
所以可以链式调用
4. Linq和Lambda具体代码示例参考：
4-1 简单的查询语句
// Linq语法：
var data=from a in db.Areas select a ;
// Lamda语法：
var data=db.Areas;
// sql语法：
string sqlStr=" SELECT * FROM Areas ";
4-2 带where的查询
// Linq语法：
var data=from a in db.orderInfo where a.orderId > 20 select a ;
// Lamda语法：
var data=db.orderInfo.Where( t=>t.orderId > 20 ) ;
// sql语法：
string sqlStr=" SELECT * FROM orderInfo WHERE orderId > 20 ";
4-3 简单的函数计算（count，min，max，sum）
// Linq语法：
var data=( from a in db.orderInfo select a ).Max( p=>p.orderId ) ;//查询该表中最大编号Id
var data=( from a in db.orderInfo select a ).Min( p=>p.orderId ) ;//查询该表中最小编号Id
var data=( from a in db.orderInfo select a ).Count() ;//查询该表数据总条数
var data=( from a in db.orderInfo select a ).Sum( p=>p.orderMoney ) ;//查询该表中所有消费额的总数（求和）
// Lamda语法：
var data=db.orderInfo.Max( t=>t.orderId );//查询该表中最大编号Id
var data=db.orderInfo.Min( t=>t.orderId );//查询该表中最小编号Id
var data=db.orderInfo.Count();//查询该表数据总条数
var data=db.orderInfo.Sum( t=>t.orderMoney );//查询该表中所有消费额的总数（求和）
// sql语法：
string sqlStr=" SELECT MAX(orderId) FROM orderInfo ";
string sqlStr=" SELECT MIN(orderId) FROM orderInfo ";
string sqlStr=" SELECT COUNT(*) FROM orderInfo ";
string sqlStr=" SELECT SUM(orderMoney ) FROM orderInfo ";
4-4 排序order by desc/asc
// Linq语法：
var data=from a in db.orderInfo where a.orderId > 20 orderby a.orderId descending select a ;//倒序排序，升序可用ascending关键字
// Lamda语法：
// 情况一，根据单字段排序： OrderByDescending
var data=db.orderInfo.OrderByDescending( t=>t.orderId ).Where( t=>t.orderId > 20 ) .ToList();// 升序可用OrderBy关键字
// 情况二，根据多字段主次排序：OrderBy == ThenBy
var priceMonthEntities = priceMonthApp.GetList().OrderBy(t => t.F_Year).ThenBy(t => t.F_Month).ToList();//先按年升序，再按月升序
// sql语法：
string sqlStr=" SELECT * FROM orderInfo WHERE orderId > 20 ORDER BY orderId DESC ";//倒序排序，升序可用ASC关键字
4-5 top(1)
// Linq语法： 取集合中第一个记录
var ss = (from r in db.Am_recProScheme
select r).FirstOrDefault();
// Lamda语法：
var ss1 = db.Am_recProScheme.FirstOrDefault();
//var ss1 = db.Am_recProScheme.First();
// Sql语法：
string sssql = "select top(1) * from Am_recProScheme";
// 取最后一个记录，先倒序排列再取值 ，实例如下：
lists.Reverse(); // 先对集合进行倒序
var s2 = lists.FirstOrDefault();
MessageBox.Show(s2.ToString());
4-6 跳过前N条取余下的数据 Skip
//1 Linq语法：
var ss = (from r in db.Am_recProScheme
orderby r.rpId descending
select r).Skip(10); //跳过前10条数据，取10条之后的所有数据
//2 Lamda语法：
var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Skip(10).ToList();
//3 Sql语法：
string sssql = "select * from (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10";
4-7 截取指定长度的数据 Take
//1 Linq语法：
var ss = (from r in db.Am_recProScheme
orderby r.rpId descending
select r).Take(10); // 截取前10条数据
//2 Lamda语法：
var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Take(10).ToList();
//3 Sql语法：
string sssql = "select * from (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum<=10";
4-8 分页查询： Skip、Take组合使用
【参考1：】
// Linq语法：
var data=( from a in db.orderInfo select a ) .Skip((pageIndex-1) * pageSize).Take(pageSize).ToList();
// Lamda语法： pageIndex:当前页码，pageSize：分页数据显示条数
var data=db.orderInfo.Skip((pageIndex-1)* pageSize).Take(pageSize).ToList();
// sql语法：
string sqlStr="SELECT TOP pageSize * FROM orderInfo WHERE orderId NOT IN(SELECT TOP( ( pageIndex - 1) * pageSize) orderId FROM orderInfo)";
【参考2：】
// 1 Linq语法：
var ss = (from r in db.Am_recProScheme
where r.rpId > 10
orderby r.rpId descending
select r).Skip(10).Take(10); //取第11条到第20条数据
//2 Lamda语法： Take(10): 数据从开始获取，获取指定数量（10）的连续数据
var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).Skip(10).Take(10).ToList();
//3 Sql语法：
string sssql = "select * from (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10 and rowNum<=20";
4-9 包含Contains ， 类似like ‘%%’
// Linq语法： 使用Contains关键字进行模糊匹配
var data= from a in db.orderInfo where a.orderId.Contains(1) select a;
// Lamda语法： 使用Contains关键字进行模糊匹配
var data=db.orderInfo.Where(t=>t.F_UserId.Contains("1")).ToList();
// sql语法： 使用like关键字进行模糊匹配
string sqlStr="SELECT * FROM orderInfo WHERE orderId LIKE '%12%'";
4-10 分组group by
【参考1：】
// Linq语法：
var data= from a in db.orderInfo orderby a.orderId descending
group a by a.orderType into s select new{
s.key,//分组字段
s.sMoney=s.Sum(a=>a.orderMoney),//分组后算出总的消费额
s.maMoney=s.Max(a=>a.orderMoney),//分组后算出最大的消费额
s.miMoney=s.Min(a=>a.orderMoney)//分组后算出最小的消费额
};
// Lamda语法：
//使用GroupBy关键字进行分组查询（单个字段）
var data=db.orderInfo.GroupBy(p => p.recType).Select(t=>t.Key).ToList();
//使用GroupBy关键字进行分组查询（多个字段）
var data=db.orderInfo.GroupBy(p =>new{ p.recType,p.orderId}).Select(t=>new{ recType=t.Key.recType,orderId=t.Key.orderId}).ToList();
// sql语法：
string sqlStr="SELECT orderType , SUM(orderMoney), MAX(orderMoney), MIN(orderMoney) FROM orderInfo GROUP BY orderType";
【参考2】
//1 Linq语法：
var ss = from r in db.Am_recProScheme
orderby r.rpId descending
group r by r.recType into n
select new
{
n.Key, //这个Key是recType
rpId = n.Sum(r => r.rpId), //组内rpId之和
MaxRpId = n.Max(r => r.rpId),//组内最大rpId
MinRpId = n.Min(r => r.rpId), //组内最小rpId
};
foreach (var t in ss)
{
Response.Write(t.Key + "--" + t.rpId + "--" + t.MaxRpId + "--" + t.MinRpId);
}
//2 Linq语法：
var ss1 = from r in db.Am_recProScheme
orderby r.rpId descending
group r by r.recType into n
select n;
foreach (var t in ss1)
{
Response.Write(t.Key + "--" + t.Min(p => p.rpId));
}
//3 Lamda语法：
var ss2 = db.Am_recProScheme.GroupBy(p => p.recType);
foreach (var t in ss2)
{
Response.Write(t.Key + "--" + t.Min(p => p.rpId));
}
//4 sql语法：
string sssql = "select recType,min(rpId),max(rpId),sum(rpId) from Am_recProScheme group by recType";
4-11 Sql中的In – 通过Contains实现
【实例1：】
// Linq语法：
var data= from a in db.orderInfo where (new int?[2213,43311,32422]).Contains(a.orderId) select a ;
// Lamda语法：
var data=db.orderInfo.Where(t=>(new int?[2213,43311,32422]).Contains(t.orderId)).ToList();
// sql语法：
string sqlStr="SELECT * FROM orderInfo WHERE orderId IN (2213,43311,32422)";
【实例2：】
// Linq语法：
var ss = from p in db.Am_recProScheme
where (new int?[] { 24, 25,26 }).Contains(p.rpId)
select p;
foreach (var p in ss)
{
Response.Write(p.Sorts);
}
// sql语法：
string st = "select * from Am_recProScheme where rpId in(24,25,26)";
4-12 内连接 Inner Join
【参考1】
// Linq语法：
var ss = from r in db.Am_recProScheme
join w in db.Am_Test_Result on r.rpId equals w.rsId
orderby r.rpId descending
select r;
// Lamda语法：
var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();
// sql语法：
string sssql = "SELECT r.* FROM Am_recProScheme AS r INNER JOIN Am_Test_Result AS t ON r.[rpId] = t.[rsId] ORDER BY r.[rpId] DESC";
【参考2】
//Linq
var ss = from r in db.Am_recProScheme
join w in db.Am_Test_Result on r.rpId equals w.rsId
orderby r.rpId descending
select r;
//Lambda
var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();
//SQL
string sssql = "select r.* from [Am_recProScheme] as r inner join [dbo].[Am_Test_Result] as t on r.[rpId] = t.[rsId] order by r.[rpId] desc";
4-13 Linq和Lambda实现 左链接、右链接、内链接参考：
4-13-1 先准备个数据类
//客户类
public class Customer
{
public int id { get; set; }
public string name { get; set; }
public string email { get; set; }
}
//联系方式类
public class CustomerContact
{
public int ccid { get; set; }
public int CustomerId { get; set; }//客户的id，外键
public string Phone { get; set; }
public string Address { get; set; }
}
//模拟数据
public static List<Customer> GetCustomer()//客户
{
List<Customer> list = new List<Customer>();
list.Add(new Customer { id = 1, name = "刘德华", email = "ldh@net.cn" });
list.Add(new Customer { id = 2, name = "张学友", email = "zxy@net.cn" });
list.Add(new Customer { id = 3, name = "黎明", email = "lm@net.cn" });
list.Add(new Customer { id = 4, name = "郭富城", email = "gfc@net.cn" });
list.Add(new Customer { id = 4, name = "古天乐", email = "gtl@net.cn" });
return list;
}
public static List<CustomerContact> GetCustomerContact()//联系人
{
List<CustomerContact> list = new List<CustomerContact>();
list.Add(new CustomerContact { ccid = 1,CustomerId=1, Phone="13566769988",Address="北京"});
list.Add(new CustomerContact { ccid = 2, CustomerId = 1, Phone = "13566769986", Address = "天津" });
list.Add(new CustomerContact { ccid = 3, CustomerId =2, Phone = "13677889900", Address = "香港" });
list.Add(new CustomerContact { ccid = 4, CustomerId = 8, Phone = "13677889332", Address = "上海" });
return list;
}
4-13-2 Linq：左连接、右连接、内连接
// 1. 左连接
var LeftJoin = from cusetomer in GetCustomer()
join cc in GetCustomerContact()
on cusetomer.id equals cc.CustomerId
// 内连接的基础上， 加入这行代码就实现类左连接
into JoinCC from cc in JoinCC.DefaultIfEmpty()
select new
{
CustomerName = cusetomer.name,
phone = cc != null ? cc.Phone : null
};
// 2. 右连接：
// 右链接跟左链接相反，只需要改一下顺序就可以了。
var LightJoin = from cc in GetCustomerContact()
join cusetomer in GetCustomer()
on cc.CustomerId equals cusetomer.id
// 内连接的基础上， 加入这行代码就实现类左连接
into JoinCC from cusetomer in JoinCC.DefaultIfEmpty()
select new
{
phone = cc.Phone,
CustomerName =cusetomer != null ? cusetomer.name : null,
};
// 3. 内连接：
var InnerJoin = from cc in GetCustomerContact()
join cusetomer in GetCustomer()
on cc.CustomerId equals cusetomer.id
select new
{
phone = cc.Phone,
CustomerName = cusetomer.name
};
// 3-2 内连接： 多个条件关联的join
var whiteDiagList = (from r1 in diagControlList
where r1.ControlRelation == 1
join r2 in args.DiagList on new { code = r1.DiagCode, name = r1.DiagName }
equals new{code=r2.DiagCode,name=r2.DiagName}
select r1).ToList<DiagControlModel>();
4-13-3 Lambda：左连接、右连接、内连接 [ 推荐使用上方Linq写法 ]
// 1. 左连接：
var LMLeftJoin = GetCustomer().GroupJoin(GetCustomerContact(),
a => a.id, b => b.CustomerId, (a, b) =>new { a,b })
.SelectMany(c=>c.b.DefaultIfEmpty(), (c, b)
=>new { CustomerName= c.a.name,Phone=b!=null?b.Phone:null });
// 2. 右连接：参考左连接，两个集合对调位置就行了
// 3. 内连接：
var LMInnerJoin = GetCustomer().Join(GetCustomerContact(), a => a.id, b => b.CustomerId
, (a, b) => new { CustomerName = a.name, Phone = b.Phone });
4-14 扩展：交集、并集、差集的用法 [了解，使用不多]
4-14-1 简单类型的交集、并集、差集用法：
List<string> ListA = new List<string>();
List<string> ListB = new List<string>();
List<string> ListResult = new List<string>();
ListResult = ListA.Distinct().ToList();//去重
ListResult = ListA.Except(ListB).ToList();//差集
ListResult = ListA.Union(ListB).ToList(); //并集
ListResult = ListA.Intersect(ListB).ToList();//交集
4-14-2 对象类型：List的交集、并集、差集用法
若上面的例子不是List类型，
而是List，则需要对XXXModel进行处理。
步骤如下：
4-14-2-1 先定义Model
public class ItemModel
{
public string ItemCode { get; set; }
public string ItemName { get; set; }
}
4-14-2-2 定义Model间如何比较
说明： 若不定义，比较的是两个引用
public class ItemModelComparer : IEqualityComparer<ItemModel>
{
//比较
public bool Equals(ItemModel x, ItemModel y)
{
bool checkFlag = true;
if (Object.ReferenceEquals(x, y))
{
checkFlag = true;
}
else if (Object.ReferenceEquals(x, null) || Object.ReferenceEquals(y, null))
{
checkFlag = false;
}
else
{
if (x.ItemCode == y.ItemCode) //若Model有多个条件则需要添加。例如 if(x.ItemCode==y.ItemCode && x.Other==y.Other)
{
checkFlag = true;
}
else
{
checkFlag = false;
}
}
return checkFlag;
}
//实现获取哈希值
public int GetHashCode(ItemModel model)
{
if (Object.ReferenceEquals(model, null)) return 0;
int hashNurse = model.ItemCode.GetHashCode();
// 若两个集合有多个关联条件，则哈希值也需要进行计算
// int hashOther=model.Other.GetHashCode();
// int resultHash=hashNurse^hashOther;
// return resultHash;
return hashNurse;
}
}
4-14-2-3 实例代码参考：
List<ItemModel> ListA = new List<ItemModel>();
List<ItemModel> ListB = new List<ItemModel>();
List<ItemModel> ListResult = new List<ItemModel>();
ListResult = ListA.Distinct(new ItemModelComparer()).ToList();//去重
ListResult = ListA.Except(ListB, new ItemModelComparer()).ToList();//差集
ListResult = ListA.Union(ListB, new ItemModelComparer()).ToList(); //并集
ListResult = ListA.Intersect(ListB, new ItemModelComparer()).ToList();//交集
4-15 一些使用的实例代码：
//数据库 + 自定义名称 =new 数据库
mydbDataContext con = new mydbDataContext();
//模糊查询表达式中用.Contains
con.car.Where(r=>r.name.Contains(TextBox1.Text.Trim())).ToList(）;
//开头查用.StartWith
con.car.Where(r => r.name.StartsWith(TextBox1.Text)).ToList();
//结尾查用.EndWith
con.car.Where(r => r.name.EndsWith(TextBox1.Text)).ToList();
//最大值
con.car.Max(r => r.price * r.oil).ToString();
//最小值
con.car.Min(r => r.price).ToString();
//求和
con.car.Sum(r => r.price).ToString();
//平均值
con.car.Average(r => r.price).ToString();
//升序：
con.car.OrderBy(r => r.price).ToList();
//降序：
con.car.OrderByDescending(r => r.price).ToList();
//上一页，下一页，组合查询：
int PageCount = 5;//每页显示条数
//上一页，PageCount_Label.Text为当前页码
int pageNum = Convert.ToInt32(PageCount_Label.Text) - 1;
Repeater1.DataSource = con.car.Skip((pageNum - 1) * PageCount).Take(PageCount);
Repeater1.DataBind();
PageCount_Label.Text = pageNum.ToString();
//下一页
int pageNum = Convert.ToInt32(PageCount_Label.Text) + 1;
Repeater1.DataSource = con.car.Skip((pageNum - 1) * PageCount).Take(PageCount);
Repeater1.DataBind();
PageCount_Label.Text = pageNum.ToString();
//组合查询的点击事件
List<car> list = con.car.ToList();
if (TextBox2.Text != "")
{
List<car> list1 = con.car.Where(r => r.name.Contains(TextBox2.Text)).ToList();
list = list.Intersect(list1).ToList();
}
if (TextBox3.Text != "")
{
List<car> list1 = con.car.Where(r => r.oil == Convert.ToDecimal(TextBox3.Text)).ToList();
list = list.Intersect(list1).ToList();
}
if (TextBox4.Text != "")
{
List<car> list1 = con.car.Where(r => r.powers == Convert.ToInt32(TextBox4.Text)).ToList();
list = list.Intersect(list1).ToList();
}
Repeater1.DataSource = list;
Repeater1.DataBind();
715
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
