Linq知识集（翻译）

最新推荐文章于 2025-05-13 09:47:18 发布
转载 最新推荐文章于 2025-05-13 09:47:18 发布 · 410 阅读 · 1 ·
CC 4.0 BY-SA版权
原文链接：https://blog.youkuaiyun.com/WuLex
文章标签：

#linq #c#

Linq简介

简介

LINQ（Language Integrated Query)，语言集成查询。.NET Framework3.5和C# 3.0一同发行。提供通用查询语法来支持不同数据源，包括内存中的数据、数据库数据（SQL、Oracle等）、XML文档等。如果没有Linq，那么你需要根据数据源的不同，学习不同的查询语法来支持数据查询工作。

Linq提供者（Provider），通过实现IQueryProvider和IQueryable接口来实现具体数据源数。而程序开发人员只需要针对Linq提供者提供的数据查询即可，可以像使用对象一样来编写查询。

架构
Linq架构

例子

Linq语句包含三个部分：

  • 初始化： 确定数据源
  • 条件：where、过滤、排序等
  • 查询：单独查询、分组查询、联合查询等

Linq语句的三种书写方式：
查询语句式
方法式
混合式

//准备数据源（内存中的数组）
List<int> intList = new List<int>()
{1,2,3,4,5,6,7,8,9};
//使用查询语句式的Linq
var linqQueries = (from obj in intList
                    where obj > 5
                    select obj);
//执行
foreach(var item in linqQueries)
{
    Console.Write(item + " ");
}

优点：

  1. 无需为新的数据源学习新的查询语言语法
  2. 精简代码
  3. 编译时检查错误
  4. 提供内置方法方便实现查询、排序、分组等
  5. 查询是可复用的

缺点

  1. 很难写出复杂的SQL查询
  2. 并没有实现所有的SQL功能，比如存储过程
  3. 如果查询编写的不好，性能将会非常差
  4. 修改查询，则需要重新部署应用，重新发布dll至服务器

IEnumerable与IQueryable

IEnumerable在System.Collection命名空间下，它只有一个GetEnumerator()方法。该方法的定义如下（泛型和非泛型）

public interface IEnumerable
{
    IEnumerator GetEnumerator();
}
public interface IEnumerable<out T>:IEnumerable
{
    IEnumerator<T> GetEnumerator();
}

IQueryable在System.Linq命名空间下，继承自IEnumerable接口。因此我们可以把一个IQueryable的变量赋值给IEnumerable变量。IQueryable接口有一个IQueryProvider成员。

namespace System.Linq
{
    public interface IQueryable: IEnumerable
    {
        Expression Expression {get;}
        Type ElementType {get;}
        IQueryProvider Provider {get;}
    }
    public interface IQueryProvider
    {
        IQueryable CreateQuery(Expression expression);
        IQueryable<TElement> CreateQuery<TElement>(Expression expression);
        object Execution(Expression expression);
        TResult Execute<TResult>(Expression expression);
    }
}

IEnumerable与IQueryable区别
总结：

IEnumerable
  1. 在System.Collections命名空间下的接口
  2. 从数据库查询数据时，IEnumerable在服务端（数据库）执行select语句。数据加载到客户端内存中，然后在内存中的数据获取需要的（执行条件过滤）
  3. 当需要查询内存中数据（List、Array等）要使用IEnumerable接口
  4. 大多用于LINQ to Object 和LINQ to XML查询
  5. IEnumerable只能向前获取数据，不能往后或截取片段
  6. 不支持自定义查询
  7. 不支持懒加载，因此不支持分页场景Enumerable类中也有Where方法的实现，该方法定义如下：
IEnumerable<TSource> Where<TSource> (this System.Collections.Generic.IEnumerable<TSource> source, Func<TSource,bool> predicate);
IQueryable
  1. 在System.Linq命名空间下的接口
  2. 从数据库查询数据时，IQueryable在服务端（数据库）执行带过滤的查询语句，然后获取需要的数据
  3. 当需要获取非内存数据（如远端数据库）时使用IQueryable接口
  4. 通常用于LINQ to SQL 和LINQ to Entities查询
  5. 类型集合只能往前，不能往后或截取片段
  6. 支持延迟执行
  7. 通过CreateQuery和Executes方法来支持自定义查询
  8. 支持延迟加载（lazy loading），支持分页场景

