LINQ查询 - 《C#编程指南》 - 严富坤的知识库专栏(yanfukun.com)

LINQ的基本概念
- LINQ的意义
- LINQ的组成
LINQ查询的基本语法
- 查询表达式
- 方法语法
LINQ查询操作符
LINQ to Objects
- LINQ to Objects的基本概念
- 对象集合的查询
LINQ to XML
- LINQ to XML的基本概念
- XML数据的查询
LINQ to SQL
- LINQ to SQL的基本概念
- 数据库数据的查询
LINQ to Entities
- LINQ to Entities的基本概念
- 实体数据的查询
LINQ to DataSet
- LINQ to DataSet的基本概念
- DataSet数据的查询
LINQ的高级用法
LINQ的性能优化
小结

语言集成查询（Language Integrated Query，LINQ）是C#中一项强大的功能，允许开发者以简洁而一致的方式对各种数据源（如集合、XML、数据库等）进行查询和操作。LINQ不仅提供了统一的查询语法，还能利用编译时类型检查和代码补全，提高开发效率和代码质量。本文将深入探讨C#中的LINQ查询，从基本概念到高级用法，全面解析LINQ的原理和机制，并结合实际案例，帮助读者掌握LINQ查询的精髓。

LINQ的基本概念

LINQ的意义

LINQ通过引入一种新的查询语法，使得对各种数据源的查询变得更加简洁和一致。LINQ支持对集合、XML、数据库、对象等数据源进行查询，提供了丰富的查询操作符，如投影、过滤、排序、分组、聚合等。

LINQ的组成

LINQ主要由以下几个部分组成：

LINQ to Objects：用于查询内存中的对象集合，如数组、列表等。
LINQ to XML：用于查询和操作XML数据。
LINQ to SQL：用于查询和操作关系数据库。
LINQ to Entities：用于查询和操作Entity Framework中的数据。
LINQ to DataSet：用于查询和操作DataSet中的数据。

LINQ查询的基本语法

查询表达式

LINQ查询表达式是一种类似SQL的查询语法，用于对数据源进行查询。查询表达式由from、select、where、order by、group by等关键字组成。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        var query = from number in numbers
                    where number > 2
                    select number;
        foreach (var num in query)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，我们使用查询表达式对列表中的数字进行过滤，选取大于2的数字。

方法语法

除了查询表达式，LINQ还支持方法语法，即通过方法调用链进行查询。方法语法与查询表达式等效，但更符合C#方法调用的风格。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        var query = numbers.Where(number => number > 2)
                           .Select(number => number);
        foreach (var num in query)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，我们使用方法语法对列表中的数字进行过滤，选取大于2的数字。

LINQ查询操作符

投影操作符

投影操作符用于从数据源中选择和转换数据。常用的投影操作符包括select和selectMany。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        var query = from number in numbers
                    select number * 2;
        foreach (var num in query)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，我们使用select操作符对列表中的数字进行投影，将每个数字乘以2。

过滤操作符

过滤操作符用于从数据源中筛选满足条件的数据。常用的过滤操作符包括where。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        var query = from number in numbers
                    where number > 2
                    select number;
        foreach (var num in query)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，我们使用where操作符对列表中的数字进行过滤，选取大于2的数字。

排序操作符

排序操作符用于对数据源中的数据进行排序。常用的排序操作符包括order by、then by、orderbyDescending、thenbyDescending。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 5, 3, 1, 4, 2 };
        var query = from number in numbers
                    orderby number
                    select number;
        foreach (var num in query)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，我们使用orderby操作符对列表中的数字进行排序，按升序排列。

分组操作符

分组操作符用于将数据源中的数据按指定条件分组。常用的分组操作符包括group by。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<string> words = new List<string> { "apple", "banana", "cherry", "date", "fig", "grape" };
        var query = from word in words
                    group word by word[0] into wordGroup
                    select wordGroup;
        foreach (var group in query)
        {
            Console.WriteLine($"Group: {group.Key}");
            foreach (var word in group)
            {
                Console.WriteLine($"  {word}");
            }
        }
    }
}

