精华内容
下载资源
问答
  • 文章来源:https://blog.csdn.net/horses/article/details/108174837来源平台:CSDN原文作者:不剪发的Tony老师数据表与集合理论集合非常类似,表是由...UNION,用于将两个查询结果合并成一个结果集,返回第一个...

    文章来源:https://blog.csdn.net/horses/article/details/108174837

    来源平台:CSDN

    原文作者:不剪发的Tony老师

    数据表与集合理论中的集合非常类似,表是由行组成的集合。SQL 标准定义了基于行的各种集合操作:并集运算(UNION)、交集运算(INTERSECT)和差集运算(EXCEPT)。

    1. UNION,用于将两个查询结果合并成一个结果集,返回第一个查询或者第二个查询中的数据;
    2. INTERSECT,用于返回两个查询结果中的共同部分,即同时属于第一个查询结果和第二个查询结果的数据;
    3. EXCEPT,用于返回出现在第一个查询结果中,但不在第二个查询结果中的数据。

    这些操作符都可以将两个查询的结果集合并成一个结果集,但是合并的规则各不相同,如下图所示:

    d03773c8275b4841ca1a03676b24befa.png

    对于集合操作符,参与运算的两个查询结果需要满足以下条件:

    • 结果集中字段的数量和顺序必须相同;
    • 结果集中对应字段的类型必须匹配或兼容。

    也就是说,两个查询结果的字段结构必须相同。如果一个查询返回 2 个字段,另一个查询返回 3 个字段,肯定无法合并。如果一个查询返回数字类型的字段,另一个查询返回字符类型的字段,通常也无法合并;不过 MySQL 可能会执行隐式的类型转换。

    21.1 并集(UNION)

    UNION 操作符用于将两个查询结果合并成一个结果集,返回第一个查询或者第二个查询中的数据:

    SELECT column1, column2, ...  FROM table1  UNION [DISTINCT | ALL]SELECT col1, col2, ...  FROM table2;

    其中,DISTINCT 表示将合并后的结果集进行去重;ALL 表示保留结果集中的重复记录;如果省略,默认为 DISTINCT。例如:

    CREATE TABLE t1(id int);INSERT INTO t1 VALUES (1), (2);CREATE TABLE t2(id int);INSERT INTO t2 VALUES (1), (3);SELECT id AS n FROM t1 UNION SELECT id AS m FROM t2;n|-|1|2|3|SELECT id AS n FROM t1 UNION ALLSELECT id AS m FROM t2;n|-|1|2|1|3|

    第一个查询结果中只返回了一个数字 1;第二个查询结果中保留了重复的数字 1。另外,UNION 操作返回的字段名由第一个 SELECT 语句决定。

    以下语句由于两个 SELECT 返回的字段数量不同而产生错误:

    SELECT 1  AS n, 'a' AS sUNION ALLSELECT 1 AS m;ERROR 1222 (21000): The used SELECT statements have a different number of columns

    以下语句通过隐式类型转换返回了合并之后的结果:

    SELECT 1 AS n, 'a' AS sUNION ALLSELECT 1, 2;n|s|-|-|1|a|1|2|

    返回结果中的第二个字段类型为字符串。

    对于多个表的 UNION 操作,按照从前到后的自然顺序执行。例如:

    SELECT 1 AS nUNION ALLSELECT 1UNION SELECT 1;n|-|1|

    由于第二个 UNION 操作没有 ALL 选项,最终返回了去重之后的结果,也就是一个 1。

    21.1.1 ORDER BY 和 LIMIT

    如果要对整个 UNION 操作的结果进行排序和数量限定,可以将 ORDER BY 和 LIMIT 子句加到语句的最后。例如:

    SELECT id AS n FROM t1UNION ALLSELECT id AS m FROM t2ORDER BY n;n|-|1|1|2|3|

    如果要对参与 UNION 的 SELECT 语句进行排序和数量限定,需要使用括号包含。例如:

    (SELECT id AS n FROM t1 ORDER BY id DESC LIMIT 1)UNION ALL(SELECT id AS m FROM t2  ORDER BY id LIMIT 1);n|-|2|1|

    这种排序操作不会影响到最终的结果顺序,如果要对最终结果进行排序,还需要在查询语句的最后再加上一个 ORDER BY 子句。

    21.2 交集(INTERSECT)

    MySQL 没有实现 SQL 标准中的 INTERSECT 操作符。按照定义,它可以返回两个查询结果中的共同部分,即同时出现在第一个查询结果和第二个查询结果中的数据:

    SELECT DISTINCT table1.column1, table1.column2, ...  FROM table1   JOIN table2     ON (table1.column1 = table2.col1 AND table1.column2 = table2.col2 ...);

    虽然 MySQL 不支持以上语法,但是我们可以通过 JOIN 查询实现相同的结果。

    SELECT DISTINCT table1.column1, table1.column2, ...  FROM table1   JOIN table2     ON (table1.column1 = table2.col1 AND table1.column2 = table2.col2 ...);

    其中,DISTINCT 用于去除查询结果中的重复记录,实现和 INTERSECT 相同的效果。例如:

    SELECT DISTINCT t1.idFROM t1JOIN t2 ON (t1.id = t2.id);id|--| 1|

    以上查询返回了 t1 和 t2 的交集。

    还有一种方法也可以实现相同的结果,就是使用 IN 或者 EXISTS 子查询语句。例如:

    SELECT DISTINCT idFROM t1WHERE id IN (SELECT id FROM t2);id|--| 1|

    21.3 差集(EXCEPT)

    MySQL 没有实现 SQL 标准中的 EXCEPT 操作符。按照定义,它可以返回出现在第一个查询结果中,但不在第二个查询结果中的数据:

    SELECT column1, column2, ...  FROM table1 EXCEPTSELECT col1, col2, ...  FROM table2;

    虽然 MySQL 不支持以上语法,但是我们同样可以通过 JOIN 查询实现相同的结果。

    SELECT column1, column2, ...  FROM table1   LEFT JOIN table2    ON (table1.column1 = table2.col1 AND table1.column2 = table2.col2 ...) WHERE table2.col1 IS NULL;

    左外连接返回了 table1 中的所有数据,WHERE 条件排除了其中属于 table2 的数据,从而实现了 EXCEPT 操作符的效果。例如:

    SELECT t1.idFROM t1 LEFT JOIN t2 ON (t2.id = t1.id)WHERE t2.id IS NULL;id|--| 2|

    还有一种方法也可以实现相同的结果,就是使用 NOT IN 或者 NOT EXISTS 子查询语句。例如:

    SELECT DISTINCT idFROM t1WHERE id NOT IN (SELECT id FROM t2);id|--| 2|

    对了,在这里说一下,我目前是在职Java开发,如果你现在正在学习Java,了解Java,渴望成为一名合格的Java开发工程师,在入门学习Java的过程当中缺乏基础入门的视频教程,可以关注并私信我:01。获取。我这里有最新的Java基础全套视频教程。

    展开全文
  • LINQ学习第一

    2012-11-22 21:22:00
     先看个例子吧,假如你要从一个Person集合里面获取姓名含有"z"的Person,一般我们遍历这个集合,然后把符合条件的Person对象添加到另一个集合,如下: 1 List<Person> listPerson = PersonHelper....

     1.为什么学习LINQ

      先看个例子吧,假如你要从一个Person集合里面获取姓名中含有"z"的Person,一般我们遍历这个集合,然后把符合条件的Person对象添加到另一个集合,如下:

    1  List<Person> listPerson = PersonHelper.GetAllPerson();
    2  List<Person> matchList = new List<Person>(); 
    3  foreach (Person person in listPersons)
    4  {
    5       if (person.Name.Contains("z"))
    6       {
    7            matchList.Add(person);
    8       }
    9  }

    通过以上的代码就可以得到符合条件的Person对象,这是我们常用的方法。

    下面是Linq的做法

    1 List<Person> listPersons = PersonHelper.GetAllPerson();
    2 IEnumerable<Person> matchList = null;
    3 matchList = from person in listPerson where person.Name.Contains("z") select person;

    2.LINQ表达式

    LINQ表达式和SQL查询表面还是很相似,所有的LINQ表达式都必须有一个指定数据源的from字句和一个表示要获取数据的select字句(或者定义了数据要放入组的group子句),from子句被放在最前面:

    1 matchList = from person in listPerson where person.Name.Contains("z") select person;

    from子句确定了两部分信息,紧随in之后的字段表明了查询的数据源(这里就是Person的实例集合对象listPersons),而紧随from之后的字段为数据源中每个个体的假名,就是当前Person集合listPersons中每个实例的命名,之后构建表达式的其他部分时,就可以使用这个假名(例如:where person.Name.Contains("z")),紧随where之后的表达式就是过滤条件(类似于T-SQL中的where 相同),select后的字段就是要查询的字段(类似于T-SQL中的select)

    3.LINQ查询

    依然以上面的listPerson集合,几种查询的语句:

     1 查询单个字段的语句
     2 var data = from person in listPerson select person.Name;
     3 查询组合字段
     4 var data = from person in listPerson select person.Name+person.Age;
     5 别名(实际就是匿名类)
     6 var data = from person in listPerson select new { 姓名 = person.Name,年龄=person.Age };
     7 组合别名
     8 var data = from person in listPerson select new { 姓名和年龄 = (person.Name + person.Age) };
     9 已存在的类
    10 var data = from person in listPerson select new PersonBase { Name = person.Name ,Age=person.Age,Sex=person.Sex };
    11 使用构造函数
    12 var data = from person in listPerson select new PersonBase(person.Name,person.Sex,person.Age);

     4.过滤和排序

     开始的例子就是用where把结果过滤为只包括那些匹配特定条件的记录

    1 matchList = from person in listPerson where person.Name.Contains("z") select person;

     where字句类似于T-SQL的where字句,where字句接受一个表达式,他对集合里面的每项进行计算,如果结果为true,该项就会被包含在结果中,可以使用逻辑与(&&)以及逻辑(||)操作符组合多个条件表达式并且能够使用关系操作符(如<、<=、>以及>=),例如:

    1 IEnumerable<Person> matchList =null;
    2 matchList = from person in listPerson where person.Age > 20 && person.Age < 30 select person;//查询年龄在20-30之间的人

    where子句也可以使用自己定义的方法,例如创建一个方法根据年龄判断是否成年大于界限为age=18,成年为true,未成年为false,下面的语句查询成年的人:

    1 //定义判断的方法
    2 private bool IsNotAdult(Person person) 
    3 {
    4       return person.Age >= 18;
    5 }
    6 //使用自定义方法
    7 IEnumerable<Person> matchList =null;
    8 matchList = from person in listPerson where IsNotAdult(person) select person ;

     LINQ排序使用关键字orderby,按指定的字段排序,默认为升序(ascending),降序(descending),使用方法,放在每个排序字段之后,例如以下语句,按照年龄大小降序排列,姓名升序排列

    1 IEnumerable<Person> matchList =null;
    2 matchList = from person in listPerson where IsNotAdult(person) orderby person.Age ascending, person.Name descending select person;

     

     

     

     

     

     

    转载于:https://www.cnblogs.com/SmileHan/archive/2012/11/22/2781702.html

    展开全文
  • C# LINQ

    2020-07-27 16:16:49
    语言集成查询(LINQ)是将系列的功能,集成到C#语言的技术的统称 Linq 可以应用的场景: 数据库 XML 文档 ADO.net 数据集 IEnumerable 接口的任何对象集合 三方的 web 服务 在写完Linq 语句以后,其本身只是...

    Linq 简介

    语言集成查询(LINQ)是将一系列的功能,集成到C#语言中的技术的统称

    Linq 可以应用的场景:

    数据库
    XML 文档
    ADO.net 数据集
    IEnumerable 接口的任何对象集合
    第三方的 web 服务

    • 在写完Linq 语句以后,其本身只是存储查询变量。并不会真正的执行。只有当调用 ToList 和 ToArray 方法的时候,才会真正的执行,而且调试的话,也进不去 Linq 语句。
    • 一般使用 Tolist 这种写法,我个人也没调试出来着两种方法有什么区别。

    查询表达式可以由三个部分组成:

    • 获取数据源
    • 建立查询表达式
    • 执行查询

    下边的例子

      static void Main()
        {
           
            int[] numbers = new int[7] { 0, 1, 2, 3, 4, 5, 6 };
    
            var numQuery =
                from num in numbers     //建立结果集
                where (num % 2) == 0    //查询条件
                select num;             //选出来
    
            // 3. Query execution.
            foreach (int num in numQuery)
            {
                Console.Write("{0,1} ", num);
            }
        }
    

    带有-排序-分组的语句

    var queryLondonCustomers3 =
        from cust in customers
        where cust.City == "London"
        orderby cust.Name ascending
        //orderby cust.Name descending
        select cust;
    

    综合案例:

    1.建立一个 student 类

    public class Student
    {
        public string First { get; set; }
        public string Last { get; set; }
        public int ID { get; set; }
        public List<int> Scores;
    }
    
    // Create a data source by using a collection initializer.
    static List<Student> students = new List<Student>
    {
        new Student {First="Svetlana", Last="Omelchenko", ID=111, Scores= new List<int> {97, 92, 81, 60}},
        new Student {First="Claire", Last="O'Donnell", ID=112, Scores= new List<int> {75, 84, 91, 39}},
        new Student {First="Sven", Last="Mortensen", ID=113, Scores= new List<int> {88, 94, 65, 91}},
        new Student {First="Cesar", Last="Garcia", ID=114, Scores= new List<int> {97, 89, 85, 82}},
        new Student {First="Debra", Last="Garcia", ID=115, Scores= new List<int> {35, 72, 91, 70}},
        new Student {First="Fadi", Last="Fakhouri", ID=116, Scores= new List<int> {99, 86, 90, 94}},
        new Student {First="Hanying", Last="Feng", ID=117, Scores= new List<int> {93, 92, 80, 87}},
        new Student {First="Hugo", Last="Garcia", ID=118, Scores= new List<int> {92, 90, 83, 78}},
        new Student {First="Lance", Last="Tucker", ID=119, Scores= new List<int> {68, 79, 88, 92}},
        new Student {First="Terry", Last="Adams", ID=120, Scores= new List<int> {99, 82, 81, 79}},
        new Student {First="Eugene", Last="Zabokritski", ID=121, Scores= new List<int> {96, 85, 91, 60}},
        new Student {First="Michael", Last="Tucker", ID=122, Scores= new List<int> {94, 92, 91, 91}}
    };
    

    2.把第一科成绩 > 90 ,第四门成绩 < 90 的人筛选出来,并且按照 升序 排序

     public  static void  show()
            {
                var studentsss =
                        from stu in Student.students
                        where stu.Scores[0] > 90 && stu.Scores[3]<90
                        orderby stu.Scores[0] ascending
                        // orderby stu.Scores[0] descending
                        select stu;
                foreach (var item in studentsss)
                {
                    Console.Write($"***{item.Last}****{item.First}****");
                    Console.Write("每个人的成绩是");
                    foreach (var items in item.Scores)
                    {
                        Console.Write(items.ToString()+"--");
                    }
                    Console.WriteLine();
                }
            }
        }
    

    结果如下:
    在这里插入图片描述

    3.结果进行分组

    对结果进行分组的时候,注意分组后的结果,想要读出来,必须使用两个 foreach 循环

     public  static void  show()
        {
    
                //怎么分组查找
    
                var studentQuery2 =
                     from studentaa in Student.students
                     group studentaa by studentaa.Last[0];
    
                // 怎么把分组的结果打印出来
    
                foreach (var studentGroup in studentQuery2)
                {
                    Console.WriteLine(studentGroup.Key);
                    foreach (Student student in studentGroup)
                    {
                        Console.WriteLine($"{student.First}**{student.Last}");
                    }
          } }
    

    最后输出的结果:
    在这里插入图片描述

    Let 关键字

    Let 关键字可以用来储存结果

    代码如下:

      public static void Show()
            {
                var studentQuery5 =
              from student in Student.students
              let totalScore = student.Scores[0] + student.Scores[1] +
                  student.Scores[2] + student.Scores[3]
              where totalScore / 4 < student.Scores[0]
              select student.Last + " " + student.First;
    
                foreach (string s in studentQuery5)
                {
                    Console.WriteLine(s);
                }
            }
    

    运行结果如下:
    在这里插入图片描述

    展开全文
  • 获取数据列表。//获取数据列表,Model是类IList list = dao.getmx...GroupBy与group by //GroupBy//单条件,并返回序列满足指定条件的第一个元素(相当于list按照user_type去重,可以是多条).list = list.GroupBy(a =...

    获取数据列表。

    //获取数据列表,Model是类

    IList list = dao.getmx(Model, pageInfo);

    //DataTable数据

    DataTable dt = ......;

    GroupBy与group by

    //GroupBy

    //单条件,并返回序列中满足指定条件的第一个元素(相当于list按照user_type去重,可以是多条).

    list = list.GroupBy(a => a.user_type).Select(it => it.First()).ToList();

    //多条件,使用了匿名函数.

    var quary = list.Where(a => a.p_num == "1" || a.c_num == "1")

    .GroupBy(a => new { student_id = a.student_id, user_type = a.user_type })

    .Select(group => new

    {

    student_id = group.Key.student_id,

    user_type = group.Key.user_type,

    Count = group.Count()

    });

    //group by

    //单条件

    var quary = from a in list.Where(a => "1,8".Contains(a.user_type))

    group a by new { a.school } into m

    select new

    {

    school = m.Key.school

    };

    //多条件

    var quary = from a in list.Where(a => "1,8".Contains(a.user_type))

    group a by new { a.provice, a.school } into m

    select new

    {

    provice = m.Key.provice,

    school = m.Key.school

    };

    //quary取值方法,此处可写可不写ToList()。

    //经过测试,数据30W,无ToList()比ToList()的耗时少几百毫秒,具体原因未知。下面是实验的几组数据:第一次9689 9398,第二次13529 10458,第三次10772 10392,第四次11370 10833。实际差距并不大。

    foreach (var item in quary.ToList())

    {

    //取值item

    }

    Where条件筛选。

    //将provice=吉林的筛选出来。

    list = list.Where(x => x.provice == "吉林").ToList();

    //将包含1,5条件的数据筛选出来,相当于sql里的in用法:select * from 表 where user_type in (1,5)

    list= list.Where(a => "1,5".Contains(a.user_type)).ToList();

    //此处等同于上面

    list= list.Where(a => a.user_type == "1" || a.user_type == "5").ToList();

    //另一种形式,from开头

    IList query = (from item in list

    where ("," + projectmodel.ids + ",").Contains("," + item.id + ",")

    select item).ToList();

    Select(取list中的id列数据,并按逗号分隔成字符串。例:1,2,3,4,5)

    //方式一

    //分成key-value的数组

    string[] id = list.Select(a => a.id.ToString()).ToArray();

    //dt是datatable类型的,执行LINQ语句,这里的.AsEnumerable()是延迟发生,不会立即执行,实际上什么都没有发生

    string[] id = dt.AsEnumerable().Select(a => a.Field("id").ToString()).ToArray();

    //将数组变成1,2,3,4,5的字符串

    string ids = string.Join(",", id);

    //方式二

    //效果等同于foreach循环

    foreach (var i in list)

    {

    ids += i.id + ",";

    }

    ids = ids.TrimEnd(',');

    上述代码使用LINQ 针对数据集中的数据进行筛选和整理,同样能够以一种面向对象的思想进行数据集中数据的筛选。

    在使用LINQ 进行数据集操作时,LINQ 不能直接从数据集对象中查询,因为数据集对象不支持LINQ 查询,所以需要使用AsEnumerable 方法返回一个泛型的对象以支持LINQ的查询操作。

    .AsEnumerable()与相对应的.AsQueryable()的区别:

    1) AsEnumerable()是 LINQ TO OBJECT,AsQueryable()是 LINQ TO SQL

    2) AsEnumerable将一个序列向上转换为一个IEnumerable, 强制将Enumerable类下面的查询操作符绑定到后续的子查询当中。AsQueryable将一个序列向下转换为一个IQueryable, 它生成了一个本地查询的IQueryable包装。

    3) AsEnumerable()延迟执行,不会立即执行。当你调用.AsEnumerable()的时候,实际上什么都没有发生。当真正使用对象的时候(例如调用:First, Single, ToList....的时候)才执行。

    4) .ToList()立即执行

    Where与Select的同时使用,取list中的id列数据,并按逗号分隔成字符串。

    string[] id = list.Where(a => !string.IsNullOrEmpty(a.user_type)).Select(a => a.id).ToArray();

    //ids="1,2,3,4,5,6,7";

    string ids = string.Join(",", id);

    左联与内联(例子是DataTable类型)

    //dt,dt1,dt2都为DataTable类型。

    //左联比内联,需要多写into,需要多写from gc1 in corr.DefaultIfEmpty(),需要多写corr=gc1。

    //当on为单条件时。

    var results = from student in dt.AsEnumerable()

    join user in dt1.AsEnumerable() on student.Field("student_id") equals user.Field("id")//内联

    join corr in dt2.AsEnumerable() on student.Field("id") equals corr.Field("studentproject_id") into corr//左联

    from gc1 in corr.DefaultIfEmpty()

    select new

    {

    student,

    user,

    corr = gc1

    };

    //当on为多条件时,借助于匿名类型:其实和解决按多条件分组的思路是一样的。

    var results = from student in dt.AsEnumerable()

    join zrs in result_zrs on new { districtcounty = student.Field("districtcounty"), school = student.Field("school") }

    equals new { districtcounty = zrs.districtcounty, school = zrs.school } into zrs

    from gc1 in zrs.DefaultIfEmpty()

    select new

    {

    student,

    corr = gc1

    };

    //取值方式

    foreach (var i in results.ToList())

    {

    name = i.user.Field("name");

    }

    OrderBy排序

    //1个排序

    list.OrderBy(a => a.student_id);

    //2个排序

    list.OrderBy(a => a.student_id).ThenBy(a => a.name);

    //多个排序

    list.OrderBy(a => a.student_id).ThenBy(a => a.name).ThenBy(a => a.sex);

    //参数排序

    List liststr = new List();

    liststr.Add("aaa");

    liststr.Add("bbb");

    liststr.Add("ccc");

    liststr = liststr.OrderBy(a => a).ToList();//aaa bbb ccc

    liststr = liststr.OrderBy(a => a == "bbb" ? "1" : a == "ccc" ? "2" : "3").ToList();//bbb ccc aaa

    OrderBy随机排序

    //方式一

    Random rd = new Random();

    List liststr = new List();

    liststr.Add("aaa");

    liststr.Add("bbb");

    liststr.Add("ccc");

    liststr.Add("111");

    liststr.Add("222");

    liststr.Add("333");

    //随机一个

    var s = liststr.OrderBy(_ => Guid.NewGuid()).First();

    //随机两个

    var ss = liststr.OrderBy(_ => Guid.NewGuid()).Take(2);

    //乱序

    var sss = liststr.OrderBy(o => rd.Next(0, liststr.Count())).ToList();

    //方式二

    Random rd = new Random();

    list.OrderBy(_=>rd.Next(1,99)).First();

    //随机排序通用方法

    //就是从原List中每次随机取一项,添加到新的List中,并在原List中删除。这样重复,直到原List为空为止。

    //不过要注意,如果要保护原List不受变化,就必须先Copy一份List,再在Copy上进行操作

    public static List GetRandomList(List inputList)

    {

    //Copy to a array

    T[] copyArray = new T[inputList.Count];

    inputList.CopyTo(copyArray);

    //Add range

    List copyList = new List();

    copyList.AddRange(copyArray);

    //Set outputList and random

    List outputList = new List();

    Random rd = new Random(DateTime.Now.Millisecond);

    while (copyList.Count > 0)

    {

    //Select an index and item

    int rdIndex = rd.Next(0, copyList.Count - 1);

    T remove = copyList[rdIndex];

    //remove it from copyList and add it to output

    copyList.Remove(remove);

    outputList.Add(remove);

    }

    return outputList;

    }

    //Skip是起始数据,表示从第n+1条数据开始.(此处pageNum应从0开始)

    //pageNum:页数、=0是第一页,pageSize:一页多少条

    list = list.Skip(pageNum * pageSize).Take(pageSize).ToList();

    //取前1-10条

    list = list.Skip(0).Take(10).ToList();

    //也可以这么写取前1-10条

    list = list.Take(10).ToList();

    //取第11-20条

    list = list.Skip(10).Take(10).ToList();

    Distinct去重

    //字符串数组

    string[] idlist = new string[ ]{"aaa","bbb","aaa"};

    //去除重复aaa

    idlist = idlist.Distinct().ToArray();

    展开全文
  • 在项目开发过程可能会与第三方框架相集合,比如lauiy,vue,bootstrap等,我这里呢就使用了layui和EF结合开发的一个下项目 这里能可以直接去官网下载:传送门下载完成之后呢 第一步,创建数据库和添加视图类这儿呢 ...
  • LINQ之Aggregate

    千次阅读 2010-06-30 14:22:00
    如果没有指定种子值的话,种子值默认为集合的第一个元素。 下面用一个表格总结一下这篇说的LINQ to SQL语句Where过滤;延迟Select选择;延迟Distinct查询不重复的结果集;延迟Count返回集合中的元素个数,返回...
  • 6.3.4 FirstOrDefault 集合中第一个元素(没有则返回类型默认值),浅复本 22 6.3.5 Last 集合中的最后一个元素,浅复本 22 6.3.6 LastOrDefault 集合中的最后一个元素(没有则返回类型默认值),浅复本 22 6.3.7 ...
  • Linq之旅2

    2011-05-10 17:10:25
    Intersect(相交) 说明:取相交项;延迟。即是获取不同集合的相同项(交集)。即先遍历第一个集合,找出所有唯一的元素...先遍历第一个集合,找出所有唯一的元素,然后再遍历第二个集合,返回第二个集合中所有未出...
  • 中第一条或最后一条记录 实例195 利用聚合函数显示数据库中重复记录的数量 实例196 查询大于平均值的所有数据 实例197 获取无重复或者不为空的记录数 实例198 随机查询求和 实例199 统计某个值出现的次数 6.13 多表...
  • 实例229 用First或Last求数据表中第一条或最后一条 7.11 多表查询(连接查询) 实例230 多表连接查询 实例231 在连接查询中使用表别名 实例232 使用UNION关键字合并多结果集 7.12 嵌套查询 实例233 简单...
  • C#高级编程(6版)

    2011-05-11 11:10:30
     2.2 第一个C#程序  2.2.1 代码  2.2.2 编译并运行程序  2.2.3 详细介绍  2.3 变量  2.3.1 变量的初始化  2.3.2 类型推断  2.3.3 变量的作用域  2.3.4 常量  2.4 预定义数据类型  2.4.1 值类型和引用类型...
  • 2.2 第一个C#程序 2.2.1 代码 2.2.2 编译并运行程序 2.2.3 详细介绍 2.3 变量 2.3.1 变量的初始化 2.3.2 类型推断 2.3.3 变量的作用域 2.3.4 常量 2.4 预定义数据类型 2.4.1 值类型和引用类型 2.4.2 CTS类型 2.4.3 ...
  •  2.2 第一个C#程序  2.2.1 代码  2.2.2 编译并运行程序  2.2.3 详细介绍  2.3 变量  2.3.1 变量的初始化  2.3.2 类型推断  2.3.3 变量的作用域  2.3.4 常量  2.4 预定义数据类型  2.4.1 值类型和引用类型...
  • 2.2 第一个C#程序 2.2.1 代码 2.2.2 编译并运行程序 2.2.3 详细介绍 2.3 变量 2.3.1 变量的初始化 2.3.2 类型推断 2.3.3 变量的作用域 2.3.4 常量 2.4 预定义数据类型 2.4.1 值类型和引用类型 2.4.2 CTS类型 2.4.3 ...
  • 5.7.5 构造器链:使用this调用另一个构造器 168 5.8 静态成员 172 5.8.1 静态字段 172 5.8.2 静态方法 174 5.8.3 静态构造器 175 5.8.4 静态属性 176 5.8.5 静态类 177 5.9 扩展方法 ...
  • 款非常好的WPF编程宝典2010 源代码

    热门讨论 2014-04-14 09:57:41
    9.2.5 在另外一个页面宿主页面 212 9.2.6 在Web浏览器宿主页面 213 9.3 页面历史 214 9.3.1 深入分析WPF的URI 214 9.3.2 导航历史 215 9.3.3 维护自定义的属性 216 9.4 导航服务 217 9.4.1 通过编程...
  • 实例054 向班级集合中添加学生信息 87 实例055 不改变长度删除数组中的元素 89 实例056 删除数组元素后改变其长度 90 6章 c#面向对象程序设计 92 实例057 创建类的对象 93 实例058 使用构造函数 94 实例059 通过...
  • C#全能速查宝典

    热门讨论 2014-04-26 16:16:27
    1.4.11 First函数——返回查询结果的第一个记录 55 1.4.12 FirstDayOfWeek属性——获取或设置一周的第一天 56 1.4.13 Format方法——格式化字符串 56 1.4.14 GETDATE函数——返回当前系统日期和时间 58 1.4.15 ...
  • 19.1.3 第一个工作流示例程序 459 19.1.4 WF架构简介 463 19.2 使用WorkflowRuntime和WorkflowInstance类 464 19.2.1 理解WorkflowRuntime工作流引擎 464 19.2.2 理解WorkflowInstance工作流实例 467 19.3 工作流...
  • 2.2 第一个C#程序 2.2.1 代码 2.2.2 编译并运行程序 2.2.3 详细介绍 2.3 变量 2.3.1 变量的初始化 2.3.2 类型推断 2.3.3 变量的作用域 2.3.4 常量 2.4 预定义数据类型 2.4.1 值类型和引用类型 2.4.2 CTS类型 2.4.3 ...
  • 2.2 第一个C#程序 2.2.1 代码 2.2.2 编译并运行程序 2.2.3 详细介绍 2.3 变量 2.3.1 变量的初始化 2.3.2 类型推断 2.3.3 变量的作用域 2.3.4 常量 2.4 预定义数据类型 2.4.1 值类型和引用类型 2.4.2 CTS类型 2.4.3 ...
  • 2.2 第一个C#程序 2.2.1 代码 2.2.2 编译并运行程序 2.2.3 详细介绍 2.3 变量 2.3.1 变量的初始化 2.3.2 类型推断 2.3.3 变量的作用域 2.3.4 常量 2.4 预定义数据类型 2.4.1 值类型和引用类型 2.4.2 CTS类型 2.4.3 ...
  • WPF编程宝典 part1

    2015-07-20 23:33:59
    Ⅰ部分 基础知识 1章 WPF概述 3 1.1 Windows图形演化 3 1.1.1 DirectX:新的图形引擎 4 1.1.2 硬件加速与WPF 4 1.2 WPF:高级API 4 1.3 分辨率无关性 5 1.3.1 WPF单位 6 1.3.2 系统DPI 7 1.3.3 位图和矢量图形 9...
  • 全书共分三部分:第一部分阐释了数据库的基本概念,讲解了数据库建模语言;第二部分展示了从概念建模到在 sql server 2008上真正实现数据库的过程;第三部分深入探讨了 sql server若干方面的技术细节,如数据保护...
  • 读者可以在欣赏一个个有趣例子的过程,不知不觉具备开发真正商业项目的能力。 本书集实用性、思想性、趣味性于一体,内容共分为技术基础总结、系统架构设计思想及项目实战解析三部分,随书所附光盘收录大量实例...
  • C#从入门到实践 源文件

    热门讨论 2010-10-17 18:32:05
    本书共分为27章,从第一个C#应用程序开始,首先介绍搭建、配置开发环境等基础知识,然后介绍C# 3.0的基础语法知识,如类型、变量、表达式、语句、命名空间等。再重点介绍C# 3.0的面向对象编程技术和常用的扩展技术...

空空如也

空空如也

1 2
收藏数 28
精华内容 11
关键字:

linq获取集合中第一个