LINQ 基本子句

最新推荐文章于 2023-01-17 21:25:16 发布
最新推荐文章于 2023-01-17 21:25:16 发布
阅读量410 收藏 1
点赞数
分类专栏： ASP.NET 文章标签： ASP.NE 基本子句  物小白
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/moonlis/article/details/79795846
版权

       查询表达式必须以from子句开头，并且必须以select或group子句结束。在第一个from子句和最后一个select或group子句之间，查询表达式可以包含一个或多个where、orderby、group、join、let子句，甚至from子句。另外，join和group子句还可以使用into子句指定临时标识符号。

     LINQ查询表达式的基本语法很容易掌握，它使用C#常见的语言构造，从外观上看，和我们常用的SQL类似，并且查询表达式中的变量可以用匿名类型，所以在很多情况下，不需要指定变量类型就可以构建LINQ表达式。

　　LINQ的数据源可以是数据库对象或是XML流等，也可以使实现了IEnumerable或者泛型IEnumberable<T>接口的集合对象。

　　LINQ的基本语法包含如下的8个上下文关键字，这些关键字和具体的说明如下：

关键字说明
from指定范围变量和数据源
where　　根据bool表达式从数据源中筛选数据
select指定查询结果中的元素所具有的类型或表现形式
group对查询结果按照键值进行分组(IGrouping<TKey,TElement>)
into提供一个标识符，它可以充当对join、group或select子句结果的引用
orderby对查询出的元素进行排序(ascending/descending)
join按照两个指定匹配条件来Equals连接两个数据源
let产生一个用于存储查询表达式中的子表达式查询结果的范围变量

 

 

 

 

 

 

 

 

 

下面依此总结这8个关键字的常用查询语句写法。

1.from子句

如果要写一个LINQ表达式，就必须是以from子句开头。个人觉得from子句中需要注意的地方就是多个from子句的书写。

复制代码 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Collections;

namespace LINQ
{
    /// <summary>
    /// LINQ,重点是感悟from子句中的查询变量的灵活
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            //1单个form子句
            string[] values = { "LINQ学习","LINQ基本语句","from子句","单个from子句"};
            var value = from v in values
                        where v.IndexOf("LINQ") > -1
                        select new { v, v.Length };
            foreach (var n in value)
            {
                Console.WriteLine("{0},{1}",n.v,n.Length );
            }
            Console.ReadKey(false);
            //2使用LINQ查询ArrayList
            ArrayList gList = new ArrayList();
            gList.Add(new GustInfo {  Name="DebugLZQ", Age=26, Tel="88888888"});
            gList.Add(new GustInfo { Name="博客园",Age=6, Tel ="666666"});
            gList.Add(new GustInfo { Name = "M&MSoft", Age =9, Tel = "55555" });

            var query = from GustInfo gust in gList
                        where gust.Age > 9
                        select gust;//范围变量gust制定了数据类型
            foreach (GustInfo g in query)
            {
                Console.WriteLine("{0} 年龄:{1} 电话:{2}",g.Name,g.Age,g.Tel );
            }
            Console.ReadKey(false);
            //3复合from子句
            List<GustInfo2> gList2 = new List<GustInfo2>() 
            {
                new GustInfo2{ Name="DebugLZQ",Age=26,TelTable=new List<string>(){"8888888","138******"}},
                new GustInfo2{ Name="博客园",Age=6,TelTable =new List<string>(){"666666","138******"}},
                new GustInfo2{ Name="M&MSoft",Age=9,TelTable=new List<string>(){"55555","138******"}}
            };

            //gust、tel都是查询变量,作用域为当前查询语句！！！
            var query2 = from gust in gList2
                         from tel in gust.TelTable 
                         where tel.IndexOf("5555") > -1
                         select gust;
            foreach (var g in query2)
            {
                Console.WriteLine("{0} 年龄{1}",g.Name,g.Age );
                foreach (var t in g.TelTable)
                {
                    Console.WriteLine("电话：{0}",t);
                }
            }

            Console.ReadKey(false);