查看Where方法定义如下，它是IQueryable接口的一个扩展方法

public static IQeueryable<TSource> Where<TSource>(this IQueryable<TSource> source, Func<TSource, bool> predicate)

关于何时使用IEnumerable和IQueryable，在之前的文章中也有过讨论

扩展方法

C#的扩展方法允许我们在不改变已有类的代码前提下，向该类添加一个方法。具体做法是定义一个静态类，该静态类下实现一个静态方法，方法的第一个参数需要使用this关键字。举个例子，在string类中添加一个方法获取字符串中单词的个数。

public static class StringExtension
{
    public int GetWordCount(this string str)
    {
        if(!IsEmptyOrNull(str))
        {
            return str.Split(' ').Length;
        }
        return 0;
    }
}

此时，我们在项目中定义的string类型变量，就可以直接以.GetWordCount()方式调用这个方法了。因为这是一个静态方法，当然也可以使用类名.方法名()的方式来调用。

//扩展方法调用
string str = "hello word";
Console.WriteLine(str.GetWordCount());
//静态方法调用
Console.WriteLine(StringExtesion.GetWordCount(str));

Enumerable.cs类中实现了许多扩展方法如Where、Join等，既然是扩展方法，调用方式就有上面两种。

List<int> intList = new List<int>()
{1,2,3,4,5,6,7,8,9};
var linqList = (from obj in intList
                select obj)
                .Where(obj => obj > 5);
IEnumerable<int> enurableList = Enumerable.Where(intList, obj => obj > 5);
foreach(int item in enurableList)
{
    Console.Write(item + "  ");
}

LINQ查询操作符

LINQ操作符就是一系列的扩展方法用来写LINQ查询。

查询操作符（Select）：用来投影（Projection），从数据源中查询数据的机制。你可以按数据源原样查询出，也可以创建自己的结果形式。下面举例仅引用一些原文的图片，代码片段有点长，后期考虑github上建个repo。

下面两条语句将Employee对象原样查询出来

下面两条语句构建一个新的数据对象，不包含ID字段

下面两条语句构建一个新的数据匿名对象

下面两条语句创建带有索引值的对象

SelectMany查询，用于合并一系列的结果成为一个。下面看个例子：

  static void Main(string[] args)
        {
            List<string> nameList =new List<string>(){"Pranaya", "Kumar" };
            IEnumerable<char> methodSyntax = nameList.SelectMany(x => x);
            foreach(char c in methodSyntax)
            {
                Console.Write(c + " ");
            }
            //相当于下面的查询方式
            IEnumerable<char> querySyntax = from str in nameList
                                            from ch in str
                                            select ch;
            foreach(char c in querySyntax)
            {
                Console.Write(c + " ");
            }
            Console.ReadKey();
        }

另外一个例子

var methodSyntax = Student.GetStudents()
                    .SelectMany(stu => stu.Programming, 
                    (stu, pro) => new
                    {
                        StudentName = stu.Name,
                        Programing = pro
                    })
                    .Distinct()
                    .ToList();
var querySyntax = (from stu in Student.GetStudents()
                    from pro in stu.Programming
                    select new 
                    {
                        StudentName =stu.Name,
                        Programing = pro
                    }).Distinct()
                    .ToList();
//foreach(var item in methodSyntax)
foreach(var item in querySyntax)
{
    Console.WriteLine(item.StudentName + " => " + item.Programing);
}
public class Student
{
    public int ID { get; set; }
    public string Name { get; set; }
    public string Email { get; set; }
    public List<string> Programming { get; set; }
    public static List<Student> GetStudents()
    {
        return new List<Student>()
        {
            new Student(){ID = 1, Name = "James", Email = "James@j.com", Programming = new List<string>() { "C#", "Jave", "C++"} },
            new Student(){ID = 2, Name = "Sam", Email = "Sara@j.com", Programming = new List<string>() { "WCF", "SQL Server", "C#" }},
            new Student(){ID = 3, Name = "Patrik", Email = "Patrik@j.com", Programming = new List<string>() { "MVC", "Jave", "LINQ"} },
            new Student(){ID = 4, Name = "Sara", Email = "Sara@j.com", Programming = new List<string>() { "ADO.NET", "C#", "LINQ" } }
        };
    }
}

Linq知识集二

