C#LINQ 查询【学习笔记】

【LINQ 查询】

2016-10-24


事例:

先定义两个类Master和KongFu,然后在这两个类中定义变量

  1.  1 class Master
     2 {
     3     publicintId{ get;set;}
     4     publicstringName{ get;set;}
     5     publicintAge{ get;set;}
     6     publicstringKongfu{ get;set;}
     7     publicstringMenPai{ get;set;}
     8     publicintLevel{ get;set;}
     9     public overide string ToString()
    10    {
    11         return string.Fromat("Id:{0},Name:{1},Age:{2},Kongfu:{3},MenPai:{4},Level:{5}", Id, Name, Age, Kongfu, Menpai, Leve)
    12    }
    13 }    
     1 class KongFu
     2 {
     3    public int Id { get;set;}
     4    public string Name { get;set;}
     5    public int Power { get;set;}
     6
     7    public override string ToString()
     8    {
     9       return string.Format("Id:{0},Name:{1},Power:{2}", Id, Name, Power);
    10    }
    11 }
     1 static void Main(String[] args)
     2 {
     3     var master =newList<Master>()
     4     {
     5         newMaster(){Id=1,Name="黄蓉",Age=18,Menpai="丐帮", Kongfu="打狗棒法",Level=9},
     6         newMaster(){Id=2,Name="洪七公",Age=70,Menpai="丐帮", Kongfu="打狗棒法",Level=10},
     7         newMaster(){Id=3,Name="郭靖",Age=22,Menpai="丐帮", Kongfu="降龙十八掌",Level=10},
     8         newMaster(){Id=4,Name="任我行",Age=50,Menpai="明教", Kongfu="葵花宝典",Level=1},
     9         newMaster(){Id=5,Name="东方不败",Age=35,Menpai="明教", Kongfu="葵花宝典", Level=10},
    10         newMaster(){Id=6,Name="林平之",Age=23,Menpai="华山", Kongfu="葵花宝典", Level=7},
    11         newMaster(){Id=7,Name="岳不群", Age=50,Menpai="华山",Kongfu="葵花宝典",Level=8},
    12         newMaster(){Id=8,Name="令狐冲",Age=23,Menpai="华山",Kongfu="独孤九剑", Level=10},
    13         newMaster(){Id=9,Name="梅超风",Age=23,Menpai="梅花岛",Kongfu="九阴真经", Level=10},
    14         newMaster(){Id=10,Name="黄药师",Age=23,Menpai="梅花岛",Kongfu="弹指神功",Level=10},
    15         newMaster(){ Id = 11, Name = "风清扬", Age = 23, Menpai = "华山", Kongfu = "独孤九剑", Level = 10 }
    16     };
    17     var kongfu =newList<KongFu>()
    18     {
    19         newKongFu(){Id=1,Name="打狗棒法", Power=95 },
    20         newKongFu(){Id=2,Name="降龙十八掌",Power=100},
    21         newKongFu(){Id=3,Name="葵花宝典", Power=100},
    22         newKongFu(){Id=4,Name="独孤九剑", Power=100},
    23         newKongFu(){Id=5,Name="九阴真经", Power=100},
    24         newKongFu(){Id=6,Name="弹指神功", Power=100},
    25     };
    26 }            

开始建立查询:

【第一种】:找出Level大于8的列表来
         var result = new List<Master>();
            foreach (var item in master)
            {
                if (item.Level > 8)
                {
                    result.Add(item);
                }
            }
            foreach (var item in result)
            {
                Console.WriteLine(item.ToString());//ToString()不写默认存在
            }
            Console.ReadKey();
          //需要在 master类和KongFu中创建 ToString()方法,因为在查询完以后进行遍历(foreach)的时候h会出现以下错误

【第二种】:利用专业查询语言查找并排序
    //from:表示从哪个集合里查找……where:查新条件……select:返回结果列表
            var result2 = from m in master
                          where m.Level < 10//查询条件
                          orderby m.Level//根据level进行升序排序
                          orderby m.Level descending//根据level进行降序排序
                          select m;
            foreach (var item in result2)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

  【按条件查找并排序】

            var ressult22 = from m in master.Where(m => m.Level < 10).OrderBy(m => m.Age)//OrderBy && OrderByDescending   升序和降序 排列
                            select m;
            foreach (var item in ressult22)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