            //4多个from子句
            var query3 = from GustInfo gust in gList
                         where gust.Age > 6
                         from GustInfo2 gust2 in gList2
                         where gust2.Age> 9
                         select new { gust, gust2 };//查询结果定制
            foreach (var g in query3)
            {
                Console.WriteLine("{0}  {1}", g.gust.Name, g.gust2.Name);
            }

            Console.ReadKey(false);
        }
    }
}

程序中列举了from子句的用法示例，注意复合from子句和多个from子句的书写，同时需要理解范围变量和数据源变量这两个概念。

 2.where子句

where子句，它是LINQ表达式的元素筛选机制，除了开始和结束的位置，它几乎可以出现在LINQ表达式的任意位置上。

在一个LINQ表达式中，可以有where子句，也可以没有；可以有一个，也可以有多个；多个where子句之间的逻辑关系相当于逻辑“与”，每个 where子句可以包含1个或多个bool逻辑表达式，这些条件成为谓词，谓词逻辑之间用的是“&&”“||”等而不是SQL中的and 、or。

复制代码 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LINQ_WHERE
{
    /// <summary>
    /// LINQ where子句
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            //1常见的where语句
            List<GustInfo> gList = new List<GustInfo>() 
            {
                new GustInfo(){ Name="DebugLZQ", Age=26,Tel="88888888"},
                new GustInfo(){ Name="cnblogs",Age=6,Tel="666666"},
                new GustInfo(){ Name="M&MSoft",Age=9,Tel="55555"}
            };

            var query = from gust in gList
                        where (gust.Name.Length > 7 || gust.Name.Substring(0, 1) == "M") && gust.Age > 9
                        select new { gust.Name, gust.Age };
            foreach (var g in query)
            {
                Console.WriteLine("{0},{1}", g.Name, g.Age);
            }

            Console.ReadKey(false);

            //2.在where子句中使用自定义函数
            var query2 = from GustInfo gust in gList
                         where gust.Name.Length > 5
                         && Check(gust.Name)
                         select gust;
            foreach (var g in query2)
            {
                Console.WriteLine("{0},{1},{2}", g.Name, g.Age, g.Tel);
            }
            Console.ReadKey(false);

            //3.动态谓词的筛选
            //定义动态谓词数组,在实际开发中可以动态获得
            string[] names = { "SB","XXX","***","@@@","一些敏感词"};

            var query3 = from GustInfo guest in gList
                         where !names.Contains(guest.Name)
                         select guest;

            foreach (var q in query3)
            {
                Console.WriteLine("{0} 年龄：{1},电话：{2}",q.Name,q.Age,q.Tel );
            }
            Console.ReadKey(false);
        }

        //自定义函数
        static bool Check(string name)
        {
            if (name.Substring(0, 1) == "N")
                return false;
            return true;
        }
    }
}

需要注意一些常用的where子句的写法。

 3.Select子句

在select子句上可以非常灵活的处理查询到的元素，然后再把结果返回。

