Tải bản đầy đủ

C in depth, 2nd edition

Covers C # 4

IN DEPTH
SECOND EDITION
Jon Skeet
FOREWORD BY ERIC LIPPERT

MANNING
www.it-ebooks.info


Praise for the First Edition
The best C# book available for intermediate to expert developers. Experienced .NET
developers who think they know everything there is to know about the C# language will
almost certainly learn more than a thing or two in this book. It is an interesting coverto-cover read, and will be a handy desktop reference as well. I recommend this book to
anyone who wants to become a C# expert.
—Alvin Ashcraft, DZone review
Simply put, C# in Depth is perhaps the best computer book I’ve read.
—Craig Pelkie, Author, System iNetwork
I have been developing in C# from the very beginning and this book had some nice surprises even for me. I was especially impressed with the excellent coverage of delegates,
anonymous methods, covariance and contravariance. Even if you are a seasoned developer, C# in Depth will teach you something new about the C# language... This book

truly has depth that no other C# language book can touch.
—Adam J. Wolf
Southeast Valley .NET User Group
I enjoyed reading the whole book; it is well-written—the samples are easy to understand.
I actually found it very easy to engage into the whole lambda expressions topic and
really liked the chapter about lambda expressions.
—Jose Rolando Guay Paz
Web Developer, CSW Solutions
This book wraps up the author’s great knowledge of the inner workings of C# and
hands it over to readers in a well-written, concise, usable book.
—Jim Holmes
Author of Windows Developer Power Tools
Every term is used appropriately and in the right context, every example is spot-on
and contains the least amount of code that shows the full extent of the feature...this
is a rare treat.
—Franck Jeannin, Amazon UK reviewer
If you have developed using C# for several years now, and would like to know the internals, this book is absolutely right for you.
—Golo Roden, Author, Speaker, and
Trainer for .NET and related technologies

www.it-ebooks.info


More Praise for the First Edition
If there’s one must-have book for .NET developers, this is it. Jon Skeet provides everything you need to know about C# mazes, with particular attention to LINQ. The
author really knows his stuff and provides invaluable comments about C# features.
—Luigi Zambetti, Developer, Milan
This book is the best C# reference money can buy at the moment.
—Jan Van Ryswyck, ElegantCode.com
Jon Skeet’s writing style is clear and concise and he’s got lots of great examples.
—Peter Kellner, Blogger
A first-class book about C#.
—Teemu Keiski, ASP.NET MVP, AspInsider
Become a C# 3 maestro!
—Fabrice Marguerie, C# MVP, author of LINQ in Action
The best C# book I’ve ever read.
—Chris Mullins, C# MVP
Clear and concise.
—Robin Shahan, GoldMail.com
A treat!


—Anil Radhakrishna, ASP.NET MVP
Reveals C#’s powerful mysteries.
—Christopher Haupt, BuildingWebApps.com
So good, it hurts my head.
—J.D. Conley, Hive7 Inc.
Enriches the beginner, polishes the expert.
—Josh Cronemeyer ThoughtWorks

www.it-ebooks.info


C# in Depth
SECOND EDITION
JON SKEET

MANNING
Greenwich
(74° w. long.)

www.it-ebooks.info


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.
180 Broad St.
Suite 1323
Stamford, CT 06901
Email: orders@manning.com

©2011 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 percent recycled and processed without the use of
elemental chlorine.

Manning Publications Co.
180 Broad St.
Suite 1323
Stamford, CT 06901

Development editor:
Copyeditor:
Proofreader:
Typesetter:
Cover designer:

Jeff Bleiel
Benjamin Berg
Katie Tennant
Dottie Marsico
Marija Tudor

ISBN 978-1-935182-47-4
Printed in the United States of America
1 2 3 4 5 6 7 8 9 10 – MAL – 15 14 13 12 11 10

www.it-ebooks.info


For Holly, with much, much love

www.it-ebooks.info


www.it-ebooks.info


brief contents
PART 1 PREPARING FOR THE JOURNEY .......................................1
1



