那天有个小孩跟我说LINQ（二）转载

最新推荐文章于 2024-11-14 12:03:10 发布
最新推荐文章于 2024-11-14 12:03:10 发布
阅读量69 收藏
点赞数
文章标签： 数据结构与算法 数据库
原文链接：http://www.cnblogs.com/kloseking/p/3168029.html
版权

1  LINQ TO Objects续(代码下载)

     新建项目 linq_Ch2控制台程序，新建一个Entity文件夹

   1.1 学生成绩查询（练习Join）

        有三张表如下：学生表，班级表，成绩表。接下来我们按照这个在Entity文件夹建立3个实体类，类名跟表名一样。

image

 
    public class StudentInfo
    {
        /// <summary>
        /// 学生编号
        /// </summary>
        public int StuId { get; set; }

        /// <summary>
        /// 学生姓名
        /// </summary>
        public string StuName { get; set; }

        /// <summary>
        /// 班级ID
        /// </summary>
        public int ClassId { get; set; }

        /// <summary>
        /// 班级
        /// </summary>
        public ClassRoom Classrooms { get; set; }
    }

 

  
    public class Classroom
    {
        /// <summary>
        /// 班级Id
        /// </summary>
        public int ClassId { get; set; }

        /// <summary>
        /// 班级名称
        /// </summary>
        public string ClassName { get; set; }
    }
    public class Score
    {
        /// <summary>
        /// 分数Id
        /// </summary>
        public int ScoreId { get; set; }

        /// <summary>
        /// 学科名称
        /// </summary>
        public string ItemName { get; set; }

        /// <summary>
        /// 学生ID
        /// </summary>
        public int StuId { get; set; }

        /// <summary>
        /// 学生
        /// </summary>
        public Student Students { get; set; }

        /// <summary>
        /// 分数
        /// </summary>
        public double Scores { get; set; }
    }

 

如上，3个实体类创建好了

①查询出       学生名 学科  分数  3列信息

   首先我们初始化一点数据，在void main方法中写

List<Student> students = new List<Student> { 
                 new Student{StuId=1,StuName="钱一",ClassId=1},
                 new Student{StuId=2,StuName="赵二",ClassId=1},
                 new Student{StuId=3,StuName="张三",ClassId=2},
                 new Student{StuId=4,StuName="李四",ClassId=1},
                 new Student{StuId=5,StuName="王五",ClassId=3},
                 new Student{StuId=6,StuName="陈六",ClassId=2},
                 new Student{StuId=7,StuName="田七",ClassId=3}

              };

            List<Score> scores = new List<Score> { 
                 new Score{ScoreId=1,ItemName="语文",StuId=1,Scores=56},
                 new Score{ScoreId=2,ItemName="语文",StuId=2,Scores=65},
                 new Score{ScoreId=3,ItemName="语文",StuId=3,Scores=37},
                 new Score{ScoreId=4,ItemName="数学",StuId=1,Scores=33},
                 new Score{ScoreId=5,ItemName="数学",StuId=2,Scores=77},
                 new Score{ScoreId=6,ItemName="数学",StuId=3,Scores=84},
                 new Score{ScoreId=7,ItemName="英语",StuId=1,Scores=133},
                 new Score{ScoreId=8,ItemName="英语",StuId=2,Scores=53},
                 new Score{ScoreId=9,ItemName="英语",StuId=3,Scores=42},
                 new Score{ScoreId=10,ItemName="英语",StuId=4,Scores=33},
                 new Score{ScoreId=11,ItemName="数学",StuId=7,Scores=127}

            };

            List<ClassRoom> classrooms = new List<ClassRoom> { 
                 new ClassRoom{ClassId=1,ClassName="高三（1）班"},
                 new ClassRoom{ClassId=2,ClassName="高三（2）班"},
                 new ClassRoom{ClassId=3,ClassName="高三（3）班"}

             };

 

开始查询，用集合.Join(另一个集合，第一个集合的条件列，第二个集合的条件列，怎么处理（一个方法）)

            //学生名 学科  分数
            var query1 = students.Join(
                scores,                         //另一个集合
                stu => stu.StuId,         //建立关系stu.StuId=sc.StuId
                sc => sc.StuId,
                (s, sc) => new
                {           
                    //选出要的数据
                    学生姓名 = s.StuName,
                    学科 = sc.ItemName,
                    分数 = sc.Scores
                }
                );

            Console.WriteLine("学生姓名\t学科\t\t分数");

            foreach (var stu in query1)
            {
                Console.WriteLine(string.Format("{0}\t\t{1}\t\t{2}", stu.学生姓名, stu.学科, stu.分数));
            }

            Console.ReadKey();

 