复制代码 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LINQ_select
{
    /// <summary>
    /// LINQ select
    /// 在select子句上，可以非常灵活的处理查询到的元素，然后再把结果返回
    /// </summary>
    class MyGustInfo
    {
        public string Name { get; set; }
        public int Age { get; set; }
    }
    class Program
    {
        static void Main(string[] args)
        {
            List<GustInfo> gList = new List<GustInfo>() 
            {
                new GustInfo(){ Name="DebugLZQ", Age=25, Tel="88888888"},
                 new GustInfo(){ Name="cnblogs", Age=6, Tel="666666"},
                  new GustInfo(){ Name="M&M", Age=9, Tel="55555"}
            };
            var query = from gust in gList
                        where gust.Age >= 9 && gust.Age <= 30
                        select gust.Name.Replace("&", "mm");//select子句灵活应用
            var query2 = from gust in gList
                         where gust.Age >= 9 && gust.Age <= 30
                         select MyProc(gust.Name);
            var query3 = from gust in gList
                         where gust.Age >= 9 && gust.Age <= 30
                         select new { gust.Name,gust.Age};

            var query4 = from gust in gList
                         where gust.Age >= 9 && gust.Age <= 30
                         select new MyGustInfo {  Name=gust.Name+"My", Age=gust.Age+1};//对查询结果进行投影

            foreach (var v in query)
            {
                Console.WriteLine(v);
            }
            foreach (var v in query2)
            {
                Console.WriteLine(v);
            }
            foreach (var v in query3)
            {
                Console.WriteLine(v.Name+v.Age );
            }
            foreach (var v in query4)
            {
                Console.WriteLine(v.Name+v.Age );
            }

            Console.ReadKey(false);
        }
        static string MyProc(string s)
        {
            return s + "Better";
        }
    }

4.group子句

 根据语法的规定，LINQ表达式必须以from子句开头，以select或group子句结束，所以除了使用select来返回结果外，也可以使用group子句来返回元素分组后的结果。

group子句返回的是一个基于IGrouping<TKey,TElement>泛型接口的对象序列。

语法和SQL的group有点区别，不注意的话可能会写错。

复制代码 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LINQ_group
{
    /// <summary>
    /// LINQ group子句
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            List<GustInfo> gList = new List<GustInfo>() 
            {
                new GustInfo(){ Name="DebugLZQ",Age=26,Tel="187********"},
                new GustInfo(){ Name="Sarah",Age=25,Tel="159********"},
                new GustInfo(){ Name="Jerry",Age=35,Tel="135********"},
                new GustInfo(){ Name="M&M",Age=16,Tel="136********"},
                new GustInfo(){ Name="DebugMan",Age=26,Tel="136********"},
                new GustInfo(){ Name="Jerry&Tom",Age=19,Tel="136********"},
            };

            var query = from guest in gList
                        group guest by guest.Name.Substring(0, 1);//分组键key是string类型

            //遍历键值和键值所属元素
            foreach (IGrouping<string, GustInfo> guestGroup in query)
            {
                Console.WriteLine("分组键：{0}",guestGroup.Key );
                foreach (var g in guestGroup)
                {
                    Console.WriteLine("{0} 年龄：{1}  电话：{2}",g.Name,g.Age,g.Tel );
                }
            }
            Console.ReadKey(false);

            Console.WriteLine("-----------------------------------");

            var query2 = from guest in gList
                         group guest by guest.Age > 20;//分组键key是bool类型表达式的结果

            foreach (IGrouping<bool, GustInfo> guestGroup in query2)
            {
                Console.WriteLine("年龄是否大于20  分组键：{0}", guestGroup.Key);
                foreach (var g in guestGroup)
                {
                    Console.WriteLine("{0} 年龄：{1}  电话：{2}", g.Name, g.Age, g.Tel);
                }
            }
            Console.ReadKey(false);
        }
    }
}

 5.into子句

 into子句作为一个临时标识符，用于group、select、join子句中充当其结果的引用。 

复制代码 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LINQ_into
{
    /// <summary>
    /// LINQ group
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            List<GustInfo> gList = new List<GustInfo>() 
            {
                new GustInfo(){ Name="DebugLZQ",Age=26,Tel="187********"},
                new GustInfo(){ Name="Sarah",Age=25,Tel="159********"},
                new GustInfo(){ Name="Jerry",Age=35,Tel="135********"},
                new GustInfo(){ Name="M&M",Age=16,Tel="136********"},
                new GustInfo(){ Name="DebugMan",Age=26,Tel="136********"},
                new GustInfo(){ Name="Jerry&Tom",Age=19,Tel="136********"},
            };

            //1.into用于group子句
            var query = from guest in gList
                        group guest by guest.Name.Substring(0, 1) into grguest
                        orderby grguest.Key descending
                        select grguest;

            var query2 = from guest in gList
                        group guest by guest.Name.Substring(0, 1) into grguest
                        orderby grguest.Key ascending 
                        select grguest;

            //2.select 子句中的into子句
            var query3 = from guest in gList
                         select new { NewName = guest.Name, NewAge = guest.Age } into newguest
                         orderby newguest.NewAge
                         select newguest;

            foreach (var guestGroup in query)
            {
                Console.WriteLine("分组键：{0}",guestGroup.Key );
                foreach (var g in guestGroup)
                {
                    Console.WriteLine("{0} 电话:{1}",g.Name,g.Tel );
                }
            }
            Console.ReadKey(false);

            foreach (var newg in query3)
            {
                Console.WriteLine("{0} 年龄：{1}",newg.NewName,newg.NewAge );
            }

            Console.ReadKey(false);
        }
    }
}