The changing face of C# development

2



Core foundations: building on C# 1 27

3

PART 2 C# 2: SOLVING THE ISSUES OF C# 1 ............................ 55
3



Parameterized typing with generics

4



Saying nothing with nullable types

5



Fast-tracked delegates

6



Implementing iterators the easy way

7



Concluding C# 2: the final features

57
103

130
156
179

PART 3 C# 3: REVOLUTIONIZING HOW WE CODE . ................... 201
8



Cutting fluff with a smart compiler 203

9



Lambda expressions and expression trees

10



Extension methods

11



Query expressions and LINQ to Objects

12



LINQ beyond collections

227

256
321

vii

www.it-ebooks.info

279


viii

PART 4 C# 4: PLAYING NICELY WITH OTHERS......................... 363
13



Minor changes to simplify code

14



Dynamic binding in a static language

15



Letting your code speak more clearly with Code Contracts

16



Whither now?

490

www.it-ebooks.info

365
401
452


contents
foreword xix
preface xxi
acknowledgments xxiii
about this book xxv

PART 1 PREPARING FOR THE JOURNEY ..............................1

1

The changing face of C# development
1.1

3

Starting with a simple data type 4
The Product type in C# 1 4 Strongly typed collections in
C# 2 6 Automatically implemented properties in C# 3 7
Named arguments in C# 4 7




1.2

Sorting and filtering 9
Sorting products by name

1.3

9



Handling an absence of data
Representing an unknown price
and default values 15

1.4

Introducing LINQ

Querying collections

12

14
14



Optional parameters

16

Query expressions and in-process queries
XML 17 LINQ to SQL 18


ix

www.it-ebooks.info

16



Querying


x

1.5

COM and dynamic typing

19

Simplifying COM interoperability
dynamic language 20

1.6

Interoperating with a



Dissecting the .NET platform 21
C#, the language

1.7

19

22

Runtime



22

Framework libraries



Making your code super awesome

22

23

Presenting full programs as snippets 23 Didactic code isn’t
production code 24 Your new best friend: the language
specification 25




1.8

2

Summary

26

Core foundations: building on C# 1
2.1

Delegates

27

28

A recipe for simple delegates 28 Combining and removing
delegates 33 A brief diversion into events 34 Summary
of delegates 35




2.2



Type system characteristics

36

C#’s place in the world of type systems 36 When is C# 1’s
type system not rich enough? 39 Summary of type system
characteristics 42




2.3

Value types and reference types

42

Values and references in the real world 43 Value and reference
type fundamentals 43 Dispelling myths 45 Boxing and
unboxing 47 Summary of value types and reference types 48








2.4

Beyond C# 1: new features on a solid base 48
Features related to delegates 49 Features related to the type
system 51 Features related to value types 53




2.5

Summary

54

PART 2 C# 2: SOLVING THE ISSUES OF C# .....................155

3

Parameterized typing with generics
3.1
3.2

Why generics are necessary 58
Simple generics for everyday use

57
60

Learning by example: a generic dictionary 60 Generic types
and type parameters 62 Generic methods and reading generic
declarations 65




www.it-ebooks.info


xi

3.3

Beyond the basics

68

Type constraints 69 Type inference for type arguments of generic
methods 74 Implementing generics 75




3.4

Advanced generics

81

Static fields and static constructors 81 How the JIT compiler
handles generics 83 Generic iteration 85 Reflection and
generics 88




3.5



Limitations of generics in C# and other languages

91

Lack of generic variance 92 Lack of operator constraints or a
“numeric” constraint 97 Lack of generic properties, indexers,
and other member types 98 Comparison with C++ templates 99
Comparison with Java generics 100






3.6

4

Summary

101

Saying nothing with nullable types
4.1

103

What do you do when you just don’t have a value? 104
Why value type variables can’t be null 104
representing null values in C# 1 105

4.2



Patterns for

System.Nullableand System.Nullable

107

