Linq和Lambda学习

故里2130

已于 2023-10-07 22:37:13 修改

阅读量1.1k

点赞数 2

分类专栏： # 基础知识文章标签： linq 学习 sql

于 2022-05-17 16:36:49 首次发布

分享的越多，得到的越多。记录的越多，忘记的越少。----故里2130

本文链接：https://blog.csdn.net/u012563853/article/details/124817451

版权

基础知识专栏收录该内容

13 篇文章 8 订阅

订阅专栏

本文通过实例详细介绍了C#中LINQ和Lambda表达式的使用，包括排序（按长度、按子字符串）、集合操作（去重、差集、交集、并集）、数据过滤（Where条件筛选）以及投影（选择子字符串、分隔字符串）。示例代码涵盖了从基础到进阶的各种应用场景，帮助读者深入理解这两种强大的查询工具。

摘要由CSDN通过智能技术生成

Linq：在数据库中，可以使用sql语句进行查询数据。在C#程序中，我们可以得到数据后，使用linq进行查询。包括LINQ to Objects、LINQ to SQL、LINQ to Datasets、LINQ to Entities、LINQ to Data Source、LINQ to XML/XSD等。

Lambda：是一个匿名函数，它可以包含表达式和语句，并且可用于创建委托或表达式目录树类型。

其实有时候，Linq和Lambda是可以替换使用，有时候使用Linq简单，有时候使用Lambda简单，这个就要根据业务来判断使用了。

sql的语法是：select * from * where *

linq的语法是 from *

where *

select *

第一部分，排列数据

数据源

var words = new[] { "the", "quick", "brown", "fox", "jumps" };

1.根据words中，字符的长度进行排序

       //1.根据words中，字符的长度进行排序
            var query1 = from word in words
                         orderby word.Length
                         select word;

            foreach (var word in query1)
            {
                Console.WriteLine(word);
            }
            Console.ReadLine();

lambda：

var query1L = words.OrderBy(o => o.Length)

2.截取第一个子母后，再进行倒序排列

  //2.截取第一个子母后，再进行倒序排列
            var query2 = from word in words
                         orderby word.Substring(0, 1) descending
                         select word;

            foreach (var word in query2)
            {
                Console.WriteLine(word);
            }
            Console.ReadLine();

lambda：

var query2L = words.OrderByDescending(o => o.Substring(0, 1));

3.先根据字符的长度排序，再根据第一个子母排序

   //3.先根据字符的长度排序，再根据第一个子母排序
            var query3 = from word in words
                         orderby word.Length, word.Substring(0, 1)
                         select word;

            foreach (var word in query3)
            {
                Console.WriteLine(word);
            }
            Console.ReadLine();

lambda：

var query3L = words.OrderBy(o =>o.Length).ThenBy(o=>o.Substring(0,1));

4.先根据字符的长度排序，再根据第一个子母排序

  //4.先根据字符的长度正序排序，再根据第一个子母倒序排序
            var query4 = from word in words
                         orderby word.Length, word.Substring(0, 1) descending
                         select word;

            foreach (var word in query4)
            {
                Console.WriteLine(word);
            }
            Console.ReadLine();

lambda：

var query4L = words.OrderBy(o => o.Length).ThenByDescending(o => o.Substring(0, 1));

第二部分，集合操作

数据源

var words = new[] { "the", "the", "quick", "brown", "fox", "jumps" };

1.从集合移除重复值，Distinct

  //1.从集合移除重复值，Distinct
            var query1 = words.Distinct();
            foreach (var item in query1)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();

2.差集，Except，一个集合减掉另一个集合，剩下的集合。words2中除过words中，剩下的就是a

  //2.差集，Except，一个集合减掉另一个集合，剩下的集合。words2中除过words中，剩下的就是a。
            var words2 = new[] { "the", "a", "quick", "brown", "fox", "jumps" };
            var query2 = words2.Except(words);
            foreach (var item in query2)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();

3.交集，Intersect，2个集合共同存在的集合

    //3.交集，Intersect，2个集合共同存在的集合
            var words3 = new[] { "the", "bb", "quick", "brown", "fox", "jumps" };
            var query3 = words3.Intersect(words);
            foreach (var item in query3)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();

4.并集，Union，2个集合中任何一个元素的唯一值

   //4.并集，Union，2个集合中任何一个元素的唯一值
            var words4 = new[] { "the", "bb", "quick1", "brown", "fox", "jumps" };
            var query4 = words4.Union(words);
            foreach (var item in query4)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();

第三部分，数据过滤

数据源

string[] words = { "the", "qui", "brown", "fox", "jumps" };

1.Where，和sql语句中的Where一样

  //1.Where，和sql语句中的Where一样
            var query = from word in words
                        where word.Length == 3
                        select word;
            foreach (var item in query)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();

lambda：

var queryL = words.Where(w => w.Length ==3);

第四部分，量词操作

数据源

string[] words1 = { "the", "qui", "brown", "fox", "jumps" };

1.All,集合中所有的集合都满足的时候，返回true

 //1.All,集合中所有的集合都满足的时候，返回true
            var query1 = words1.All(i => i.Length > 3);
            Console.WriteLine(query1);
            Console.ReadLine();

2.Any，集合中只要有满足的时候，返回true

   //2.Any，集合中只要有满足的时候，返回true
            var query2 = words1.Any(i => i.Length > 4);
            Console.WriteLine(query2);
            Console.ReadLine();

3.Contains，集合中是否包含某一个元素

 //3.Contains，集合中是否包含某一个元素
            var query3 = words1.Contains("fox");
            Console.WriteLine(query3);
            Console.ReadLine();