6.orderby子句、thenby子句

 LINQ可以按照元素的一个或多个属性对元素进行排序。 

复制代码 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LINQ_orderby
{
    class Program
    {
        /// <summary>
        /// LINQ orderby (ascending descending)
        /// </summary>
        /// <param name="args"></param>
        static void Main(string[] args)
        {
            List<GustInfo> gList = new List<GustInfo>() 
            {
                new GustInfo(){ Name="DebugLZQ",Age=26,Tel="187********"},
                new GustInfo(){ Name="Sarah",Age=25,Tel="159********"},
                new GustInfo(){ Name="Jerry",Age=35,Tel="135********"},
                new GustInfo(){ Name="M&M",Age=16,Tel="136********"},
                new GustInfo(){ Name="DebugMan",Age=26,Tel="136********"},
                new GustInfo(){ Name="Jerry&Tom",Age=19,Tel="136********"},
            };

            //按照年龄排序
            var query = from guest in gList
                        orderby guest.Age
                        select guest;
            var query1 = from guest in gList
                         orderby guest.Age ascending
                         select guest;
            var query2 = from guest in gList
                         orderby guest.Age descending
                         select guest;
            //按照年龄进行排序，按照名字字数进行次要排序
            var query3 = from guest in gList
                        orderby guest.Age, guest.Name.Length
                        select guest;
            var query4 = from guest in gList
                         orderby guest.Age descending , guest.Name.Length ascending 
                         select guest;
            var query5 = from guest in gList
                         orderby guest.Age, guest.Name.Length,guest.Tel 
                         select guest;

            foreach (var guest in query2)
            {
                Console.WriteLine("{0} 年龄：{1} 电话：{2}",guest.Name,guest.Age,guest.Tel );
            }
            Console.ReadKey(false);
            foreach (var guest in query4)
            {
                Console.WriteLine("{0} 年龄：{1} 电话：{2}", guest.Name, guest.Age, guest.Tel);
            }
            Console.ReadKey(false);
        }
    }
}

 7.let子句

let子句用于在LINQ表达式中存储子表达式的计算结果。 

复制代码 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LINQ_let
{
    /// <summary>
    /// LINQ let用来存子储表达式的计算结果
    /// </summary>
    class Program
    {
        static void Main(string[] args)
        {
            List<GustInfo> gList = new List<GustInfo>() 
            {
                new GustInfo(){ Name="DebugLZQ",Age=26,Tel="187********"},
                new GustInfo(){ Name="Sarah",Age=25,Tel="159********"},
                new GustInfo(){ Name="Jerry",Age=35,Tel="135********"},
                new GustInfo(){ Name="M&M",Age=16,Tel="136********"},
                new GustInfo(){ Name="DebugMan",Age=26,Tel="136********"},
                new GustInfo(){ Name="Jerry&Tom",Age=19,Tel="136********"},
            };

            //使用let子句创建范围变量g，并通过g构建查询表达式
            var query = from guest in gList
                        let g = guest.Name.Substring(0, 1)
                        where g == "D" || g == "J"
                        select guest;
            //也可以不使用let，上面的语句等效于下
            var query2 = from guest in gList
                         where guest.Name.Substring(0, 1) == "D" || guest.Name.Substring(0, 1) == "J"
                         select guest;

            foreach (var g in query)
            {
                Console.WriteLine("{0} 年龄：{1} 电话：{2}",g.Name,g.Age,g.Tel );
            }
            Console.ReadKey(false);
            Console.WriteLine("不使用let，等效的语句结果");
            foreach (var g in query2)
            {
                Console.WriteLine("{0} 年龄：{1} 电话：{2}", g.Name, g.Age, g.Tel);
            }
            Console.ReadKey(false);
        }
    }
}

8.join子句

