C# LINQ函数的用法

最新推荐文章于 2022-09-09 23:07:49 发布
最新推荐文章于 2022-09-09 23:07:49 发布
阅读量2k 收藏 19
点赞数 2
文章标签： LINQ C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/minyi0703/article/details/82789051
版权

文章目录

一、查询过滤：where()

where() 的参数是用于过滤的条件，要求条件必须返回bool

例：

 			    var news = new[] {
                new {Name="张三",Age=19,Address="北京" },
                new {Name="李四",Age=22,Address="上海" },
                new {Name="王五",Age=34,Address="广州" },
                new {Name="赵六",Age=45,Address="杭州" },
                new {Name="孙琦",Age=25,Address="深圳" },
                new {Name="钱玖",Age=45,Address="成都" },
            };
            var list1 = news.Where(i=>i.Age>20 && i.Address=="深圳");
            foreach (var item in list1)
            {
                Console.WriteLine("Name:{0},Age:{1},Address:{2}",item.Name,item.Age,item.Address);
            }

结果：

Name:孙琦,Age:25,Address:深圳

二、选取数据：Select()、SelectMany()

1.select()*

返回一个对象，对数据进行选取或重新组装

例：

			    var news = new[] {
                new {Name="张三",Age=19,Address="北京" },
                new {Name="李四",Age=22,Address="上海" },
                new {Name="王五",Age=34,Address="广州" },
                new {Name="赵六",Age=45,Address="杭州" },
                new {Name="孙琦",Age=25,Address="深圳" },
                new {Name="钱玖",Age=45,Address="成都" },
            };
             var list1 = news.Select(i=>new {name=i.Name,age=i.Age });
            foreach (var item in list1)
            {
                Console.WriteLine("Name:{0},Age:{1}", item.name, item.age);
            }

结果：

Name:张三,Age:19
Name:李四,Age:22
Name:王五,Age:34
Name:赵六,Age:45
Name:孙琦,Age:25
Name:钱玖,Age:45
2. SelectMany()

类似于数据库的CROSS JOIN ,参考以下例子

例:

	List<int> list1 = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            List<int> list2 = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
            var query = list1.SelectMany(i => list2, (x, y) => new { result = "" + y + "*" + x + "=" + x * y + "" });
            string str = string.Empty;
            foreach (var item in query)
            {
                if (item.result == "9*1=9" || item.result == "9*2=18" ||
                    item.result == "9*3=27" || item.result == "9*4=36" ||
                    item.result == "9*5=45" || item.result == "9*6=54" ||
                    item.result == "9*7=63" || item.result == "9*8=72")
                {
                    str +=item.result+"\n";
                }
                else
                {
                    str += item.result + "\t";
                }
            }
            string[] array = str.Split('\n');
            for (int i = 0; i < array.Length; i++)
            {
                if (i < 3)
                { array[i] = array[i].Substring(0, ((i + 1) * 6)); }
                else if (i > 3)
                { array[i] = array[i].Substring(0, ((i + 1) * 6 + i)); }
                else
                 { array[i] = array[i].Substring(0, ((i + 1) * 6 +2)); } 

                Console.WriteLine(array[i]);
            }

结果：

1*1=1
1*2=2   2*2=4
1*3=3   2*3=6   3*3=9
1*4=4   2*4=8   3*4=12  4*4=16
1*5=5   2*5=10  3*5=15  4*5=20  5*5=25
1*6=6   2*6=12  3*6=18  4*6=24  5*6=30  6*6=36
1*7=7   2*7=14  3*7=21  4*7=28  5*7=35  6*7=42  7*7=49
1*8=8   2*8=16  3*8=24  4*8=32  5*8=40  6*8=48  7*8=56  8*8=64
1*9=9   2*9=18  3*9=27  4*9=36  5*9=45  6*9=54  7*9=63  8*9=72  9*9=81

三、联接查询：Join()、GroupJoin()

1.Join()

数据1.Join(数据2,数据1.key,数据2.key,查询结果)