效果图

 

 

第二种方式：

            var query2 = from a in students
                         join b in scores
                         on a.StuId equals b.StuId
                         select new
                         {
                              学生姓名 = a.StuName,
                              学科 = b.ItemName,
                              分数 = b.Scores
                          };

            Console.WriteLine("方式二");
            Console.WriteLine("学生姓名\t学科\t\t分数");

            foreach (var stu in query2)
            {
                Console.WriteLine(string.Format("{0}\t\t{1}\t\t{2}", stu.学生姓名, stu.学科, stu.分数));
            }

            Console.ReadKey();

 

②算学生的总分，查出 学生名  总分

// 学生名  总分（如果分数表找不到，就算0分）
            var query3 = from c in query2
                         group c by c.学生姓名 into stuInfo
                         select new
                        {
                           学生姓名 = stuInfo.Key,
                           学生总分 = stuInfo.Sum(x => x.分数)
                        };

            Console.WriteLine("求总分的案例");
            Console.WriteLine("学生姓名\t总分");

            foreach (var stu in query3)
            {
                Console.WriteLine(string.Format("{0}\t\t{1}", stu.学生姓名, stu.学生总分));
            }

 

效果图：

image

 

③左查询(用join实现),DefaultIfEmpty后面括号中的参数是默认值，以students为主表，scores为副表，主表的信息全显示，副表只显示匹配学生Id相同的。

  （如果分数表找不到，就算0分）

Console.WriteLine("左查询方式");

var query5 = from a in students
　　　　　　　　join b in scores
　　　　　　　　on a.StuId equals b.StuId
　　　　　　　　into pGroup
　　　　　　　　from pItem in pGroup.DefaultIfEmpty(new Score { Scores = 0, ItemName = "没参考", StuId = a.StuId, ScoreId = 0 })
　　　　　　　　select new
　　　　　　　　{
　　　　　　　　　　学生姓名 = a.StuName,
　　　　　　　　　　学科 = pItem.ItemName,
　　　　　　　　　　分数 = pItem.Scores
　　　　　　　　};

Console.WriteLine("学生姓名\t学科\t\t分数");

foreach (var stu in query5)
{
　　Console.WriteLine(string.Format("{0}\t\t{1}\t\t{2}", stu.学生姓名, stu.学科, stu.分数));
}

Console.ReadKey();

 

image

效果图：

image

如果是数据库，则等同于SQL语句

select s.StuId,s.StuName,s.ClassID,isnull(sc.ScoreId,0),isnull(sc.itemName,'没参考 '),isnull(sc.stuID,0),isnull(sc.score,0) from dbo.Student s left join dbo.Score sc on s.StuID=sc.stuID

 

④交叉查询

效果图：

image

代码：

            Console.WriteLine("交叉查询方式");
            var query6 = from a in students
                         from b in scores
                         select new
                        {
                            学生姓名 = a.StuName,
                            学科 = b.ItemName,
                            分数 = b.Scores
                        };

            Console.WriteLine("学生姓名\t学科\t\t分数");

            foreach (var stu in query6)
            {
                Console.WriteLine(string.Format("{0}\t\t{1}\t\t{2}", stu.学生姓名, stu.学科, stu.分数));
            }

 

等同于SQL：

select * from Student,Score

 

 1.2 类型转换操作

 ①将数据源转换为IEnumerable<T>类型，使用AsEnumerable<T>方法

image

 ②将数据源转换为IQueryable<T>类型，使用AsQueryable<T>方法，用法同上

③将数据源转换成字典类型

   代码如下：

     //转换成Dictionary
　　  Dictionary<int, Student> query9 = students.ToDictionary(i => i.StuId);
　　  Console.WriteLine(query9[0].StuName);

 

 ④使用Enumerable类的Cast方法，该方法将非泛型的IEnumerable类型转换为泛型的IEnumerable<T>，至于转换成何种类型有Cast方法的TResult参数指定。

    例如：

   ArrayList arrList = new ArrayList();
