LINQ TO OBJECT

LINQ to OBJECT

转自：汇智网~！ http://www.hubwiz.com/ 概述：

LINQ to OBJECT是用于操作内存对象的LINQ编程接口，包含了大量的查询操作符，针对内存中的集合对象进行操作。　　LINQ to OBJECT的实现基于IEnumerable<T>泛型接口、序列（sequences）以及标准查询操作符（Standard Query Operators）等基本概念。其中，IEnumerable<T>泛型接口是使用C# 2.0泛型技术实现的一个接口，该接口与IEnumerable类似，允许对接口内部的元素进行列举操作；序列是一个专门术语，表示一个实现了IEnumerable<T>接口的集合对象。　　LINQ to OBJECT的大部分操作是针对序列的。标准查询操作符本质上是一些扩展方法，这些扩展方法定义在静态类System.Linq.Enumerable中，其原型的第一个参数（带this修饰符的参数）是IEnumerable<T>类型。由于这些方法都是扩展方法，它们可以在IEnumerable<T>实例对象上直接调用，无需为调用传递一个类型为IEnumerable<T>的对象作为第一个参数。　　要在代码中使用LINQ to OBJECT标准查询操作符，需要在代码中添加using System.Linq指令，以引入必要的命名空间。我们在后面的课程中将学习LINQ to OBJECT的一些操作符。

SelectMany

SelectMany将序列的每个元素投影到 IEnumerable<T> 并将结果序列合并为一个序列。用法如下代码：

static void Main()
{
string[] text = { "Albert was here",
"Burke slept late",
"Connor is happy" };
// SelectMany合并并返回一个新序列
var tt = text.SelectMany((s, index) => from ss in s.Split(' ')
select new { Word = ss, Index = index });
foreach (var n in tt)
Console.WriteLine("{0}:{1}", n.Word,n.Index);
}

运行结果为：

Albert:0
was:0
here:0
Burke:1
slept:1
late:1
Connor:2
is:2
happy:2

Take

Take操作符用于从输入序列中返回指定数量的元素。用法如下代码：

static void Main()
{
int[] grades = { 59, 82, 70, 56, 92, 98, 85 };
//对数组降序排序并取出前三个记录
IEnumerable<int> topThreeGrades =
grades.OrderByDescending(grade => grade).Take(3);
Console.WriteLine("The top three grades are:");
foreach (int grade in topThreeGrades)
{
Console.WriteLine(grade);
}
}
运行结果为：
The top three grades are:
98
92
85

TakeWhile

TakeWhile操作符用于从输入序列中返加指定数量且满足一定条件的元素。用法如下代码：

static void Main()
{
string[] fruits = { "apple", "banana", "mango",
"orange","passionfruit", "grape" };
//TakeWhile用法
IEnumerable<string> query =fruits.TakeWhile(
fruit => String.Compare("orange", fruit, true) != 0);
foreach (string fruit in query)
{
Console.WriteLine(fruit);
}
}

运行结果为:

apple
banana
mango

Skip

Skip用于从输入序列中跳过指定数量的元素，返回由序列中剩余元素所组成的新元素。用法如下代码：

static void Main()
{
int[] grades = { 59, 82, 70, 56, 92, 98, 85 };
IEnumerable<int> lowerGrades =
grades.OrderByDescending(g => g).Skip(3);
Console.WriteLine("All grades except the top three are:");
foreach (int grade in lowerGrades)
{
Console.WriteLine(grade);
}
}

运行结果为：

All grades except the top three are:
82
70
59
56

SkipWhile

TakeWhile操作符用于跳过满足一定条件指定数量的元素。用法如下代码：

static void Main()
{
int[] grades = { 59, 82, 70, 56, 92, 98, 85 };
// SkipWhile的用法
IEnumerable<int> lowerGrades =
grades.OrderByDescending(grade => grade).SkipWhile(grade => grade >= 80);
Console.WriteLine("All grades below 80:");
foreach (int grade in lowerGrades)
{
Console.WriteLine(grade);
}
}