在这个例子中，我们使用group by操作符将列表中的单词按首字母分组。

聚合操作符

聚合操作符用于对数据源中的数据进行汇总计算。常用的聚合操作符包括count、sum、min、max、average等。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        int count = numbers.Count();
        int sum = numbers.Sum();
        int min = numbers.Min();
        int max = numbers.Max();
        double average = numbers.Average();
        Console.WriteLine($"Count: {count}");
        Console.WriteLine($"Sum: {sum}");
        Console.WriteLine($"Min: {min}");
        Console.WriteLine($"Max: {max}");
        Console.WriteLine($"Average: {average}");
    }
}

在这个例子中，我们使用聚合操作符对列表中的数字进行汇总计算，得到数字的个数、总和、最小值、最大值和平均值。

LINQ to Objects

LINQ to Objects的基本概念

LINQ to Objects用于查询内存中的对象集合，如数组、列表等。LINQ to Objects提供了对对象集合进行查询、过滤、排序、分组等操作的功能。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        var query = from number in numbers
                    where number > 2
                    select number;
        foreach (var num in query)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，我们使用LINQ to Objects对列表中的数字进行过滤，选取大于2的数字。

对象集合的查询

对象集合的查询可以使用查询表达式或方法语法。常用的查询操作包括投影、过滤、排序、分组、聚合等。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        // 查询表达式
        var query1 = from number in numbers
                     where number > 2
                     select number;
        // 方法语法
        var query2 = numbers.Where(number => number > 2)
                            .Select(number => number);
        foreach (var num in query1)
        {
            Console.WriteLine(num);
        }
        foreach (var num in query2)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，我们分别使用查询表达式和方法语法对列表中的数字进行过滤，选取大于2的数字。

LINQ to XML

LINQ to XML的基本概念

LINQ to XML用于查询和操作XML数据，提供了对XML文档的加载、查询、修改、保存等操作的功能。LINQ to XML通过XElement、XDocument等类实现。

using System;
using System.Xml.Linq;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        string xml = @"<books>
                           <book>
                               <title>Book 1</title>
                               <author>Author 1</author>
                           </book>
                           <book>
                               <title>Book 2</title>
                               <author>Author 2</author>
                           </book>
                       </books>";
        XDocument doc = XDocument.Parse(xml);
        var query = from book in doc.Descendants("book")
                    select new
                    {
                        Title = book.Element("title").Value,
                        Author = book.Element("author").Value
                    };
        foreach (var book in query)
        {
            Console.WriteLine($"Title: {book.Title}, Author: {book.Author}");
        }
    }
}

在这个例子中，我们使用LINQ to XML对XML文档中的书籍信息进行查询，选取每本书的标题和作者。

XML数据的查询

XML数据的查询可以使用查询表达式或方法语法。常用的查询操作包括元素选择、属性选择、条件过滤等。

using System;
using System.Xml.Linq;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        string xml = @"<books>
                           <book>
                               <title>Book 1</title>
                               <author>Author 1</author>
                           </book>
                           <book>
                               <title>Book 2</title>
                               <author>Author 2</author>
                           </book>
                       </books>";
        XDocument doc = XDocument.Parse(xml);
        // 查询表达式
        var query1 = from book in doc.Descendants("book")
                     select new
                     {
                         Title = book.Element("title").Value,
                         Author = book.Element("author").Value
                     };
        // 方法语法
        var query2 = doc.Descendants("book")
                        .Select(book => new
                        {
                            Title = book.Element("title").Value,
                            Author = book.Element("author").Value
                        });
        foreach (var book in query1)
        {
            Console.WriteLine($"Title: {book.Title}, Author: {book.Author}");
        }
        foreach (var book in query2)
        {
            Console.WriteLine($"Title: {book.Title}, Author: {book.Author}");
        }
    }
}

在这个例子中，我们分别使用查询表达式和方法语法对XML文档中的书籍信息进行查询，选取每本书的标题和作者。

