.NET Framework 4中的LINQ入门指南

4星 · 超过85%的资源需积分: 10 188 浏览量更新于2024-07-31 收藏 4.46MB PDF 举报

LINQ (Language Integrated Query) 是.NET框架4中的一个重要特性，它使得在.NET环境中编写查询更加直观、简洁，能够轻松地处理各种数据源，包括数据库、XML文档、集合等。本资料由Microsoft Corporation授权出版，由Paolo Pialorsi和Marco Russo撰写，旨在提供深入理解LINQ概念和技术的全面指南。在.NET Framework 4中，LINQ的核心理念是将查询语言融入到C#和VB.NET的语法中，使开发者能够在编程时采用标准的SQL查询风格来操作数据。这极大地提高了代码的可读性和可维护性，尤其是在处理大量数据或进行复杂数据转换时。该资料涵盖了以下几个关键知识点： 1. **基础概念**：介绍了LINQ的基本概念，包括查询表达式（query expressions）、查询操作符（query operators）以及lambda表达式（lambda functions），这些都是构建查询的主要工具。 2. **数据源支持**：讲解了LINQ如何与多种数据源协作，包括ADO.NET对象模型（如DataSet、DataTable和Entity Framework）、数组、集合和泛型列表。 3. **投影和选择**：演示如何通过Lambda表达式实现数据的投影（projection）和选择（selection），以提取所需的信息。 4. **分组和聚合**：学习如何使用LINQ对数据进行分组并执行聚合操作，如计算平均值、计数、最大值和最小值。 5. **排序和过滤**：介绍如何使用OrderBy和Where等方法对数据进行排序和筛选，以满足特定条件。 6. **连接和子查询**：探讨如何使用Join和其他子查询操作，以便在多个数据源之间进行关联和嵌套查询。 7. **延迟加载和性能优化**：讨论如何利用LINQ的延迟加载机制提高应用程序性能，避免不必要的数据加载。 8. **LINQ to XML**：专门章节讲解如何处理XML数据，包括查询、修改和创建XML文档。 9. **LINQ to SQL和Entity Framework**：介绍如何在.NET Framework 4中使用LINQ与关系数据库交互，包括LINQ to SQL和Entity Framework的集成。 10. **示例和最佳实践**：书中提供了大量的实战示例和实用技巧，帮助读者理解和掌握LINQ的使用，以及如何避免常见的陷阱。此资料是.NET Framework 4开发人员学习和掌握LINQ不可或缺的资源，无论你是初学者还是经验丰富的开发人员，都能从中获得提升数据处理能力的宝贵知识和技能。

Chapter 1 LINQ Introduction 

PLINQ. Many other services can be offered by an execution framework to a program written

using a higher level of abstraction, such as the one offered by LINQ. A good understanding of

this technology is important because LINQ has become a “standard” way to describe data

manipulation operations inside a program written in the .NET Framework.

More Info

PLINQ s covered n Chapter 16, “Para e sm and Asynchronous Process ng”



Today, data managed by a program can originate from various data sources: an array, an

object graph, an XML document, a database, a text le, a registry key, an email message, Sim-

ple Object Access Protocol (SOAP) message content, a Microsoft Excel le…. The list is long.

Each data source has its own specic data access model. When you have to query a database,

you typically use SQL. You navigate XML data by using the Document Object Model (DOM) or

XPath/XQuery. You iterate an array and build algorithms to navigate an object graph. You use

specic application programming interfaces (APIs) to access other data sources, such as an

Excel le, an email message, or the Windows registry. In the end, you use different program-

ming models to access different data sources.

The unication of data access techniques into a single comprehensive model has been attempted

in many ways. For example, by using Open Database Connectivity (ODBC) providers, you can

query an Excel le as you would a Windows Management Instrumentation (WMI) repository.

With ODBC, you use a SQL-like language to access data represented through a relational

model.

Sometimes, however, data is represented more effectively in a hierarchical or network model

instead of a relational one. Moreover, if a data model is not tied to a specic language, you

probably need to manage several type systems. All these differences create an “impedance

mismatch” between data and code.