【第三种】:调用函数的方法来实现查找功能
        var result3 = master.Where(T1);
            foreach (var item in result3)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
       //需要调用的类
        static bool T1(Master m)
        {
            if (m.Level < 10)
            { return true; }
            else
            { return false; }
        }

【第四种】:利用lamada表达式查找
        var result4 = master.Where(m => m.Level < 10);//lamada表达式    参数名=>表达式
            foreach (var item in result4)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

【第五种】:将两个列表联合起来,形成 Count(master) * Count(Kongfu) 的列表
        var result5 = from m in master
                          from f in kongfu
                          select new { mm = m, ff = f };//
            foreach (var item in result5)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey()
【第六种】:查询当 master.Level == Kongfu.Id,时两个的信息
        var result6 = from m in master
                          from f in kongfu
                          //where m.Level == f.Id
                          where m.Kongfu == f.Name && f.Power > 90
                          select new { mm = m, ff = f };
            foreach (var item in result6)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
【第七种】:实现master和Kongfu中属性相等的信息输出
        var result7 = from m in master
                          //将kongfu列表中的信息放入k中,选出 m.Kongfu == k.Name的信息
                          join k in kongfu on m.Kongfu equals k.Name
                          select new { mm = m, kk = k };
            foreach (var item in result7)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

【第八种】:一人修炼一门功夫,一门功夫被多少人修炼
        var result8 = from k in kongfu
                          join m in master on k.Name equals m.Kongfu
                          into groups//把武林高手分类,看看哪门功夫被人修炼的多
                          orderby groups.Count()//按照修炼人进行
                          select new { kongfu = k, count = groups.Count() };//groups.count:获取到
            foreach (var item in result8)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

//将修炼功夫一样的人放在一起并输出master和kongfu的信息
            var result = from k in kongfu
                         join m in master on k.Name equals m.Kongfu
                         select new { mm = m, kk = k };
            foreach (var item in result)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();
【第九种】:按照自身帮派进行分组,
        var result9 = from m in master
                          group m by m.Menpai//将门派分组,放到m中
                              into p//表示放到p中
                              select new { count = p.Count(), key = p.Key };//count = p.Count()表示这组有多少人
            //key = p.Key表示这个是按照什么分的,即关键字"Key"为Menpai
            foreach (var item in result9)
            {
                Console.WriteLine(item);
            }
            Console.ReadKey();

【第十种】:确定序列中元素是否满足条件

       Any在内部循环遍历每个元素

       根据m=>m.Menpai判断是否满足条件
            bool result10 = master.Any(m => m.Menpai == "丐帮");
            Console.WriteLine(result10);
            Console.ReadKey();

来自为知笔记(Wiz)

时间: 2024-12-10 10:36:56

C#LINQ 查询【学习笔记】的相关文章

分组统计查询(学习笔记)

查询出公司每个月支出的工资总和 --查询出公司每个月支出的工资总和 SELECT SUM(sal) FROM emp; 查询出公司的最高工资,最低工资和平均工资 --查询出公司的最高工资,最低工资和平均工资 SELECT MAX(sal),MIN(sal),ROUND(AVG(sal),2) FROM emp; 统计出公司最早雇佣和最晚雇佣的雇佣日期 --统计出公司最早雇佣和最晚雇佣的雇佣日期 SELECT MIN(hiredate) 最早雇佣日期 , MAX(hiredate) 最晚雇佣日期

多表查询(学习笔记)

语法: SELECT [DISTINCT] * | 列名称 [AS]别名,........ FROM 表名称1 [别名1],表名称2 [别名2],... [WHERE 条件(s)] [ORDER BY 排序的字段 1,ASC| DESC,排序的字段2 ASC| DESC,....] 示例一 查询所有员工的信息和部门信息     SELECT * FROM EMP,DEPT; 查询结果可以看到有56条记录,而emp表只有14条,dept表只有4条,很多重复记录,这就是多表查询所产生的笛卡尔积 消除