LINQ to SQL

LINQ to SQL的基本概念

LINQ to SQL用于查询和操作关系数据库，提供了对数据库表的映射、查询、修改、保存等操作的功能。LINQ to SQL通过DataContext、Table<T>等类实现。

using System;
using System.Data.Linq;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        string connectionString = "your_connection_string_here";
        DataContext context = new DataContext(connectionString);
        var query = from customer in context.GetTable<Customer>()
                    where customer.City == "Seattle"
                    select customer;
        foreach (var customer in query)
        {
            Console.WriteLine($"Name: {customer.Name}, City: {customer.City}");
        }
    }
}
public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string City { get; set; }
}

在这个例子中，我们使用LINQ to SQL对数据库中的客户信息进行查询，选取位于西雅图的客户。

数据库数据的查询

数据库数据的查询可以使用查询表达式或方法语法。常用的查询操作包括投影、过滤、排序、分组、聚合等。

using System;
using System.Data.Linq;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        string connectionString = "your_connection_string_here";
        DataContext context = new DataContext(connectionString);
        // 查询表达式
        var query1 = from customer in context.GetTable<Customer>()
                     where customer.City == "Seattle"
                     select customer;
        // 方法语法
        var query2 = context.GetTable<Customer>()
                            .Where(customer => customer.City == "Seattle")
                            .Select(customer => customer);
        foreach (var customer in query1)
        {
            Console.WriteLine($"Name: {customer.Name}, City: {customer.City}");
        }
        foreach (var customer in query2)
        {
            Console.WriteLine($"Name: {customer.Name}, City: {customer.City}");
        }
    }
}
public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string City { get; set; }
}

在这个例子中，我们分别使用查询表达式和方法语法对数据库中的客户信息进行查询，选取位于西雅图的客户。

LINQ to Entities

LINQ to Entities的基本概念

LINQ to Entities用于查询和操作Entity Framework中的数据，提供了对实体模型的加载、查询、修改、保存等操作的功能。LINQ to Entities通过DbContext、DbSet<T>等类实现。

using System;
using System.Data.Entity;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        using (var context = new MyDbContext())
        {
            var query = from customer in context.Customers
                        where customer.City == "Seattle"
                        select customer;
            foreach (var customer in query)
            {
                Console.WriteLine($"Name: {customer.Name}, City: {customer.City}");
            }
        }
    }
}
public class MyDbContext : DbContext
{
    public DbSet<Customer> Customers { get; set; }
}
public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string City { get; set; }
}

在这个例子中，我们使用LINQ to Entities对Entity Framework中的客户信息进行查询，选取位于西雅图的客户。

实体数据的查询

实体数据的查询可以使用查询表达式或方法语法。常用的查询操作包括投影、过滤、排序、分组、聚合等。

using System;
using System.Data.Entity;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        using (var context = new MyDbContext())
        {
            // 查询表达式
            var query1 = from customer in context.Customers
                         where customer.City == "Seattle"
                         select customer;
            // 方法语法
            var query2 = context.Customers
                                .Where(customer => customer.City == "Seattle")
                                .Select(customer => customer);
            foreach (var customer in query1)
            {
                Console.WriteLine($"Name: {customer.Name}, City: {customer.City}");
            }
            foreach (var customer in query2)
            {
                Console.WriteLine($"Name: {customer.Name}, City: {customer.City}");
            }
        }
    }
}
public class MyDbContext : DbContext
{
    public DbSet<Customer> Customers { get; set; }
}
public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
    public string City { get; set; }
}

在这个例子中，我们分别使用查询表达式和方法语法对Entity Framework中的客户信息进行查询，选取位于西雅图的客户。

LINQ to DataSet

LINQ to DataSet的基本概念

LINQ to DataSet用于查询和操作DataSet中的数据，提供了对DataTable的加载、查询、修改、保存等操作的功能。LINQ to DataSet通过DataTable、DataRow等类实现。

