LINQ之查询基础学习笔记（二）

最新推荐文章于 2022-11-02 11:01:07 发布

string_user_get_set

最新推荐文章于 2022-11-02 11:01:07 发布

阅读量288

点赞数

分类专栏： C#

本文链接：https://blog.csdn.net/string_user_get_set/article/details/53405452

版权

C# 专栏收录该内容

8 篇文章

订阅专栏

LINQ查询方法的学习笔记：

在LINQ中，数据源和查询结果实际上是Ienumerable<T>或IQueryable<T>类型的对象，所以可以用通过使用普通的对象形式对数据源或者查询结果进行操作。

Ienumerable<T>接口：

该接口支持在指定的数据集合上进行迭代操作。在ＬＩＮＱ中，数据源实际上是实现了接口Ienumerable<T>的类，通过子句返回的查询结果也是实现了接口Ienumerable<T>的类。在.NET类库中提供了大量操作接口Ienumerable<T>的方法。

1. Ienumerable<T>接口提供的方法分类：

数值运算：

成员功能

Aggregate 对序列应用累加器函数，可以指定累加方法。

Sum 计算序列中所有的元素和，返回值有int,doublie,long,float,类型。

Average 计算元素平均值，返回值有int,doublie,long,float,类型。

Max 计算元素中的最大值，返回值有int,doublie,long,float,类型。

Min 计算元素中的最小值，返回值有int,doublie,long,float,类型。

判断操作：

成员功能
All 检查是否所有的元素都满足条件，可指定条件判断方法，返回false/true。

Any 检查是否有一个元素满足条件，可指定条件判断方法，返回false/true。

Contains 检查数据中是否包含特定元素，可以指定相等的比较方法。

元素数量：

成员功能

Count 返回满足条件的元素个数，可指定判断方法。

LongCount 返回满足条件的元素的长数量，可指定条件判断方法。

取值：

成员功能

First 返回满足条件的第一个元素，可指定条件判断方法。

Last 返回满足条件的最后一个元素，可指定判断方法。

ElemnetAt 返回指定索引出元素。

提取子集：

成员功能

Skip 剔除指定数量的元素，返回剩余元素。

SkipWhile 剔除满足指定条件的元素，返回剩余元素，可指定判断条件的方法。

Take 从序号开头，返回指定数量的连续元素。

TakeWhile 返回满足条件的连续元素，可指定条件。

集合操作：

成员功能

Reverse 反转序列中的元素顺序。

Distinct 返回不重复的元素，可以指定相等的方法。

Concat 连接两个序号，直接首尾连接。

Except 获取两个元素的差集。

Intersect 获取两个元素的交集。

Union 获取两个元素的并集。

SequenceEqual 比较两个序列是否相等，可指定判断方法。

Where 根据指定的条件对集合进行筛选。

其他：

成员功能

Aggregate 对序列应用累加器函数，可以指定累加方法。

ToArray 从Ienumerable<T>创建一个数组。

ToList 从Ienumerable<T>创建一个List集合

2.查询表达式和方法之间的对应关系：

方法查询表达式关键字功能

Cast() from 子句指定元素类型使用显示类型化的范围变量

GroupBy() group...by /group...by...into 对查询结果进行分组

GruopJoin() join ...in...on..equals...into 左外联接查询

Join() join ...in...on..equals 内部联接查询

OrderBy() ordery 升序排序

OrderByDescending Orderby.....descending 降序排序

Select() select 指定影射元素

SelectMany() select 多个from 复合查询

TenBy() Orderby......,........ 多个元素排序，后一个元素升序

TenByDescending() Orderby.....,....descending 多个元素排序，后一个降序

where() Where 条件过滤

3.Lambda表达式在LINQ中的使用和说明：

3.1.为什么在LINQ中使用Lambdba表达式：

Lambda 表达式实际上是匿名函数，它可以赋值到一个委托，而在Ienumerable<T> 的方法中很多都是通过函数的委托来实现自定义运算，条件等操作。

3.2. Lambda表达式的简单说明和使用：

3.2.1.格式问题：

