精华内容
下载资源
问答
  • 集合变更,无论是使用 foreach 遍历还是使用 Linq 语句,即使是 FirstOrDefault 获取第一项,都会失败 例如下面代码,在两线程里面,第一个线程获取使用 FirstOrDefault 方法,第二线程变更集合内容 static...

    在集合变更,无论是使用 foreach 遍历还是使用 Linq 语句,即使是 FirstOrDefault 获取第一项,都会失败

    例如下面代码,在两个线程里面,第一个线程获取使用 FirstOrDefault 方法,第二个线程变更集合内容

            static void Main(string[] args)
            {
                var list = new List<string>();
                Task.Run(() =>
                {
                    while (true)
                    {
                        var str = list.FirstOrDefault();
                        Console.WriteLine(str);
                    }
                });
    
                Task.Run(() =>
                {
                    while (true)
                    {
                        list.Clear();
                        list.Add("doubi");
                    }
                });
    
                Console.Read();
            }

    运行以上代码,可以看到抛出了 ArgumentOutOfRangeException 如下面代码

    System.ArgumentOutOfRangeException:“Index was out of range. Must be non-negative and less than the size of the collection. ”
    

    本文所有代码放在 githubgitee 欢迎小伙伴访问

    可以通过如下方式获取本文的源代码,先创建一个空文件夹,接着使用命令行 cd 命令进入此空文件夹,在命令行里面输入以下代码,即可获取到本文的代码

    git init
    git remote add origin https://gitee.com/lindexi/lindexi_gd.git
    git pull origin ffc985358957cc0c06c0985caa1d166c7ef8757d
    

    以上使用的是 gitee 的源,如果 gitee 不能访问,请替换为 github 的源

    git remote remove origin
    git remote add origin https://github.com/lindexi/lindexi_gd.git
    

    获取代码之后,进入 GujidearkiLicairfeeka 文件夹

    我搭建了自己的博客 https://blog.lindexi.com/ 欢迎大家访问,里面有很多新的博客。只有在我看到博客写成熟之后才会放在csdn或博客园,但是一旦发布了就不再更新

    如果在博客看到有任何不懂的,欢迎交流,我搭建了 dotnet 职业技术学院 欢迎大家加入

    如有不方便在博客评论的问题,可以加我 QQ 2844808902 交流

    知识共享许可协议
    本作品采用知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。欢迎转载、使用、重新发布,但务必保留文章署名林德熙(包含链接:http://blog.csdn.net/lindexi_gd ),不得用于商业目的,基于本文修改后的作品务必以相同的许可发布。如有任何疑问,请与我联系

    展开全文
  • LINQ集合操作

    千次阅读 2017-10-19 10:37:53
    一个集合中,我们想要得到集合里满足特定条件下的集合,通常情况下我们会用foreach循环来获取里面的集合。 首先我们先定义两个集合//武林高手集合 class MartialArtsMaster { public int Id { g

    LINQ是一个用于操作集合的语法,它能够查询一个集合里的字段,并且能够分组、排序,除此之外还有其他的功能。它的语法规则和SQL语言非常相似。


    在一个集合中,我们想要得到集合里满足特定条件下的集合,通常情况下我们会用foreach循环来获取里面的集合。
    首先我们先定义两个集合

    //武林高手集合
    class MartialArtsMaster
        {
            public int Id { get; set; }
            public string Name { get; set; }
            public int Age { get; set; }
            public string Menpai { get; set; }
            public string Kungfu { get; set; }
            public int Level { get; set; }
    
            //重写ToString方法
            public override string ToString()
            {
                return $"Id: {Id}, Name: {Name}, Age: {Age}, Menpai: {Menpai}, Kungfu: {Kungfu}, Level: {Level}";
            }
        }
    
    //武学集合
    class Kungfu
        {
            public int Id;
            public string Name;
            public int Power;
    
            public override string ToString()
            {
                return $"Id: {Id}, Name: {Name}, Power: {Power}";
            }
        }

    然后在主函数里new两个集合对象

    static void Main(string[] args)
            {
                //初始化武林高手
                var masterList = new List<MartialArtsMaster>()
                {
                    new MartialArtsMaster() {Id = 1, Name = "黄蓉", Age = 18, Menpai = "丐帮", Kungfu = "打狗棒法", Level = 9},
                    new MartialArtsMaster() {Id = 2, Name = "洪七公", Age = 70, Menpai = "丐帮", Kungfu = "打狗棒法", Level = 10},
                    new MartialArtsMaster() {Id = 3, Name = "郭靖", Age = 22, Menpai = "丐帮", Kungfu = "降龙十八掌", Level = 10},
                    new MartialArtsMaster() {Id = 4, Name = "任我行", Age = 50, Menpai = "明教", Kungfu = "葵花宝典", Level = 1},
                    new MartialArtsMaster() {Id = 5, Name = "东方不败", Age = 35, Menpai = "明教", Kungfu = "葵花宝典", Level = 10},
                    new MartialArtsMaster() {Id = 6, Name = "林平之", Age = 23, Menpai = "华山", Kungfu = "葵花宝典", Level = 7},
                    new MartialArtsMaster() {Id = 7, Name = "岳不群", Age = 50, Menpai = "华山", Kungfu = "葵花宝典", Level = 8},
                    new MartialArtsMaster() {Id = 8, Name = "令狐冲", Age = 23, Menpai = "华山", Kungfu = "独孤九剑", Level = 10},
                    new MartialArtsMaster() {Id = 9, Name = "梅超风", Age = 23, Menpai = "桃花岛", Kungfu = "九阴真经", Level = 8},
                    new MartialArtsMaster() {Id = 10, Name = "黄药师", Age = 23, Menpai = "梅花岛", Kungfu = "弹指神通", Level = 10},
                    new MartialArtsMaster() {Id = 11, Name = "风清扬", Age = 23, Menpai = "华山", Kungfu = "独孤九剑", Level = 10}
                };
    
                //初始化武学
                var KungfuList = new List<Kungfu>()
                {
                    new Kungfu() {Id = 1, Name = "打狗棒法", Power = 90},
                    new Kungfu() {Id = 2, Name = "降龙十八掌", Power = 95},
                    new Kungfu() {Id = 3, Name = "葵花宝典", Power = 100},
                    new Kungfu() {Id = 4, Name = "独孤九剑", Power = 100},
                    new Kungfu() {Id = 5, Name = "九阴真经", Power = 100},
                    new Kungfu() {Id = 6, Name = "弹指神通", Power = 100}
                };
            }

    查询

    然后我们使用foreach循环来查询武学级别大于8的武林高手

    //查询所有武学级别大于8的武林高手
                var res = new List<MartialArtsMaster>();
                foreach (var temp in masterList)
                {
                    if (temp.Level > 8)
                    {
                        res.Add(temp);
                    }
                }

    但是使用LINQ能够使代码更加的简洁并且易懂

    //使用LINQ查询
                var res = from m in masterList //from后面设置查询的集合
                    where m.Level > 8 //where后面跟上查询的条件
                    select m.Name; //表示m的结果返回

    我们使用扩展方法可以使它更加简洁,写一个方法来存储判断条件,每次要判断的时候就调用这个方法

    //扩展方法
                var res = masterList.Where(Test1);
    
    //判断方法
                bool Test1(MartialArtsMaster master)
                {
                    if (master.Level > 8) return true;
                    return false;
                }

    但是写一个判断方法对我们来说,如果条件修改了,那这个方法也需要修改,这时候我们可以使用之前学的Lambda表达式,因为这个判断方法可以作为一个匿名方法,里面的方法体才是对我们有用的。

    //Lambda表达式
                var res = masterList.Where(m => m.Level > 8 && m.Menpai == "丐帮");

    联合查询

    前面几个方法都是对一个集合查询,我们还可以使用LINQ对两个集合进行联合查询

    //LINQ联合查询
                var res = from m in masterList
                    from k in Kungfu
                    where m.Kungfu == k.Name && k.Power >= 95
                    select m;

    然后我们还是使用扩展方法和Lambda表达式来对代码进行优化

    //扩展方法——LINQ联合查询
                var res = masterList.SelectMany(m => KungfuList, (m, k) => new {master = m, Kungfu = k})
                    .Where(x => x.master.Kungfu == x.Kungfu.Name && x.Kungfu.Power > 95);

    这里的代码使用了Func委托,我们可以在代码中查看SelectMany这个方法是如何使用的,否则很难理解这里代码的意思。

    联合查询还有另外一种方法:join in集合联合查询

    //join in集合联合查询
                var res = from m in masterList
                    join k in KungfuList on m.Kungfu equals k.Name
                    where k.Power > 95
                    select new {master = m,Kungfu=k}; //表示将两个集合结合在一起成为一个新的集合然后返回该集合

    排序

    我们查询完结果后,可以对结果的某个字段进行排序,默认排序是从小到大,使用descending则倒序

    //对查询结果进行排序orderby  倒序descending
                var res = from m in masterList
                    where m.Level > 8 && m.Menpai == "丐帮"
                    //orderby m.Age descending //倒序
                    orderby m.Level,m.Age //按照多个字段排序,若前面的字段属性相同,再对第二个字段进行排序
                    select m;

    代码优化之后

    //扩展方法
                var res = masterList.Where(m => m.Level > 8 && m.Menpai == "丐帮").OrderBy(m=>m.Age);
                //按照多个字段排序
                var res = masterList.Where(m => m.Level > 8 && m.Menpai == "丐帮").OrderBy(m => m.Level).ThenBy(m => m.Age);

    扩展方法里的多个字段排序,只能使用ThenBy关键字,如果还是使用OrderBy关键字,则会在level排序之后,再根据Age再重新排序。


    分组查询

    查询完结果之后,我们可以对集合进行分组,只得到自己想要的结果,其余的字段可以忽略

    //分组查询 into groups(按照功夫分类)
                var res = from k in KungfuList
                    join m in masterList on k.Name equals m.Kungfu
                    into groups //分组关键字
                    orderby groups.Count()
                    //将master=m改成groups.Count()是因为分完组后,
                    //master就是作为组来输出了,不再以单个形式出现
                    select new {Kungfu = k, count = groups.Count()}; 

    我们还可以根据集合里的某个字段进行分组

    //按照自身字段分组 group
                var res = from m in masterList
                          group m by m.Menpai
                          into g //将分组完的信息放入g中
                          select new { count = g.Count(), key = g.Key }; //key是指分组所根据的字段,在这里指Menpai这个字段

    量词操作符

    使用量词操作符我们可以判断这个集合里是否存在某个字段

    //Any只需要其中一个字段相同就返回True
                bool result = masterList.Any(m => m.Menpai == "丐帮");
                //All需要全部字段都相同才返回True
                bool result2 = masterList.All(m => m.Menpai == "丐帮");
                Console.WriteLine(result);
                Console.WriteLine(result2);

    LINQ的方法还有很多,这些是最常用的,上面的代码得到的结果可以使用foreach遍历返回的集合来输出

    foreach (var temp in res)
                {
                    Console.WriteLine(temp);
                }

    LINQ不仅仅能够对集合进行操作,还能够对XML数据源、Sql Server进行操作,但是微软已不再更新对Sql的操作,所以推荐使用LINQ to Entitles。但是我们最经常使用的还是对内存中的集合的操作。

    展开全文
  • Linq查询集合

    2020-12-30 13:43:52
    Linq语法详细 闲言碎语 近期比较忙,但还是想写点什么,就分享一些基础的知识给大家看吧,希望能帮助一些linq新手,如果有其它疑问...1.简单的linq语法 //1 var ss = from r in db.Am_recProScheme select r;

    Linq语法详细

    闲言碎语

    近期比较忙,但还是想写点什么,就分享一些基础的知识给大家看吧,希望能帮助一些linq新手,如果有其它疑问,可以进右上角群,进行交流探讨,谢谢。

    开门见山

    读这篇文章之前,我先说下,每一种搜索结果集,我都以三种方式变现出来,为啦更好的理解,希望不要嫌我啰嗦。

    1.简单的linq语法

    复制代码

      //1
                var ss = from r in db.Am_recProScheme
                         select r;
                //2
                var ss1 = db.Am_recProScheme;
                //3
                string sssql = "select * from Am_recProScheme";

    复制代码

    2.带where的查询

    复制代码

                //1
                var ss = from r in db.Am_recProScheme
                         where r.rpId > 10
                         select r;
                //2
                var ss1 = db.Am_recProScheme.Where(p => p.rpId > 10);
                //3
                string sssql = "select * from Am_recProScheme where rpid>10";

    复制代码

    3.简单的函数计算(count,min,max,sum)

    复制代码

                //1
                获取最大的rpId
                //var ss = (from r in db.Am_recProScheme
                //          select r).Max(p => p.rpId);
                获取最小的rpId
                //var ss = (from r in db.Am_recProScheme
                //          select r).Min(p => p.rpId);
                //获取结果集的总数
                //var ss = (from r in db.Am_recProScheme                  
                //         select r).Count();
                //获取rpId的和
                var ss = (from r in db.Am_recProScheme
                          select r).Sum(p => p.rpId);
    
    
                //2
                //var ss1 = db.Am_recProScheme.Max(p=>p.rpId);
                //var ss1 = db.Am_recProScheme.Min(p => p.rpId);
                //var ss1 = db.Am_recProScheme.Count() ;
                var ss1 = db.Am_recProScheme.Sum(p => p.rpId);
                Response.Write(ss);
    
                //3
                string sssql = "select max(rpId) from Am_recProScheme";
                       sssql = "select min(rpId) from Am_recProScheme";
                       sssql = "select count(1) from Am_recProScheme";
                       sssql = "select sum(rpId) from Am_recProScheme";

    复制代码

    4.排序order by desc/asc

    复制代码

                var ss = from r in db.Am_recProScheme
                         where r.rpId > 10
                         orderby r.rpId descending  //倒序
                         //  orderby r.rpId ascending   //正序
                         select r;
    
                //正序
                var ss1 = db.Am_recProScheme.OrderBy(p => p.rpId).Where(p => p.rpId > 10).ToList();
                //倒序
                var ss2 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).ToList();
    
                string sssql = "select * from Am_recProScheme where rpid>10 order by rpId [desc|asc]";

    复制代码

    5.top(1)

    复制代码

                //如果取最后一个可以按倒叙排列再取值
                var ss = (from r in db.Am_recProScheme                     
                          select r).FirstOrDefault();
    
                //()linq to ef 好像不支持 Last() 
                var ss1 = db.Am_recProScheme.FirstOrDefault();
                //var ss1 = db.Am_recProScheme.First();          
    
                string sssql = "select top(1) * from Am_recProScheme";

    复制代码

    6.跳过前面多少条数据取余下的数据

    复制代码

                //1
                var ss = (from r in db.Am_recProScheme
                          orderby r.rpId descending
                          select r).Skip(10); //跳过前10条数据,取10条之后的所有数据   
                //2  
                var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Skip(10).ToList();
                //3
                string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10";

    复制代码

    7.分页数据查询

    复制代码

                //1
                var ss = (from r in db.Am_recProScheme
                          where r.rpId > 10
                          orderby r.rpId descending
                          select r).Skip(10).Take(10); //取第11条到第20条数据                   
    
                //2 Take(10): 数据从开始获取,获取指定数量(10)的连续数据
                var ss1 = db.Am_recProScheme.OrderByDescending(p => p.rpId).Where(p => p.rpId > 10).Skip(10).Take(10).ToList();
                //3
                string sssql = "select * from  (select ROW_NUMBER()over(order by rpId desc) as rowNum, * from [Am_recProScheme]) as t where rowNum>10 and rowNum<=20";

    复制代码

    8.包含,类似like '%%'

    复制代码

                //1
                var ss = from r in db.Am_recProScheme
                         where r.SortsText.Contains("张")
                         select r;
                //2
                var ss1 = db.Am_recProScheme.Where(p => p.SortsText.Contains("张")).ToList();
                //3
                string sssql = "select * from Am_recProScheme where SortsText like '%张%'";

    复制代码

    9.分组group by

    复制代码

                //1
                var ss = from r in db.Am_recProScheme
                         orderby r.rpId descending
                         group r by r.recType into n
                         select new
                         {
                             n.Key,  //这个Key是recType
                             rpId = n.Sum(r => r.rpId), //组内rpId之和
                             MaxRpId = n.Max(r => r.rpId),//组内最大rpId
                             MinRpId = n.Min(r => r.rpId), //组内最小rpId
                         };
                foreach (var t in ss)
                {
                    Response.Write(t.Key + "--" + t.rpId + "--" + t.MaxRpId + "--" + t.MinRpId);
                }
                //2
                var ss1 = from r in db.Am_recProScheme
                         orderby r.rpId descending
                         group r by r.recType into n
                         select n;
                foreach (var t in ss1)
                {
                    Response.Write(t.Key + "--" + t.Min(p => p.rpId));
                }
                //3
                var ss2 = db.Am_recProScheme.GroupBy(p => p.recType);
                foreach (var t in ss2)
                {
                    Response.Write(t.Key + "--" + t.Min(p => p.rpId));
                }
                //4
                string sssql = "select recType,min(rpId),max(rpId),sum(rpId) from Am_recProScheme group by recType";
    
    
               //多字段

    var result = (from item in data
    group item by new { item.Name, item.Type } into items
    select new
    {
        items.Key.Name,
        items.Key.Type,
        Cnt = items.Count()
    }).ToList();


    var s = data.GroupBy(p => new { p.Type, p.Name }).Select(p=>new {
              p.Key.Type,
              p.Key.Name,
              cnt=p.Count()
    }).ToList();

     

    复制代码

    10.连接查询 

    复制代码

                //1
                var ss = from r in db.Am_recProScheme
                         join w in db.Am_Test_Result on r.rpId equals w.rsId
                         orderby r.rpId descending
                         select r;
                //2
                var ss1 = db.Am_recProScheme.Join(db.Am_Test_Result, p => p.rpId, r => r.rsId, (p, r) => p).OrderByDescending(p => p.rpId).ToList();
                //3
                string sssql = "select r.* from  [Am_recProScheme] as r inner join [dbo].[Am_Test_Result] as t on r.[rpId] = t.[rsId] order by r.[rpId] desc";

    复制代码

    11.sql中的In

    复制代码

                //1
                var ss = from p in db.Am_recProScheme
                                  where (new int?[] { 24, 25,26 }).Contains(p.rpId)
                                  select p;
                foreach (var p in ss)
                {
                    Response.Write(p.Sorts);
                }
                //2
                string st = "select * from Am_recProScheme where rpId in(24,25,26)";

    复制代码

     

    如果你是linq新手,建议这十个常用的查询标记学习,再加上视图,基本上就能解决大部分的查询问题啦。

    原文地址:https://www.cnblogs.com/knowledgesea/p/3897665.html

    展开全文
  • 语言集成查询 (LINQ) 是系列直接将查询功能集成到 C# 语言的技术统称。 数据查询历来都表示为简单的字符串,没有编译时类型检查或 IntelliSense 支持。 此外,需要针对每种类型的数据源了解不同的查询语言:SQL ...

    看一下官网的介绍:
    语言集成查询 (LINQ) 是一系列直接将查询功能集成到 C# 语言的技术统称。 数据查询历来都表示为简单的字符串,没有编译时类型检查或 IntelliSense 支持。 此外,需要针对每种类型的数据源了解不同的查询语言:SQL 数据库、XML 文档、各种 Web 服务等。 借助 LINQ,查询成为了最高级的语言构造,就像类、方法和事件一样。 可以使用语言关键字和熟悉的运算符针对强类型化对象集合编写查询。 LINQ 系列技术提供了针对对象 (LINQ to Objects)、关系数据库 (LINQ to SQL) 和 XML (LINQ to XML) 的一致查询体验。
    对于编写查询的开发者来说,LINQ 最明显的“语言集成”部分就是查询表达式。 查询表达式采用声明性 查询语法 编写而成。 使用查询语法,可以用最少的代码对数据源执行筛选、排序和分组操作。 可使用相同的基本查询表达式模式来查询和转换 SQL 数据库、ADO .NET 数据集、XML 文档和流以及 .NET 集合中的数据。
    在 C# 中可为以下对象编写 LINQ 查询:SQL Server 数据库、XML 文档、ADO.NET 数据集以及支持 IEnumerable 或泛型 IEnumerable 接口的任何对象集合。 此外,第三方也为许多 Web 服务和其他数据库实现提供了 LINQ 支持。
    我的理解:
    为了方便查询而诞生出的一系列语法糖
    查询操作的三个部分:
    所有 LINQ 查询操作都由以下三个不同的操作组成:
    1.获取数据源。
    2.创建查询。
    3.执行查询。
    简单示例:

    using System;
    using System.Collections.Generic;
    using System.Linq;
    
    namespace TestSqlSugar
    {
        /// <summary>
        /// LINQLINQ
        /// </summary>
        class Program
         {
           static void Main()
           {
                //获取数据源 需支持泛型 IEnumerable<T> 接口
                List<Student> Students = new();
                Students.Add(new Student("A",18));
                Students.Add(new Student("B",19));
                Students.Add(new Student("C",20));
                Students.Add(new Student("D",21));
                Students.Add(new Student("E",22));
                Students.Add(new Student("F",23));
                Students.Add(new Student("G",24));
                //创建查询
                var queryResult = from stu in Students
                                  where stu.Age > 21
                                  select stu;
                //执行查询
                foreach (var item in queryResult)
                {
                    Console.WriteLine(item);
                }
    
                
            }
        
         }
    
        class Student { 
            public string Name { get; set; }
    
            public int Age { get; set; }
    
            public Student(string name,int age)
            {
                Name = name;
                Age = age;
            }
            public override string ToString()
            {
                return $"{Name}---->{Age}";
            }
        }
       
    }
    

    查询出年龄大于21的所有Student对象
    在这里插入图片描述
    我是狗子 希望你幸福!

    展开全文
  • 实际开发,遇到一个问题,即在某个对象下的list下,还有list,再获取某个字段的所有数据,类结构层级如下: public sealed class accountbooks { public DateTime CreateDate { get; set; } public string ...
  • C# Linq获取List或数组的差集交集

    千次阅读 2016-11-18 13:30:21
    C# Linq获取List或数组的差集交集 2016-03-28 11:31 by 转身寻找静谧, 37 阅读, 0 评论, 收藏, 编辑 Listint> list1 = new Listint>(); list1.Add(1); list1.Add(2); list1.Add(3); Listint> ...
  • 就以下面的列表举小例子吧: List<T> epList = new List<T>(); 方法1: ...试了Max()取最大值的方法,但是...//从列表匹配值等于最大值的第一项 T item = epList.Where(x=>x.value == maxValue)...
  • LINQ查询结果集 SystemArray 数组 基于SystemArray定义数组 基于类型定义数组 数组元素的清空 SystemArray类静态成员 不用循环填充数组 数组类实例成员 SystemCollections 集合 ArrayList 实例...
  • 在C#的List集合操作过程,如果要获取List集合中第一个元素对象,则一般会先通过获取到list[0]这种方式来获取第一个元素。其实在List集合中提供了获取最后一元素的First()方法,调用此方法可直接获取List集合中...
  • 使用LINQ to SQL (第一部分) 【原文地址】Using LINQ to SQL (Part 1) 【原文发表日期】 Saturday, May 19, 2007 12:41 AM 在过去的几我写了一系列涵盖了VS和.NET Framework Orcas版的一些新特性的...
  • https://codedefault.com/2018/using-linq-to-get-the-last-n-elements-of-a-collection-in-csharp-application 方案 collection.Skip(Math.Max(0, ...我们也可以把它写成一个静态扩展方法,如: public s...
  • 以下的代码演示了如何使用LINQ to XML来快速创建一个xml: public static void CreateDocument() { string path = @"d:\website"; XDocument xdoc = new XDocument(new XDeclaration("1.0", "ut...
  • LINQ查询结果集 Linq System.Collections.Generic.IEnumerableT>
  • Linq

    2021-03-28 23:01:59
    Linq中提供了很多集合的扩展方法,配合Lambda能简化数据处理. 比如我们需要获取数组大于10的数 using System.Linq; int[] nums = new int[]{3,88,99,55,77,66,15,7}; IEnumerable<int> items = nums.Where(i...
  • List<int>...list1.Add(1);list1.Add(2);list1.Add(3);List<int>list2=newList<int>();list2.Add(3);list2.Add(4);list2.Add(5);//得到的结果是4,5即减去了相同的元素。List&l...
  • .NET[C#]LINQ查询List集合中所有重复的元素如何实现?(转载) 方案 var query = lst.GroupBy(x=>x) .Where(g=>g.Count()>1) .Select(y=>y.Key) .ToL...
  • 【转载】今天心情非常好,再发Linq集合、数组、Lambda、QuerySyntax 的文章 目录 1 LINQ查询结果集 1  2 System.Array 数组 1 2.1 
  • 【转载】今天心情非常好,再发Linq集合、数组、Lambda、QuerySyntax 的文章 【转载】今天心情非常好,再发Linq集合、数组、Lambda、QuerySyntax 的文章 目录 1LINQ查询结果集1 2...
  • Linq第二讲

    2016-11-19 17:02:00
    讲,来说说集合。因为linq主要用于对数据源进行查询,集合是最常见的数据源。 集合 形式: 数组,列表List<T> Arraylist等。 特点: 可通过索引或键访问。可进行foreach循环。可通过属性获取成员...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 10,430
精华内容 4,172
关键字:

linq获取集合中第一个