说明：翻译接上篇，上一篇翻译到了LINQ中的操作符，所谓操作符就是LINQ中的一系列扩展方法，用来对数据操作的一系列方法（如查询、过滤、排序等）。我们已经介绍了查询的Select方法，接下来继续。

LINQ中过滤操作符

过滤操作符，顾名思义就是对数据进行符合条件过滤。LINQ中过滤方法有两个：

  • Where
  • OfType

Where过滤

where通常需要至少一个条件，通过谓词来具体化条件。条件可以是一下操作符

==, >=, <=, &&, ||, >, <, etc.

从Where方法的签名可以看出，它是作为IEnumerable<T>的扩展方法来实现的。

public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, bool> predicate);
public static IEnumerable<TSource> Where<TSource>(this IEnumerable<TSource> source, Func<TSource, int, bool> predicate);
断言

断言是用来测试每个数据是否符合条件的方法，看下面例子

 List<int> intList = new List<int> { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
            //Method Syntax
            IEnumerable<int> filteredData = intList.Where(num => num > 5);
            //Query Syntax
            IEnumerable<int> filteredResult = from num in intList
                                              where num > 5
                                              select num;
            
            foreach (int number in filteredData)
            {
                Console.WriteLine(number);
            }
            Console.ReadKey();

num => num > 5 这个匿名函数就是一个断言，Where对数据源中的每一项都执行该方法。

where第一个重载方法断言参数Func<int, bool> preidcate期望是一个整型的输入参数，返回一个布尔类型值。这是一个泛型代理，需要一个或多个输入参数，以及一个输出参数。最后一个参数作为输出参数，且是强制必须要的，输出参数可选。上面的lambada表达式即为传给Func的参数，可以重写为如下形式。

Func<int, bool> preidicate = i => i > 5;
//当然也可以把这个匿名方法写成一个有名字的方法
//public static bool CheckNumber(int number)
//{
//    if(number > 5)
//        return true;
//    else
//        return false;
//}
IEnumerable<int> filterData = intList.Where(predicate);
//IEnumerable<int> filterData = intList.Where(num => CheckNumber(num));

where第二个重载方法，断言方法的int型参数表示数据源元素的索引位置。参考下面例子

List<int> intList = new List<int>{1,2,3,4,5,6,7,8,9};
var oddNumberWithIndex = intList.Select((num, index) => 
                    new {
                        Numbers = num,
                        IndexPosition = index
                    }).Where(x => x.Numbers % 2 != 0)
                    .Select(data => 
                    new {
                        Number = data.Numbers,
                        IndexPostion = data.IndexPostion
                    });
foreach(var item in oddNumberWithIndex)
{
      Console.WriteLine($"IndexPosition :{item.IndexPosition} , Value : {item.Number}");
}

OfType操作符

OfType用于过滤数据源中指定类型的数据，实际上也可以通过where来判断数据源中数据的类型，来获得指定数据。看下面的例子

List<object> datasource = new List<object>()
{"Tom", "Mary", 1, 2, "Price", 40, 20, 10};
//通过OfType的泛型方法可以直接获取到整型数组
List<int> intData = datasource.OfType<int>().ToList();
//采用查询语法where条件来获取指定类型数据
var strData = from name in datasource
                where name is string
                select name;

Set操作符

set操作符用于根据数据源元素的显隐来产生结果集，意味着这些操作有可能针对单个数据源或多个数据源，输出数据中这些数据有可能出现有可能不出现。主要有以下方法：

  • Distinct : 用于查询无重复数据的方法
  • Except： 用于查询在某一集合里的且不在另一集合内的数据(1.Except(2)在1不在2, 2.Except(1)在2不在1)
  • Intersect ： 用于查询多个数据源相交的集合数据（在1且在2）
  • Union ：用于查询具有相同结构的数据源数据的集合（1和2一起）

4个操作结果如下图
在这里插入图片描述

LINQ Distinct

Distinct的两个重载签名如下：

public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source);
public static IEnumerable<TSource> Distinct<TSource>(this IEnumerable<TSource> source, IEqualityComparer<TSource> comparer);

举两个例子说明Distinct的用法

 List<int> intCollection = new List<int>(){1,2,3,2,3,4,4,5,6,3,4,5};
 //查询数组中去除重复项后的数据
var MS = intCollection.Distinct();
foreach (var item in MS)
{
    Console.WriteLine(item);
}