例:

		   var list1 = new[]  {
                new {id=1,Name="Jack"},
                new {id=2,Name="Wiseman" },
                new {id=3,Name="Witt"},
                new {id=4,Name="Wolf" }
            };
            var list2 = new[] {
                new { id=2,Name="Woodrow"},
                new {id=3,Name="Wooten" },
                new {id=5,Name="Hays" },
                new {id=8,Name="Hayley" }
            };

            var query = list1.Join(list2, item1 => item1.id, item2 => item2.id, (item1, item2) => new { item1, item2 });
            foreach (var item in query)
            {
                Console.WriteLine("List1----ID:{0},Name:{1}", item.item1.id, item.item1.Name);
                Console.WriteLine("List2----ID:{0},Name:{1}\n", item.item1.id, item.item2.Name);
            }

结果:

List1----ID:2,Name:Wiseman
List2----ID:2,Name:Woodrow

List1----ID:3,Name:Witt
List2----ID:3,Name:Wooten
GroupJoin()

同上,返回数据1的所有元素和根据数据1的key获取的数据2的元素集合,具体请参考以下例子

例：

		    var list1 = new[] {
                new {ID=1,Name="张老师" },
                new {ID=2,Name="李老师" },
                new {ID=3,Name="周老师" },
                new {ID=4,Name="王老师" }
            };
            var list2 = new[] {
                new {ID=1,Subject="C#" },
                new {ID=2,Subject="Java" },
                new {ID=3,Subject="lua" },
                new {ID=1,Subject="javacirpt" },
                new {ID=2,Subject="C" },
                new {ID=4,Subject="C++" },
                new {ID=5,Subject="python" },
                new {ID=4,Subject="php" },
                new {ID=6,Subject="html" }
            };
            Console.WriteLine("-------查询所有老师教的课程-------\n\n");
            var query =  list1.GroupJoin(list2,item1=>item1.ID,item2=>item2.ID,(item1,item2)=>new {item1,item2});
            foreach (var item in query)
            {
                Console.WriteLine("{0}教{1}门课程,其中有{2}\n",item.item1.Name,item.item2.Count(),
                string.Join("、",item.item2.Select(i=>i.Subject)));
            }
            //或者这样写，结果一样：
            Console.WriteLine("--------------------------\n");
            var query2 = list1.GroupJoin(list2, item1 => item1.ID, item2 => item2.ID, (item1, item2) =>
            new { t = item1.Name, c = item2.Count(), s = string.Join("、", item2.Select(i => i.Subject)) });
            foreach (var item in query2)
            {
                Console.WriteLine("{0}教{1}门课程,其中有{2}\n", item.t, item.c, item.s);
            }

            Console.WriteLine("\n-------查询没有老师教的课程-------\n\n");
            var query3 = list2.GroupJoin(list1, item2 => item2.ID, item1 => item1.ID, 
            (item2, item1) => new {s=item1.Count()==0?item2.Subject:null});
            string str = string.Empty;
            foreach (var item in query3)
            {
                if (item.s != null)
                {
                    str += item.s + ",";
                }
            }
            Console.WriteLine("目前没有老师教的课程有:{0}\n\n",str.Substring(0,str.Length-1));

结果：

-------查询所有老师教的课程-------


张老师教2门课程,其中有C#、javacirpt

李老师教2门课程,其中有Java、C

周老师教1门课程,其中有lua

王老师教2门课程,其中有C++、php

--------------------------

张老师教2门课程,其中有C#、javacirpt

李老师教2门课程,其中有Java、C

周老师教1门课程,其中有lua

王老师教2门课程,其中有C++、php


-------查询没有老师教的课程-------


目前没有老师教的课程有:python,html

四、分组查询：GroupBy()、ToLookup()

都是根据传入的参数对key进行分组,区别在于GroupBy() 是延迟查询，ToLookup() 不是。

1.GroupBy() 延迟加载