Introducing Nullable 107 Boxing Nullableand
unboxing 110 Equality of Nullable instances 111
Support from the nongeneric Nullable class 111




4.3

C# 2’s syntactic sugar for nullable types

112

The ? modifier 113 Assigning and comparing with null 114
Nullable conversions and operators 116 Nullable logic 119
Using the as operator with nullable types 120 The null
coalescing operator 121






4.4

Novel uses of nullable types

124

Trying an operation without using output parameters 124
Painless comparisons with the null coalescing operator 126

4.5

5

Summary

129

Fast-tracked delegates
5.1
5.2
5.3

130

Saying goodbye to awkward delegate syntax 131
Method group conversions 133
Covariance and contravariance 134
Contravariance for delegate parameters 135 Covariance of
delegate return types 136 A small risk of incompatibility 138




www.it-ebooks.info


xii

5.4

Inline delegate actions with anonymous methods

138

Starting simply: acting on a parameter 139 Returning
values from anonymous methods 141 Ignoring delegate
parameters 143




5.5

Capturing variables in anonymous methods

144

Defining closures and different types of variables 145
Examining the behavior of captured variables 146 What’s the
point of captured variables ? 147 The extended lifetime of
captured variables 148 Local variable instantiations 149
Mixtures of shared and distinct variables 151 Captured variable
guidelines and summary 153








5.6

6

Summary

154

Implementing iterators the easy way
6.1
6.2

156

C# 1: the pain of handwritten iterators 157
C# 2: simple iterators with yield statements 160
Introducing iterator blocks and yield return 160 Visualizing an
iterator’s workflow 162 Advanced iterator execution flow 164
Quirks in the implementation 167




6.3

Real-life iterator examples

169

Iterating over the dates in a timetable 169 Iterating over lines in
a file 170 Filtering items lazily using an iterator block and a
predicate 173




6.4
6.5

7

Pseudo-synchronous code with the Concurrency and
Coordination Runtime 175
Summary 177

Concluding C# 2: the final features
7.1

Partial types

179

180

Creating a type with multiple files 181 Uses of partial
types 183 Partial methods—C# 3 only! 184




7.2
7.3
7.4

Static classes 186
Separate getter/setter property access
Namespace aliases 190
Qualifying namespace aliases
alias 192 Extern aliases


7.5
7.6

Pragma directives

194

Warning pragmas

194



191
192



189

The global namespace

Checksum pragmas

Fixed-size buffers in unsafe code

www.it-ebooks.info

196

195


xiii

7.7

Exposing internal members to selected assemblies

198

Friend assemblies in the simple case 198 Why use
InternalsVisibleTo? 199 InternalsVisibleTo and signed
assemblies 199




7.8

Summary

200

PART 3 C# 3: REVOLUTIONIZING HOW WE CODE . .......... 201

8

Cutting fluff with a smart compiler
8.1
8.2

203

Automatically implemented properties
Implicit typing of local variables 207

204

Using var to declare a local variable 207 Restrictions on
implicit typing 208 Pros and cons of implicit typing 209
Recommendations 211




8.3

Simplified initialization

211

Defining our sample types 212 Setting simple properties
Setting properties on embedded objects 214 Collection
initializers 215 Uses of initialization features 218


213





8.4
8.5

Implicitly typed arrays 219
Anonymous types 220
First encounters of the anonymous kind 220 Members of
anonymous types 222 Projection initializers 223
What’s the point? 225




8.6

9

Summary

226

Lambda expressions and expression trees
9.1

Lambda expressions as delegates

227

229

Preliminaries: introducing the Func<...> delegate types 229
First transformation to a lambda expression 230 Using a single
expression as the body 231 Implicitly typed parameter lists 231
Shortcut for a single parameter 232




9.2

Simple examples using List and events
Filtering, sorting, and actions on lists
event handler 235

9.3

Expression trees

233



233

Logging in an

236

Building expression trees programmatically 236 Compiling
expression trees into delegates 238 Converting C# lambda
expressions to expression trees 239 Expression trees at the heart
of LINQ 242 Expression trees beyond LINQ 244