如果数据源是复杂类型的列表，当使用Distinct的默认Comparer时，只会判断两个引用对象是否相同，而不会判断对象中每个属性值是否相等。

List<Student> students = new List<Student>()
            {
                new Student {ID = 101, Name = "Preety" },
                new Student {ID = 102, Name = "Sambit" },
                new Student {ID = 103, Name = "Hina"},
                new Student {ID = 104, Name = "Anurag"},
                new Student {ID = 102, Name = "Sambit"},
                new Student {ID = 103, Name = "Hina"},
                new Student {ID = 101, Name = "Preety" },
            };
//Using Method Syntax
var MS = students
        .Distinct().ToList();
// var MS = students
//         .Select(stu => new {
//             ID = stu.ID,
//             Name = stu.Name
//         })
//         .Distinct().ToList();
foreach (var item in QS)
{
    Console.WriteLine($"ID : {item.ID} , Name : {item.Name} ");
}

运行上面代码，获得输出全部学生ID、姓名，原因上面已经解释。如何解决这个问题，可以通过以下三种方法来实现

  1. 定义一个类，实现IEqualityComparer接口，然后将这个类对象传递给Distinct作为参数
  2. 重写Student类的Equals和GetHashCode方法
  3. 使用匿名类，如上面示例代码中Select中创建匿名类
  4. 在Student类中实现IEquatable<T>接口
//方法1
public class StudentComparer : IEqualityComparer<Student>
{
    public bool Equals(Student x, Student y)
    {
        if(object.ReferenceEquals(x, y))
            return true;
        if (object.ReferenceEquals(x,null) || object.ReferenceEquals(y, null))
            return false;
        return x.ID == y.ID && x.Name == y.Name;
    }
    public int GetHashCode(Student obj)
    {
        if (obj == null)
            return 0;
        int IDHashCode = obj.ID.GetHashCode();
        int NameHashCode = obj.Name == null ? 0 : obj.Name.GetHashCode();
        return IDHashCode ^ NameHashCode;
    }
}
//方法2，Student类中重写下面两个方法
public override bool Equals(object obj)
{
    return this.ID == ((Student)obj).ID && this.Name == ((Student)obj).Name;
}
public override int GetHashCode()
{
    int IDHashCode = this.ID.GetHashCode();
    int NameHashCode = this.Name == null ? 0 : this.Name.GetHashCode();
    return IDHashCode ^ NameHashCode;
}
//方法4，Student类继承IEquatable<Student>
public bool Equals(Student other)
{
    if (object.ReferenceEquals(other, null))
    {
        return false;
    }
    if (object.ReferenceEquals(this, other))
    {
        return true;
    }
    return this.ID.Equals(other.ID) && this.Name.Equals(other.Name);
}
IEqualityComparer<T> 和 IEquatable<T>区别

从上面的方法1和方法4势力代码能看出两者区别。
IEqualityComparer<T>接口，是使用第三方类，来实现两个泛型类<T>对象之间的比较。
IEquatable<T>接口，则是使用泛型类<T>与该类自身的新对象进行比较。

LINQ中的Except

首先来看Except的两个方法签名，和Distinct基本一样。只是该操作是针对两个数据源，因此多一个数据参数。同样，第二个方法的签名最后一个参数传入一个IEqualityComparer接口，意味着处理复杂类型数据时，需要自己实现这个接口进行对象间的比较。

public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);
public static IEnumerable<TSource> Except<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);

接下来通过例子说明

List<int> dataSource1 = new List<int>() { 1, 2, 3, 4, 5, 6 };
List<int> dataSource2 = new List<int>() { 1, 3, 5, 8, 9, 10 };
//Method Syntax
var MS = dataSource1.Except(dataSource2).ToList();
var QS = (from num in dataSource1
        select num)
        .Except(dataSource2).ToList();
foreach (var item in QS)
{
    Console.WriteLine(item);
}