　　for (int i = 0; i < 100; i++)
　　{
　　　　arrList.Add(i.ToString());
　　}

　　var query10 = from i in arrList.Cast<string>()
　　　　　　　　　　where i.IndexOf("0") > -1
　　　　　　　　　　select i;

　　foreach (var item in query10)
　　{
　　　　Console.Write(item+",");
　　}
　　Console.WriteLine();

 

效果图：

image

  ⑤使用 OfType<T> 筛选指定类型的元素

    代码如下：

　　//OfType<T>
　　ArrayList arrList2 = new ArrayList();
　　arrList2.Add(1);
　　arrList2.Add("茗洋");
　　arrList2.Add("A");
　　arrList2.Add(3);
　　arrList2.Add("dd");

　　var query11=from item in arrList2.OfType<string>()
　　　　　　　　　　select item;

　　foreach (var item in query11)
　　{
　　　　Console.Write(item+",");
　　}
　　Console.WriteLine();

 

效果图：

image

⑥将数据源转换为List<T>类型，使用ToList<T>()方法，用法同IQueryable<T>

⑦将数据源转换为数组类型，使用ToArray()方法，用法同IQueryable<T>

⑧转换为一对多的字典Lookup<TKey,TSource>，与Dictionary区别就是 相同key会对应多个值

   下面我们 把班级作为key列出来，然后列出班级里面的学生

 

var query12 = from o in students
　　　　　　　　join c in classrooms
　　　　　　　　on o.ClassId equals c.ClassId
　　　　　　　　select new Student
　　　　　　　　{
　　　　　　　　　　StuId = o.StuId,
　　　　　　　　　　StuName = o.StuName,
　　　　　　　　　　ClassId = o.ClassId,
　　　　　　　　　　Classrooms = new ClassRoom{
　　　　　　　　　　　　ClassId = c.ClassId,
　　　　　　　　　　　　ClassName = c.ClassName
　　　　　　　　　　}
　　　　　　　  };

            ILookup<string, Student> query13 = query12.ToLookup(f => f.Classrooms.ClassName);

            foreach (var item in query13)
            {
                Console.WriteLine(item.Key + "的学生如下");
                foreach (var stu in item)
                {
                    Console.Write(stu.StuName + ",");
                }
                Console.WriteLine();
            }

 

效果图如下

image

1.3 操作集合

  1. 使用字符串的 EndsWith或者StartsWith过滤，使用CompareTo比较字符串的大小（）

       例如：找出以“张”开头的学生姓名

//StartWith
var query14 = from o in query2
　　　　　　　　where o.学生姓名.StartsWith("张")
　　　　　　　　select o;

foreach (var item in query14)
{
　　Console.Write(item.学生姓名+",");
}

Console.WriteLine();

 

效果图：

image

其中query2可以是 很多，例如List<T>,string[],IQueryable<T>等

 

  2. 操作泛型作排序列表SortList<TKey,TValue>

        SortList<TKey,TValue>表示按照键进行排序的键/值对的集合，键/值对是KeyValuePair<TKey,TValue>

       

//SortList
SortedList<int, Student> users = new SortedList<int, Student>
{
　　{2,new Student{StuId=2,StuName="钱一",ClassId=1}},
　　{12,new Student{StuId=12,StuName="赵二",ClassId=1}},
　　{1,new Student{StuId=1,StuName="张三",ClassId=2}},
};

Console.WriteLine("未按学生姓名排序前的结果如下：");

foreach (var item in users)
{
　　Console.Write("     键" + item.Key + "：" + item.Value.StuName);
}

var query15 = from s in users
　　　　　　　　orderby s.Value.StuName descending
　　　　　　　　select s;

Console.WriteLine();

Console.WriteLine("按学生姓名排序后的结果如下：");

foreach (var item in query15)
{
　　Console.Write("     键" + item.Key + "：" + item.Value.StuName);
}

Console.ReadKey();

效果图

image

  3. 操作泛型双向链表LinkedList<T>

       泛型双向列表LinkedList<T>表示由T指定类型的双向链表，它通过当前元素可以直接访问该元素的前一个或者后一个元素（如果不存在返回空），元素为LinkedListNode<T>类型

image

效果图：

image

代码：

　　Console.WriteLine();

　　//LinkedList
　　LinkedList<int> ints2 = new LinkedList<int>();
　　ints2.AddFirst(0);