www.it-ebooks.info


xiv

9.4

Changes to type inference and overload resolution

246

Reasons for change: streamlining generic method calls 246
Inferred return types of anonymous functions 247 Two-phase
type inference 248 Picking the right overloaded method 252
Wrapping up type inference and overload resolution 254




9.5

10

Summary

254

Extension methods
10.1
10.2

256

Life before extension methods 257
Extension method syntax 259
Declaring extension methods 259 Calling extension
methods 261 Extension method discovery 262
Calling a method on a null reference 263




10.3

Extension methods in .NET 3.5 265
First steps with Enumerable 265 Filtering with Where and
chaining method calls together 267 Interlude: haven’t we seen
the Where method before? 269 Projections using the Select method
and anonymous types 269 Sorting using the OrderBy
method 270 Business examples involving chaining 272










10.4

Usage ideas and guidelines

273

“Extending the world” and making interfaces richer 274
Fluent interfaces 274 Using extension methods sensibly


10.5

11

Summary

277

Query expressions and LINQ to Objects
11.1

Introducing LINQ

279

280

Fundamental concepts in LINQ
data model 285

11.2

276

280



Defining the sample

Simple beginnings: selecting elements

285

Starting with a source and ending with a selection 286 Compiler
translations as the basis of query expressions 287 Range
variables and nontrivial projections 290 Cast, OfType, and
explicitly typed range variables 292






11.3

Filtering and ordering a sequence

294

Filtering using a where clause 294 Degenerate query
expressions 295 Ordering using an orderby clause 296




11.4

Let clauses and transparent identifiers

298

Introducing an intermediate computation with let
Transparent identifiers 299

www.it-ebooks.info

298


xv

11.5

Joins

301

Inner joins using join clauses 301 Group joins with join ... into
clauses 305 Cross joins and flattening sequences using multiple
from clauses 308




11.6

Groupings and continuations

311

Grouping with the group ... by clause
continuations 314

11.7

311



Query

Choosing between query expressions and dot
notation 317
Operations that require dot notation 317 Query expressions
where dot notation may be simpler 318 Where query
expressions shine 319




11.8

12

Summary

320

LINQ beyond collections
12.1

321

Querying a database with LINQ to SQL

322

Getting started: the database and model 323 Initial
queries 325 Queries involving joins 327




12.2

Translations using IQueryable and IQueryProvider

329

Introducing IQueryable and related interfaces 330 Faking
it: interface implementations to log calls 331 Gluing expressions
together: the Queryable extension methods 334 The fake query
provider in action 335 Wrapping up IQueryable 337








12.3

LINQ-friendly APIs and LINQ to XML

337

Core types in LINQ to XML 338 Declarative construction 340
Queries on single nodes 342 Flattened query operators 344
Working in harmony with LINQ 345




12.4

Replacing LINQ to Objects with Parallel LINQ

346

Plotting the Mandelbrot set with a single thread 346
Introducing ParallelEnumerable, ParallelQuery, and
AsParallel 347 Tweaking parallel queries 349


12.5

Inverting the query model with LINQ to Rx

350

IObservable and IObserver 351 Starting simply
(again) 353 Querying observables 354 What’s the
point? 356




12.6

Extending LINQ to Objects



357

Design and implementation guidelines
selecting a random element 359

12.7

Summary

360

www.it-ebooks.info

357



Sample extension:


xvi

PART 4 C# 4: PLAYING NICELY WITH OTHERS ................363

13

Minor changes to simplify code
13.1

365

Optional parameters and named arguments
Optional parameters 366 Named arguments
Putting the two together 376

13.2

Improvements for COM interoperability

366
372



380

The horrors of automating Word before C# 4 380 The revenge
of optional parameters and named arguments 381 When is a
ref parameter not a ref parameter? 382 Calling named
indexers 383 Linking primary interop assemblies 385








13.3

Generic variance for interfaces and delegates

387