下面的代码处理复杂类，如果Student类没有重写Equals方法和GetHasCode方法的话，输出结果将不是我们期望的。参考Distinct方法中给Student重写方法、实现IEqualityCompare接口、匿名类等方法来实现我们期望的结果。

  List<Student> AllStudents = new List<Student>()
    {
        new Student {ID = 101, Name = "Preety" },
        new Student {ID = 102, Name = "Sambit" },
        new Student {ID = 103, Name = "Hina"},
        new Student {ID = 104, Name = "Anurag"},
        new Student {ID = 105, Name = "Pranaya"},
        new Student {ID = 106, Name = "Santosh"},
    };
    List<Student> Class6Students = new List<Student>()
    {
        new Student {ID = 102, Name = "Sambit" },
        new Student {ID = 104, Name = "Anurag"},
        new Student {ID = 105, Name = "Pranaya"},
    };
    
    //Method Syntax
    var MS = AllStudents.Except(Class6Students).ToList();
    //Query Syntax
    var QS = (from std in AllStudents
                select std).Except(Class6Students).ToList();
    
    foreach (var student in MS)
    {
        Console.WriteLine($" ID : {student.ID} Name : {student.Name}");
    }

LINQ中的Intersect

首先来看Intersect的两个方法签名，和上面的Except基本一样。所以后面的示例代码以及如何处理复杂类数据元素都不具体提供示例了。

public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);
public static IEnumerable<TSource> Intersect<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);

LINQ中的Union

首先来看Union的两个方法签名，和上面的Except基本一样。所以后面的示例代码以及如何处理复杂类数据元素都不具体提供示例了。