　　for (int i = 1; i < 10; i++)
　　{
　　　　ints2.AddAfter(ints2.Find(i - 1), i);
　　}

　　//使用Linq过滤，排序泛型双向链表
　　var query16 = from item in ints2
　　　　　　　　　　where item > 0 && item < 9
　　　　　　　　　　orderby item descending
　　　　　　　　　　select item;
　　//显示结果
　　foreach (var item in query16)
　　{
　　　　Console.Write(item.ToString() + ",");
　　}

 

另一种方式：

　　Console.WriteLine();
　　var query17 = ints2.Where(x => x > 0 && x < 9).OrderByDescending(x => x);
　　//显示结果
　　foreach (var item in query17)
　　{
　　　　Console.Write(item.ToString() + ",");
　　}

 

  4. 操作泛型队列Queue<T>

        先进先出的线性表，使用Enqueue方法进行元素入队（添加）操作，使用Dequeue方法进行元素出队（删除）操作；使用Clear方法进行清空队列 操作。Queue类没有实现IEnumerable<T>接口或IEnumerable接口，所以不能使用LINQ直接操作Queue类型的 对象，可以使用Queue对象的Cast方法先把它转换为IEnumerable<T>类型，然后在使用LINQ对齐操作

　　Console.WriteLine();
　　Queue<Student> queues = new Queue<Student>();
　　queues.Enqueue(new Student { StuId=11,StuName="大一",ClassId=1});
　　queues.Enqueue(new Student { StuId = 2, StuName = "大二", ClassId = 1 });
　　queues.Enqueue(new Student { StuId = 34, StuName = "大三", ClassId = 2 });
　　queues.Enqueue(new Student { StuId = 4, StuName = "大四", ClassId = 1 });
　　var query18 = queues.OrderByDescending(x=>x.StuId);

　　//显示结果
　　foreach (var item in query18)
　　{
　　　　Console.Write(item.StuName + ",");
　　}

 

效果图：image

如果是Queue先转换成IEnumerable<T>，在LINQ操作

 5. 操作泛型堆栈Stack<T>

      后进先 出的线性表，使用Push方法进行元素入栈（添加）操作，使用Dequeue方法进行元素出栈（删除）操作；使用Clear方法进行清空堆栈操作。 Stack类没有实现IEnumerable<T>接口或IEnumerable接口，所以不能使用LINQ直接操作Queue类型的对象， 可以使用Stack对象的Cast方法先把它转换为IEnumerable<T>类型，然后在使用LINQ对齐操作

效果图：image

代码：

　　Console.WriteLine();
　　Stack<Student> stacks = new Stack<Student>();
　　stacks.Push(new Student { StuId = 11, StuName = "大一", ClassId = 1 });
　　stacks.Push(new Student { StuId = 2, StuName = "大二", ClassId = 1 });
　　stacks.Push(new Student { StuId = 34, StuName = "大三", ClassId = 2 });
　　stacks.Push(new Student { StuId = 4, StuName = "大四", ClassId = 1 });
　　var query19 = from s in stacks
　　　　　　　　　　where s.ClassId != 1 || s.StuId!=2
　　　　　　　　　　select s;

　　//显示结果
　　foreach (var item in query19)
　　{
　　　　Console.Write(item.StuName + ",");
　　}

 

 6. 操作泛型哈希集HashSet<T>

      后泛型哈希集HashSet<T>是由T指定类型的基于集合的模型，泛型哈希集可以提供高性能的如并集，交集，补集等集合运算。泛型哈希集中的元素不能重复。泛型哈希集提供许多集合操作，如并集，交集，补集等。

      代码：

　　/*HashSet*/
　　Console.WriteLine();
　　HashSet<Student> hashsets = new HashSet<Student> { 
　　　　new Student{StuId=1,StuName="钱一",ClassId=1},
　　　　new Student{StuId=2,StuName="赵二",ClassId=1},
　　　　new Student{StuId=3,StuName="张三",ClassId=2},
　　　　new Student{StuId=4,StuName="李四",ClassId=1},
　　　　new Student{StuId=5,StuName="王五",ClassId=3},
　　　　new Student{StuId=6,StuName="陈六",ClassId=2},
　　　　new Student{StuId=7,StuName="田七",ClassId=3}
　　};