Lambda表达式实际上是一个匿名函数，包括表达式和语句，用于创建委托或者表达式目录树类型。运算符都为“=>”,运算符的右边是表达式或语句块，左边是输入参数（可能没有）。（input param）=> expression

3.2.2.参数问题：

在Lamdba表达式中只有一个输入参数的时候，括号可以省了，否则是必须要的。如果有两个参数或者更多参数的时候。在括号中用逗号隔开。（x,y）=>x+y

当Lamdba表达式中没有参数的时候，需要使用空括号表示，（）=>AMethod()

4.方法的使用及代码：

ANLI1:

项目图：

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

namespace LINQ2.Comparer
{
    class MyStrEqualityComparer : IEqualityComparer<string>
    {
        public bool Equals(string x, string y)
        {
            return x.Substring(0, 1) == y.Substring(0,1);
            throw new NotImplementedException();
        }

        public int GetHashCode(string obj)
        {
            return obj.Length;
            throw new NotImplementedException();
        }
    }
}

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

namespace LINQ2.Comparer
{
    /// <summary>
    /// 自定义的int类型比较器，实现IComparer<int>接口
    /// </summary>
    class MyIntComparer : IComparer<int>
    {
        /// <summary>
        /// 比较函数具体实现，对x,y的绝对值进行比较
        /// </summary>
        /// <returns></returns>
        public int Compare(int x, int y)
        {
            int x1 = Math.Abs(x);
            int y1 = Math.Abs(y);
            if (x1 > y1)
                return 1;
            else if (x1 == y1)
                return 0;
            else
                return -1;
        }


    }
}