using System;
using System.Data;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        DataTable table = new DataTable();
        table.Columns.Add("Id", typeof(int));
        table.Columns.Add("Name", typeof(string));
        table.Columns.Add("City", typeof(string));
        table.Rows.Add(1, "John Doe", "Seattle");
        table.Rows.Add(2, "Jane Smith", "New York");
        table.Rows.Add(3, "Sam Brown", "Seattle");
        var query = from row in table.AsEnumerable()
                    where row.Field<string>("City") == "Seattle"
                    select row;
        foreach (var row in query)
        {
            Console.WriteLine($"Name: {row["Name"]}, City: {row["City"]}");
        }
    }
}

在这个例子中，我们使用LINQ to DataSet对DataTable中的客户信息进行查询，选取位于西雅图的客户。

DataSet数据的查询

DataSet数据的查询可以使用查询表达式或方法语法。常用的查询操作包括投影、过滤、排序、分组、聚合等。

using System;
using System.Data;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        DataTable table = new DataTable();
        table.Columns.Add("Id", typeof(int));
        table.Columns.Add("Name", typeof(string));
        table.Columns.Add("City", typeof(string));
        table.Rows.Add(1, "John Doe", "Seattle");
        table.Rows.Add(2, "Jane Smith", "New York");
        table.Rows.Add(3, "Sam Brown", "Seattle");
        // 查询表达式
        var query1 = from row in table.AsEnumerable()
                     where row.Field<string>("City") == "Seattle"
                     select row;
        // 方法语法
        var query2 = table.AsEnumerable()
                          .Where(row => row.Field<string>("City") == "Seattle")
                          .Select(row => row);
        foreach (var row in query1)
        {
            Console.WriteLine($"Name: {row["Name"]}, City: {row["City"]}");
        }
        foreach (var row in query2)
        {
            Console.WriteLine($"Name: {row["Name"]}, City: {row["City"]}");
        }
    }
}

在这个例子中，我们分别使用查询表达式和方法语法对DataTable中的客户信息进行查询，选取位于西雅图的客户。

LINQ的高级用法

连接操作

连接操作用于将多个数据源按指定条件进行连接，常用的连接操作包括join、group join、left join等。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<Customer> customers = new List<Customer>
        {
            new Customer { Id = 1, Name = "John Doe" },
            new Customer { Id = 2, Name = "Jane Smith" },
            new Customer { Id = 3, Name = "Sam Brown" }
        };
        List<Order> orders = new List<Order>
        {
            new Order { Id = 1, CustomerId = 1, Amount = 100 },
            new Order { Id = 2, CustomerId = 1, Amount = 200 },
            new Order { Id = 3, CustomerId = 2, Amount = 300 }
        };
        var query = from customer in customers
                    join order in orders on customer.Id equals order.CustomerId
                    select new
                    {
                        CustomerName = customer.Name,
                        OrderAmount = order.Amount
                    };
        foreach (var result in query)
        {
            Console.WriteLine($"Customer: {result.CustomerName}, Order Amount: {result.OrderAmount}");
        }
    }
}
public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
}
public class Order
{
    public int Id { get; set; }
    public int CustomerId { get; set; }
    public int Amount { get; set; }
}

在这个例子中，我们使用join操作将客户和订单按客户ID进行连接，选取客户名称和订单金额。

子查询

子查询用于在查询中嵌套另一个查询，常用于复杂的数据操作。子查询可以是标量子查询、相关子查询或独立子查询。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<Customer> customers = new List<Customer>
        {
            new Customer { Id = 1, Name = "John Doe" },
            new Customer { Id = 2, Name = "Jane Smith" },
            new Customer { Id = 3, Name = "Sam Brown" }
        };
        List<Order> orders = new List<Order>
        {
            new Order { Id = 1, CustomerId = 1, Amount = 100 },
            new Order { Id = 2, CustomerId = 1, Amount = 200 },
            new Order { Id = 3, CustomerId = 2, Amount = 300 }
        };
        var query = from customer in customers
                    select new
                    {
                        CustomerName = customer.Name,
                        TotalOrderAmount = (from order in orders
                                            where order.CustomerId == customer.Id
                                            select order.Amount).Sum()
                    };
        foreach (var result in query)
        {
            Console.WriteLine($"Customer: {result.CustomerName}, Total Order Amount: {result.TotalOrderAmount}");
        }
    }
}
public class Customer
{
    public int Id { get; set; }
    public string Name { get; set; }
}
public class Order
{
    public int Id { get; set; }
    public int CustomerId { get; set; }
    public int Amount { get; set; }
}

