Tài liệu Linq in action.4207

LINQ in Action LINQ in Action FABRICE MARGUERIE STEVE EICHERT JIM WOOLEY MANNING Greenwich (74° w. long.) For online information and ordering of this and other Manning books, please visit www.manning.com. The publisher offers discounts on this book when ordered in quantity. For more information, please contact: Special Sales Department Manning Publications Co. Sound View Court 3B fax: (609) 877-8256 Greenwich, CT 06830 email: [email protected] ©2008 by Manning Publications Co. All rights reserved. No part of this publication may be reproduced, stored in a retrieval system, or transmitted, in any form or by means electronic, mechanical, photocopying, or otherwise, without prior written permission of the publisher. Many of the designations used by manufacturers and sellers to distinguish their products are claimed as trademarks. Where those designations appear in the book, and Manning Publications was aware of a trademark claim, the designations have been printed in initial caps or all caps. Recognizing the importance of preserving what has been written, it is Manning’s policy to have the books we publish printed on acid-free paper, and we exert our best efforts to that end. Recognizing also our responsibility to conserve the resources of our planet, Manning books are printed on paper that is at least 15% recycled and processed without the use of elemental chlorine. Manning Publications Co. Sound View Court 3B Greenwich, CT 06830 Copyeditor: Benjamin Berg Typesetter: Gordan Salinovic Cover designer: Leslie Haimes ISBN 1-933988-16-9 Printed in the United States of America 1 2 3 4 5 6 7 8 9 10 – MAL – 13 12 11 10 09 08 brief contents PART 1 PART 2 PART 3 PART 4 GETTING STARTED ....................................................... 1 1 ■ Introducing LINQ 3 2 ■ C# and VB.NET language enhancements 3 ■ LINQ building blocks 44 82 QUERYING OBJECTS IN MEMORY ............................... 113 4 ■ Getting familiar with LINQ to Objects 5 ■ Beyond basic in-memory queries 115 160 QUERYING RELATIONAL DATA ................................... 203 6 ■ Getting started with LINQ to SQL 205 7 ■ Peeking under the covers of LINQ to SQL 8 ■ Advanced LINQ to SQL features 237 267 MANIPULATING XML ............................................... 311 9 ■ Introducing LINQ to XML 10 ■ Query and transform XML with LINQ to XML 11 ■ Common LINQ to XML scenarios v 313 385 350 vi PART 5 BRIEF CONTENTS LINQING IT ALL TOGETHER ..................................... 435 12 ■ Extending LINQ 437 13 ■ LINQ in every layer 482 contents foreword xv preface xvii acknowledgments xix about this book xxii PART 1 GETTING STARTED ......................................... 1 1 Introducing LINQ 3 1.1 What is LINQ? 4 Overview 5 LINQ as a toolset 6 extensions 7 ■ 1.2 ■ Addressing a paradigm mismatch Design goals and origins of LINQ The goals of the LINQ project 1.4 LINQ as language Why do we need LINQ? 9 Common problems 10 LINQ to the rescue 18 1.3 ■ 20 ■ 12 19 A bit of history 21 First steps with LINQ to Objects: Querying collections in memory 23 What you need to get started 23 vii ■ Hello LINQ to Objects 25 viii CONTENTS 1.5 First steps with LINQ to XML: Querying XML documents 29 Why we need LINQ to XML 1.6 30 ■ Hello LINQ to XML 32 First steps with LINQ to SQL: Querying relational databases 37 Overview of LINQ to SQL’s features 37 Hello LINQ to SQL 38 A closer look at LINQ to SQL 42 ■ ■ 1.7 2 Summary 42 C# and VB.NET language enhancements 44 2.1 Discovering the new language enhancements Generating a list of running processes into a class 47 2.2 Implicitly typed local variables 46 ■ 45 Grouping results 49 Syntax 49 Improving our example using implicitly typed local variables 50 ■ 2.3 Object and collection initializers 52 The need for object initializers 52 Collection initializers 53 Improving our example using an object initializer 54 ■ 2.4 Lambda expressions 55 A refresher on delegates 56 Anonymous methods 58 Introducing lambda expressions 58 ■ ■ 2.5 Extension methods 64 Creating a sample extension method 64 More examples using LINQ’s standard query operators 68 Extension methods in action in our example 70 Warnings 71 ■ 2.6 Anonymous types 73 Using anonymous types to group data into an object 74 Types without names, but types nonetheless 74 Improving our example using anonymous types 76 Limitations 76 ■ 2.7 Summary 79 CONTENTS 3 LINQ building blocks 3.1 82 How LINQ extends .NET 83 Refresher on the language extensions 83 of the LINQ foundation 85 3.2 Introducing sequences ■ The key elements 85 IEnumerable 86 Refresher on iterators 87 Deferred query execution 89 ■ 3.3 Introducing query operators What makes a query operator? operators 96 3.4 93 93 Introducing query expressions The standard query ■ 97 What is a query expression? 98 Writing query expressions 98 How the standard query operators relate to query expressions 100 Limitations 102 ■ ■ ■ 3.5 Introducing expression trees 104 Return of the lambda expressions 105 What are expression trees? 105 IQueryable, deferred query execution redux 108 ■ ■ 3.6 3.7 LINQ DLLs and namespaces Summary 111 109 PART 2 QUERYING OBJECTS IN MEMORY ................. 113 4 Getting familiar with LINQ to Objects 4.1 Introducing our running example 115 116 Goals 116 Features 117 The business entities 117 Database schema 118 Sample data 118 ■ ■ ■ 4.2 Using LINQ with in-memory collections What can we query? 4.3 121 ■ 121 Supported operations 126 Using LINQ with ASP.NET and Windows Forms Data binding for web applications 127 for Windows Forms applications 133 ■ Data binding 126 ix x CONTENTS 4.4 Focus on major standard query operators 137 Where, the restriction operator 138 Using projection operators 139 Using Distinct 142 Using conversion operators 143 Using aggregate operators 145 ■ ■ ■ ■ 4.5 Creating views on an object graph in memory Sorting 146 Nested queries 147 Grouping Using joins 151 Partitioning 155 ■ ■ 146 150 ■ 4.6 5 Summary 159 Beyond basic in-memory queries 160 5.1 Common scenarios 161 Querying nongeneric collections 162 Grouping by multiple criteria 164 Dynamic queries 167 LINQ to Text Files 178 ■ ■ 5.2 ■ Design patterns 180 The Functional Construction pattern pattern 184 5.3 Performance considerations 181 ■ The ForEach 186 Favor a streaming approach 187 Be careful about immediate execution 189 Will LINQ to Objects hurt the performance of my code? 191 Getting an idea about the overhead of LINQ to Objects 195 Performance versus conciseness: A cruel dilemma? 198 ■ ■ ■ ■ 5.4 Summary 200 PART 3 QUERYING RELATIONAL DATA ..................... 203 6 Getting started with LINQ to SQL 205 6.1 Jump into LINQ to SQL Setting up the object mapping DataContext 212 6.2 6.3 207 209 Reading data with LINQ to SQL Refining our queries 217 ■ Setting up the 212 Filtering 217 Sorting and grouping Aggregation 221 Joining 222 ■ ■ 219 CONTENTS 6.4 6.5 Working with object trees 226 When is my data loaded and why does it matter? 229 Lazy loading 6.6 6.7 7 229 ■ Loading details immediately Updating data 233 Summary 236 Peeking under the covers of LINQ to SQL 7.1 231 Mapping objects to relational data 237 238 Using inline attributes 239 Mapping with external XML files 245 Using the SqlMetal tool 247 The LINQ to SQL Designer 249 ■ ■ 7.2 Translating query expressions to SQL IQueryable 7.3 ■ 252 ■ 252 Expression trees 254 The entity life cycle 257 Tracking changes 259 Submitting changes 260 Working with disconnected data 263 ■ 7.4 8 Summary 266 Advanced LINQ to SQL features 8.1 267 Handling simultaneous changes 268 Pessimistic concurrency 268 Optimistic concurrency 269 Handling concurrency exceptions 272 Resolving conflicts using transactions 276 ■ ■ 8.2 Advanced database capabilities 278 SQL pass-through: Returning objects from SQL queries Working with stored procedures 280 User-defined functions 290 278 ■ 8.3 Improving the business tier 294 Compiled queries 294 Partial classes for custom business logic 296 Taking advantage of partial methods 299 Using object inheritance 301 ■ ■ 8.4 8.5 A brief diversion into LINQ to Entities Summary 309 306 xi xii CONTENTS PART 4 MANIPULATING XML ................................. 311 9 Introducing LINQ to XML 9.1 9.2 9.3 313 What is an XML API? 314 Why do we need another XML programming API? LINQ to XML design principles 317 316 Key concept: functional construction 319 Key concept: contextfree XML creation 320 Key concept: simplified names 320 ■ ■ 9.4 9.5 LINQ to XML class hierarchy 323 Working with XML using LINQ 326 Loading XML 327 Parsing XML 329 Creating XML 330 Creating XML with Visual Basic XML literals 335 Creating XML documents 338 Adding content to XML 341 Removing content from XML 343 Updating XML content 344 Working with attributes 347 Saving XML 348 ■ ■ ■ ■ ■ ■ 9.6 10 Summary ■ 349 Query and transform XML with LINQ to XML 350 10.1 LINQ to XML axis methods 352 Element 354 Attribute 355 Elements 356 Descendants 357 Ancestors 360 ElementsAfterSelf, NodesAfterSelf, ElementsBeforeSelf, and NodesBeforeSelf 362 Visual Basic XML axis properties 363 ■ ■ ■ ■ ■ ■ 10.2 Standard query operators 366 Projecting with Select 369 Filtering with Where 370 Ordering and grouping 372 ■ 10.3 10.4 Querying LINQ to XML objects with XPath Transforming XML 378 LINQ to XML transformations 378 XML objects with XSLT 382 10.5 Summary 383 ■ 376 Transforming LINQ to CONTENTS 11 xiii Common LINQ to XML scenarios 385 11.1 Building objects from XML Goal 11.2 ■ Implementation 393 399 ■ Implementation 398 401 406 ■ Implementation 407 412 ■ Implementation 413 Transforming text files into XML Goal 11.7 392 392 Reading XML and updating a database 411 Goal 11.6 389 Filtering and mixing data from a database with XML data 406 Goal 11.5 Implementation Creating XML with data from a database Goal 11.4 ■ Creating XML from object graphs Goal 11.3 387 386 428 Summary ■ Implementation 428 429 432 PART 5 LINQING IT ALL TOGETHER ...................... 435 12 Extending LINQ 437 12.1 Discovering LINQ’s extension mechanisms 438 How the LINQ flavors are LINQ implementations 439 What can be done with custom LINQ extensions 441 12.2 Creating custom query operators 442 Improving the standard query operators 443 domain-specific query operators 446 12.3 ■ Utility or Custom implementations of the basic query operators 451 Refresh on the query translation mechanism 452 Query expression pattern specification 453 Example 1: tracing standard query operators’ execution 455 Limitation: query expression collision 457 Example 2: nongeneric, domain-specific operators 459 Example 3: non-sequence operator 461 ■ ■ ■ ■ ■ xiv CONTENTS 12.4 Querying a web service: LINQ to Amazon Introducing LINQ to Amazon Implementation 467 12.5 463 ■ 463 Requirements 465 IQueryable and IQueryProvider: LINQ to Amazon advanced edition 474 The IQueryable and IQueryProvider interfaces 474 Implementation 479 What happens exactly 480 ■ 12.6 13 Summary 481 LINQ in every layer 13.1 Overview of the LinqBooks application Features 13.2 482 483 ■ Overview of the UI 484 ■ LINQ to SQL and the data access layer 483 The data model 486 486 Refresher on the traditional three-tier architecture 487 Do we need a separate data access layer or is LINQ to SQL enough? 488 Sample uses of LINQ to SQL in LinqBooks 495 ■ 13.3 Use of LINQ to XML 502 Importing data from Amazon 13.4 13.5 13.6 502 Generating RSS feeds 504 Use of LINQ to DataSet 505 Using LINQ to Objects 509 Extensibility 509 Custom query operators 509 provider 510 13.7 ■ ■ Creating and using a custom LINQ A look into the future 511 Custom LINQ flavors 511 LINQ to XSD, the typed LINQ to XML 513 PLINQ: LINQ meets parallel computing 513 LINQ to Entities, a LINQ interface for the ADO.NET Entity Framework 514 ■ ■ 13.8 bonus chapter: Summary 515 appendix: The standard query operators 517 resources 523 index 527 Working with LINQ and DataSets available online only from www.manning.com/LINQinAction foreword It’s difficult for me to write this foreword, not because the road to LINQ was long and arduous or that I’m teary-eyed, wrought with emotion, or finding it difficult to compose just the right the words for a send-off worthy of a product that I’ve poured my very soul into. It’s difficult because I know that this is going to be a well-respected book and I’m finding it tricky to work in a punch line. For me the LINQ project started years before anything official, back when I was involved in plotting and scheming over a new managed ADO. Back then, a few very smart developers had the audacity to suggest shucking off the chains of traditional data access APIs and designing around the ubiquity of objects and metadata that were fundamental to the new runtime—the Java runtime. Unfortunately, none of that happened. The traditionalists won, and at the time I was one of them. Yet what I gained from that experience was a perspective that data belongs at the heart of any programming system, not bolted on as an afterthought. It made sense that in a system based on objects, data should be objects too. But getting there was going to take overcoming a lot of challenges. As an engineer, I was at the center of the advancements happening inside Microsoft, designing new APIs and influencing language features that would move us forward. Many of these never made it all the way to shipping products, yet each attempt was a step in the right direction. LINQ is a culmination of these endeavors, of battles fought and lessons learned. It is born out of an accretion of insights from a group of my peers, draws upon existing theories and techniques from computer xv xvi FOREWORD science at large, and would never have come together without the clear-cut wisdom and attention to detail that is Anders Hejlsberg. Of course, there were all of you too. LINQ was shaped significantly by the community of developers discussing it on forums and blogs. The ability to receive such immediate feedback was like turning on the lights in a darkened room. It was also energizing to watch as the spark caught fire in so many of you, how you became experts and evangelists, gave talks, wrote articles, and inspired each other. That’s why this book is so important. Fabrice, Jim, and Steve were a large part of that community and have captured its essence within the pages of their book. LINQ in Action is a book from the people to the people. It’s as if they had decided to throw a party for LINQ and everyone who’s anyone showed up. So read on, enjoy, and don’t waste time waiting in line for the punch. MATT WARREN PRINCIPAL ARCHITECT MICROSOFT preface I chose software development as the way to make a living mainly because it’s a technology that is constantly evolving. There’s always something new to learn. No chance of getting bored in this line of work! In addition to learning, I also enjoy teaching software development. Writing LINQ in Action was a good opportunity to both learn and teach at the same time. When we started writing this book, LINQ was still an early prototype. We followed its evolution as it was taking shape. There was a lot to discover and a lot to understand. This is part of a software developer’s everyday job. We have to stay up-to-date with the technologies we use and learn new ones as they come out. The software development environment is evolving at an increasingly fast pace, and I don’t see any signs that that’s going to change. .NET is a fast-moving environment. Over the last couple of years, we’ve seen two major releases of the .NET Framework, and several companion technologies have appeared: Windows Presentation Foundation, Windows Communication Foundation, Windows Workflow Foundation, ASP.NET AJAX, Silverlight, and LINQ have joined our developer toolbox. Another trend in .NET is the multiplication of programming languages. F#, which will receive the same support as C# or VB.NET in Visual Studio, introduces functional programming in .NET. Dynamic languages, such as Python and Ruby, are going to be supported by the .NET Dynamic Language Runtime. xvii xviii PREFACE In coming years, we’ll have to deal with more programming languages than the ones we currently master. An advantage of C#, Visual Basic, and the other .NET languages is that they are constantly adapting. C# and VB.NET have been improved in their latest versions to offer support for language-integrated querying through LINQ. In addition to offering novel approaches to deal with data, LINQ represents a shift toward declarative and functional programming. When people ask me for reasons to learn LINQ, I tell them that they should learn it in order to be able to use it with XML, relational data, or in-memory collections, but above all to be able to start using declarative programming, deferred execution, and lambda expressions. Start learning LINQ now! When you do, you’ll not only learn how to use this new technology, but you’ll also discover where programming is heading. One of our main goals with LINQ in Action was to help you fully comprehend the new approaches associated with LINQ. FABRICE MARGUERIE acknowledgments Writing this book was a long process. It gave us the opportunity to have informative discussions with a lot of interesting people, as well as to learn and get input from some very smart individuals. We received help from many different sources—this book would not have been possible without them. Not only that: They also brought out the best in us. The people who contributed to the book in ways both large and small kept pushing us to raise the quality of our work higher and higher. We forgive them now for being so demanding. It was all for a good cause. First, we’d like to express our gratitude to everyone at Manning. We appreciate the trust they placed in us and their involvement in asking us for our best in this project. A sincere thank-you to our publisher Marjan Bace for his vote of confidence in offering us the opportunity to write this book and to our editor Michael Stephens for being there throughout the process and helping make this project a reality. Thanks to the editorial team at Manning who worked with us on turning this book into the end product you are now holding in your hands: Cynthia Kane, Mary Piergies, Karen Tegtmeyer, Ron Tomich, Lianna Wlasiuk, Megan Yockey, Benjamin Berg, Gordan Salinovic, Dottie Marsico, Elizabeth Martin, and Tiffany Taylor all guided us and kept us moving in the right direction. We would also thank the many reviewers of the manuscript, who looked at it in various stages of development and whose thoughtful feedback made this a much better book: Dave Corun, Marius Bancila, Keith Farmer, Curt Christianson, Mark xix