LINQ addresses these issues by offering a uniform way to access and manage data without

forcing the adoption of a “one size ts all” model. LINQ makes use of common capabilities in

the operations in different data models instead of attening the different structures between

them. In other words, by using LINQ, you keep existing heterogeneous data structures, such

as classes or tables, but you get a uniform syntax to query all these data types—regardless

of their physical representation. Think about the differences between a graph of in-memory

objects and relational tables with proper relationships. With LINQ, you can use the same

query syntax over both models.

 Part I LINQ Foundations

Here is a simple LINQ query for a typical software solution that returns the names of customers

in Italy:

varquery=

fromcinCustomers



wherec.Country=="Italy"



selectc.CompanyName;

The result of this query is a list of strings. You can enumerate these values with a foreach loop

in Microsoft Visual C#:

foreach(stringnameinquery){

Console.WriteLine(name);



}

Both the query denition and the foreach loop are regular C# 3.0 statements, but what is

Customers? At this point, you might be wondering what it is we are querying. Is this query a

new form of Embedded SQL? Not at all. You can apply the same query (and the foreach loop)

to a SQL database, to a DataSet object, to an array of objects in memory, to a remote service,

or to many other kinds of data.

For example, Customers could be a collection of objects:

Customer[]Customers;

Customer data could reside in a DataTable in a DataSet:

DataSetds=GetDataSet();

DataTableCustomers=ds.Tables["Customers"];

Customers could be an entity class that describes a physical table in a relational database:

DataContextdb=newDataContext(ConnectionString);

Table<Customer>Customers=db.GetTable<Customer>();

Or Customers could be an entity class that describes a conceptual model and is mapped to a

relational database:

NorthwindModeldataModel=newNorthwindModel();

ObjectSet<Customer>Customers=dataModel.Customers;



As you will learn in Chapter 2, “LINQ Syntax Fundamentals,” the SQL-like syntax used in LINQ

is called a query expression. A SQL-like query mixed with the syntax of a program written in

a language that is not SQL is typically called Embedded SQL, but languages that implement it

do so using a simplied syntax. In Embedded SQL, these statements are not integrated into

the language’s native syntax and type system because they have a different syntax and several

Chapter 1 LINQ Introduction 

restrictions related to their interaction. Moreover, Embedded SQL is limited to querying data-

bases, whereas LINQ is not. LINQ provides much more than Embedded SQL does; it provides a

query syntax that is integrated into a language. But how does LINQ work?

Let’s say you write the following code using LINQ:

Customer[]Customers=GetCustomers();

varquery=



fromcinCustomers



wherec.Country=="Italy"



selectc;

The compiler generates this code:

Customer[]Customers=GetCustomers();

IEnumerable<Customer>query=



Customers



.Where(c=>c.Country=="Italy");

The following query is a more complex example (without the Customers declaration, for the

sake of brevity):

varquery=

fromcinCustomers



wherec.Country=="Italy"



orderbyc.Name



selectnew{c.Name,c.City};

As you can see, the generated code is more complex too:

varquery=

Customers

.Where(c=>c.Country=="Italy");



.OrderBy(c=>c.Name)



.Select(c=>new{c.Name,c.City});

As you can see, the generated code apparently calls instance members on the object returned

from the previous call: Where is called on Customers, OrderBy is called on the object returned

by Where, and nally Select is called on the object returned by OrderBy. You will see that this

behavior is regulated by what are known as extension methods in the host language (C# in

this case). The implementation of the Where, OrderBy, and Select methods—called by the

sample query—depends on the type of Customers and on namespaces specied in relevant

using statements. Extension methods are a fundamental syntax feature that is used by LINQ

operate with different data sources by using the same syntax.

More Info

An extens on method appears to extend a c ass (the Customers c ass n our examp es),

but n rea ty a method of an externa type rece ves the nstance of the c ass that seems to be

extended as the rst argument The var keyword used to dec are query nfers the var ab e type

dec arat on from the n t a ass gnment, wh ch n th s case w return an IEnumerable<T> type

 Part I LINQ Foundations