精通SQL结构化查询---学习笔记1

1.数据库体系结构的三级模式为:外模式.概念模式.内模式. 内模式又称存储模式,是对数据的物理结构和存储方式的描述.内模式是由数据库系统提供的数据定义语言定义的. 概念模式又称数据库模式,是数据库中全部数据的逻辑结构的描述.概念模式以某种数据模型为基础,并用模式定义语言定义这些内容.概念模式可以看作是现实世界中的实体在具体数据库系统中的实现. 外模式又称用户模式或子模式,通常由概念模式导出,是概念模式的子集.其主要功能是定义了允许用户操作的数据.可以将外模式理解为用户看到的数据视图. 2.一个完

精通SQL结构化查询---学习笔记2

1. SQL中表的规定: * 每张表的表名必须以字母开头,最大长度为30个字符. * 一张表可以由若干列组成.同一张表中,列名惟一,列名也称为属性名或字段. * 同一列的数据必须有相同的数据类型. * 表中的每一列值必须是不可分割的基本数据项. * 表中的一行称为一个元组,相当于一条记录.2. SQL数据类型2.1.字符类型:包括固定长度和可变长字符变量,固定长度字符变量少于定义的长度时,数据库会自动在字符右边以空格填补到20个字符:可变长字符串可以存储任意长度的字符(其最大存储长度取决于采用的

精通SQL结构化查询---学习笔记3

对于汉字的排序,是按首字母的顺序来排序的.使用DISTINCT是要要付出代价的:因为要去掉重复值,必须对结果关系进行排序,相同的元组排列在一起,只有按这种方法对元组进行分组才能去掉重复值,而这一工作甚至比查询本身还费时间. 使用'*'通配符时要慎重,在不需要查询所有列时,尽量采用前面介绍的单列查询或多列查询,以免占用过多的资源. ORDERBY子句一定要放在所有子句的最后,默认是ASC(递增排序):ORDER BY后面可 以采用1.2.3--进行排序,1.2.3--代表了SELECT后面列的次序

LinQ实战学习笔记(二) C#增强特性

C# 为支持LINQ添加了许多语言特性: 隐式类型局部变量 对象初始化器 Lambda表达式 扩展方法 匿名类型 了解这些新特性是全面了解LINQ的重要先解条件,因此请不要忽视它们. (一)  隐式类型局部变量 processData这个类中的亮点是 {get;set;} 它是一个新特性, 系统会自动产生一个匿名私有变量. 1 public Int32 Id { get; set; } 2 public Int64 Memory { get; set; } 3 public string Nam

mybatis-分页查询学习笔记

import java.util.LinkedHashMap; import java.util.List; import java.util.Map; import org.apache.ibatis.session.SqlSession; import cn.itcast.javaee.mybatis.util.MybatisUtil; /** * 持久层 * @author AdminTC */ public class StudentDao { /** * 增加学生 */ public

MySQL 连接查询 学习笔记

#交叉连接(返回笛卡尔交集)AXB={(a,b)|a属于A且b属于B },则AXB所形成的集合就叫笛卡尔集 1 SELECT * from employees cross join depts; 2 SELECT * from employees,depts; #内连接(只返回满足连接条件的记录,不返回不满足连接条件的记录) 1 select * from employees t1 INNER join depts t2 2 on t1.dept_id = t2.dept_id; #右外连接(不

Silverlight项目笔记1:UI控件与布局、MVVM、数据绑定、await/async、Linq查询、WCF RIA Services、序列化、委托与事件

最近从技术支持转到开发岗,做Silverlight部分的开发,用的Prism+MVVM,框架由同事搭好,目前做的主要是功能实现,用到了一些东西,侧重于如何使用,总结如下:   1.UI控件与布局     2.MVVM     3.数据绑定     4.await/async     5.Linq查询     6.WCF RIA Services     7.序列化     8.委托与事件 1.UI控件与布局 常用的主要是Grid.StackPanel.Border,其中最常用的的是Grid,是一