Types of variance: covariance and contravariance 387 Using
variance in interfaces 389 Using variance in delegates 392
Complex situations 392 Restrictions and notes 394






13.4

Teeny tiny changes to locking and field-like events
Robust locking

13.5

14

Summary

398



Changes to field-like events

400

Dynamic binding in a static language
14.1

398

399

What? When? Why? How?

401

403

What is dynamic typing? 403 When is dynamic typing useful,
and why? 404 How does C# 4 provide dynamic typing? 405




14.2
14.3

The five-minute guide to dynamic 406
Examples of dynamic typing 408
COM in general, and Microsoft Office in particular 408
Dynamic languages such as IronPython 410 Dynamic typing
in purely managed code 415


14.4

Looking behind the scenes

421

Introducing the Dynamic Language Runtime 421 DLR core
concepts 422 How the C# compiler handles dynamic 426
The C# compiler gets even smarter 430 Restrictions on dynamic
code 432






14.5

Implementing dynamic behavior

435

Using ExpandoObject 435 Using DynamicObject
Implementing IDynamicMetaObjectProvider 446


14.6

Summary

450

www.it-ebooks.info

440


xvii

15

Letting your code speak more clearly with Code Contracts
15.1
15.2

452

Life before Code Contracts 454
Introducing Code Contracts 455
Preconditions 456 Postconditions 458 Invariants 459
Assertions and assumptions 461 Legacy contracts 462






15.3

Rewriting binaries with ccrewrite and ccrefgen
Simple rewriting 464 Contract inheritance 466
Contract reference assemblies 469 Failure behavior

464





15.4

Static checking

472

Getting started with static checking 473 Implicit
obligations 475 Selective checking 478




15.5
15.6

Documenting contracts with ccdocgen
Practical contracts 482

480

Philosophy: what’s in a contract? 483 How do I get
started? 484 Options, options everywhere 485




15.7

16

Summary

Whither now?
16.1
16.2
16.3
16.4

appendix A
appendix B
appendix C

488

490

C#—mixing tradition and modernity
Computer science and .NET 491
The world of computing 492
Farewell 493
LINQ standard query operators 495
Generic collections in .NET 508
Version summaries 521
index 529

www.it-ebooks.info

490

470


www.it-ebooks.info


foreword
There are two kinds of pianists.
There are some pianists who play, not because they enjoy it, but because their parents force them to take lessons. Then there are those who play the piano because it
pleases them to create music. They don’t need to be forced; on the contrary, they
sometimes don’t know when to stop.
Of the latter kind, there are some who play the piano as a hobby. Then there are
those who play for a living. That requires a whole new level of dedication, skill, and talent. They may have some degree of freedom about what genre of music they play and
the stylistic choices they make when playing it, but fundamentally those choices are
driven by the needs of the employer or the tastes of the audience.
Of the latter kind, there are some who do it primarily for the money. Then there
are those professionals who would want to play the piano in public even if they weren’t
being paid. They enjoy using their skills and talents to make music for others. That
they can have fun and get paid for it is so much the better.
Of the latter kind, there are some who are self-taught, who play by ear, who might
have great talent and ability but can’t communicate that intuitive understanding to
others except through the music itself. Then there are those who have formal training
in both theory and practice. They can explain what techniques the composer used to
achieve the intended emotional effect, and use that knowledge to shape their interpretation of the piece.
Of the latter kind, there are some who have never looked inside their pianos. Then
there are those who are fascinated by the clever escapements that lift the damper felts
a fraction of a second before the hammers strike the strings. They own key levelers

xix

www.it-ebooks.info


xx

FOREWORD