如果一个数据源中元素的某个属性可以跟另外一个数据源的中元素的某个属性进行相等比较，那么这两个数据源可以用join子句进行关联。

join子句使用equals关键字进行相等比较，而不是常用的双等号。 

复制代码 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace LINQ_join
{
    class Program
    {
        static void Main(string[] args)
        {
            //定义两个数据源
            List<GustInfo> gList = new List<GustInfo>() 
            {
                new GustInfo(){ Name="DebugLZQ",Age=26,Tel="187********"},
                new GustInfo(){ Name="Sarah",Age=25,Tel="159********"},
                new GustInfo(){ Name="Jerry",Age=35,Tel="135********"},
                new GustInfo(){ Name="M&M",Age=16,Tel="136********"},
                new GustInfo(){ Name="DebugMan",Age=26,Tel="136********"},
                new GustInfo(){ Name="Jerry&Tom",Age=19,Tel="136********"},
            };

            List<GuestTitle> titleList = new List<GuestTitle>() 
            {
                new GuestTitle(){Name="DebugLZQ",Title="Soft Engineer"},
                new GuestTitle(){Name="DebugLZQ",Title="Team Leader"},
                new GuestTitle(){Name="Sarah",Title="Test Engineer"},
                new GuestTitle(){Name="Jerry",Title="Head Master"}
            };
            //1.根据姓名进行内连接
            var query = from guest in gList
                        join title in titleList on guest.Name equals title.Name
                        select new { Name=guest.Name ,Title=title.Title,Age=guest.Age };

            foreach (var g in query)
            {
                Console.WriteLine("{0} {1} 年龄：{2}",g.Name,g.Title ,g.Age );
            }
            Console.ReadKey(false);

            //前面的多个from实现相同的作用:与内连接区别在于：这个中间的操作是叉乘获得笛卡尔积
            var query2=from guest in gList 
                       from title in titleList 
                       where guest.Name==title.Name
                       select new { Name = guest.Name, Title = title.Title, Age = guest.Age };

            foreach (var g in query2)
            {
                Console.WriteLine("{0} {1} 年龄：{2}", g.Name, g.Title, g.Age);
            }
            Console.ReadKey(false);

            //2.根据姓名进行分组连接
            //根据名字分组后，得到每个名字下的全部名称
            var query3 = from guest in gList
                         join title in titleList on guest.Name equals title.Name into tgroup
                         select new { Name=guest.Name,Titles=tgroup };

            foreach (var g in query3)
            {
                Console.WriteLine(g.Name);
                foreach (var g2 in g.Titles)
                {
                    Console.WriteLine("    {0}",g2.Title );
                }
            }
            Console.ReadKey(false);
            //3.根据姓名进行左外连接
            //无职务的输出为空缺
            var query4 = from guest in gList
                         join title in titleList on guest.Name equals title.Name into tgroup
                         from subtitle in tgroup.DefaultIfEmpty()
                         select new { Name=guest.Name,Title=subtitle==null?"空缺":subtitle.Title };
            foreach (var g in query4)
            {
                Console.WriteLine("{0}  {1}  ",g.Name ,g.Title );
            }
            Console.ReadKey(false);
            
        }
    }
}

 以上就是LINQ的基本子句的常用用法