public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second);
public static IEnumerable<TSource> Union<TSource>(this IEnumerable<TSource> first, IEnumerable<TSource> second, IEqualityComparer<TSource> comparer);
如何优化C#中的LINQ查询性能：延迟加载与惰性求值
威哥说编程
03-22 767
优化C#中的LINQ查询性能主要依赖于理解和合理利用延迟加载和惰性求值的特性。避免不必要的查询：缓存查询结果，避免多次执行相同的查询。减少数据量：提前进行过滤，避免加载不必要的数据。避免重复查询：使用GroupByAggregate等方法减少重复计算。使用异步查询：在处理I/O密集型操作时，使用异步LINQ查询提高性能。使用合适的数据结构：选择合适的数据结构来提高查询效率。
数据库与LINQ编程核心知识点解析
最新发布
7h6j5k4l3的博客
09-10 1043
本文深入探讨了数据库完整性规则（包括实体完整性与引用完整性）、外键创建步骤、ADO.NET组件及其子组件、LINQ查询机制、标准查询运算符、IEnumerable与IQueryable接口的区别、扩展方法构建、运行时对象数据操作、存储过程设计与调用、Web应用开发基础等内容，适用于数据库与应用程序开发实践。
linq list select用法注意事项
meizhiyun的专栏
04-21 1万+
下面是我自己做的一个例子
懒加载，预加载
weixin_42150080的博客
05-19 313
一、懒加载（延迟加载） 1、概念: 当我们访问网页时，会发现页面是先把img图片替换成一张占位图，当图片出现在浏览器的可视区域内时，再设置图片的真实路径，然后才显示图片。这样只需请求一次。 2.优点： 页面内的图片过多时，在首次载入时一次性加载会耗费时间长，使用懒加载可以使页面加载速度快、减轻服务器的压力、节约流量。 3.步骤： 页面中的img元素，若没有src属性，浏览器就不会发出请求去下载图片，只有通过Javascript设置了图片路径，浏览器才会发送请求。 1）懒加载先在页面中把需要延迟加载的图片统一
C# LINQ源码分析之Select
weixin_43263355的博客
02-15 1万+
在开发过程中，LINQ代码库中的Select方法经常被使用，为了更好的了解该方法，我们从源码的角度对其进行分析。了解如何以最优的方式，使用该方法，从而提升代码的性能。
linq的使用
goodyatou的专栏
11-29 348
string  arrStr =string.empty; DataTable dt = bll.GameKind(传方法参数);         List lstID = (from d in dt.AsEnumerable()                            select d.Field("KindID")).ToList();         foreach (
Linq与SQL间自动翻译的便捷工具-LINQPad4
### 标题知识点：Linq翻译工具 #### LINQ 简介 LINQ（Language Integrated Query）是集成在.NET框架中的一种查询技术，允许开发人员使用.NET语言对各种数据源进行查询操作。这些数据源可以是SQL数据库、XML文档、...
Linq技术实践：数据库与数据集操作实例详解
开发者可以使用LINQ来编写查询，这些查询会自动翻译为SQL语句，并由数据库执行。这种映射方式为数据库操作带来了极大的便利，因为它允许开发者利用对象的思维模式来操作关系数据库。 4. LINQ操作数组及集合实例 ...
C#经典案例合集：LINQ与COM互操作实战
TerraServer是一个公开的地图影像服务，案例中可能构建了一个LINQ Provider，将本地的LINQ表达式翻译成对TerraServer SOAP接口的调用请求，返回地理图像元数据并以IEnumerable形式呈现给客户端。这种方式打破了传统...
LINQ表达式解析案例学习
综上所述，“LINQ表达式案例.rar”是一个集理论与实践于一体的高质量学习资源，涵盖了从基础查询语法到高级表达式树解析的多层次知识体系，对于提升 C# 开发者的编程技能、深化对 .NET 查询机制的理解具有重要帮助...
linq中 List＜T＞.ForEach() 与 的 Select() 方法区别——CAD c#二次开发
05-13 725
List<T>.ForEach 和 Enumerable.Select 是 C# 中用于处理集合的两种不同方法，各有其适用场景。ForEach 用于对集合中的每个元素执行操作（如修改属性），无返回值且立即执行，适合直接修改原集合。Select 则用于将集合中的元素映射为新值，生成一个新的序列，返回 IEnumerable<TResult> 并延迟执行，适合生成新集合或与其他 LINQ 方法组合使用。ForEach 更简洁，适合简单副作用操作，而 Select 更适合需要生成新集合或进
IComparer IEqualityComparer 集合的sort排序以及distinct 去重 还有一种更简单的方法lamda
zq爱生活爱代码的博客
02-26 275
实现排序以及去重的类 using System; using System.Collections; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; namespace icomparerTest { class PersonIc...
LINQ之Where
lcy的博客
04-17 1318
Where() 使用Where()可以获取序列中满足指定条件的所有元素。 MSDN public static IEnumerable<TSource> Where<TSource>( this IEnumerable<TSource> source, Func<TSource, bool> predicate ); 代码示例： public sta...
性能优化之Lazy(懒加载)-实现延迟初始化
qinzheng_chen的博客
06-11 740
在.NET4.0中，可以使用Lazy<T> 来实现对象的延迟初始化，从而优化系统的性能。延迟初始化就是将对象的初始化延迟到第一次使用该对象时。延迟初始化是我们在写程序时经常会遇到的情形，例如创建某一对象时需要花费很大的开销，而这一对象在系统的运行过程中不一定会用到，这时就可以使用延迟初始化，在第一次使用该对象时再对其进行初始化，如果没有用到则不需要进行初始化,这样的话，使用延迟初始化就提高程序的效率，从而使程序占用更少的内存。 　　下面我们来看代码，新建一个控制台程序，首先创建一个Studen
要养成习惯懒加载数据
程序人生
02-10 6238
一般的数据，在从文件或数据库中读取后，会用到多次，这时候要养成懒加载数据的习惯，以提高程序的性能，其实你不使用懒加载，从使用者来说，如果数据量小，没什么影响，但如果数据量大，使用懒加载数据就有明显的优势了。 代码如下： if (_apps == nil) { // 初始化 // 1.获得plist的全路径 NSStrin
C#12 技术手册（六）
龙哥盟
01-05 971
在本节中，我们提供标准查询操作符的概述。它们分为三类：输入序列，输出序列（序列 → 序列）输入序列，输出单个元素或标量值无输入，输出序列（生成方法）我们首先介绍每个类别和它们包含的查询操作符，然后详细讨论每个单独的查询操作符。Where返回满足给定条件的输入序列的元素。查询中可以多次出现where子句，并与letorderby和joinselect u;
C# LINQ查询方法及Select()查询方法应用
热门推荐
lichji2016的博客
01-22 2万+
class Program     {         static void Main(string[] args)         {             #region  //基本方法查询                          //int[] nums = { 1,9,3,4,8,6};             //List list = new List();
Linq:Select使用示例
我们的征途是星辰大海
12-13 1万+
一,select简单实用           select作用：select 在一个集合序列按照给定的条件进行投影，select可以返回组合的筛选结果，返回匿名类型，对返回结果进行操作，返回组合的子查询结果等等。                             select方法的原型如下： public static IEnumerable Select(t
List<String>Linq筛选数据
shaojinbo的专栏
06-20 1万+
linq用法如下： List list = new List(); var q = from String s in list where s[0] = "A" && s.Length = 4 //字符串是以A开头，并且长度为4位的 select s;q就是筛选后的结
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值