using LINQ2.Comparer;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace LINQ2
{
    class Program
    {
        static void Main(string[] args)
        {



            //创建数据源
            int[] intArry1 = { 1,2,3,4,5,6,7,8,9,15,20,25,5,40,40,45,50,-1,-2,-3,-5,-10,-15};
            string[] strArray1 = { "i","am","studying","LINQ"};
            string[] strArray2 = { "Day","by","day"};

            使用where()方法进行条件筛选/

            //查询Q1通过Where()查询数据源intArry1所以能被5整除的元素
            var Q1 = intArry1.Where(num=>num%5==0);
            //打印结果：
            System.Console.Write("能被五整除的所有元素：");
            foreach(var val in Q1){
                System.Console.Write("{0},",val);
            }
            System.Console.WriteLine();

            //查询Q2通过Where（）查询数据源intArry1中所有值大于三倍索引的元素
            var Q2 = intArry1.Where((num,index)=>num>index*3);
            //打印结果：
            System.Console.Write("值大于三倍索引的元素：");
            foreach(var val in Q2){
                System.Console.Write("{0},",val);
            }
            System.Console.WriteLine();

            使用OrderBy()方法进行排序/

//1.简单排序表达式

            //查询Q3对数据源intArry1中所有的元素对10取余后升序
            var Q3 = intArry1.OrderBy(val=>val%10);
            //打印结果：
            System.Console.Write("简单排序：\n");
            System.Console.Write("元素10取余升序：");
            foreach(var val in Q3){
                System.Console.Write("{0},",val);
            }
            System.Console.WriteLine();

            //查询Q4对数据源intArry1中所有的元素对10取余后降序
            var Q4 = intArry1.OrderByDescending(val=>val%10);
            //打印结果：
            System.Console.Write("元素10取余升序：");
            foreach (var val in Q4)
            {
                System.Console.Write("{0},", val);
            }
            System.Console.WriteLine();

//2.自定义int比较器排序

            //创建自定义int选择器类对象
            MyIntComparer MIC = new MyIntComparer();
            //查询Q5对数据源intArry1中所有的元素使用自定义比较器后升序
            var Q5 = intArry1.OrderBy(val => val,MIC);
            //打印结果：
            System.Console.Write("自定义int选择器后升序：\n");
            foreach(var vla in Q5){
                System.Console.Write("{0},",vla);
            }
            System.Console.WriteLine();

            //查询Q6对数据源intArry1中所有的元素使用自定义比较器后降序
            var Q6 = intArry1.OrderByDescending(val => val, MIC);
            //打印结果：
            System.Console.Write("自定义int选择器后降序：\n");
            foreach (var vla in Q6)
            {
                System.Console.Write("{0},", vla);
            }
            System.Console.WriteLine();

            使用Skip(),SkipWhile()跳过元素/

            //查询Q7对数据源intArray1中跳过前3个元素的剩余元素
            var Q7 = intArry1.Skip(3);
            //打印结果：
            System.Console.Write("跳过前3个元素后的剩余元素：");
            foreach(var val in Q7){
                System.Console.Write("{0},",val);
            }
            System.Console.WriteLine();

            //查询Q8对数据源intArray1中从第0个元素开始连续的绝对值大于10的元素剩余元素
            var Q8 = intArry1.SkipWhile(num=>num/10==0);
            //打印结果：
            System.Console.Write("连续绝对值小于10的剩余元素：");
            foreach (var val in Q8)
            {
                System.Console.Write("{0},", val);
            }
            System.Console.WriteLine();

            使用Take(),TakeWhile()提取元素/

            //查询Q9对数据源intArray1中提取前3个元素
            var Q9 = intArry1.Take(3);
            //打印结果：
            System.Console.Write("前三个元素：");
            foreach(var val in Q9){
                System.Console.Write("{0},",val);
            }
            System.Console.WriteLine();

            //查询Q10对数据源intArray1中从第0个元素开始连续的绝对值于10的元素
            var Q10 = intArry1.TakeWhile(num=>num/10==0);
            //打印结果：
            System.Console.Write("连续绝对值小于10的元素：");
            foreach (var val in Q10)
            {
                System.Console.Write("{0},", val);
            }
            System.Console.WriteLine();

            使用Max()等方法进行数值计算/

            //对数据源intArry1操作
            var intMax = intArry1.Max();         //最大值
            var intMin = intArry1.Min();         //最小值
            var intAvg = intArry1.Average();     //平均值
            var intSum = intArry1.Sum();         //总和
            //打印结果
            System.Console.WriteLine("数据源intArray1中最大值：{0},最小值：{1},平均值：{2},总和：{3}",intMax,intMin,intAvg,intSum);

            //对数据源strArray1操作
            var strMax = strArray1.Max();       //最大值
            var strMin = strArray1.Min();       //最小值
           //打印结果
            System.Console.WriteLine("数据源strArray1中最大值：{0},最小值：{1}",strMax,strMin);

    //对非数据类型求和，求平均等操作（重载，接受委托参数）
            //对数据源strArray1操作
            var StrMax = strArray1.Max(str=>str.Length);      //字符长度最长的元素长度最大值
            var StrMin = strArray1.Min(str=>str.Length);      //最小长度
            var StrAvg = strArray1.Average(str=>str.Length); //平均长度
            var StrSum = strArray1.Sum(str=>str.Length);      //总长度
            //打印结果：
            System.Console.WriteLine("数据源strArray1中最大字符长度为：{0},最小字符长度：{1},平均字符长度：{2},字符长度总和：{3}",StrMax,StrMin,StrAvg,StrSum);

            使用Distinct消除集合中相等的元素/
    //1.简单消除

            //对查询结果消除相等元素
            var Q11 = intArry1.Distinct();
            //打印结果：
            System.Console.Write("消除后：");
            foreach(var val in Q11){
                System.Console.Write("{0}", val);
            }
            System.Console.WriteLine();
//2.自定义消除
            //创建对象
            MyStrEqualityComparer MSEC = new MyStrEqualityComparer();

            //查询消除重复项
            var Q12 = strArray1.Distinct(MSEC);

            //打印结果：
            System.Console.Write("自定义消除后：");
            foreach (var val in Q12)
            {
                System.Console.Write("{0}", val);
            }
            System.Console.WriteLine();

            使用Concat()连接两个集合/

            //连接数据源
            var Q13 = strArray1.Concat(strArray2);
            //打印结果：
            System.Console.Write("连接后：");
            foreach(var val in Q13){
                System.Console.Write(val);
            }
            System.Console.WriteLine();

            System.Console.ReadLine();
        }
    }
}

运行结果：