and capstan wrenches. They take delight and pride in being able to understand the
mechanisms of an instrument that has 5–10,000 moving parts.
Of the latter kind, there are some who are content to master their craft and exercise their talents for the pleasure and profit it brings. Then there are those who are
not just artists, theorists, and technicians; somehow they find the time to pass that
knowledge on to others as mentors.
I have no idea if Jon Skeet is any kind of pianist. But from my email conversations
with him as one of the C# team’s Most Valuable Professionals over the years, from
reading his blog, and from reading every word of this book at least three times, it has
become clear to me that Jon is that latter kind of software developer: enthusiastic,
knowledgeable, talented, curious and analytical—a teacher of others.
C# is a highly pragmatic and rapidly evolving language. Through the addition of
query comprehensions, richer type inference, a compact syntax for anonymous functions, and so on, I hope that we have enabled a whole new style of programming while
still staying true to the statically typed, component-oriented approach that has made
C# a success.
Many of these new stylistic elements have the paradoxical quality of feeling very
old (lambda expressions go back to the foundations of computer science in the first
half of the twentieth century) and yet at the same time feeling new and unfamiliar to
developers used to a more modern object-oriented approach.
Jon gets all that. This book is ideal for professional developers who have a need to
understand the what and how of the latest revision to C#. But it is also for those developers whose understanding is enriched by exploring the why of the language’s design
principles.
Being able to take advantage of all that new power will require new ways of thinking about data, functions, and the relationship between them. It’s not unlike trying to
play jazz after years of classical training—or vice versa. Either way, I’m looking forward
to finding out what sorts of functional compositions the next generation of C# programmers come up with. Happy composing, and thanks for choosing the key of C# to
do it in.
ERIC LIPPERT
Senior Software
Engineer, Microsoft

www.it-ebooks.info


preface
It feels like a very long time since I wrote the preface to the first edition, but it’s actually only been about two and a half years. In that time, there have been many changes
both for myself and in the landscape of technology.
In my personal life, I’m now very proud to be a software engineer at Google—with
the one downside that I don’t spend as much time working in C# as I used to. I’ve
found a new addiction in the form of Stack Overflow, the developer question-andanswer forum. My youngest sons who were barely two years old when the first edition
came out are now about to start school. I’ve had the privilege of giving talks about C#
in London, Oslo, Copenhagen, and various other places, with more to come. It’s all
been a lot of fun, although occasionally somewhat hectic.
The technological world has been no less shaken up. I’m writing this on a netbook—a word which barely had any meaning when I was writing the first edition. The
smartest of smart phones was pretty primitive by today’s standards, and my current
laptop would have served as an outrageously overpowered desktop machine. The
developments in software have been less mind-blowing in my opinion, although many
of the projects which are now becoming mainstream (such as Parallel Extensions)
were in their early stages back then. Silverlight had only just made the leap to being a
fully managed language, and ASP.NET MVC was still very young, and wouldn’t have its
1.0 release for some time. Of course, C# itself has changed as well—otherwise there’d
be little reason to bring out a second edition.
Despite all this change, the focus of this book has stayed the same. I remain committed to helping people form a more intimate connection with C#. As ever more
frameworks pop up—and as we have to learn them ever more quickly—it’s vital to

xxi

www.it-ebooks.info


xxii

FOREWORD

have a firm foundation to build on. We should at least be secure in saying, “this is a
generic method call, this is a property access, this is a lambda expression being converted into a delegate,” and so on.
I believe the general standard of language knowledge is improving, in fact. I’ve
been pleasantly surprised to see how well LINQ seems to be understood by many developers, although to some it’s clearly still a black box of magic. Admittedly these observations are mostly via Stack Overflow, which is obviously a biased, self-selecting subset
of all developers—but even so, I think there’s reason for optimism. I hope the first
edition of this book has played some small part in that improvement, and that this edition will too.
I keep meaning to learn a new language, properly. I’ve dabbled with F# and
Python. I’ve promised myself that I’ll learn Erlang and Haskell. I keep meaning to see
what all the fuss is about with Ruby... but C# pulls me back, every time. It’s not perfect,
but it usually allows me to express myself clearly and concisely, and those are probably
the most important attributes a language can have. One day I’ll manage to stray far
enough away to start genuinely thinking in a different language—but until that time, I
hope I can convey some of my passion for C# to you in this book.

www.it-ebooks.info


