LINQ to Objects 上
查询用的类,和对象
public class student
{
public string name { get; set; }
public int age { get; set; }
public int Igrades { get; set; }
public order[] oders;
}
public class grade
{
public int grades { get; set; }
public string name { get; set; }
}
public class order
{
public int oid { get; set; }
public int quantity { get; set; }
}
student[] stu = {
new student { name = "a", age = 11, Igrades = 1, oders=new order[]{ new order{ oid=1, quantity=11},new order{ oid=2, quantity=111}}},
new student { name = "b", age = 13, Igrades = 1,oders=new order[]{ new order{ oid=1, quantity=11},new order{ oid=2, quantity=111}} },
new student { name = "c", age = 12, Igrades = 2,oders=new order[]{ new order{ oid=1, quantity=11},new order{ oid=2, quantity=111}} },
new student { name = "e", age = 10, Igrades = 1,oders=new order[]{ new order{ oid=1, quantity=11},new order{ oid=2, quantity=111}} }
};
grade[] g = {
new grade { grades = 1, name = "1年级" },
new grade { grades = 2, name = "2年级" },
new grade { grades = 3, name = "3年级" }
};
----------------------------------------------------------------------------------------------------
查询操作符:
where操作符
例子1
var expr = stu.Where((c, index) => (c.Igrades == 1 && index >= 1)).Select(c => c.name);
foreach (var item in expr)
{
Response.Write(item);
}结果:
例子2:分页
int startIndex=0;
int endIndex=2;
var exp = stu.Where((s, index) => ((s.Igrades > startIndex) && (s.Igrades < endIndex))).Select(s=>s.name);
foreach (var item in exp)
{
Response.Write(item+"</br>");
}效果:
select操作符
例子1
var exp = stu.Select(s => new { name = s.name, age = s.age });
foreach (var item in exp)
{
Response.Write(item + "</br>");}
例子2:
var exp = stu.Select((s, index) => new { index, s.name, s.age });
foreach (var item in exp)
{
Response.Write(item + "</br>");}
SelectMany
4种重载
public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TResult>> selector);
//
// 摘要:
// 将序列的每个元素投影到 System.Collections.Generic.IEnumerable<T>，并将结果序列合并为一个序列。每个源元素的索引用于该元素的投影表。
//
// 参数:
// source:
// 一个要投影的值序列。
//
// selector:
// 一个应用于每个源元素的转换函数；函数的第二个参数表示源元素的索引。
//
// 类型参数:
// TSource:
// source 中的元素的类型。
//
// TResult:
// selector 返回的序列元素的类型。
//
// 返回结果:
// 一个 System.Collections.Generic.IEnumerable<T>，其元素是对输入序列的每个元素调用一对多转换函数的结果。
//
// 异常:
// System.ArgumentNullException:
// source 或 selector 为 null。
public static IEnumerable<TResult> SelectMany<TSource, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TResult>> selector);
//
// 摘要:
// 将序列的每个元素投影到 System.Collections.Generic.IEnumerable<T>，并将结果序列合并为一个序列，并对其中每个元素调用结果选择器函数。
//
// 参数:
// source:
// 一个要投影的值序列。
//
// collectionSelector:
// 一个应用于输入序列的每个元素的转换函数。
//
// resultSelector:
// 一个应用于中间序列的每个元素的转换函数。
//
// 类型参数:
// TSource:
// source 中的元素的类型。
//
// TCollection:
// collectionSelector 收集的中间元素的类型。
//
// TResult:
// 结果序列的元素的类型。
//
// 返回结果:
// 一个 System.Collections.Generic.IEnumerable<T>，其元素是对 source 的每个元素调用一对多转换函数
// collectionSelector，然后将那些序列元素中的每一个及其相应的源元素映射为结果元素的结果。
//
// 异常:
// System.ArgumentNullException:
// source 或 collectionSelector 或 resultSelector 为 null。
public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
//
// 摘要:
// 将序列的每个元素投影到 System.Collections.Generic.IEnumerable<T>，并将结果序列合并为一个序列，并对其中每个元素调用结果选择器函数。每个源元素的索引用于该元素的中间投影表。
//
// 参数:
// source:
// 一个要投影的值序列。
//
// collectionSelector:
// 一个应用于每个源元素的转换函数；函数的第二个参数表示源元素的索引。
//
// resultSelector:
// 一个应用于中间序列的每个元素的转换函数。
//
// 类型参数:
// TSource:
// source 中的元素的类型。
//
// TCollection:
// collectionSelector 收集的中间元素的类型。
//
// TResult:
// 结果序列的元素的类型。
//
// 返回结果:
// 一个 System.Collections.Generic.IEnumerable<T>，其元素是对 source 的每个元素调用一对多转换函数
// collectionSelector，然后将那些序列元素中的每一个及其相应的源元素映射为结果元素的结果。
//
// 异常:
// System.ArgumentNullException:
// source 或 collectionSelector 或 resultSelector 为 null。
public static IEnumerable<TResult> SelectMany<TSource, TCollection, TResult>(this IEnumerable<TSource> source, Func<TSource, int, IEnumerable<TCollection>> collectionSelector, Func<TSource, TCollection, TResult> resultSelector);
//
// 摘要:
// 通过使用相应类型的默认相等比较器对序列的元素进行比较，以确定两个序列是否相等。
//
// 参数:
// first:
// 一个用于比较 second 的 System.Collections.Generic.IEnumerable<T>。
//
// second:
// 一个 System.Collections.Generic.IEnumerable<T>，用于与第一个序列进行比较。
//
// 类型参数:
// TSource:
// 输入序列中的元素的类型。
//
// 返回结果:
// 如果根据相应类型的默认相等比较器，两个源序列的长度相等，且其相应元素相等，则为 true；否则为 false。
//
// 异常:
// System.ArgumentNullException:
// first 或 second 为 null。
[TargetedPatchingOptOut("Performance critical to inline this type of method across NGen image boundaries")]
var sss = stu.Where(s => s.Igrades == 1).SelectMany(s => s.oders);
foreach (var item in sss)
{
Response.Write(item.quantity+);}
使用查询表达式:
var sss = from asd in stu
where asd.Igrades == 1
from o in asd.oders
select o;
foreach (var item in sss)
{
Response.Write(item.quantity + "</br>");}
结果:
总结:第一个from子句之前的select被转换成 Select调用,其他的select命令都会被转换成 SelectMany调用.
第三和第四个重载 形式,适合于 从源序列集选出 自定义结果,而不是简单合并源序列集的项.
var sss = stu.Where(s => s.Igrades == 1).SelectMany(s => s.oders, (s, o) => new { o.quantity, o.oid });
foreach (var item in sss)
{
Response.Write(item+"</br>");
}查询表达式实现:
var sss = from asd in stu
where asd.Igrades == 1
from o in asd.oders
select new { o.oid, o.quantity };
foreach (var item in sss)
{
Response.Write(item+"</br>");
}
排序操作符
OrderBy 和 OrderByDescending
var sss = stu.Where(s => s.Igrades == 1).OrderByDescending(s => s.name).Select(s => new { s.name, s.age });
foreach (var item in sss)
{
Response.Write(item + "</br>");}
ThenBy, ThenByDescending
var sss = stu.Where(s => s.Igrades == 1).OrderByDescending(s => s.age).ThenByDescending(s=>s.name).Select(s => new { s.name, s.age });
foreach (var item in sss)
{
Response.Write(item + "</br>");}
对应的查询表达式:
var sss = from asd in stu
where asd.Igrades == 1
orderby asd.age descending, asd.name
select new
{asd.name,
asd.age};
foreach (var item in sss)
{
Response.Write(item + "</br>");}
Reverse操作符
颠倒查询结果,把最后一项放在返回结果的最前面(查询的所有结果 全反序)
var sss = stu.Where(s => s.Igrades == 1).OrderByDescending(s => s.age).Select(s => new { s.name, s.age }).Reverse();
foreach (var item in sss)
{
Response.Write(item+"</br>");
}
结果:
分组操作符
GroupBy
var sss = stu.GroupBy(s => s.age);
foreach (IGrouping<int, student> gg in sss)
{
Response.Write(string.Format("age:{0}", gg.Key)+"</br>");foreach (var item in gg)
{
Response.Write(item.name + "</br>");
}}
效果:
按年级对学生名字进行分组
var sss = stu.GroupBy(s => s.age, s => s.name);
foreach (IGrouping<int, string> gg in sss)
{
Response.Write(string.Format("age:{0}", gg.Key) + "</br>");foreach (var item in gg)
{
Response.Write(item + "</br>");}
}
具有自定义的 resultSelector 和elementSelector,并使用GroupBy操作符按 年级对学生名字进行分组
var sss = stu.GroupBy(
s => s.Igrades,
s => new { orderCount = s.oders.Count() }, //elementSelector
(key, element) => new //resultSelector
{Key = key,
Count = element.Count(),
orderContent = element.Sum(item => item.orderCount)});
foreach (var group in sss)
{
Response.Write("key:"+group.Key + "-组成员数量" + group.Count + "-订单总数量" + group.orderContent + "</br>");}