　　hashsets.Add(new Student { StuId = 11, StuName = "大一", ClassId = 1 });
　　//先按班级升序排序，再按姓名降序
　　var query20 = from s in hashsets
　　　　　　　　　　orderby s.ClassId ascending, s.StuName descending
　　　　　　　　　　select s;

　　//显示结果
　　foreach (var item in query20)
　　{
　　　　Console.Write(item.StuName + ",");
　　}

 

效果图：image

   7. 操作泛型字典Dictionary<TKey,TValue> 

       键不能重复，值可重复，键不会自动排序

       代码：query9是一个Dictionary类型的

　　Console.WriteLine();
　　var query21 = from o in query9
　　　　　　　　　　where o.Value.StuName.CompareTo("张") > 0 //学生姓名大于“张”
　　　　　　　　　　orderby o.Key
　　　　　　　　　　select o;

　　foreach (var item in query21)
　　{
　　　　Console.WriteLine(item.Key + ":"+item.Value.StuName);
　　}

 

效果图：

image

    8. 操作泛型排序字典SortedDictionary<TKey,TValue> 

         与Dictionary<TKey,TValue>的区别：泛型排序字典对添加的元素自动按键进行排序,代码例如：SortDictionary<int,Student> c=new SortDictionary<int,Student>{…….}

   9. 操作泛型通用集合Collection<T>,跟List<T>一样用就行了

   10. 操作泛型绑定列表 BindingList<T>

           泛型绑定列表BindingList<T>能够提供支持数据绑定的泛型集合，他提供了IBindingList接口的具体泛型实现，可以用作创建双向数据绑定机制的积累，还可以通过AddNew方法支持创建实例

跟List<T>一样用就行了

 

 

关于还剩一点linq to objects明天写，顺便带点Linq to SQL

转载于:https://www.cnblogs.com/kloseking/p/3168029.html