Another important concept is the timing of operations over data. In general, a LINQ query is

not executed until the result of the query is required. Each query describes a set of operations

that will be performed only when the result is actually accessed by the program. In the follow-

ing example, this access is performed only when the foreach loop executes:

varquery=fromcinCustomers...

foreach(stringnameinquery)...

There are also methods that iterate a LINQ query result, producing a persistent copy of data

in memory. For example, the ToList method produces a typed List<T> collection:

varquery=fromcinCustomers...

List<Customer>customers=query.ToList();

When the LINQ query operates on data that is in a relational database (such as a Microsoft

SQL Server database), it generates an equivalent SQL statement instead of operating with

in-memory copies of data tables. The query’s execution on the database is delayed until

the query results are rst accessed. Therefore, if in the last two examples Customers was a

Table<Customer> type (a physical table in a relational database) or an ObjectSet<Customer>

type (a conceptual entity mapped to a relational database), the equivalent SQL query would

not be sent to the database until the foreach loop was executed or the ToList method was

called. The LINQ query can be manipulated and composed in different ways until those

events occur.

More Info

A LINQ query can be represented as an express on tree Chapter 14, “Ins de Expres-

s on Trees,” descr bes how to v s t and dynam ca y bu d an express on tree, and thereby bu d a

LINQ query

Relational Model vs. Hierarchical/Network Model

At rst, LINQ might appear to be just another SQL dialect. This similarity has its roots in the

way a LINQ query can describe a relationship between entities, as shown in the following

code:

varquery=

fromcinCustomers



joinoinOrders



onc.CustomerIDequalso.CustomerID



selectnew{c.CustomerID,c.CompanyName,o.OrderID};

Chapter 1 LINQ Introduction 

This syntax is similar to the regular way of querying data in a relational model by using a SQL

join clause. However, LINQ is not limited to a single data representation model such as the

relational one, where relationships between entities are expressed inside a query but not in

the data model. (Foreign keys keep referential integrity but do not participate in a query.) In

a hierarchical or network model, parent/child relationships are part of the data structure. For

example, suppose that each customer has its own set of orders, and each order has its own list

of products. In LINQ, you can get the list of products ordered by each customer in this way:

varquery=

fromcinCustomers



fromoinc.Orders



selectnew{c.Name,o.Quantity,o.Product.ProductName};

This query contains no joins. The relationship between Customers and Orders is expressed

by the second from clause, which uses c.Orders to say “get all Orders for the c Customer.”

The relationship between Orders and Products is expressed by the Product member of the

Order instance. The result projects the product name for each order row by using o.Product.

ProductName.

Hierarchical and network relationships are expressed in type denitions through references to

other objects. (Throughout, we will use the phrase “graph of objects” to generically refer to

hierarchical or network models.) To support the previous query, we would have classes similar

to those in Listing 1-1.

 Type dec arat ons w th s mp e re at onsh ps

publicclassCustomer{

publicstringName;

publicstringCity;



publicOrder[]Orders;



}

publicstructOrder{



publicintQuantity;

publicProductProduct;



}

publicclassProduct{



publicintIdProduct;

publicdecimalPrice;



publicstringProductName;



}

However, chances are that we want to use the same Product instance for many different

Orders of the same product. We probably also want to lter Orders or Products without

accessing them through Customer. A common scenario is the one shown in Listing 1-2.

剩余655页未读，继续阅读

xuwedo2003

粉丝: 31
资源: 195

.NET Framework 4中的LINQ入门指南

Programming Microsoft LINQ in Microsoft.NET Framework 4

Programming Microsoft LINQ in Microsoft .NET Framework 4

掌握ADO.NET 3.5与LINQ及Entity Framework：专业教程

C# 3.5并行编程实战：ADO.NET与LINQ及Entity Framework

使用LINQ和Entity Framework进行数据操作与处理

LINQ与EF Core协作：数据操作更上一层楼，LINQ与Entity Framework

【LINQ与Entity Framework实战】：灵活操作数据库的ORM技巧

MVC学习之LINQ篇，linq in .NET4

LINQ in Action

LINQ IN Action

最新资源