MoonLis
关注
专栏目录
linq 子句查询
weixin_47746700的博客
09-13 638
* 子句 * 1、以from语句开始，以select、group结束，中间可以包含多个where，let，join，orderby，group子句，也可以有from * from 指定查询操作的数据源或范围变量 * select 指定查询结果的类型和表现形式 * where 筛选元素的逻辑条件 * let 引入用来临时保存查询表达式中的子表达式结构的范围变量 * order by 对查询结果进行排序， * group 对查询结果进行分组 * into 提供一个临时标识符，join、group...
LINQ基本子句
weixin_34040079的博客
11-07 118
　　出于工作需要，准备把LINQ的相关知识梳理一遍，希望能填补下之前学习漏掉的或是没有注意的地方，也为未来减轻压力~ 　　LINQ查询表达式的基本语法很容易掌握，它使用C#常见的语言构造，从外观上看，和我们常用的SQL类似，并且查询表达式中的变量可以用匿名类型，所以在很多情况下，不需要指定变量类型就可以构建LINQ表达式。 　　LINQ的数据源可以是数据库对象或是XML流等，也可以使实现了IE...
LINQ八大基本子句
刘峰的技术知识博客
04-03 755
LINQ的基本语法包含如下的8个上下文关键字，这些关键字和具体的说明如下：八大子句from...in子句指定查询操作的数据源和范围变量select子句指定查询结果的类型和表现形式where子句筛选元素的逻辑条件，一般由逻辑运算符组成group...by子句对查询进行分组orderby子句对查询结果进行排序，可以是“升序”或降序“”jion子句连接多个查询操作的数据源let子句引入用于存储查询表达式...
Linq基本子句
weixin_30896763的博客
06-23 102
由于个人在学校没有接触过Linq，而且在工作上运用Linq的时候也比较多，准备把LINQ的相关知识学习整理梳理一遍，希望能填补下这个知识点，也为未来减轻压力。 LINQ查询表达式使用C#常见的语言构造，从外观上看，和我们常用的SQL类似，并且查询表达式中的变量可以用匿名类型，所以在很多情况下，不需要指定变量类型就可以构建LINQ表达式。 LINQ的数据源可以是数据库对象或是XML流等，也可以使...
Linq的基本语法包含的8个上下文关键字
天外有天，人外有人。 专注品质 不断创新 让精益求精成为习惯
11-18 1024
Linq的基本语法包含如下8个上下文关键字： 1. from  制定数据源和范围变量 2. where 根据布尔表达式（由逻辑"与"，“或”等组成）从数据源中筛选元素 3. select 制定查询结果中的元素所具有的类型或变现形式 4. group 对查询结果按照键值进行分组 5. into  提供一个标示符，它可以充当对join、group或select自居结果的引用 6. orde
LINQ基本子句介绍
不积跬步无以至千里不积小流无以成江海
08-11 1479
要使用LINQ来编程，首先要学会使用由LINQ的子句和关键字以及按查询语法组成的查询表达式。这里要说明，.NET公共语言运行库（CLR）本身并不具有查询语法的概念，在编译时，查询表达式会自动转换为CLR确实了解的内容（方法调用）。LINQ表达式的作用就是从给定一个或多个数据源中，按照指定的条件检索数据，检索出的结果按找指定类型或表现形式返回。数据源可以是数据库对象或XML流等，也可以是实现了IEnumerable或者泛型IEnumerable接口的集合对象，这些都可以被当作LINQ的数据源来使用LINQ基本
C#使用LINQ查询表达式的基本子句总结
09-02
me="博客园",Age=6,TelTable=new List(){"666666"}}, new GustInfo2{Name="M&MSoft",Age=9,TelTable=new List(){"55555","9999999"}} }; var query2 = from gust2 in gList2 from tel in gust2.TelTable where gust2...
T396240109.zip VB.net中，如何动态构建Linq的Where子句
03-30
Where子句是LINQ查询表达式中最基本的部分，用于筛选满足特定条件的元素。 在VB.NET中，静态构建的Where子句通常如下所示： ```vbnet Dim numbers = {1, 2, 3, 4, 5} Dim evenNumbers = From num In numbers Where...
C#中Linq查询基本操作使用实例
09-04
以下将详细解释标题和描述中提到的Linq查询基本操作及其使用实例。 1. **from子句**：from子句是LINQ查询表达式的基础，用于指定数据源。在示例中，`from stuent in students` 定义了查询将从名为`students`的列表...
linQ 八大子句
萧莯技术知识博客
04-02 269
a.LINQ查询简介　LINQ查询表达式的基本语法很容易掌握，它使用C#常见的语言构造，从外观上看，和我们常用的SQL类似，并且查询表达式中的变量可以用匿名类型，所以在很多情况下，不需要指定变量类型就可以构建LINQ表达式。b.什么是LINQ的数据源　　LINQ的数据源可以是数据库对象或是XML流等，也可以使实现了IEnumerable或者泛型IEnumberable&lt;T&gt;接口的集合对...
linq语句大全（笔记）
11-25
linq语句 大全（笔记 最全面最权威的linq语句）
LINQ查询语句
05-09
LINQ查询语句，用来查询数据库下的相应信息，基础便捷
C#的LINQ select查询、where过滤、group分组、join关联
小龙在线
10-22 2132
语言集成查询 (Language Integrated Query) 是一系列直接将查询功能集成到 C# 语言的技术统称，用于在所有基于.NET平台的变成语言中更加直接地声明跨越、过滤和投射操作的一种方式，标准查询操作允许查询作用于所有基于IEnumerable接口的源。
Linq分组
最新发布
weixin_51327185的博客
01-17 910
linq的语法通过System.Linq下面的Enumerable类提供支持，也就是说，只要是实现了IEnumerable的对象都可以使用Linq的语法来查询。LINQ定义了大约40个查询操作符，如select、from、in、where、group by 以及order by,通过查看源代码，实际上linq为IEnumerable实现了一系列的扩展方法。：这里将查询结果 命名为g，一旦重新命名，T 的作用域就结束了，所以，最后select时，只能select g。
6.3LINQ查询技术
qq_33046143的博客
08-19 210
89.什么是LINQ       LINQ是Visual Studio 2008 中的领军人物。借助于LINQ技术，可以使用一种类似SQL的语法来查询任何形式的数据。目前为止，LINQ所支持的数据源有SQL Server、XML以及内存中的数据集合，开发人员也可以使用其提供的扩展框架添加更多的数据源。 90.LINQ查询关键字       在使用LINQ查询数据源时经常用到的关键字有FROM、S...
Linq语句
Kinoyss的博客
06-18 2179
1.LINQ LINQ（Language Integrated Query） 定义：语言集成查询是一组用于c#和Visual Basic语言的扩展。它允许编写C#或者Visual Basic代码以操作内存数据的方式，查询数据库。 通过使用查询语法，您甚至可以使用最少的代码对数据源执行复杂的筛选、排序和分组操作。 您使用相同的基本查询表达式模式来查询和转换 SQL 数据库、ADO.NET 数据集、XML 文档和流以及 .NET 集合中的数据。 2.Lambda表达式 定义：Lambda 表达式是一种可用于创建
Linq基础语句
weixin_44541143的博客
06-28 3133
Linq基础语句 什么是LINQ 查询语句呢，这次我就来讲一下LINQ 查询语句是什么。LINQ 查询语句，LINQ 是 .NET Framework 3.5 的一个扩展集并且它的管理语言使查询更类似于是一种对象。它定义了一种通用的语法和程序模型，使我们可以使用一种惯用的语法完成查找不同类型的数据。 相关操作像查找可以在 LINQ 中使用，并且在 .NET Framework 3.5 中的 C# ...
c# linq
weixin_33881041的博客
06-05 1829
LINQ(读音link)代表语言集成查询（Language Integrated Query），是.NEt框架的扩展，它允许我们用SQL查询数据库的方式来查询数据的集合，使用它，你可以从数据库、程序对象的集合以及XML文档中查询数据 Linq语法 let子句 let子句接受一个表达式的运算并且把它赋值给一个需要在其他运算中使用的标识符,它是from...let...wher...
【LINQ语句】LINQ语句
热门推荐
张姐姐聊编程
12-30 2万+
LINQ（Language Integrated Query）是C＃和VB.NET中的统一查询语法，用于保存和检索不同来源的数据。它集成在C＃或VB中，从而消除了编程语言和数据库之间的不匹配，以及为不同类型的数据源提供单个查询接口。例如，SQL是一种结构化查询语言，用于保存和检索数据库中的数据。同样的，LINQ是一个用C＃和VB.NET构建的结构化查询语法，用于保存和检索
C# LINQ查询基础：8个关键子句详解
C#使用LINQ查询表达式的基本子句总结是一篇介绍如何在C#编程中利用LINQ（Language Integrated Query）进行数据查询和操作的文章。LINQ是C#语言的一项功能，它允许开发者以一种直观的方式处理各种数据源，包括SQL...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值