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里的用法呢？呵呵