精华内容
下载资源
问答
  • 2021-08-07 14:31:08

    1.语言集成查询

    语言集成查询 (LINQ) 是一系列直接将查询功能集成到 C# 语言的技术统称。 数据查询历来都表示为简单的字符串,没有编译时类型检查或 IntelliSense 支持。 此外,需要针对每种类型的数据源了解不同的查询语言:SQL 数据库、XML 文档、各种 Web 服务等。 借助 LINQ,查询成为了最高级的语言构造,就像类、方法和事件一样。

    对于编写查询的开发者来说,LINQ 最明显的“语言集成”部分就是查询表达式。 查询表达式采用声明性 查询语法 编写而成。 使用查询语法,可以用最少的代码对数据源执行筛选、排序和分组操作。 可使用相同的基本查询表达式模式来查询和转换 SQL 数据库、ADO .NET 数据集、XML 文档和流以及 .NET 集合中的数据。

    class LINQQueryExpressions
    {
        static void Main()
        {
    
            // Specify the data source.
            int[] scores = new int[] { 97, 92, 81, 60 };
    
            // Define the query expression.
            IEnumerable<int> scoreQuery =
                from score in scores
                where score > 80
                select score;
    
            // Execute the query.
            foreach (int i in scoreQuery)
            {
                Console.Write(i + " ");
            }
        }
    }

    2.查询表达式概述

    • 查询表达式可用于查询并转换所有启用了 LINQ 的数据源中的数据。 例如,通过一个查询即可检索 SQL 数据库中的数据,并生成 XML 流作为输出。

    • 查询表达式易于掌握,因为使用了许多熟悉的 C# 语言构造。

    • 查询表达式中的变量全都是强类型,尽管在许多情况下,无需显式提供类型,因为编译器可以推断出。 有关详细信息,请参阅 LINQ 查询操作中的类型关系

    • 只有在循环访问查询变量后,才会执行查询(例如,在 foreach 语句中)。 有关详细信息,请参阅 LINQ 查询简介

    • 在编译时,查询表达式根据 C# 规范规则转换成标准查询运算符方法调用。 可使用查询语法表示的任何查询都可以使用方法语法进行表示。 不过,在大多数情况下,查询语法的可读性更高,也更为简洁。 有关详细信息,请参阅 C# 语言规范标准查询运算符概述

    • 通常,我们建议在编写 LINQ 查询时尽量使用查询语法,并在必要时尽可能使用方法语法。 这两种不同的形式在语义或性能上毫无差异。 查询表达式通常比使用方法语法编写的等同表达式更具可读性。

    • 一些查询操作(如 CountMax)没有等效的查询表达式子句,因此必须表示为方法调用。 可以各种方式结合使用方法语法和查询语法。 有关详细信息,请参阅 LINQ 中的查询语法和方法语法

    • 查询表达式可被编译成表达式树或委托,具体视应用查询的类型而定。 IEnumerable<T> 查询编译为委托。 IQueryableIQueryable<T> 查询编译为表达式树。 有关详细信息,请参阅表达式树

    3.查询表达式基础

    1.查询是什么及其作用是什么?

    查询是一组指令,描述要从给定数据源(或源)检索的数据以及返回的数据应具有的形状和组织。 查询与它生成的结果不同。

    通常情况下,源数据按逻辑方式组织为相同类型的元素的序列。 例如,SQL 数据库表包含行的序列。 在 XML 文件中,存在 XML 元素的“序列”(尽管这些元素在树结构按层次结构进行组织)。 内存中集合包含对象的序列。

    从应用程序的角度来看,原始源数据的特定类型和结构并不重要。 应用程序始终将源数据视为 IEnumerable<T>IQueryable<T> 集合。 例如在 LINQ to XML 中,源数据显示为 IEnumerable<XElement>。

    对于此源序列,查询可能会执行三种操作之一:

    • 检索元素的子集以生成新序列,而不修改各个元素。 查询然后可能以各种方式对返回的序列进行排序或分组,如下面的示例所示(假定 scoresint[]):

    IEnumerable<int> highScoresQuery =
        from score in scores
        where score > 80
        orderby score descending
        select score;

    检索有关源数据的单独值,如:

    • 与特定条件匹配的元素数。

    • 具有最大或最小值的元素。

    • 与某个条件匹配的第一个元素,或指定元素集中特定值的总和。 例如,下面的查询从 scores 整数数组返回大于 80 的分数的数量:

    int highScoreCount =
        (from score in scores
         where score > 80
         select score)
         .Count();

     在前面的示例中,请注意在调用 Count 方法之前,在查询表达式两边使用了括号。 也可以通过使用新变量存储具体结果,来表示此行为。 这种方法更具可读性,因为它使存储查询的变量与存储结果的查询分开。

    2.查询表达式是什么?

    查询表达式是以查询语法表示的查询。 查询表达式是一流的语言构造。 它如同任何其他表达式一样,可以在 C# 表达式有效的任何上下文中使用。 查询表达式由一组用类似于 SQL 或 XQuery 的声明性语法所编写的子句组成。 每个子句进而包含一个或多个 C# 表达式,而这些表达式可能本身是查询表达式或包含查询表达式。

    查询表达式必须以 from 子句开头,且必须以 selectgroup 子句结尾。 在第一个 from 子句与最后一个 selectgroup 子句之间,可以包含以下这些可选子句中的一个或多个:whereorderbyjoinlet,甚至是其他 from 子句。 还可以使用 into 关键字,使 joingroup 子句的结果可以充当相同查询表达式中的其他查询子句的源。

    3.查询变量

    在 LINQ 中,查询变量是存储查询而不是查询结果的任何变量。 更具体地说,查询变量始终是可枚举类型,在 foreach 语句或对其 IEnumerator.MoveNext 方法的直接调用中循环访问时会生成元素序列。

    下面的代码示例演示一个简单查询表达式,它具有一个数据源、一个筛选子句、一个排序子句并且不转换源元素。 该查询以 select 子句结尾。

    static void Main()
    {
        // Data source.
        int[] scores = { 90, 71, 82, 93, 75, 82 };
    
        // Query Expression.
        IEnumerable<int> scoreQuery = //query variable
            from score in scores //required
            where score > 80 // optional
            orderby score descending // optional
            select score; //must end with select or group
    
        // Execute the query to produce the results
        foreach (int testScore in scoreQuery)
        {
            Console.WriteLine(testScore);
        }
    }

    4.开始查询表达式

    查询表达式必须以 from 子句开头。 它指定数据源以及范围变量。 范围变量表示遍历源序列时,源序列中的每个连续元素。 范围变量基于数据源中元素的类型进行强类型化。 在下面的示例中,因为 countriesCountry 对象的数组,所以范围变量也类型化为 Country。 因为范围变量是强类型,所以可以使用点运算符访问该类型的任何可用成员。

    Enumerable<Country> countryAreaQuery =
        from country in countries
        where country.Area > 500000 //sq km
        select country;

    5.结束查询表达式

    查询表达式必须以 group 子句或 select 子句结尾。

    (1).group 子句

    使用 group 子句可生成按指定键组织的组的序列。 键可以是任何数据类型。 例如,以下查询会创建包含一个或多个 Country 对象,并且其关键值是数值为国家/地区名称首字母的 char 类型。

    ar queryCountryGroups =
        from country in countries
        group country by country.Name[0]

    (2).select 子句

    使用 select 子句可生成所有其他类型的序列。 简单 select 子句只生成类型与数据源中包含的对象相同的对象的序列。 在此示例中,数据源包含 Country 对象。 orderby 子句只按新顺序对元素进行排序,而 select 子句生成重新排序的 Country 对象的序列。

    IEnumerable<Country> sortedQuery =
        from country in countries
        orderby country.Area
        select country;

    elect 子句可以用于将源数据转换为新类型的序列。 此转换也称为投影。 在下面的示例中,select 子句对只包含原始元素中的字段子集的匿名类型序列进行投影。 请注意,新对象使用对象初始值设定项进行初始化。

    6.where 子句

    使用 where 子句可基于一个或多个谓词表达式,从源数据中筛选出元素。 以下示例中的 where 子句具有一个谓词及两个条件。

    Enumerable<City> queryCityPop =
        from city in cities
        where city.Population < 200000 && city.Population > 100000
        select city;

     

    更多相关内容
  • LINQ查询语句

    2019-11-21 18:08:03
    然而在程序中却与数据库相反,保存在类对象或结构中的数据差异很大,因此,没有通用的查询语言来从数据结构中获取数据,从对象获取数据的方法一直都是作为程序的一部分而设计的,然而使用LINQ可以轻松查询对象集合。...

    在关系型数据库中,数据被组织放入规范化很好的表中,并通过简单而又强大的语言SQL来进行访问,SQL可以和数据库中任何数据配合使用,因为数据被放入表中,并遵从一些严格的规则。

    然而在程序中却与数据库相反,保存在类对象或结构中的数据差异很大,因此,没有通用的查询语言来从数据结构中获取数据,从对象获取数据的方法一直都是作为程序的一部分而设计的,然而使用LINQ可以轻松查询对象集合。LINQ是.NET框架的扩展,它允许我们以使用SQL查询数据库的方式来查询数据集合。使用LINQ可以从数据库、程序对象的集合以及XML文档中查询数据。如下程序中语句中查询的定义就是from和select关键字,尽管查询在语句中定义,但直到最后的foreach语句请求其结果的时候才会执行。

       public class Program
        {
            static void Main(string[] args)
            {
                int[] numbers = { 2, 12, 5, 15 };
    
                IEnumerable<int> lowNums = from n in numbers where n < 10 select n;
                foreach (var x in lowNums)
                    Console.WriteLine(x);
            }
        }

    匿名类型

    匿名类型也叫无名类类型,创建匿名类型的变量使用相同的形式,但是没有类名和构造函数,匿名类型经常用于LINQ查询的结果之中。

    (1)匿名类型只能和局部变量配合使用,不能用于类成员
    (2)由于匿名类型没有名字,我们必须使用var关键字作为变量类型
    (3)不能设置匿名类型对象的属性,编译器为匿名类型创建的属性是只读的

    当编译器遇到匿名类型的对象初始化语句时,它创建了一个有名字的新类类型,对于每一个成员初始化语句,它推断其类型并创建一个只读属性来访问它的值,属性和成员初始化语句具有相同的名字,匿名类型被构造后,编译器创建了这个类型的对象,如果编译器遇到了另一个具有相同的参数名、相同的推断类型和相同顺序的匿名类型,它会重用这个类型并直接创建新的实例,不会创建新的匿名类型。

    LINQ查询时的俩种语法(方法语法、查询语法)

    方法语法:使用标准的方法调用,这些方法是一组叫做标准查询运算符的方法,方法语法是命令式的,它指明了查询方法调用的顺序,编译器会将使用查询语法表示的查询,翻译为方法调用的形式,它和查询语法在运行时没有性能上的差异。

    查询语法:看上去和SQL语句很相似,使用查询表达式形式书写,查询语法是声明式的,也就是说,查询描述的是你想返回的东西,但并没有指明如何执行这个查询。

        public class Program
        {
            static void Main(string[] args)
            {
                int[] numbers = { 2, 5, 28, 31, 17, 16, 42 };
    
                var numsQuery = from n in numbers where n < 20 select n;  //查询语法
    
                var numsMethod = numbers.Where(x => x < 20);  //方法语法
    
                int numsCount = (from n in numbers where n < 20 select n).Count();  //俩种方法的组合
    
                foreach (var x in numsQuery)
                    Console.WriteLine(x);
    
                foreach(var x in numsMethod)
                    Console.WriteLine(x);
    
                Console.WriteLine(numsCount);
            }
        }

    查询表达式的结构

    (1)子句必须按照一定的顺序出现
    (2)from子句和select...group子句这俩部分是必需的
    (3)在LINQ查询表达式中,select子句在表达式最后,这与SQL的SELECT语句在查询的开始处不一样,C#这么做的原因之一是让vs智能感应能在我们输入代码时给我们更多选项。

    from子句

    from子句指定了要作为数据源使用的数据集合,它还引入了迭代变量。

    from子句与foreach语句的区别:
    (1)foreach语句命令式地指定了要从第一个到最后一个按顺序地访问集合中的项,而from子句则声明式地规定集合中的每个项都要被访问,但没有假定以什么样的顺序
    (2)foreach语句在遇到代码时就执行其主体,而from子句什么也不执行,它创建可以执行查询的后台代码对象,只有在程序的控制流遇到访问查询变量的语句时,才会执行查询

    join子句

    LINQ中的join子句和SQL中的JOIN子句很相似,联结操作接受俩个集合然后创建一个临时的对象集合,每一个对象包含原始集合对象中的所有字段。

    join子句示例:

    查询主体中的from...let...where

    可选的from...let...where部分是查询主体的第一部分,可以由任意数量的3个子句来组合(from、let、where)

    from:

    查询表达式从from子句开始,后面跟查询主体,主体本身可以从任何数量的其他from子句开始,没个from子句都指定了一个额外的源数据集合并引入了要在之后运算的迭代变量。

    let:

    let子句接受一个表达式的运算符并且把它赋值给一个需要在其他运算中使用的标识符。

    where:

    where子句根据之后的运算来除去不符合指定条件的项。

    orderby子句

    orderby子句接受一个表达式并根据表达式按照顺序放回结果项,order子句的默认排序方式是升序,可以使用ascending()升序和descending(降序)关键字显示设置。

        public class Program
        {
            static void Main(string[] args)
            {
                int[] numbers = { 2, 5, 28, 31, 17, 16, 42 };
    
                var asc_qury = from n in numbers orderby n ascending select n;  //升序
    
                var desc_qury = from n in numbers orderby n descending select n;  //降序
    
                foreach (var v in asc_qury)
                    Console.WriteLine(v);
    
                foreach (var v in desc_qury)
                    Console.WriteLine(v);
            }
        }

    group  by子句

    group子句把select的对象根据一些标准进行分组,如果项包含在查询的结果中,它们就可以根据某个字段的值进行分组,作为分组的依据的属性叫做键(key),group子句返回的不是原始数据源中项的枚举,而是返回可以枚举已经形成的项的分组的可枚举类型,分组本身是可枚举类型,它们可以枚举实际的项。

            static void Main(string[] args)
            {
                var students = new[]
                {
                    new {LName="Jones",FName="Mary",Age=19,Major="History" },
                    new {LName="Smith",FName="Bob",Age=20,Major="CompSci" },
                    new {LName="Fleming",FName="Carol",Age=21,Major="History" },
                };
    
                var query = from student in students group student by student.Major;
    
                foreach(var s in query)
                {
                    Console.WriteLine("{0}", s.Key);  //分组键
    
                    foreach (var t in s)
                        Console.WriteLine("  {0},{1}", t.LName, t.FName);
                }
            }

    into子句

    查询延续子句可以接受查询的一部分结果并赋予一个名字,从而可以在查询的另一部分中使用。

            static void Main(string[] args)
            {
                int[] _a = { 2, 3, 4, 5 };
                int[] _b = { 4, 5, 6 };
    
                var query = from a in _a
                            join b in _b on a equals b
                            into _c       //查询延续
                            from c in _c
                            select c;
                foreach (var v in query)
                    Console.WriteLine(v);  //4,5
            }

    标准查询运算符

    (1)被查询的集合对象叫做序列,它必须实现IEnumerable<T>接口
    (2)标准查询运算符使用方法语法
    (3)一些运算符返回IEnumerable对象,而其他的一些运算符返回标量,返回标量的运算符立即执行,并返回一个值,而不是可枚举类型对象。

    System.Linq.Enumerable类声明了标准查询运算符方法,然而这些方法不仅仅而是一些方法,它们是扩展了IEnumerable<T>泛型类的扩展方法,扩展方法如之前所介绍,扩展方法时公共的静态方法,尽管定义在一个类中,但目的是为另一个类(第一个形参)增加功能,该参数前必须有关键字this。

    LINQ预定义的委托类型

    很多标准运算符的参数中第一个参数是IEnumerable<T>对象的应用,之后的参数为泛型委托,泛型委托用于给运算符提供用户自定义的代码,LINQ定义了俩套泛型委托类型与标准查询运算符一起使用,即Func委托Action委托,我们用作实参的委托对象必须是这些类型或这些形式之一,并且总是在类型参数列表中的最后一个

    使用:

     

    展开全文
  • 今天我想跟大家说一下如何用linq 的方法查询数据库的数据,大家想要通过linq 查询数据据库的数据,首先我们要学会在VS里面如何查数据,请大家看一下下面的代码部分,这是我对...一、简单的Linq查询语句: var listAc...

    今天我想跟大家说一下如何用linq 的方法查询数据库的数据,大家想要通过linq 查询数据据库的数据,首先我们要学会在VS里面如何查数据,请大家看一下下面的代码部分,这是我对一张表的查询

    表介绍:SYS-Academe为表名称
    AcademeID,AcademeName,AcademeCode 为这个表里面的字段,这个表里面还有一个学生ID为外键

    一、简单的Linq查询语句:

    var
    listAcademe = from tb in myModel.SYS-AcademeID Select tb

    查询全部:通过这样我们就可以把表里面的所有字段都查找到了。

    当然,如果你并不想把所有字段都查询出来你也可这样通过new来获取

    代码解析:from 后面接的是范围变量
    Select new直接以这样来获取,获取表里面的两个字段

    Var
    listAcademe = from tbAcademe in myModel.SYS_AcademeID Select new

    {

    tbAcademe.AcademeID,

    tbAcademe.AcademeCode

    }

    如果你以为linq 就只是这样简单的查询表么,这就错了哦!linq 对表的查询还有几种方法,上面只是一种特别简单的查询方法。

    二、带where 条件进行查询
    就是对数据进行过滤

    例如:

    var
    listAcademe= from tbAcademe in myModel.SYS_AcademeID

    where tbAcademe.AcademeID ==AcademeID

    select new

    {

    这里获取字段和上面的相同,看你需要什么字段

    }

    Where 是条件查询,因为有时候我们要判断我们页面所查询ID是否与数库中的那一个表的ID相同,这样我们才不会找错表。我页面传递过来一个ID,我要通过这个ID去与数据库里的一个表ID是判断是否相同,如果相同,再去那个表里面去获取那个表里面我所需要的字段。

    三、group by 分组

    Var listAcademe = from tbAcademe in
    myModel.SYS-AcademeID

    Group tbAcademe by tbAcademe Select new
    specialtyID

    {

    这里获取字段和上面的相同,看你需要什么字段

    }

    注:在这里我是根据他们的专业ID这个外键进行分组。

    Group by 分组查询,有时候我们不仅要对数据的查询提出where 的查询,而且我们要对所查询出来的数据进行一个分组,例如在你查出一大批学生数据的的时候,你想要对其数据进行一个简单的分组使其看其来更加舒适,这时候我用到一个group by.

    四、orderby 排序 默认为增序 OrderByDescending 为降序

    代码解释:

    var listAcademeID = from tbAcademeID in
    myModal.SYS_AcademeID

    where tbAcdemeID== AcademeID

    OrderByDescending tbAcdemeID==
    AcademeID

    Select new

    {

    这里获取字段和上面的相同,看你需要什么字段

    }

    OrderByDescending 为降序,在做表的新增的时候,很多时候我们都需要对表进行一个倒序的排列,以便我们可以更快的找到数据,因为你可以想一下,当你在一个表里面新增一条数据的时候,如果那个表里面有几千条数据,你想要看自已新增的那一条,是否得跑到最后面,这时你就可以用
    (OrderByDescending ) 它了,这样效率更高咯;

    五.Countains 包含

    代码解释:

    Var listAcademe = from tbAcademe in
    myModel.SYS-AcademeID

    Where tbAcademe.AcademeName.Contains(“外国语学院”)

    Select tbAcademeID

    解释:这个学院是否包括外国语学院这个名字

    六、分页查询

    代码解释:

    var
    listAcademe = (from tb in myModel.SYS-AcademeID
    Select tb).Skip(10).Take(10);

    特别解析:skip:跳过序列中指定数量的元素,然后返回剩余的元素
    Take:从序列的开头返回指定数量的连续元素

    七、跳前面多少条数据。取剩余的数据 与第五雷同

    代码解释:

    var
    listAcademe = (from tb in
    myModel.SYS-AcademeID Select tb).Skip(10)

    七、获取最后一条数据 倒序的另一个选择FirstOrDefault
    选取最高很大程度 ,也可看是第一条数据

    var
    listAcademe = (from tb in
    myModel.SYS-AcademeID Select tb).FirstOrDefault()

    八、多表连查, join Equals连接两个数据源

    代码解释:

    var
    listAcademe = (from tbStudent in
    myModel.PW_Student

    join tbAcademe in myModel.SYS_Specialty
    on tbStudent.AcademeID equals tbAcademe.AcademeID)

    注:在这里我新增了一张学生表PW_Student,大家请看图学生表之中有一个学院ID作为学生表的外键AcademeID 我们只需要把他们通过 equals 的方法判断它们ID为同一个ID ,我们就可以对这个表进行连查,

    多表的连查都是这种查法,简单来说就是查找它们的相同点在进行连接。

    我老师跟我说过一个很生动的例子:

    我跟你是好朋友,你跟他又是好朋友,通过你,我自然而然就认识了他。
    图片解释:

    在这里插入图片描述

    知识补充:linq 的查询必须以from 为开头 以select或者group结尾
    ,他们的中间可以使用 where ordeby
    join 等等进行一系列的查询
    留言:今天的内容就这么多了。只是一些关于linq一些很简单查询方法;希望对大家有所帮助哈!如果你有更加好的查询技巧大家也可以和我交流哈!期待与你的交流:

    对以上linq查询如果有错误的解释!希望大家留言以便我改正。因为我刚接触这个语句的查询不久.不足的地方请见谅呀!!!

    展开全文
  • (一)Linq基础 1)Linq解决的问题 面向对象编程语言与数据访问方法长期分离,以嵌入式的...SQL和XML都有各自的查询语言,而对象没有自己的查询语言,如要从List<>集合或者数组中找到符合要求的元素,非常...

    (一)Linq基础

    1)Linq解决的问题

    • 面向对象编程语言与数据访问方法长期分离,以嵌入式的方式开发,例如:在这里插入图片描述
    • 编程语言中的数据类型与数据库中的数据类型形成两套体系,如:C#中的字符串string 在SQL中使用NVarchar/ Varchar/ Char来表示;
    • SQL和XML都有各自的查询语言,而对象没有自己的查询语言,如要从List<>集合或者数组中找到符合要求的元素,非常困难;

    2)什么是Linq

    • Linq(Language Integrated Query, 语言集成查询)

      • 是微软公司提供的一项新技术,能够将查询功能直接引入到C#、VB.NET等编程语言中;
      • 查询操作可以通过编程语言自身来表示,而不是嵌入字符串SQL语句;
    • Linq 主要包含以下三个部分:

      • Linq to Objects 主要负责对象的查询;
      • Linq to XML 主要负责XML的查询;
      • Linq to ADO.NET主要负责数据库的查询:
        • (1) Linq to SQL (目前已经没人使用)
        • (2) Linq to DataSet
        • (3) Linq to Entities(重点学
    • Linq所在命名空间:

      • System.Linq; 该命名空间已经由系统自动引入;
      • 因此微软默认建议多使用Linq技术查询;
    Linq的组成架构:

    在这里插入图片描述

    3)采用Linq技术与不采用Linq技术的对比

    <1> 不使用Linq技术
    using System;
    using System.Collections.Generic;
    
    namespace LinqDemo
    {
        class Program
        {
            //找出所有的奇数
            static void Main(string[] args)
            {
                int[] nums = { 1, 7, 2, 6, 5, 4, 9, 13, 20 };
                List<int> list = new List<int>();
                foreach (var item in nums)
                {
                    if (item % 2 == 1)
                        list.Add(item);
                }
                list.Sort();
                list.Reverse();
                foreach (var item in list)
                {
                    Console.WriteLine(item);
                }
            }
        }
        
    }
    
    
    <2> 使用Linq技术

    查询的时候,可以采用优化的算法,提高查询的效率;

    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                int[] nums = { 1, 7, 2, 6, 5, 4, 9, 13, 20 };
                var list = from num in nums
                           where num % 2 == 1
                           orderby num ascending
                           select num;
                foreach (var item in list)
                {
                    Console.WriteLine(item);
                }
            }
        }
    }
    

    (二)Linq查询方法详解

    1) 获取数据:扩展方法Select()

    Select()是一个泛型扩展方法;
    Select()方法使用的时候,要求传递一个委托实例(委托实例就是一个方法)

    应用:

    在这里插入图片描述

    注意:数组、泛型集合都可以使用扩展方法Select();
    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                int[] nums = { 1, 9, 78, 55, 45, 23, 56, 89, 12, 32, 33 };
                var list = nums.Select(item => item * item);
                foreach (var item in list)
                {
                    Console.WriteLine(item);
                }
            }
        }
        
    }
    
    

    2)筛选数据:where() 方法

    • where()方法是一个扩展泛型方法;
    • where()方法使用的时候要求传递一个委托实例,但是该实例是一个判断条件,因此返回的类型必须是bool类型;
    应用:

    在这里插入图片描述

    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                int[] nums = { 1, 9, 78, 55, 45, 23, 56, 89, 12, 32, 33 };
                var list = nums.Where(item => item % 2 == 1).Select(i => i * i);
                foreach (var item in list)
                {
                    Console.WriteLine(item);
                }
            }
        }
        
    }
    
    

    3)排序数据:OrderBy()

    • OrderBy()是一个扩展方法;
    • OrderBy()里面的参数要求传递一个排序的字段,默认按照升序排序;
      如果想降序排序,可以使用OrderByDescending方法;
    应用:

    在这里插入图片描述

    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                int[] nums = { 1, 9, 78, 55, 45, 23, 56, 89, 12, 32, 33 };
                var list = nums.Where(item => item % 2 == 0).Select(item => item * 2).OrderBy(item => item);
                foreach (var item in list)
                {
                    Console.WriteLine(item);
                }
            }
        }
    }
    
    
    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                string[] names = { "张三", "李四", "郭保彦", "刘宁", "上海", "北京" };
                var list = names.Where(item => item.Length == 2).Select(item => item)
                    .OrderBy(item => item.Substring(0, 1));
                foreach (var item in list)
                {
                    Console.WriteLine(item);
                }
            }
        }
    }
    
    

    4)分组数据:GroupBy()方法

    • OrderBy()是一个扩展方法;
    • OrderBy()里面的参数要求传递一个分组的字段
    应用:

    在这里插入图片描述

    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                string[] names = { "张三", "李四", "网三三", "李思思", "上海", "北京" };
                var list = names.Select(item => item)
                    .OrderBy(item => item.Substring(0, 1)).GroupBy(item=>item.Length);
                //遍历的时候需要注意,需要两层循环
                foreach (var item in list)
                {
                    Console.WriteLine("分组字段:{0}", item.Key);
                    foreach (var i in item)
                    {
                        Console.WriteLine(i);
                    }
                }
            }
        }
    }
    
    

    (三)Linq查询时机与查询形式

    1)查询步骤:

    步骤:获取数据源、定义查询、执行查询;
    在这里插入图片描述

    结论:
    • 定义查询以后,查询并没有立即执行,而是直到需要枚举结果(遍历)时,才真正执行;
    • 这种方式称之为“延迟执行”

    2) 使用“聚合扩展方法”返回单一结果,强制查询立即执行

    在这里插入图片描述

    3)Linq查询的两种形式

    <1> Method Syntax,查询方法方式
    • 主要利用System.Linq.Enumerable类中定义的扩展方法和Lambda表达式方式进行查询;
    • 在此之前所用的查询都是这种方法;
    <2> Query Syntax,查询语句方式
    • 一种更接近于SQL语法的查询方式,可读性更好;
    • 查询语句最后还是要被翻译为查询方法;

    在这里插入图片描述

    注意:

    在这里插入图片描述

    (四)Linq查询子句

    1)Linq查询子句概述

    <1> 查询表达式
    • 是一种用查询语法表示的表达式,有一组用于类似于SQL的语法编写的句子组成;
    • 每个句子可以包含一个或者多个C#表达式;

    在这里插入图片描述

    <2> Linq查询表达式包含的子句:
    1. from子句:指定查询操作的数据源和范围变量;
    2. where子句:筛选元素的逻辑条件,返回值是一个bool类型;
    3. select子句:指定查询结果的类型和表现形式;
    4. orderby子句:对查询结果进行排序;
    5. group子句:对查询结果进行分组;
    6. into子句:提供一个临时标识符,该表示可充当对 join/ group/ select 子句结果的引用;
    7. join子句:连接多个查询操作的数据源;
    8. let子句:引入用于存储查询表达式中的子表达式结果的范围变量;

    2)from子句

    <1> 概述:
    • Linq查询表达式必须包含from子句,并且作为开头;
    • from子句指定的数据源必须为IEnumerable、Ienumerable<>或者两者的派生类型(例如:数组、集合List<>、ArrayList等)
      在这里插入图片描述
    <2> 数据源
    • 如果数据源是泛型类型,则编译器可以自动推断出范围变量的类型,比如上面的num类型为int;
    • 如果数据源为非泛型类型,如ArrayList,则必须显式地指定范围变量的数据类型;
      在这里插入图片描述
    <3> 复合from子句查询

    如果数据源(本身是一个序列)的元素还包含子数据源(如序列、列表等,如果要查询子数据源的元素),则需要使用复合from子句;
    在这里插入图片描述

    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                Student obj1 = new Student()
                {
                    StudentId = 101,
                    StudentName = "zhansan",
                    ScoreList = new List<int>() { 78, 89, 99}
                };
    
                Student obj2 = new Student()
                {
                    StudentId = 102,
                    StudentName = "LiuNing",
                    ScoreList = new List<int>() { 88, 66, 78 }
                };
    
                Student obj3 = new Student()
                {
                    StudentId = 103,
                    StudentName = "guo",
                    ScoreList = new List<int>() { 100, 89, 78 }
                };
    
                //将学员封装到集合中
                List<Student> stuList = new List<Student>() { obj1, obj2, obj3 };
                //查询95分以上的学员
                var result = from stu in stuList
                             from score in stu.ScoreList
                             where score >= 95
                             select stu;
                
                //显示查询结果
                foreach (var item in result)
                {
                    Console.WriteLine(item.StudentName);
                }
            }
        }
    }
    
    
    <4> 多个from子句查询

    若Linq查询表达式包含两个或两个以上的独立数据源时,可以使用多个from子句查询所有数据源中的数据;
    在这里插入图片描述

    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                Student obj1 = new Student()
                {
                    StudentId = 117,
                    StudentName = "zhansan",
                   
                };
    
                Student obj2 = new Student()
                {
                    StudentId = 102,
                    StudentName = "LiuNing",
                   
                };
    
                Student obj3 = new Student()
                {
                    StudentId = 103,
                    StudentName = "guo",
                    
                };
    
                Student obj4 = new Student()
                {
                    StudentId = 104,
                    StudentName = "liu",
    
                };
    
                Student obj5 = new Student()
                {
                    StudentId = 105,
                    StudentName = "yi",
    
                };
    
                Student obj6 = new Student()
                {
                    StudentId = 115,
                    StudentName = "tian",
    
                };
    
                //将学员封装到集合中
                List<Student> stuList1 = new List<Student>() { obj1, obj2, obj3 };
                List<Student> stuList2 = new List<Student>() { obj4, obj5, obj6 };
                //查询95分以上的学员
                var result = from stu1 in stuList1
                             where stu1.StudentId > 110
                             from stu2 in stuList2
                             where stu2.StudentId > 110
                             select new { stu1, stu2 };
                //显示查询结果
                foreach (var item in result)
                {
                    Console.WriteLine(item.stu1.StudentName);
                    Console.WriteLine(item.stu2.StudentName);
                }
            }
        }
    }
    
    

    3)其他子句

    在这里插入图片描述

    (五)Linq高级查询

    在这里插入图片描述

    1)Count返回集合项的数目

    在这里插入图片描述

    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                Student obj1 = new Student()
                {
                    StudentId = 117,
                    StudentName = "zhansan",
                   
                };
    
                Student obj2 = new Student()
                {
                    StudentId = 102,
                    StudentName = "LiuNing",
                   
                };
    
                Student obj3 = new Student()
                {
                    StudentId = 103,
                    StudentName = "guo",
                    
                };
    
                Student obj4 = new Student()
                {
                    StudentId = 104,
                    StudentName = "liu",
    
                };
    
                Student obj5 = new Student()
                {
                    StudentId = 105,
                    StudentName = "yi",
    
                };
    
                Student obj6 = new Student()
                {
                    StudentId = 115,
                    StudentName = "tian",
    
                };
    
                //将学员封装到集合中
                List<Student> stuList1 = new List<Student>() { obj1, obj2, obj3, obj4, obj5, obj6 };
                //查询
                var result = (from stu1 in stuList1
                              where stu1.StudentId > 102
                              select stu1).Count();
                var result1 = stuList1.Where(item => item.StudentId > 102).Count();
    
                //显示查询结果
                Console.WriteLine(result);
                Console.WriteLine(result1);
            }
        }
    }
    
    

    2)Max/Min/Average/Sum【数学上】

    在这里插入图片描述

    3)排序类

    ThenBy提供复合排序条件;
    在这里插入图片描述

    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                Student obj1 = new Student()
                {
                    StudentId = 117,
                    StudentName = "zhansan",
                    Age = 16
                };
    
                Student obj2 = new Student()
                {
                    StudentId = 102,
                    StudentName = "LiuNing",
                    Age = 18
                };
    
                Student obj3 = new Student()
                {
                    StudentId = 103,
                    StudentName = "guo",
                    Age = 21
                };
    
                Student obj4 = new Student()
                {
                    StudentId = 104,
                    StudentName = "liu",
                    Age = 89
                };
    
                Student obj5 = new Student()
                {
                    StudentId = 105,
                    StudentName = "yi",
                    Age = 78
                };
    
                Student obj6 = new Student()
                {
                    StudentId = 115,
                    StudentName = "tian",
                    Age = 56
                };
    
                //将学员封装到集合中
                List<Student> stuList1 = new List<Student>() { obj1, obj2, obj3, obj4, obj5, obj6 };
                //查询
                var result = from s in stuList1
                             orderby s.Age, s.StudentName
                             select s;
                var result1 = stuList1.OrderBy(item => item.Age).ThenBy(item => item.StudentName).Select(item => item);
                //显示查询结果
                foreach (var item in result)
                {
                    Console.WriteLine(item.StudentName);
                }
                Console.WriteLine("------------------");
                foreach (var item in result1)
                {
                    Console.WriteLine(item.StudentName);
                }
            }
        }
    }
    
    

    4)分区类查询

    • Take 提取支墩数量的项;
    • Skip 跳过指定数量的项并获取剩余的项;
    • TakeWhile 只要满足指定条件,就会返回序列的元素,然后跳过剩余的元素;
    • SkipWhile 只要满足指定的条件,就跳过序列中的元素,然后返回剩余元素;
      在这里插入图片描述
    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
                var list = nums.SkipWhile(i => i % 3 != 0).TakeWhile(i => i % 2 != 0).Select(item => item);
                foreach (var item in list)
                {
                    Console.WriteLine(item);
                }
            }
        }
    }
    
    

    5)集合类查询Distinct

    Distinct 去掉集合中的重复项;
    在这里插入图片描述

    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace LinqDemo
    {
        class Program
        {
            static void Main(string[] args)
            {
                int[] nums = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9 };
                var list = nums.Distinct();
                foreach (var item in list)
                {
                    Console.WriteLine(item);
                }
            }
        }
    }
    
    

    6) 生成类查询

    • Range生成一个整数序列;
      Repeat生成一个重复项的序列;
      在这里插入图片描述
    注意问题:
    • Range/Repeat不是扩展方法,而是普通的静态方法;
    • Range 只能产生整数序列;
    • Repeat可以产生泛型序列;
    • 所有的查询方法都存放在System.Linq.Enumerable静态类中;
    展开全文
  • 三、LINQ查询时机与查询形式 四、 LINQ查询子句 五、LINQ高级查询 一、Linq基础 1.LINQ能解决什么问题? a.面向对象编程语言与数据访问方法长期分离,以嵌入式的方式开发。(嵌入的SQL语句没有任何提示,易出错...
  • LINQ查询语句用法示例

    2013-07-04 10:14:02
    LINQ 查询 语句 用法 示例 讲解 如何利用 C#中的LINQ语句实现 查询 功能
  • Linq 查询语句中的And和Or条件扩展

    千次阅读 2019-01-17 09:47:11
    通常在EF框架中,使用Linq表达式 查询条件时,会发现And和or查询条件使用起来有些麻烦,这里,我自己对此做了一个简单的扩展,相关代码如下 using System; using System.Collections.Generic; using System.Linq; ...
  • 简单的Linq查询语句

    2019-04-08 10:29:57
    简单的Linq查询语句 下面我来我大家介绍几种简单的查询方式。 1、简单语法 下面是一段LINQ查询语句 ============================================================================================= List<...
  • LINQ语句查询

    2021-06-20 15:40:04
    Linq语句查询,目前的学习进度来说也就是我们的单表和多表查询 它为匿名类型查询提供了一种很方便的方法,可用来将一组只读属性封装到单个对象中,而且还不需要先定义一个显示类型,因为它的类型名字直接由编译器...
  • c# linq查询语句 转换为 DataTable IEnumerable<DataRow> query = from order in orders.AsEnumerable() where order.Field<DateTime>("OrderDate") > new DateTime(2001, 8, 1) select order; ...
  • Linq语句的基本查询

    2020-08-20 15:35:54
    一、LINQ的基本语法包含如下的8个上下文关键字,这些关键字和具体的说明如下图: 关键字 说明 关键字 说明 from 指定范围变量和数据源 where 根据bool表达式从数据源中筛选数据 select 指定查询结果中的...
  • Linq语句查询

    2019-04-15 17:37:45
    Linq语句查询在MVC里操作Linq语句,一般来说有两种方式,一种是Lambda表达式+扩展方法,还有另一种就是表达式,然而这个表达式的方式跟sql数据库的方式是差不多的,他们两个的区别就是在于我们是按照sql数据库执行...
  • linq(Language Integrated Query,语言集成查询)是微软提供的一项新技术,能够将查询功能直接引入到C#、VB.NET等编程语言中,查询操作可以通过编程语言自身来表示,而不是嵌入字符串SQL语句Linq to Objects主要...
  • 开发工具与关键技术:VS ASP.NET MVC 作者:张华明 撰写时间:2019/04/07 Lambda表达式是一个匿名函数。.Lambda 表达式 运算符 =>...linq查询表达式 查询表达式的关键字: (1).from:指定要查找的数据源以及...
  • LINQ语句LINQ语句

    万次阅读 多人点赞 2017-12-30 17:21:56
    LINQ(Language Integrated Query)是C#和VB.NET中的统一查询语法,用于保存和检索不同来源的数据。它集成在C#或VB中,从而消除了编程语言和数据库之间的不匹配,以及为不同类型的数据源提供单个查询接口。例如,...
  • c#--LINQ--查询语句查询方法

    千次阅读 2017-12-06 14:18:25
    初学LINQ基础 LINQ体验 什么是LINQ 对象查询的变化比较 ... LINQ查询方法详解—-Select()方法 LINQ查询方法详解–Where()方法 LINQ查询方法详解–OrderBy()方法 * LINQ查询方法详解 –GroupBy()方法* 知识小结 LI
  • c# LINQ查询语句

    万次阅读 2013-06-26 10:39:49
    LINQ,语言集成查询(Language INtegrated Query)是一组用于c#和Visual Basic语言的扩展。它允许编写C#或者Visual Basic代码以查询数据库相同的方式操作内存数据。 目录 基本概念 基础知识 语法...
  • 使用EF配合Linq语句进行查询

    千次阅读 2018-09-22 21:57:45
    //创建一个EF对象 var ef = new DemoDatabaseEntities1(); ... //查询 Grade 表的数据 Id &amp;gt; 4 的记录 IQueryable&amp;lt;Grade&amp;gt; temps = from g in ef.Grade ...
  • 在不触及数据库的前提下,从一些数据中查询出需要的数据,最简单方便的莫过于LINQ语句,而它的使用,相信只要学习过简单SQL语句的人,都会觉得非常简单,下面笔者列举了最常见的几个LINQ语句查询,而更多的内容,待...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 38,810
精华内容 15,524
关键字:

linq查询语句