例：

 var news = new[] {
                new {Name="张三",Age=19,Address="上海" },
                new {Name="李四",Age=22,Address="上海" },
                new {Name="王五",Age=34,Address="广州" },
                new {Name="赵六",Age=45,Address="广州" },
                new {Name="孙琦",Age=25,Address="深圳" },
                new {Name="钱玖",Age=45,Address="深圳" },
                new {Name="黄菲",Age=45,Address="北京" }
            };
            var list1 = news.GroupBy(i=>i.Address);
            //修改数组最后一条数据
            news[6] = new { Name = "黄菲", Age = 45, Address = "上海" };
            var list2 = news.GroupBy(i => i.Address);
            Console.WriteLine("-----------list1-----------\n\n");
            foreach (var item in list1)
            {
                Console.WriteLine("\n---------Address:{0}---------\n", item.Key);
                foreach (var item1 in item)
                {
                    Console.WriteLine("Name:{0},Age:{1}", item1.Name, item1.Age);
                }
            }
            Console.WriteLine("\n\n-----------list2-----------\n\n");
            foreach (var item in list2)
            {
                Console.WriteLine("\n---------Address:{0}---------\n", item.Key);
                foreach (var item1 in item)
                {
                    Console.WriteLine("Name:{0},Age:{1}", item1.Name, item1.Age);
                }
            }

结果：

---------------list1---------------

---------Address:上海---------

Name:张三,Age:19
Name:李四,Age:22
Name:黄菲,Age:45

---------Address:广州---------

Name:王五,Age:34
Name:赵六,Age:45

---------Address:深圳---------

Name:孙琦,Age:25
Name:钱玖,Age:45




---------------list2---------------


---------Address:上海---------

Name:张三,Age:19
Name:李四,Age:22
Name:黄菲,Age:45

---------Address:广州---------

Name:王五,Age:34
Name:赵六,Age:45

---------Address:深圳---------

Name:孙琦,Age:25
Name:钱玖,Age:45
2.ToLookUp()立即加载

例：

将上面代码中的GroupBy 改为 ToLookup

结果：

---------------list1---------------



---------Address:上海---------

Name:张三,Age:19
Name:李四,Age:22

---------Address:广州---------

Name:王五,Age:34
Name:赵六,Age:45

---------Address:深圳---------

Name:孙琦,Age:25
Name:钱玖,Age:45

---------Address:北京---------

Name:黄菲,Age:45



---------------list2---------------



---------Address:上海---------

Name:张三,Age:19
Name:李四,Age:22
Name:黄菲,Age:45

---------Address:广州---------

Name:王五,Age:34
Name:赵六,Age:45

---------Address:深圳---------

Name:孙琦,Age:25
Name:钱玖,Age:45

五、数据排序：OrderBy()、OrderByDescending()、ThenBy()、THenByDescending()

OrderBy()：

根据传入参数对数据源排序(升序)

OrderByDescending()：

与Orderby() 相同，做反向排序(降序)

ThenBy()：

用于多重排序,与OrderBy() 组合,使用于OrderBy() 之后。

THenByDescending()：

同上

例：

 var list2 = new[] {
                new {ID=1,Subject="C#" },
                new {ID=2,Subject="Java" },
                new {ID=3,Subject="lua" },
                new {ID=1,Subject="javacirpt" },
                new {ID=2,Subject="C" },
                new {ID=4,Subject="C++" },
                new {ID=5,Subject="python" },
                new {ID=4,Subject="php" },
                new {ID=6,Subject="html" }
            };
            
    Console.WriteLine("---------Orderby()、ThenBy()---------\n\n");
          var query4 =list2.OrderBy(i=>i.ID).ThenBy(i=>i.Subject);
            foreach (var item in query4)
            {
                Console.WriteLine(item);
            }
            Console.WriteLine("\n\n---------OrderByDescending()、ThenByDescending()---------\n\n");
            var query5 = list2.OrderByDescending(i => i.ID).ThenByDescending(i => i.Subject);
            foreach (var item in query5)
            {
                Console.WriteLine(item);
            }

结果：

---------Orderby()、ThenBy()---------


