public class UserInfo
{
public string userName {get; set;}
public string passWord {get; set;}
}
class Program
{
static void Main(string[] args)
{
List<UserInfo> users = new List<UserInfo>();
for (int i = 0; i < 10; i++)
{
UserInfo user = new UserInfo();
user.userName = string.Format("user{0}", i.ToString());
user.passWord = string.Format("user{0}", i.ToString());
users.Add(user);
}
foreach (var user in users)
{
Console.WriteLine(user.userName);
Console.WriteLine(user.passWord);
Console.WriteLine();
}
Console.ReadLine();
}
}
以前写foreach的时候必须知道可枚举变量的具体类型
现在只要用一个var就可以了
就像例子中：foreach (var user in users)一样。
var可以用在很多情况下，比如using块，如：
using (var file = new StreamReader("c:\\a.txt"))
{
//
}
但是开发的过程中要注意以下几点：
1：大量使用var关键字会造成程序代码难于理解
2：声明var变量的时候必须初始化，也不能把它初始化成null
3：不能在同一语句中初始化多个隐式类型的变量，
比如你可以这样写
int a = 1, b = 2;
但是不能这样写
var a = 1, b = 2;
二：对象初始化器
public class UserInfo
{
public string userName {get; set;}
public string passWord {get; set;}
}
class Program
{
static void Main(string[] args)
{
UserInfo user = new UserInfo { userName = "xland", passWord = "mypass" };
Console.WriteLine(user.userName);
Console.WriteLine(user.passWord);
Console.ReadKey();
}
}
UserInfo user = new UserInfo { userName = "xland", passWord = "mypass" };
这是初始化对象的一种新方法，叫对象初始化器
三：匿名类型对象
匿名对象表面上是var关键字和对象初始化器结合的产物
static void Main(string[] args)
{
var user = new { userName = "xland", passWord = "mypass" };
Console.WriteLine(user.userName);
Console.WriteLine(user.passWord);
Console.ReadKey();
}
编译过程中，编译器创建了一个对象，这个对象包含了相应的字段，并为这些字段创建了属性
数组也是一种对象
创建匿名数组
static void Main(string[] args)
{
var number = new[] { 0,1,2,3};
//int[] number = new int[] { 0, 1, 2, 3 };
foreach (var i in number)
{
Console.WriteLine(i);
}
Console.ReadKey();
}
匿名数组内的元素必须保持类型一致，要不然编译通不过
四：Lambda表达式
Lambda表达式其实就是一种匿名函数，只是写法不同,如：
public delegate void lambdaEventHandler();
class Program
{
public static event lambdaEventHandler lambda;
static void Main(string[] args)
{
lambda += () => Console.WriteLine("hellow linq world");
lambda();
Console.ReadKey();
}
}
如果该匿名函数有参数，并且代码块中有多条语句。如下：
public delegate void lambdaEventHandler(object sender,EventArgs e);
class Program
{
public static event lambdaEventHandler lambda;
static void Main(string[] args)
{
lambda += (sender, e) =>
{
Console.WriteLine("hellow linq world");
Console.WriteLine((string)sender);
};
lambda("sender",null);
Console.ReadKey();
}
}
一：基础知识
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);
}
1.order by 默认的排序方式为升序（ascending），降序为：descending.
2.group by 对查询的结果进行分组
3.into创建一个临时存储器，可以存储group或者select等子句的结果
order by的例子
int[] values = { 0, 2, 4, 6, 8, 1, 3, 5, 7, 9 };
var value = from v in values orderby v ascending select v;
foreach (var v in value)
{
Console.WriteLine(v);
}
group by的例子
int[] values = { 0, 3, 4, 6, 8, 1, 2, 5, 7, 9 };
var value = from v in values orderby v group v by v % 2 == 0;
foreach (var v in value)
{
foreach (var k in v)
{
Console.WriteLine(k);
}
}
1.注意我改变了 int数组的顺序
2.输出的结果与上一个例子输出的结果是一样的
3.因为group结尾的linq查询获得的将是两个集合，所以我这里用了双层嵌套循环来获取每个集合中的数据
into的例子
int[] values = { 0, 2, 4, 6, 8, 1, 3, 5};
var value = from v in values group v by v%2==0 into g where g.Count()>3 select g;
foreach (var v in value)
{
foreach(var k in v)
Console.WriteLine(k);
}
1.我再次修改了数组
2.仍然是用了嵌套foreach循环
3.这次只输出0 2 4 6 8