运行结果为：

All grades below 80:
70
59
56

Distinct

Distinct去除一个序列里相同的元素。用法如下代码：

static void Main()
{
List<int> ages = new List<int> { 21, 46, 46, 55, 17, 21, 55, 55 };
//Distinct的用法
IEnumerable<int> distinctAges = ages.Distinct();
Console.WriteLine("Distinct ages:");
foreach (int age in distinctAges)
{
Console.WriteLine(age);
}
}

运行结果为：

Distinct ages:
21
46
55
17

Intersect

Intersect将同时存在于两个序列中的元素挑选出来，组成一个新的序列。代码如下：

static void Main()
{
int[] id1 = { 44, 26, 92, 30, 71, 38 };
int[] id2 = { 39, 59, 83, 47, 26, 4, 30 };
//Intersect用法
IEnumerable<int> both = id1.Intersect(id2);
foreach (int id in both)
Console.WriteLine(id);
}

运行结果为：

26
30

Except

Except 返回两个序列中只存在于第一个序列而不存在于第二个序列中的元素所组成的新序列。用法如下代码：

static void Main()
{
double[] numbers1 = { 2.0, 2.1, 2.2, 2.3, 2.4, 2.5 };
double[] numbers2 = { 2.2 };
//Except用法
IEnumerable<double> onlyInFirstSet = numbers1.Except(numbers2);
foreach (double number in onlyInFirstSet)
Console.WriteLine(number);
}
运行结果为：

2
2.1
2.3
2.4
2.5

First

First用于返回输入序列的第一个元素或满足条件的第一个元素。

static void Main()
{
int[] numbers = { 9, 34, 65, 92, 87, 435, 3, 54,
83, 23, 87, 435, 67, 12, 19 };
// first用法
int first = numbers.First(number => number > 80);
int first1 = numbers.First();
Console.WriteLine(first1);
Console.WriteLine(first);
}

运行结果为：

9
92

Union

Union是将两个集合进行合并操作，过滤相同的项。示例代码为：

var q = ( from c in db.Customers select c.Country ).Union( from e in db.Employeesselect e.Country );

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace linq
{
class student
{
public string name { get; set; }
public int age { get; set; }
public int sex { get; set; }
public int id { get; set; }
}
class book
{
public string bookname { get; set; }
public int id { get; set; }
}
class Program
{
static void Main(string[] args)
{
var items = new List<student>();
items.AddRange(new student[]
{ new student{name="Tom",age=20,sex=1,id=1},
new student{name="Jim",age=23,sex=1,id=2},
new student{name="John",age=24,sex=1,id=3},
new student{name="Marry",age=22,sex=0,id=4},
new student{name="Lucy",age=21,sex=0,id=5}
});
var books = new List<book>();
books.AddRange(new book[]
{
new book{bookname="C",id=1},
new book{bookname="C++",id=2},
new book{bookname="C#",id=3},
new book{bookname="Word",id=1},
new book{bookname="Excel",id=1}
});
// 列出所有的id 去掉重复的
var data = (from a in items select a.id ).Union (from e in books select e.id);
foreach (var ss in data)
{
Console.WriteLine(ss);
}
}
}
}

聚合

LINQ有7个聚合操作符,如下表：
序号 名称 描述
1 Aggregate 从某一特定序列或集合中收集值，当聚合完成时，它将序列中返回值进行累积并返回结果。
2 Average 计算一个数值序列的平均值。
3 Count 计算一个特定集合中元素的个数。
4 LongCount 返回一个Int64类型的值，用它来计算元素大于Int32.MaxValue的集合中元素数。
5 Max 返回一个序列中最大值。
6 Min 返回一个序列中最小值。
7 Sum 计算集合中选定值的总和。

static void Main(string[] args)
{
List<int> Datas = new List<int> {2,5,6,3,8,4,7,9};
int min = Datas.Min();
int max = Datas.Max();
double average = Datas.Average();
int count = Datas.Count;
int sum = Datas.Sum();
}