Linq：基本语法form ，select， where（2）

一：基础知识

1：linq查询表达式必须以from子句开头

2：linq查询表达式必须以select 或者group子句结尾

3：linq查询表达式可以包含0个或多个where子句，一个where子句可以包含1个或多个布尔条件表单时

看个简单的例子

int[] values = { 0, 1, 2, 3, 4, 5, 6 };
var value = from v in values where v>2 && v<5 select v;
foreach (var v in value)
{
Console.WriteLine(v);
}

其中：

from v in values values是数据源，v可以看作是查询过程中的一个枚举，

where v>2 && v<5 是查询条件

select v 把符合条件的枚举依次添加到var value中去。value是一个可枚举变量

再看个例子

static bool CheckNum(int temp)
{
if (temp > 2 && temp < 5)
{ return true; }
else
{ return false; }
}
static void Main(string[] args)
{
int[] values = { 0, 1, 2, 3, 4, 5, 6 };
var value = from v in values where CheckNum(v) select v;
foreach (var v in value)
{
Console.WriteLine(v);
}
Console.ReadKey();
}

如上所示：你可以在查询表达式中调用其他函数

第三个例子

public class UserInfo
{
public string name { get; set; }
public int id { get; set; }
public float salary { get; set; }
}
class Program
{
static void Main(string[] args)
{
List<UserInfo> users = new List<UserInfo>();
for(int i = 0;i<10;i++)
{
users.Add(new UserInfo { name = "username" + i.ToString(), id = i, salary = i * 1000 });
}
var valid_salarys = from user in users select user.salary*0.9;
foreach (var valid_salary in valid_salarys)
{
Console.WriteLine(valid_salary);
}
Console.ReadKey();
}
}

1.我们是用上一篇文章中讲到的对象初始化器初始化users集合的

2.linq表达式获取的是一个int类型的可枚举集合，

所以我们知道主要是select子句决定了获取的数据的类型，甚至可以在select子句中创建新类型，比如employee的对象。

二：多类from子句查询

List<UserInfo> users1 = new List<UserInfo>();
List<UserInfo> users2 = new List<UserInfo>();
for (int i = 0; i < 10; i++)
{
users1.Add(
new UserInfo
{
name = "username1" + i.ToString(),
id = i,
salary = i * 1000
}
);
users2.Add(
new UserInfo
{
name = "username1" + i.ToString(),
id = i,
salary = i * 1000
}
);
}
var valid_salarys = from user1 in users1
from user2 in users2
where user1.salary > 1000 && user2.id == user1.id
select user1.salary * 0.9;

foreach (var valid_salary in valid_salarys)
{
Console.WriteLine(valid_salary);
}

1.UserInfo就是上个例子中的UserInfo类

2.from子句可以检索无限多个对象

三：多层form子句查询

public class UserInfo
{
public string name { get; set; }
public int id { get; set; }
public float salary { get; set; }
public List<UserInfo> family { get; set; }
}
class Program
{
static void Main(string[] args)
{
List<UserInfo> users = new List<UserInfo>();
for (int i = 0; i < 10; i++)
{
users.Add(
new UserInfo
{
name = "username" + i.ToString(),
id = i,
salary = i * 1000,
family = new List<UserInfo>
{
new UserInfo
{
name = "username's family" + i.ToString(),
id = i,
salary = i * 1000-100
}
}
}
);
}
var valid_salarys = from user in users
from u in user.family
where user.salary>1000 && u.salary>900
select user.salary * 0.9;
foreach (var valid_salary in valid_salarys)
{
Console.WriteLine(valid_salary);
}
Console.ReadKey();
}
}

1.UserInfo类内部有一个List<Userinfo>的集合

2.from子句可以深入无限多层。

四：linq多次查询

int[] values = { 0, 3, 4, 6, 8, 1, 2, 5, 7, 9 };
var value = from v in (from v_in in values where v_in % 2 == 0 select v_in)  select v;
foreach (var v in value)
{
Console.WriteLine(v);
}

是不是很像sql里的用法呢？呵呵

原文出自：http://www.cnblogs.com/liulun/archive/2009/06/02/1494740.html