weixin_30263277
关注
那天有个小孩跟我说Linq （一）代码
04-02
在LINQ中，有三个核心概念：查询表达式、扩展方法和匿名类型。查询表达式是用类似SQL的语法编写在C#或VB代码中的，这使得查询更加直观易读。例如： ```csharp var query = from item in collection where item....
那天有个小孩跟我说Linq （二）
04-03
在LINQ（Language Integrated Query，语言集成查询）的第二部分中，我们将...在"那天有个小孩跟我说Linq （二）"的压缩包文件`linq_Ch2`中，可能包含了更多关于LINQ查询的实际示例和详细解释，建议你下载并仔细研究。
那天有个小孩跟我说Linq （四）
04-07
标题中的“那天有个小孩跟我说Linq（四）”暗示了这是一个关于LINQ（Language Integrated Query，语言集成查询）的系列教程的一部分，可能是作者与他人交流后的学习笔记或讲解。LINQ是.NET框架中的一项功能，它允许...
那天有个小孩跟我说Linq （三）
04-04
在“那天有个小孩跟我说Linq （三）”的学习过程中，你可能会接触到更高级的LINQ特性和技巧，比如使用`Join()`进行连接查询，使用`SelectMany()`处理嵌套集合，或者结合`async/await`关键字进行异步查询。...
为什么说LINQ要胜过SQL
02-01
流行的说法是LINQ同 C#(或者VB)集成在了一起，故而消除了编程语言和数据库之间...如果你还没有沉溺于LINQ，就会想这有啥大惊小怪的。SQL并没有坏掉，为什么还要对它进行修补呢? 为什么我们还需要另外一种查询语言呢?
动态规划习题其七【力扣】【算法学习day.29】
2301_79232523的博客
11-11 331
##我做这类文档一个重要的目的还是给正在学习的大家提供方向（例如想要掌握基础用法，该刷哪些题？）我的解析也不会做的非常详细，只会提供思路和一些关键点，力扣上的大佬们的题解质量是非常非常高滴！！！
Leetcode 3352. Count K-Reducible Numbers Less Than N
codename_cys的博客
11-11 677
Leetcode 3352. Count K-Reducible Numbers Less Than N
gbase8s数据库常见的连接算法
wangyx01的博客
11-13 178
外表指针指向第一条数据，内表指针顺序移动，找到和外表匹配项，记录，内表循环结束后外边指针继续向下移动，一直到外表循环结束为止。hash 连接中只有极少量的随机读，大部分都为顺序读，极大缓解了大量随机读的压力。有则取捅中进行匹配（若捅中有多条数据则发生hash碰撞），没有则继续匹配下一。hash 连接避免了嵌套循环的大量的随机读，简单伪代码如下。在gbase8s 中 ，常见的连接算法主要分为如下几种。细分可分为索引嵌套循环，块嵌套循环，半嵌套循环等。嵌套循环的缺点，在大量数据下会发生大量的随机读。
OJ08题：876. 链表的中间结点
吴先生的博客
11-12 361
过程简单，这题主要在于我们怎样让循环停下来，我们来分析一下：我们先来看一下有奇数个节点：我们可以看到，当slow指向中间节点的时候fast->next = NULL,这时候循环结束有偶数个节点：这个时候当slow指向中间节点的时候，fast指向NULL；对这两种情况分析我们知道，当fast指向NULL或fast->next=NULL时，循环结束，此时，slow指向的节点为中间节点，
LeetCode 216-组合总数Ⅲ
qq_45801839的博客
11-11 265
【代码】LeetCode 216-组合总数Ⅲ。
渐进最优 (asymptotically optimal)
天天向上的专栏
11-13 249
渐进最优 (asymptotically optimal) 这个名词看到很多次了，在这篇博客总结一下这个概念。一个算法的复杂度，在输入值无限大时，与已知的最优算法的复杂度相比（相除），为一个常数，则该算法为渐进最优算法。的极限存在（若存在，极限值为1），则该算法为渐进最优算法。为输入值的大小，当前算法的运行时间为。，而堆排序与归并排序的算法复杂度都是。例如，最优的排序算法的复杂度为。若最优算法的运行时间下界为。，因此这两个算法为渐进最优。
C++ STL -- 模版
最新发布
无限大的博客
11-14 1005
在C++编程中，对于不同数据类型的操作，常常需要编写多个相似的函数。例如，在一个项目中，我们可能需要实现一个加法功能。
leetcode206. Reverse Linked List
weixin_44245188的博客
11-10 248
考虑使用递归法遍历链表，当越过尾节点后终止递归，在回溯时修改各节点的 next 引用指向。给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。输入：head = [1,2,3,4,5]输出：[5,4,3,2,1]
详解二叉树(上)---堆
shsbyshdbdhjsk的博客
11-13 739
树的概念，二叉树的概念和性质结构，堆的概念和实现
5.3.4 实战 - Shell采集数据按日期上传到HDFS
howard2005的专栏
11-11 148
本实战项目涉及使用Shell脚本将日志数据按日期上传至HDFS。首先，配置必要的环境变量以确保脚本能在无环境变量的机器上运行。接着，设置日志存放目录和待上传文件目录，以便监控上传进度。定义HDFS目标路径，并格式化日期。脚本遍历日志文件，将它们移动到待上传目录，并记录于列表文件中。然后，从列表文件中读取文件路径，上传至HDFS，并更新文件状态。最后，通过执行脚本、查看目录和Hadoop WebUI来验证上传结果。这一流程自动化了数据上传，提高了数据处理的效率和可靠性。
每日算法一练：剑指offer——字符串篇（3）
m0_53926113的博客
11-11 1040
将前面步骤读入的这些数字转换为整数（即，"123" -> 123， "0032" -> 32）。第 2 步："4193 with words"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）由于 "4193" 在范围 [-231, 231 - 1] 内，最终结果为 4193。读入下一个字符，直到到达下一个非数字字符或到达输入的结尾。由于 "-42" 在范围 [-231, 231 - 1] 内，最终结果为 -42。第 2 步："42"（当前没有读入字符，因为这里不存在 '-' 或者 '+'）
Leetcode 3351. Sum of Good Subsequences
codename_cys的博客
11-11 409
Leetcode 3351. Sum of Good Subsequences
LeetCode 56.合并区间
m0_58087746的博客
11-10 221
2024.11.10 持续进步（贪心算法）
[2024最新] java八股文实用版（附带原理）---java基础篇
indexqian的博客
11-13 501
短时间想要快速提升面试能力，新手必备八股文
使用LINQ高效计算多个Sum的方法
总结来说，这个例子展示了如何使用LINQ一次性计算多个字段的Sum和Average，通过这种方式，我们可以减少对数据库的多次访问，提高查询效率。在处理大数据集时，这样的优化尤其重要，因为它能减少网络延迟和数据库负载...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值