在这个例子中，我们使用子查询计算每个客户的订单总金额。

延迟执行

LINQ查询默认使用延迟执行，即在查询结果被实际迭代或枚举之前，查询不会执行。这种机制可以提高性能，避免不必要的计算。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        var query = from number in numbers
                    where number > 2
                    select number;
        Console.WriteLine("查询尚未执行");
        foreach (var num in query)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，LINQ查询在被迭代之前不会执行，体现了延迟执行的特点。

即时执行

通过调用ToList、ToArray、First、Single等方法，可以将延迟执行的查询转换为即时执行。即时执行会立即执行查询并返回结果。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        var query = from number in numbers
                    where number > 2
                    select number;
        List<int> result = query.ToList();
        Console.WriteLine("查询已执行");
        foreach (var num in result)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，我们通过调用ToList方法将延迟执行的查询转换为即时执行，立即执行查询并返回结果。

LINQ的性能优化

减少不必要的计算

在使用LINQ查询时，应该尽量减少不必要的计算。例如，可以在过滤操作之前进行投影，减少数据量，提高查询效率。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = new List<int> { 1, 2, 3, 4, 5 };
        // 先投影再过滤
        var query = from number in numbers
                    select number * 2 into doubled
                    where doubled > 5
                    select doubled;
        foreach (var num in query)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，我们先对数字进行投影，再进行过滤，减少了不必要的计算。

使用合适的数据结构

选择合适的数据结构可以提高LINQ查询的性能。例如，对于需要频繁查找的操作，可以使用字典；对于需要顺序访问的操作，可以使用列表。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        Dictionary<int, string> dictionary = new Dictionary<int, string>
        {
            { 1, "One" },
            { 2, "Two" },
            { 3, "Three" }
        };
        var query = from kvp in dictionary
                    where kvp.Key > 1
                    select kvp.Value;
        foreach (var value in query)
        {
            Console.WriteLine(value);
        }
    }
}

在这个例子中，我们使用字典进行查询，提高了查询的性能。

使用并行查询

对于大型数据集，可以使用并行查询提高查询性能。并行查询通过将查询操作并行化，利用多核CPU提高查询效率。

using System;
using System.Collections.Generic;
using System.Linq;
public class Program
{
    public static void Main(string[] args)
    {
        List<int> numbers = Enumerable.Range(1, 1000000).ToList();
        var query = from number in numbers.AsParallel()
                    where number % 2 == 0
                    select number;
        foreach (var num in query)
        {
            Console.WriteLine(num);
        }
    }
}

在这个例子中，我们使用并行查询对大型数据集进行查询，提高了查询性能。

小结

LINQ是C#中的一项强大功能，提供了对各种数据源进行查询和操作的简洁而一致的语法。通过LINQ，开发者可以高效地进行投影、过滤、排序、分组、聚合等操作，简化代码，提高开发效率和代码质量。本文深入探讨了C#中的LINQ查询，从基本概念到高级用法，全面解析了LINQ的原理和机制，并结合实际案例展示了LINQ在各种场景中的应用。

掌握LINQ不仅能够提高代码的简洁性和可读性，还能够在复杂数据处理场景中发挥重要作用。希望本文能帮助读者更好地理解和掌握C#中的LINQ查询，在实际开发中充分利用这一强大的编程工具。通过对LINQ的深入理解和合理应用，可以编写出更加高效、可靠和稳定的程序。