第五部分，投影操作

1.select，单个from,查询每一个元素的第一个子母

   var words = new[] { "the", "quick", "brown", "fox", "jumps" };
            var query = from word in words
                        select word.Substring(0, 1);
            foreach (var item in query)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();

lambda：

var queryL = words.Select(s => s.Substring(0, 1));

2.select，多个from，根据' '分隔后，输出每一个元素

   var phrases = new List<string>() { "an apple a day", "the quick brown fox" };
            var query2 = from phrase in phrases
                         from word in phrase.Split(' ')
                         select word;
            foreach (var item in query2)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();

lambda：

var query2L = phrases.Select(s => s.Split(' '));

所有代码

using System;
using System.Collections.Generic;
using System.Data;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp1
{
    class Program
    {
        static void Main(string[] args)
        {
            //第一部分,排列数据
            //var words = new[] { "the", "quick", "brown", "fox", "jumps" };
            1.根据words中，字符的长度进行排序
            //var query1 = from word in words
            //             orderby word.Length
            //             select word;

            //var query1L = words.OrderBy(o => o.Length);
            //foreach (var word in query1)
            //{
            //    Console.WriteLine(word);
            //}
            //Console.ReadLine();

            //2.截取第一个子母后，再进行倒序排列
            //var query2 = from word in words
            //             orderby word.Substring(0, 1) descending
            //             select word;
            //var query2L = words.OrderByDescending(o => o.Substring(0, 1));
            //foreach (var word in query2)
            //{
            //    Console.WriteLine(word);
            //}
            //Console.ReadLine();

            //3.先根据字符的长度排序，再根据第一个子母排序
            //var query3 = from word in words
            //             orderby word.Length, word.Substring(0, 1)
            //             select word;
            //var query3L = words.OrderBy(o => o.Length).ThenBy(o => o.Substring(0, 1));
            //foreach (var word in query3)
            //{
            //    Console.WriteLine(word);
            //}
            //Console.ReadLine();

            //4.先根据字符的长度正序排序，再根据第一个子母倒序排序
            //var query4 = from word in words
            //             orderby word.Length , word.Substring(0, 1) descending
            //             select word;
            //var query4L = words.OrderBy(o => o.Length).ThenByDescending(o => o.Substring(0, 1));
            //foreach (var word in query4)
            //{
            //    Console.WriteLine(word);
            //}
            //Console.ReadLine();

            //第二部分,集合操作
            //var words = new[] { "the", "the", "quick", "brown", "fox", "jumps" };

            1.从集合移除重复值，Distinct
            //var query1 = words.Distinct();
            //foreach (var item in query1)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadLine();

            2.差集，Except，一个集合减掉另一个集合，剩下的集合。words2中除过words中，剩下的就是a。
            //var words2 = new[] { "the", "a", "quick", "brown", "fox", "jumps" };
            //var query2 = words2.Except(words);
            //foreach (var item in query2)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadLine();

            3.交集，Intersect，2个集合共同存在的集合
            //var words3 = new[] { "the", "bb", "quick", "brown", "fox", "jumps" };
            //var query3 = words3.Intersect(words);
            //foreach (var item in query3)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadLine();

            4.并集，Union，2个集合中任何一个元素的唯一值
            //var words4 = new[] { "the", "bb", "quick1", "brown", "fox", "jumps" };
            //var query4 = words4.Union(words);
            //foreach (var item in query4)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadLine();

            //第三部分，数据过滤
            //string[] words = { "the", "qui", "brown", "fox", "jumps" };
            1.Where，和sql语句中的Where一样
            //var query = from word in words
            //            where word.Length == 3
            //            select word;
            //var queryL = words.Where(w => w.Length ==3);
            //foreach (var item in query)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadLine();

            //第四部分，量词操作
            //string[] words1 = { "the", "qui", "brown", "fox", "jumps" };
            1.All,集合中所有的集合都满足的时候，返回true
            //var query1 = words1.All(i => i.Length > 3);
            //Console.WriteLine(query1);
            //Console.ReadLine();
            2.Any，集合中只要有满足的时候，返回true
            //var query2 = words1.Any(i => i.Length > 4);
            //Console.WriteLine(query2);
            //Console.ReadLine();
            3.Contains，集合中是否包含某一个元素
            //var query3 = words1.Contains("fox");
            //Console.WriteLine(query3);
            //Console.ReadLine();

            //第五部分，投影操作
            //1.select，单个from,查询每一个元素的第一个子母
            var words = new[] { "the", "quick", "brown", "fox", "jumps" };
            //var query = from word in words
            //            select word.Substring(0, 1);
            //var queryL = words.Select(s => s.Substring(0, 1));
            //foreach (var item in query)
            //{
            //    Console.WriteLine(item);
            //}
            //Console.ReadLine();
            2.select，多个from，根据' '分隔后，输出每一个元素
            var phrases = new List<string>() { "an apple a day", "the quick brown fox" };
            var query2 = from phrase in phrases
                         from word in phrase.Split(' ')
                         select word;
            var query2L = phrases.Select(s => s.Split(' '));
            foreach (var item in query2)
            {
                Console.WriteLine(item);
            }
            Console.ReadLine();
        }
    }
}

本人手动敲了一遍，主要是加深印象。

感谢原作者。

文章来源于：[C#] 进阶 - LINQ 标准查询操作概述 - 反骨仔 - 博客园

先看[C#] 走进 LINQ 的世界 - 反骨仔 - 博客园

来源：Linq和Lambda学习_linq la_故里2130的博客-CSDN博客