{ ID = 1, Subject = C# }
{ ID = 1, Subject = javacirpt }
{ ID = 2, Subject = C }
{ ID = 2, Subject = Java }
{ ID = 3, Subject = lua }
{ ID = 4, Subject = C++ }
{ ID = 4, Subject = php }
{ ID = 5, Subject = python }
{ ID = 6, Subject = html }


---------OrderByDescending()、ThenByDescending()---------


{ ID = 6, Subject = html }
{ ID = 5, Subject = python }
{ ID = 4, Subject = php }
{ ID = 4, Subject = C++ }
{ ID = 3, Subject = lua }
{ ID = 2, Subject = Java }
{ ID = 2, Subject = C }
{ ID = 1, Subject = javacirpt }
{ ID = 1, Subject = C# }

六、集合划分：Take()、Skip()、TakeWhile()、SkipWhile()

Skip()：

跳过指定的元素数量，返回剩余元素

例：

 var list = new[] { 1,2,3,4,5,6,7,8};
            var query = list.Skip(2);

            Console.WriteLine("-------------Skip-------------");
            foreach (var item in query)
            {
                Console.WriteLine(item);
            }

结果：

-------------Skip-------------
3
4
5
6
7
8
SkipWhile()：

跳过满足条件的元素，返回剩余元素
注：当第一次检测到条件为false时，将不在检测，直接返回剩余所有元素

例：

    var list = new[] { 1,2,3,4,5,6,7,8};
    Console.WriteLine("-------------SkipWhile>>1-------------");
            var query2 = list.SkipWhile(x => x <= 5);
            foreach (var item in query2)
            {
                Console.WriteLine(item);
            }
            //1==5 为false(不满足条件)，将返回1(包括1)后面的所有元素
            Console.WriteLine("-------------SkipWhile>>2-------------");
            var query5 = list.SkipWhile(x => x >= 5);
            foreach (var item in query5)
            {
                Console.WriteLine(item);
            }

结果：

-------------SkipWhile>>1-------------
6
7
8
-------------SkipWhile>>2-------------
1
2
3
4
5
6
7
8
Take()：

返回指定数量的元素

例：

  var list = new[] { 1,2,3,4,5,6,7,8};
            var query = list.Take(5);

            Console.WriteLine("-------------Take-------------");
            foreach (var item in query)
            {
                Console.WriteLine(item);
            }

结果：

-------------Take-------------
1
2
3
4
5
TakeWhile()：

返回满足条件的所有元素
注：当第一次检测到条件为false时，将不在检测，返回满足条件的元素

例1：

 var list = new[] { 1,2,3,4,5,6,7,8};
 			//由于 1>2 为false(不满足条件)，所以1 (包括1)后面的所有元素都不会返回
            var query = list.TakeWhile(i=>i>2);
            Console.WriteLine("-------------TakeWhile-------------");
            foreach (var item in query)
            {
                Console.WriteLine(item);
            }

结果：

-------------TakeWhile-------------

例2：

利用 Skip() 和 TakeWhile() 做一个简单的分页*

  var list2 = new[]{
                new { iD=1,Str="数据1"},new { iD=2,Str="数据2"},new { iD=3,Str="数据3"},
                new { iD=4,Str="数据4"},new { iD=5,Str="数据5"},new { iD=6,Str="数据6"},
                new { iD=7,Str="数据7"},new { iD=8,Str="数据8"},new { iD=9,Str="数据9"},
                new { iD=10,Str="数据10"},new { iD=11,Str="数据11"},new { iD=12,Str="数据12"},
                new { iD=13,Str="数据13"},new { iD=14,Str="数据14"},new { iD=15,Str="数据15"},
                new { iD=16,Str="数据16"},new { iD=17,Str="数据17"},new { iD=18,Str="数据18"}
            };
            Console.WriteLine();
            Console.WriteLine("----------------使用Skip()和TakeWhile()进行分页查询----------------\n\n\n");
            int sum = 0;//每页显示数量
            int page = 1;//当前页数
            Console.WriteLine("开始查詢数据，按任意键继续，按Q退出\n");
            while (Console.ReadLine().ToLower() != "q")
            {
                tag1:
                Console.WriteLine("\n输入每页显示数量：\t");

                try
                {
                    sum = int.Parse(Console.ReadLine());
                    if (sum <= 0)
                    {
                        Console.WriteLine("\n每页显示数量不得小于1！");
                        goto tag1;
                    }
                }
                catch (Exception)
                {

                    Console.WriteLine("\n输入数量有误，请重新输入！");
                    goto tag1;
                }
                int pageCount = list2.Length % sum == 0 ? (list2.Length / sum) : ((list2.Length / sum) + 1);
                tag2:
                Console.WriteLine("\n当前共" + pageCount + "页,输入跳转页数：\t");
                try
                {
                    page = int.Parse(Console.ReadLine());
                    if (sum <= 0)
                    {
                        Console.WriteLine("\n页数必须大于0！！");
                        goto tag2;
                    }
                }
                catch (Exception)
                {

                    Console.WriteLine("\n输入页数有误，请重新输入！");
                    goto tag2;
                }
                if (page > pageCount)
                {
                    Console.WriteLine("\n输入頁数超过总页数，將为你显示最后一页！");
                    page = pageCount;
                }
                    if (page < 1)
                {
                    Console.WriteLine("\n输入頁面小于1，將为你显示第一页！");
                    page = 1;
                }
                var query4 = list2.Skip(sum * (page - 1)).TakeWhile(i => i.iD <= sum * page);
                foreach (var item in query4)
                {
                    Console.WriteLine("ID：{0},\tstr：{1}", item.iD, item.Str);
                }
                Console.WriteLine("\n\n开始查询数据，按任意键继续，按Q退出!");
            }

结果：


----------------使用Skip()和TakeWhile()進行分頁查詢----------------



开始查询数据，按任意键继续，按Q退出

f

输入每页显示数量：      f

输入数量有误,请重新输入！

输入每页显示数量：      -5

每页显示数量不得小于1！

输入每页显示数量：      5

当前共4页,输入跳转页数：        f

输入頁面有误，请重新输入！

当前共4页,輸入跳转页数：        -2

输入页数小于1，将为你显示第一页！

ID：1,  str：数据1
ID：2,  str：数据2
ID：3,  str：数据3
ID：4,  str：数据4
ID：5,  str：数据5


开始查询数据，按任意键继续，按Q退出!

f

输入每页显示数量：      4

当前共5页,輸入跳转页数：        23

输入页数超过总页数，将为你显示最后一页！

ID：17, str：数据17
ID：18, str：数据18


开始查询数据，按任意键继续，按Q退出!

Q
Press any key to continue . . .

七、集合运算：Union()、Intersect()、Except()

Union()：

返回两个集合中的并集(两集合重复元素只保留一个)

例：

		    int [] array1 = new int[] {1,3,5,2,8,7,9 };
            int [] array2 = new int[] { 1,4,8,6,3,2 };
            var result=array1.Union(array2);
            Console.WriteLine("----------Union----------\n");
            foreach (var item in result)
            {
                Console.Write(item+"\t");
            }

结果：

----------Union----------

1       3       5       2       8       7       9       4       6

若要合并自定义数据类型对象集合,则需要实现 IEqualityComparer< T > 泛型接口
参考以下实例

  class News
    {
        public int ID { get; set; }
        public string Name { get; set; }
    }
    class NewsComparer : IEqualityComparer<News>
    {
     
        public bool Equals(News new1, News new2)
        {
            if (ReferenceEquals(new1, new2)) return true;
            return new1 != null && new2 != null && 
              new1.ID.Equals(new2.ID) && new1.Name.Equals(new2.Name);
        }

        public int GetHashCode(News news)
        {
            int HashName = news.Name == null ? 0 : news.Name.GetHashCode();
            int HashID = news.ID.GetHashCode();
            return HashName ^ HashID;
        }
    }
			 //-------------------------main方法----------------------
                List<News> list1 = new List<News>() {
                new News() {ID=1,Name="张三" },
                new News() {ID=2,Name="李四" },
                new News() {ID=3,Name="王五" }
            };
                List<News> list2 = new List<News>() {
                new News() {ID=4,Name="李玖" },
                new News() {ID=2,Name="李四" },
                new News() {ID=3,Name="王五" }
            };
            var query = list1.Union(list2,new NewsComparer());
            foreach (var item in query)
            {
                Console.WriteLine("ID:{0},\tName:{1}",item.ID,item.Name);
            }

结果：

ID:1,    Name:张三
ID:2,    Name:李四
ID:3,    Name:王五
ID:4,    Name:李玖
Intersect()：

返回两个集合的交集

例：

		    int [] array1 = new int[] {1,3,5,2,8,7,9 };
            int [] array2 = new int[] { 1,4,8,6,3,2 };
            var result=array1.Intersect(array2);
            Console.WriteLine("----------Inersect----------\n");
            foreach (var item in result)
            {
                Console.Write(item+"\t");
            }

结果：

----------Inersect----------

1       3       2       8

获取自定义数据类型对象集合的交集,参考 Union() 的例子

Except()：

返回两个集合的差集

例：

			int[] array1 = new int[] { 1, 3, 5, 2, 8, 7, 9 };
            int[] array2 = new int[] { 1, 4, 8, 6, 3, 2 };
            var result = array1.Except(array2);
            Console.WriteLine("----------Inersect----------\n");

结果：

----------Inersect----------

5       7       9

获取自定义数据类型对象集合的差集,参考 Union() 的例子

Distinct()：

返回集合中非重复的元素

例1：

		    int[] int1 = new int[] { 1, 2, 1, 3, 4, 4, 3, 2, 5, 6 };
            var list4 = int1.Distinct();
            foreach (var item in list4)
            {
                Console.Write(item+"\t");
            }

结果：

1       2       3       4       5       6

对自定义数据类型对象集合去重,需要实现 IEquatable< T > 泛型接口
参考以下实例

例2：

	class News : IEquatable<News>
    {
        public int ID { get; set; }
        public string Name { get; set; }
        public bool Equals(News news)
        {
            if (ReferenceEquals(news, null)) return false;
            if (ReferenceEquals(this, news)) return true;
            return ID.Equals(news.ID) && Name.Equals(news.Name);
        }

        public override int GetHashCode()
        {
            int HashName = Name == null ? 0 : Name.GetHashCode();
            int HashID = ID.GetHashCode();
            return HashName ^ HashID;
        }
    }

	//-----------------------------------------Mian函数-----------------------------------------
				List<News> list1 = new List<News>() {
                new News() {ID=1,Name="张三" },
                new News() {ID=2,Name="李四" },
                new News() {ID=3,Name="王五" },
                new News() {ID=2,Name="李四" },
                new News() {ID=3,Name="王五" }
            };
            var query =  list1.Distinct();
            foreach (var item in query)
            {
                Console.WriteLine("ID:{0}\tName:{1}",item.ID,item.Name);
            }

结果：

ID:1    Name:张三
ID:2    Name:李四
ID:3    Name:王五

八、汇总聚合：Average()、Max()、Min()、Sum()、Aggregate()、Zip()

Average()：

计算集合的平均值
只支持int 、long、double、single、deciaml 等值类型

Max()：

返回集合中的最大值
支持类型同上

Min()：

返回集合中的最小值
支持类型同上

Sum()：

计算集合的和
支持类型同上

例：

			 int [] list = new [] {4,5,6,14,3,10 };

            Console.WriteLine("平均值为:{0}\n\n",list.Average());

            Console.WriteLine("最大值为:{0}\n\n", list.Max());

            Console.WriteLine("最小值为:{0}\n\n", list.Min());

            Console.WriteLine("总和为:{0}\n\n", list.Sum());

结果：

平均值为:7


最大值为:14


最小值为:3


总和为:42
Aggregate()：

1.按照传入的条件对元素进行累计运算
2.可传入种子值作为累计计算的初始值，对返回结果进行处理
参考以下两个实例：

例1：

           //按照字符串长度排序输出
 	    	List<string> list = new List<string>() { "red", "yellow", "green", "blue", "paleturquoise", "papayawhip", "peachpuff" };
            int count = list.Count;
            for (int i = 0; i < count; i++)
            {
                string a = list.Aggregate((x, y) => x.Length > y.Length ? x : y);
                list.Remove(a);
                Console.WriteLine(a + "\n");
            }


paleturquoise

papayawhip

peachpuff

yellow

green

blue

red

例2：

		  //用输入的数对数组依次相减,若结果为 小于0 则 返回 0;
	    	  while (true)
              {
                int[] list = new int[] { 81, 55, 22, 7, 12, 18, 20 };
                tag:
                Console.WriteLine("\n请输入一個数字,输入Q退出:\n");
                int a = 0;
                dynamic d = Console.ReadLine();
                if (d == "q" || d == "Q")
                {
                    break;
                }
                try
                {
                    a = int.Parse(d);
                }
                catch (Exception)
                {

                    Console.WriteLine("\n请输入有效数字！");
                    goto tag;
                }

                int ret = list.Aggregate(a, (x, y) => x - y, (result) => result <= 0 ? 0 : result);
                Console.WriteLine("\n结果为：" + ret+"");
            }

结果：


请输入一个数字,输入Q退出:

200

结果为：0

请输入一个数字,输入Q退出:

300

结果为：85

请输入一个数字,输入Q退出:

q
Press any key to continue . . .
Zip()：

对两个集合中元素进行合并,若两集合元素数量不一致，则返回结果元素数量与元素数量少的一致(即：一个集合是4个元素，一个是3个，返回结果元素是3个)
参考以下例子

例：

		    List<int> list1 = new List<int> { 19, 20, 34, 42, 22, 14, 25 };
            List<string> list2 = new List<string> {"张三","李四","王五","赵二","牛六","周玖"};
            var result = list1.Zip(list2, (x, y) => string.Format("{0}今年{1}岁了",y,x));
            foreach (var item in result)
            {
                Console.WriteLine(item);
            }

结果：

張三今年19岁了
李四今年20岁了
王五今年34岁了
趙二今年42岁了
牛六今年22岁了
周玖今年14岁了
vae莫凌
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C#中LINQ模块常用函数介绍
sunyao1314的博客
05-13 252
用于获取序列中的最后一个元素或满足条件的最后一个元素。：用于获取序列中的第一个元素或满足条件的第一个元素。：用于对序列中的每个元素执行指定的转换操作。：用于按照指定的条件对序列中的元素进行排序。：用于检查序列中是否存在满足指定条件的元素。：用于计算序列中满足指定条件的元素个数。：根据指定的键对序列中的元素进行分组。：用于筛选序列中满足指定条件的元素。：用于计算序列中所有元素的平均值。：用于计算序列中所有元素的总和。
C#在LINQ中使用GroupBy
08-18
C#在LINQ中使用GroupBy C#中的语言集成查询（Language Integrated Query，LINQ）是一个强大的查询语言，可以对数据进行筛选、排序、分组等操作。在LINQ中，GroupBy是一个非常重要的操作，它可以将数据分组，以便更...
c# Linq之求和，平均值，最大值，最小值
橙-极纪元-cplvfx-JJY.Cheng
11-26 1213
转载：Linq之求和，平均值，最大值，最小值 - wolfy - 博客园写在前面最近一直在弄统计的内容，和统计相关的操作，就需要用到了，而有些在数据库中操作起来非常不方便，没办法就用c#中的linq来实现了。代码一个例子using System;using System.https://www.cnblogs.com/wolf-sun/p/4483134.html using System; using System.Collections.Generic; using System.Linq; ..
C# linq语法
Chengrui_404的博客
09-09 1129
博客链接：https://www.ccrui.cn/archives/c-linq-yu-fa.html。
C#4.0新特性之(四)新的LINQ扩展方法-Zip()
weixin_33828101的博客
01-07 1729
C#4.0新特性之(四)新的LINQ扩展方法-Zip() 1.简介 　　所谓zip（中文有拉链的意思），就是像拉链一样，把两个list缝合在一起。Python中有个zip函数可以用来方便的合并两个或者多个集合，例如： &gt;&gt;&gt; firstName=['Freesc','Joshua','Ken']&gt;&gt;&gt; lastName=['Huang','Guan',...
linq Group by 多表 sum 分组 .net C#
大柱子
06-16 788
var list = from a in oSC_CaiGou join b in oSC_Contractlist on a.ContractGuid equals b.Guid join c in oSC_XiangMulist on b.XiangMuGuid equals c.Guid ...
C# Linq介绍和使用
lvxingzhe3的博客
03-17 3464
C# Linq介绍和使用
C#字符串的截取函数用法总结
12-26
本文实例总结了C#常用的字符串截取函数用法。分享给大家供大家参考。具体分析如下： 在C#中字符串截取函数包括有substring 函数,Remove 函数,indexOf 函数，它们三个都可以对字符串进行截取操作，下面我们来分别介绍...
C# Linq lambda表达式.doc
11-06
在C#中，Lambda表达式是LINQ的核心部分，它用于创建匿名函数，使得我们可以更加便捷地进行过滤、查找、排序、分组等操作。 1. **过滤（Filtering）** 在C#中，我们可以使用Lambda表达式配合`Where()`方法来过滤...
C#使用LINQ中Enumerable类方法的延迟与立即执行的控制
01-01
LINQ标准查询运算法是依靠一组扩展方法来实现的。而这些扩展方法分别在System.Linq.Enumerable和System.Linq.Queryable这连个静态类中定义。 　Enumerable的扩展方法采用线性流程，每个运算法会被线性执行。这种执行...
C#中的高阶函数介绍
09-03
高阶函数在C#中的应用非常广泛，比如LINQ查询中的各种操作符（如`Select`, `Where`, `OrderBy`等）都是高阶函数的例子。它们允许我们以声明式的方式处理数据，增强了代码的可读性和可复用性。此外，C# 6.0引入的`...
LINQ基本语法及其示例
03-23
LINQ基本语法及其示例
LINQ技术详解C# 2008版.pdf（压缩包）
09-15
《LINQ技术详解C#2008版》将原理介绍与实践操作相结合，全面系统地阐述了Microsoft C# 2008中的语言集成查询（LINQ）技术的专业知识，包括其原理、功能和应用。特别对LINQ在对象、XML、数据集和SQL上的应用进行了深入分析，详细讲解了这些应用可以使用的操作符和操作符原型，并分别给出使用这些操作符的示例和说明，以便读者理解和编写自己的LINQ代码。 《LINQ技术详解C#2008版》可以为LINQ的初学者、中级用户和高级用户等不同层次的读者提供相应的信息，不仅为LINQ初学者提供入门级的知识和实例，还可以作为LINQ中高级开发人员的工具书。
c# Linq 求和，求平均值，求最大，求最小，分组，计数
橙-极纪元-cplvfx-JJY.Cheng
11-26 5276
转载：【转】Linq 求和，求平均值，求最大，求最小，分组，计数 - Uoolo - 博客园1.简单形式：var q = from p in db.Products group p by p.CategoryID into g select g;语句描述：使用Group By按Categorhttps://www.cnblogs.com/wuchao/archive/2012/12/25/2832744.html 1.简单形式： var q = from p in db.Product...
Linq Sum用法
长江学者
09-03 6091
Linq Sum用法 代码 List<MES_ProcessCompleteEntity> mpc = BaseRepository().FindList<MES_ProcessCompleteEntity>(t => t.F_OrderProcessId == keyValue).AsList(); decimal? F_Qua...
C#Linq语法
代码改变生活
12-05 749
1、 ZKWebForm1219_20171128Entities db = new ZKWebForm1219_20171128Entities(); protected void Button1_Click(object sender, EventArgs e) { //where:简单形式=================
一个Linq Group By 和Sum的范例
热门推荐
道法自然
11-12 1万+
using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.IO; namespace ConsoleApplication3 { class Program { static void Main(string[] args)
C#-LINQ的基本用法
闻风听雨的博客
08-13 1837
LINQ是什么？ LINQ是Language Integrated Query(语言集成查询的缩写),微软官方对其的描述： 语言集成查询 (LINQ) 是一系列直接将查询功能集成到 C# 语言的技术统称。 基本用法是什么？ (我目前也只会最基本的用法。。) LINQ查询操作由三个不同的操作组成： 获取数据源 创建查询 执行查询 下面我将用我学习时用的一个小例子来演示。 有两个数据源:武林高手的集合和武林绝学的集合。 我用的是两个集合,实际上不只是集合可以作为数据源 微软官方文档提到： 上例中1，数
C# LINQ的基础使用方法
m0_38143858的博客
03-10 1682
关键字 from、in、where、select、orderby、descending 例子 Linq的简单运用： 1.用Linq查询集合中所有符合条件的内容（表达式写法） var result = from temp（临时变量） in myList（要查询的集合） where temp.age&lt;35(判断条件) selecttemp.name;(表示将查询到的集合返回,tem...
c# linq ToDictionary 用法
最新发布
05-11
ToDictionary是LINQ的一个扩展方法，可以将一个集合转换为一个字典，其中集合的元素作为字典的键，而另一个函数则将每个元素映射到相应的值。以下是使用ToDictionary的基本语法： ```csharp var dict = collection....

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值