一、筛选操作符Where
根据谓词对源序列的内容进行筛选,类似于SQL中的where子句。
1.简单where表达式
使用扩展方法
var query1 = CustomerList.Where(c => c.Country == “USA”);
使用查询表达式语法
query1 = from c in CustomerList where c.Country == “USA” select c;
使用扩展方法需要向where方法中传入lambda表达式。
2.复合where表达式
所谓的复合where表达式就是使用&&或||操作符对数据进行筛选
使用扩展方法
var query2 = CustomerList.Where(c => c.Country == “USA”&& c.Orders.Any());
使用查询表达式语法
query2 = from c in CustomerList where c.Country == “USA”&& c.Orders.Any() select c;
Any()方法相当于Count()>0,如果集合中有元素就返回true。
3.使用Index参数和IndexOf()方法
index值代表的是集合中元素的索引号,在where()中使用index可以控制返回与指定索引号相关的集合数据。泛是返回IEnumerable<T>类型的查询操作都可以使用index。
使用扩展方法
var query3 = CustomerList.Where((c, index) => c.Country == “USA”&& index > 70);//返回国家是USA,索引号大于70的元素集合。
这里lambda表达式中接收的参数是(c,index),索引号做为第二个参数传入。
也可以使用IndexOf()方法来实现上面的功能,如果使用IndexOf()的话,那lambda表达式中传入的参数只需要一个就可以了。
使用扩展方法
var query3 = CustomerList.Where(c => c.Country == “USA” &&CustomerList.IndexOf(c) > 70);
使用查询表达式语法
query3 = from cust in CustomerList where cust.Country == “USA”&& CustomerList.IndexOf(cust)> 70 select cust;
二、投影运算符
投影运算符对应SQL中的“select列名”子句
(一)Select
Select操作符是从序列源返回一组指定属性
使用扩展方法
var infos = context.Infos.Where(p => p.Sex== true).Select(p=> new { p.Name,p.Sex});
foreach (var c in infos)
{
Console.WriteLine(c.Name + c.Sex);
}
使用查询表达式语法
var infos = from p in context.Infos wherep.Sex == true selectnew { p.Name, p.Sex };
foreach (var c in infos)
{
Console.WriteLine(c.Name + c.Sex);
}
如果使用扩展方法则在Select()方法中使用lambda表达式p=>new {p.Name,p.Sex}来对列进行投影;如果使用查询表达式语法的话,直接在select关键字后使用匿名类new { p.Name, p.Sex }即可。
(二)SelectMany
SelectMany操作符实际上实现的是相关数据的交叉连接操作。它根据lambda表达式从一对多的序列中返回指定的属性。
比如:
《图3》
查询男员工的所有家庭成员:
使用扩展方法
var q = context.Infos.Where(p => p.Sex ==true).SelectMany(f=>f.Families);
foreach (var n in q)
{
Console.WriteLine(n.Name);
}
使用查询表达式语法
var q = from p in context.Infos wherep.Sex==true from f in p.Families select f;
foreach (var n in q)
{
Console.WriteLine(n.Name);
}
三、分块操作符
(一)Skip和Take
Skip是从序列中跳过元素的个数;Take是从序列中获取元素的个数;
如:跳过集合的前2个元素,从第三个元素开始向后取4个元素。
使用扩展方法
var q = list.Skip(2).Take(4);
使用查询表达式语法
var q = (from p in list select p).Skip(2).Take(4);
(二)SkipWhile和TakeWhile
SkipWhile:条件跳过,从序列第一个元素开始依次判断,一直跳到不满足条件的元素为止,返回此元素及此元素之后的序列 ;
TakeWhile:条件抓取,从序列第一个元素开始依次判断,只要满足条件就进行下个元素判断,直到不满足条件的元素为止,返回此元素之前的序列 ;
如:取集合中第一批“性别”是“男”的元素的集合。
使用扩展方法
var q = list.SkipWhile(p => p.Sex == false).TakeWhile(p=> p.Sex == true);
使用查询表达式语法
var q = (from p in list select p).SkipWhile(p => p.Sex == false).TakeWhile(p=> p.Sex == true);
四、连接运算符
Join和GroupJoin操作符是把两个相互独立的对象通过关键属性关联起来。这种对象与对象的关联与SQL中的Join关联语法上有些不同。
1.LinQ的Join不支持SQL-92中的一些比较运算符,如>、<、<>等。它只支持相等运算符
2.在On子句中不能使用=来实现两个对象之间的关联,需要使用Equals运算符。
(一)Join
使用扩展方法
var list = infos.Join(works, p => p.Code, w =>w.InfoCode, (p, w) => new { p.Name, w.Firm, w.Depart });
使用查询表达式语法
var list = from p in infos join w in works on p.Code equals w.InfoCode select new { p.Name, w.Firm, w.Depart };
(二)GroupJoin
可以实现外联效果
Join扩展方法与GroupJoin扩展方法签名有些不一样
《图4》
《图5》
在C#3.0查询表达式语法中没有GroupJoin语法,可以使用Join...into...来实现,它与Join不同的是,它可以实现类似于SQL外联接的效果,而Join只实现类似于SQL内联的效果。
使用查询表达式语法
var list = from p in infos join w in works on p.Code equals w.InfoCode into bo from r in bo.DefaultIfEmpty() select new { p.Name, r};
五、连接运算符
Concat运算符用来把两个序列连接到一个序列中,它类似于SQL中的关系或or运算符。
使用扩展方法
var q = infos.Select(p=>p.Name).Concat(works.Select(w=>w.Firm));
使用查询表达式语法
var q = (from p in infos select p.Name).Concat(from w in works select w.Firm);
六、排序运算符
排序运算符一共包含五个运算符OrderBy、OrderByDescending、ThenBy、ThenByDescending和Reverse
OrderBy:升序排序
OrderByDescending:降序排序
ThenBy:在OrderBy或OrderByDescending后实现多级排序中实现升序排序
ThenByDescending:在OrderBy或OrderByDescending后实现多级排序中实现降序排序
Reverse:顺序倒转
如:对所有人员先按照性别升序排序,再按照生日降序排序
使用扩展方法:
var q = infos.OrderBy(p => p.Sex).ThenByDescending(p=> p.Birthday);
使用查询表达式语法:
var q = from p in infos orderby p.Sex,p.Birthday descending select p;
在查询表达式语法中实现多级排序类似于T-Sql中的方式。
七、分组操作符
分组操作符GroupBy用来按照元素的某个属性来对序列中的元素进行分组。类似于SQL中的group by 子句,但它是对象的序列,还可以获取每组中的每个元素对象。
如:按照性别对人员进行分组,并显示每组中人员的信息
使用扩展方法:
var q = infos.GroupBy(p=>p.Sex);;
使用查询表达式语法:
var q = from m in infos group m by m.Sex into g select g;
显示分组数据:
foreach (var item in q)
{
//item.Key代表分组后的关键字的值,在这里是性别Sex的值
Console.WriteLine("性别为"+item.Key+"\t共有"+item.Count()+"人");
foreach (var c in item)
{
Console.WriteLine("\t" + c.Name +"\t" + c.Sex);
}
Console.WriteLine("*********************");
}
《图6》
八、集合操作符
集合操作符包括Distinct、Union、Intersect和Except,除了Distinct之外其余的三个是用来把两个集合拼合成一个集合。
(一)Distinct
Distinct操作符用来把序列中重复的值移除掉,类似于SQL中的Distinct
如:查看Infos集合中所有
使用扩展方法:
var q = infos.Select(p => p.Nation).Distinct();
使用查询表达式语法:
var q = (from p in infos select p.Nation).Distinct();
(二)Union
Union操作符取两个具有相同结构的集合并集,如果两集合中有相同元素,则会自动滤去重复内容。而前面所讲的Concat操作符只是将两个集合进行合并,并不过滤重复元素。
如:两个集合,其中temp是infos的子集。
var infos = from p in context.Infos.ToList()select p;
var temp = infos.Where(p => p.Sex == true);
使用扩展方法:
var q = infos.Union(temp);
使用查询表达式语法:
var q = (from p in infos select p).Union(from m in temp select m);
运行结果中,子集的内容并没有重复出现
(三)Intersect
Intersect操作符是取两个具有相同结构的集合的交集部份。
如:两个集合,其中temp是infos的子集。
var infos = from p in context.Infos.ToList()select p;
var temp = infos.Where(p => p.Sex == true);
使用扩展方法:
var q = infos.Intersect(temp);
使用查询表达式语法:
var q = (from p in infos select p).Intersect(from m in temp select m);
运行结果中只显示子集中的内容。
(四)Except
Except操作符是从一个集合中取另一个集合的差集,即从集合A中取出集合B中不包含的元素。
如:两个集合,infos和temp,temp集合中包含了infos集合中不存在的元素
var infos = from p in context.Infos.ToList()select p;
var temp = infos.Where(p => p.Sex == true).ToList();
temp.Add(new Info
{
Code = "p100",
Name = "哈哈",
Sex = false,
Nation = "n004",
Birthday = DateTime.Now
});
使用扩展方法:
var q = infos.Except(temp);
使用查询表达式语法:
var q = (from p in infos select p).Except(from m in temp select m);
九、转换操作符,用来改变集合的类型
(一)ToArray
把集合转换为数组形式,不延迟
使用扩展方法:
Info[] g = infos.ToArray();
使用查询表达式语法:
Info[] g = (from p in infos select p).ToArray();
(二)ToList
把集合转换为泛型集合形式,不延迟
使用扩展方法:
List<Info>g = infos.ToList();
使用查询表达式语法:
List<Info>g = (from p in infos select p).ToList();
(三)ToDictionary
把集合转换成Dictionary<TKey,TElement>类型的集合,它每个元素的value值是原集合中的一个元素对象。
如:下面的代码把集合的内容转换为一个字典集合,字典的key值是人员代号,字典的value值是info元素对象。
使用扩展方法:
var q = infos.ToDictionary(p=>p.Code);
使用查询表达式语法:
var q = (from p in infos select p).ToDictionary(p=>p.Code);
调用语法
foreach (var item in q)
{
Console.WriteLine(item.Key+item.Value.Name);
}
从运行结果中我们可以看出,字典的第二个参数就是原集合中的元素。
(四)ToLookup
把集合转换成ILookup<TKey,TElement>类型的集合,ILookup<TKey,TElement>集合与Dictionary<TKey,TElement>集合不同的是:Dictionary<TKey,TElement>中Key和Value值一一对应,而ILookup<TKey,TElement>集合中Key和Value值是一对多的对应关系。
如:使用ILookup<TKey,TElement>把集合中的元素分组显示
使用扩展方法:
var q = infos.ToLookup(p=>p.Nation);
使用查询表达式语法:
var q = (from p in infos select p).ToLookup(p=> p.Nation);
显示数据的代码:
foreach (var item in q)
{
Console.WriteLine(item.Key);
foreach (var single in item)
{
Console.WriteLine("\t" +single.Name);
}
}
显示效果:
《图7》
(原创:灰灰虫的家http://hi.baidu.com/grayworm)
十、相等操作符:SequenceEqual
用来对两个序列进行对比。如果所有元素的值相等,并且元素个数相等,并且元素的次序相等,那SequenceEqual操作符返回的是True,否则返回False
var s1 = infos.OrderBy(p => p.Code);
var s2 = infos.OrderByDescending(p=>p.Code);
var s3 = infos.OrderBy(p => p.Code);
Console.WriteLine(s1.SequenceEqual(s2)); //结果是False
Console.WriteLine(s1.SequenceEqual(s3)); //结果是True
十一、元素操作符:
元素操作符的作用是从IEnumerable<T>集合序列中返回一个指定的元素。
如果没有找到指定的元素,所有的XXXDefault操作符返回空对象,并不会产生异常。而First、Last、Single和ElementAt操作符则会产生异常。
(一)First和FirstOrDefault
如果序列中包含一个或多个元素,这两个操作符返回序列中的第一个元素。如果序列不包含任何元素,则FirstOrDefault操作符返回null值(引用类型)或默认值(值类型),而First操作符则产生异常信息。
如:查找第一个女生
使用扩展方法:
var item = infos.First(p=>p.Sex == false);
var item = infos.Where(p => p.Sex == false).First();
使用查询表达式语法:
var item = (from p in infos where p.Sex ==false select p).First();
(二)Last和LastOrdefault
如果序列中包含一个或多个元素,这两个操作符返回序列中的最后一个元素。如果序列不包含任何元素,则LastOrDefault操作符返回null值(引用类型)或默认值(值类型),而Last操作符则产生异常信息。
如:查找最后一个女生
使用扩展方法:
var item = infos.Last(p=>p.Sex == false);
var item = infos.Where(p=> p.Sex == false).Last();
使用查询表达式语法:
var item = (from p in infos where p.Sex ==false select p).Last();
(三)Single和SingleOrDefault
如果序列中有且只有一个元素,则这两个操作符返回该元素
如果序列中没有任何元素,则Single会产生异常,而SingleOrDefault则会返回null值(引用类型)或默认值(值类型)
如果序列中包含多个元素,则这两个操作符都会产生异常。
(四)ElementAt和ElementAtOrDefault
这两个操作符是根据索引号从序列中返回指定的元素,如果未找到元素ElementAt()会产生异常,而ElementAtOrDefault()则会返回默认实例。
如:取出集合中的第二个女生
使用扩展方法:
var item = infos.Where(p=>p.Sex == false).ElementAt(2);
使用查询表达式语法:
var item = (from p in infos where p.Sex ==false select p).ElementAt(2);
十二、元素数量操作符
判断序列中元素是否满足指定的条件返回bool型的值。带有该操作符的话句不能实现延迟查询,语句会被立即执行。
(一)Any
如果序列中存在任一个满足条件的元素,就返回true
如:判断是否存在代号为P005的人员
使用扩展方法:
var q = infos.Any(p=>p.Code == "p005");
var q = infos.Where(p=> p.Code == "p005").Any();
使用查询表达式语法:
var q = (from p in infos where p.Code =="p005").Any();
(二)All
如果序列中所有元素都满足条件,就返回true
如:判断是否所有员工都是汉族
使用扩展方法:
var q = infos.All(p => p.Nation == "汉族");
使用查询表达式语法:
var q = (from p in infos select p).All(p=>p.Nation == "汉族");
(三)Contains
判断集合中是否包含指定的元素
十三、聚合操作符
聚合操作符类似于SQL中的聚合函数,所有带有聚合操作符的LinQ语句都无延迟功能,会被立即被执行。
(一)Count
取得序列中满足条件的元素的个数
使用扩展方法:
var q = infos.Count(p => p.Sex == false);
var q = infos.Where(p => p.Sex == false).Count();
使用查询表达式语法:
var q = (from p in infos where p.Sex==falseselect p).Count();
(二)Min、Max、Sum和Average
分别是取得序列中所有元素中某属性的最小值、最大值、总和、平均值等。
decimal? minFreightCharge = OrderList.Min(c => c.Freight);
decimal? maxFreightCharge = OrderList.Max(c => c.Freight);
decimal? sumFreightCharge = OrderList.Sum(c => c.Freight);
decimal? avgFreightCharge = OrderList.Average(c => c.Freight);
总结:
这一篇文章主要介绍了LinQ的标准查询操作符(SQO)。对每个操作符都介绍了使用扩展方法的使用和查询表达式的使用,对于这两种用法大家应当都掌握住,尤其要记住扩展方法的使用。
由于时间的原因没有对每个示例的运行结果抓图显示,朋友们可以自己测试一下结果。
上面的内容是LinQ to Object的基础语法,也是其它LinQ的基础,熟练使用这些操作符能够使我们在LinQ天地中自由驰骋。
案例:
var lowestConsumptions = (
from g in ctx.PubGuests
from b in ctx.PubBillItems
from r in ctx.PubRooms
from rt in ctx.PubRoomTypes
where g.GroupNo == guest.GroupNo && g.RoomID == r.ID && r.RoomTypeID == rt.ID
&& (g.GuestStatus == AppData.StatusGuest.InRoom || g.GuestStatus == AppData.StatusGuest.OutRoom || g.GuestStatus == AppData.StatusGuest.WalkIn)
&& b.ReduceStatus == AppData.ReduceStatus.None
&& rt.LowestAmt > 0
&& g.GuestNo == guest.GuestNo
group new { g, rt, b } by new { g.GroupNo, g.RoomID, g.RoomNo, rt.LowestAmt } into t
select new
{
t.Key.GroupNo,
t.Key.RoomID,
t.Key.LowestAmt,
Amt = t.Sum(a => a.b.IfLowestItem * a.b.DebitAmt)
}
).ToList()