acknowledgments
You might expect that writing the second edition of a book is easier than writing the
first: just add another few chapters, make some modifications to the existing ones,
and you’re done, right? If that sounds plausible, think about writing code for a new
project compared with trying to modify an existing application. Now imagine doing it
without a compiler or unit tests. Fortunately, although there are precious few ways of
really testing the quality of a book, I have been lucky enough to have a great set of
people supporting me and keeping the book on the straight and narrow.
Most importantly, my family have put up with me spending evenings writing,
rewriting, editing, indexing, and generally not being with them as much as I’d like. My
sons don’t seem to have been put off computing by this though, and my oldest son,
Tom, is nearly old enough to start programming. It’ll be wonderful for him to have
some idea of what I do all day at work. My children are generally in bed when I’m writing, though, so it’s mostly my wife Holly who has dealt with the worst of this. Despite
our many commitments, my family is of utmost importance to me, and I’m immensely
grateful that they have supported me in this and many other endeavors.
The formal peer reviewers are listed later on, but I’d like to add a note of personal
thanks to all those who ordered early access copies of this second edition, finding
typos and suggesting changes... and also constantly asking when the book was coming
out. The very fact that I had readers who were eager to get their hands on the finished
book was a huge source of encouragement.
I always get on well with the team at Manning, and it’s been a pleasure to work with
some familiar friends from the first edition as well as newcomers. Mike Stephens and
Jeff Bleiel have guided the whole process smoothly, as we decided what to change

xxiii

www.it-ebooks.info


xxiv

ACKNOWLEDGMENTS

from the first edition and what to keep. They’ve generally put the whole thing into the
right shape. Benjamin Berg and Katie Tennant provided expert copyediting and
proofreading, respectively, never once expressing irritation with my Englishness, pickiness, or general bewilderment. The production team has worked its magic in the
background, as ever, but I’m grateful to them nonetheless: Dottie Marsico, Janet Vail,
Marija Tudor, and Mary Piergies. Finally, I’d like to thank the publisher, Marjan Bace,
for allowing me a second edition and exploring some interesting future options.
Peer review is immensely important, not only for getting the technical details of
the book right, but also the balance and tone. Sometimes the comments we received
have merely shaped the overall book; in other cases I’ve made very specific changes in
response. Either way, all feedback has been welcome. So thanks to the following
reviewers for making the book better for all of us: Michael Caro, Austin Ziegler, Dave
Corun, Amos Bannister, Lester Lobo, Marc Gravel, Nikander Bruggeman, Margriet
Bruggeman, Joe Albahari, Tyson S. Maxwell, Horaci Macias, Eric Lippert, Kirill Osenkov, Stuart Caborn, Sean Reilly, Aleksy Nudelman, Keith Hill, Josh Heyer, and Jared
Parsons.
In the first edition of the book I thanked the C# team, but this time I have wider
thanks to give to Softies. I’m always amazed at how generous the various software engineers and project managers have been when I’ve pestered them with specific questions or sections to review. Some of these folks may not even have realized they were
helping with the book, but they certainly were: Todd Apley, Mike Barnett, Chris Burrows, Wes Dyer, Manuel Fahndrich, Neal Gafter, Eric Lippert, Francesco Logozzo, Erik
Meijer, Sam Ng, Kirill Osenkov, Alexandra Rusina, Chris Sells, Mads Torgersen, Stephen Toub, and Jeffrey Van Gogh.
Out of that list, I’d like to call Eric Lippert out for special attention, as the tech
reviewer for the book once again and for writing the foreword. Since the first edition
I’ve had many more conversations with Eric, and finally met up with him a couple of
times, both of which have been delightful. I’m still utterly in awe of both his knowledge and the meticulous but readable way in which he shares it with the world both
in his blog and on Stack Overflow. I couldn’t have asked for a better reviewer, and I
look forward to bugging Eric more in the future about anything and everything
related to C#.

www.it-ebooks.info


Tài liệu bạn tìm kiếm đã sẵn sàng tải về

Tải bản đầy đủ ngay

×