book

C# in Depth

Name: C# in Depth
Author: Jonathan Skeet
ISBN: 9781933988368

by Jonathan Skeet

April 2008

Intermediate to advanced

424 pages

12h 9m

English

Manning Publications

Read now

Unlock full access

Copyright
Dedication
Foreword
Preface
Acknowledgments
About This Book
Who should read this book?RoadmapTerminology and typographyAuthor Online and the C# in Depth websiteAbout the author
About the Cover Illustration
Comments from the Tech Review
1. Preparing for the journey
1. The changing face of C# development
1.1. Evolution in action: examples of code change1.1.1. Defining the Product type1.1.2. Sorting products by name1.1.3. Querying collections1.1.4. Representing an unknown price1.1.5. LINQ and query expressions1.2. A brief history of C# (and related technologies)1.2.1. The world before C#1.2.2. C# and .NET are born1.2.3. Minor updates with .NET 1.1 and the first major step: .NET 2.01.2.4. “Next generation” products1.2.5. Historical perspective and the fight for developer support1.3. The .NET platform1.3.1. Distinguishing between language, runtime, and librariesLanguageRuntimeFramework Libraries1.3.2. Untangling version number chaos1.4. Fully functional code in snippet form1.4.1. Snippets and their expansions1.4.2. Introducing Snippy1.5. Summary
2. Core foundations: building on C# 1
2.1. Delegates2.1.1. A recipe for simple delegatesDeclaring the Delegate TypeFinding an Appropriate Method for the Delegate Instance’s ActionCreating a Delegate InstanceInvoking a Delegate InstanceA Complete Example and Some Motivation2.1.2. Combining and removing delegates2.1.3. A brief diversion into events2.1.4. Summary of delegates2.2. Type system characteristics2.2.1. C#’s place in the world of type systemsStatic Typing vs. Dynamic TypingExplicit Typing vs. Implicit TypingType-Safe vs. Type-Unsafe2.2.2. When is C# 1’s type system not rich enough?Collections, Strongc and WeakLack of Covariant Return Types2.2.3. When does C# 1’s type system get in the way?2.2.4. Summary of type system characteristics2.3. Value types and reference types2.3.1. Values and references in the real world2.3.2. Value and reference type fundamentals2.3.3. Dispelling mythsMyth #1: “Structs are Lightweight Classes”Myth #2: “Reference Types Live on the Heap, Value Types Live on the Stack”Myth #3: “Objects are Passed by Reference in C# by Default”2.3.4. Boxing and unboxing2.3.5. Summary of value types and reference types2.4. C# 2 and 3: new features on a solid base2.4.1. Features related to delegates2.4.2. Features related to the type system2.4.3. Features related to value types2.5. Summary

2. C#2: solving the issues of C#1
3. Parameterized typing with generics
3.1. Why generics are necessary3.2. Simple generics for everyday use3.2.1. Learning by example: a generic dictionary3.2.2. Generic types and type parameters3.2.3. Generic methods and reading generic declarations3.3. Beyond the basics3.3.1. Type constraintsReference Type ConstraintsValue Type ConstraintsConstructor Type ConstraintsDerivation Type ConstraintsCombining Constraints3.3.2. Type inference for type arguments of generic methods3.3.3. Implementing genericsDefault Value ExpressionsDirect ComparisonsFull Comparison Example: Representing a Pair of Values3.4. Advanced generics3.4.1. Static fields and static constructors3.4.2. How the JIT compiler handles generics3.4.3. Generic iteration3.4.4. Reflection and genericsUsing Typeof with Generic TypesMethods and Properties of System.TypeReflecting Generic Methods3.5. Generic collection classes in .NET 2.03.5.1. List<T>New Features of List<T>Features “Missing” from List<T>3.5.2. Dictionary<TKey,TValue>3.5.3. Queue<T> and Stack<T>3.5.4. SortedList<TKey, TValue> and SortedDictionary<TKey,TValue>3.5.5. LinkedList<T>3.6. Limitations of generics in C# and other languages3.6.1. Lack of covariance and contravarianceWhy Don’T Generics Support Covariance?Where Covariance Would be UsefulWhere Contravariance Would be Useful3.6.2. Lack of operator constraints or a “numeric” constraint3.6.3. Lack of generic properties, indexers, and other member types3.6.4. Comparison with C++ templates3.6.5. Comparison with Java generics3.7. Summary
4. Saying nothing with nullable types
4.1. What do you do when you just don’t have a value?4.1.1. Why value type variables can’t be null4.1.2. Patterns for representing null values in C# 1Pattern 1: The Magic ValuePattern 2: A Reference Type WrapperPattern 3: An Extra Boolean Flag4.2. System.Nullable<T> and System.Nullable4.2.1. Introducing Nullable<T>4.2.2. Boxing and unboxing4.2.3. Equality of Nullable<T> instances4.2.4. Support from the nongeneric Nullable class4.3. C# 2’s syntactic sugar for nullable types4.3.1. The ? modifier4.3.2. Assigning and comparing with null4.3.3. Nullable conversions and operatorsConversions Involving Nullable TypesOperators Involving Nullable Types4.3.4. Nullable logic4.3.5. The null coalescing operator4.4. Novel uses of nullable types4.4.1. Trying an operation without using output parameters4.4.2. Painless comparisons with the null coalescing operator4.5. Summary
5. Fast-tracked delegates
5.1. Saying goodbye to awkward delegate syntax5.2. Method group conversions5.3. Covariance and contravariance5.4. Inline delegate actions with anonymous methods5.4.1. Starting simply: acting on a parameter5.4.2. Returning values from anonymous methods5.4.3. Ignoring delegate parameters5.5. Capturing variables in anonymous methods5.5.1. Defining closures and different types of variables5.5.2. Examining the behavior of captured variables5.5.3. What’s the point of captured variables?5.5.4. The extended lifetime of captured variables5.5.5. Local variable instantiations5.5.6. Mixtures of shared and distinct variables5.5.7. Captured variable guidelines and summaryGuidelines for Using Captured Variables5.6. Summary
6. Implementing iterators the easy way
6.1. C#1: the pain of handwritten iterators6.2. C#2: simple iterators with yield statements6.2.1. Introducing iterator blocks and yield return6.2.2. Visualizing an iterator’s workflow6.2.3. Advanced iterator execution flowEnding an Iterator with Yield BreakExecution of Finally Blocks6.2.4. Quirks in the implementation6.3. Real-life example: iterating over ranges6.3.1. Iterating over the dates in a timetable6.3.2. Scoping the Range class6.3.3. Implementation using iterator blocks6.4. Pseudo-synchronous code with the Concurrency and Coordination Runtime6.5. Summary
7. Concluding C# 2: the final features
7.1. Partial types7.1.1. Creating a type with multiple files7.1.2. Uses of partial types7.1.3. Partial methods—C# 3 only!7.2. Static classes7.3. Separate getter/setter property access7.4. Namespace aliases7.4.1. Qualifying namespace aliases7.4.2. The global namespace alias7.4.3. Extern aliases7.5. Pragma directives7.5.1. Warning pragmas7.5.2. Checksum pragmas7.6. Fixed-size buffers in unsafe code7.7. Exposing internal members to selected assemblies7.7.1. Friend assemblies in the simple case7.7.2. Why use InternalsVisibleTo?7.7.3. InternalsVisibleTo and signed assemblies7.8. Summary
3. C# 3—revolutionizing how we code
8. Cutting fluff with a smart compiler
8.1. Automatically implemented properties8.2. Implicit typing of local variables8.2.1. Using var to declare a local variable8.2.2. Restrictions on implicit typing8.2.3. Pros and cons of implicit typing8.2.4. Recommendations8.3. Simplified initialization8.3.1. Defining our sample types8.3.2. Setting simple properties8.3.3. Setting properties on embedded objects8.3.4. Collection initializersCreating New Collections with Collection InitializersPopulating Collections Within Other Object Initializers8.3.5. Uses of initialization features“Constant” CollectionsSetting Up Unit TestsParameter Encapsulation<Insert Your Favorite Use Here>8.4. Implicitly typed arrays8.5. Anonymous types8.5.1. First encounters of the anonymous kind8.5.2. Members of anonymous types8.5.3. Projection initializers8.5.4. What’s the point?8.6. Summary
9. Lambda expressions and expression trees
9.1. Lambda expressions as delegates9.1.1. Preliminaries: introducing the Func<...> delegate types9.1.2. First transformation to a lambda expression9.1.3. Using a single expression as the body9.1.4. Implicitly typed parameter lists9.1.5. Shortcut for a single parameter9.2. Simple examples using List<T> and events9.2.1. Filtering, sorting, and actions on lists9.2.2. Logging in an event handler9.3. Expression trees9.3.1. Building expression trees programmatically9.3.2. Compiling expression trees into delegates9.3.3. Converting C# lambda expressions to expression trees9.3.4. Expression trees at the heart of LINQ9.4. Changes to type inference and overload resolution9.4.1. Reasons for change: streamlining generic method calls9.4.2. Inferred return types of anonymous functions9.4.3. Two-phase type inference9.4.4. Picking the right overloaded method9.4.5. Wrapping up type inference and overload resolution9.5. Summary
10. Extension methods
10.1. Life before extension methods10.2. Extension method syntax10.2.1. Declaring extension methods10.2.2. Calling extension methods10.2.3. How extension methods are found10.2.4. Calling a method on a null reference10.3. Extension methods in .NET 3.510.3.1. First steps with Enumerable10.3.2. Filtering with Where, and chaining method calls together10.3.3. Projections using the Select method and anonymous types10.3.4. Sorting using the OrderBy method10.3.5. Business examples involving chainingAggregation: Summing SalariesGrouping: Counting Bugs Assigned to Developers10.4. Usage ideas and guidelines10.4.1. “Extending the world” and making interfaces richer10.4.2. Fluent interfaces10.4.3. Using extension methods sensibly10.5. Summary
11. Query expressions and LINQ to Objects
11.1. Introducing LINQ11.1.1. What’s in a name?11.1.2. Fundamental concepts in LINQSequencesDeferred Execution and StreamingStandard Query Operators11.1.3. Defining the sample data model11.2. Simple beginnings: selecting elements11.2.1. Starting with a source and ending with a selection11.2.2. Compiler translations as the basis of query expressions11.2.3. Range variables and nontrivial projections11.2.4. Cast, OfType, and explicitly typed range variables11.3. Filtering and ordering a sequence11.3.1. Filtering using a where clause11.3.2. Degenerate query expressions11.3.3. Ordering using an orderby clause11.4. Let clauses and transparent identifiers11.4.1. Introducing an intermediate computation with let11.4.2. Transparent identifiers11.5. Joins11.5.1. Inner joins using join clauses11.5.2. Group joins with join ... into clauses11.5.3. Cross joins using multiple from clauses11.6. Groupings and continuations11.6.1. Grouping with the group ... by clause11.6.2. Query continuations11.7. Summary
12. LINQ beyond collections
12.1. LINQ to SQL12.1.1. Creating the defect database and entitiesCreating the SQL Server 2005 Database SchemaCreating the Entity Classes12.1.2. Populating the database with sample data12.1.3. Accessing the database with query expressionsFirst Query: Finding Defects Assigned to TimSQL Generation for a More Complex Query: A Let ClauseExplicit Joins: Matching Defects with Notification SubscriptionsImplicit Joins: Showing Defect Summaries and Project Names12.1.4. Updating the database12.1.5. LINQ to SQL summary12.2. Translations using IQueryable and IQueryProvider12.2.1. Introducing IQueryable<T> and related interfaces12.2.2. Faking it: interface implementations to log calls12.2.3. Gluing expressions together: the Queryable extension methods12.2.4. The fake query provider in action12.2.5. Wrapping up IQueryable12.3. LINQ to DataSet12.3.1. Working with untyped datasets12.3.2. Working with typed datasetsCreating the Typed Dataset with Visual StudioPopulating and Querying Typed Datasets12.4. LINQ to XML12.4.1. XElement and XAttribute12.4.2. Converting sample defect data into XML12.4.3. Queries in LINQ to XML12.4.4. LINQ to XML summary12.5. LINQ beyond .NET 3.512.5.1. Third-party LINQLINQ to AmazonLINQ to NhibernateLINQ to Active Directory12.5.2. Future Microsoft LINQ technologiesThe ADO.NET Entity FrameworkParallel LINQ (PLINQ)12.6. Summary
13. Elegant code in the new era
13.1. The changing nature of language preferences13.1.1. A more functional emphasis13.1.2. Static, dynamic, implicit, explicit, or a mixture?13.2. Delegation as the new inheritance13.3. Readability of results over implementation13.4. Life in a parallel universe13.5. Farewell
LINQ standard query operators
A.1. AggregationA.2. ConcatenationA.3. ConversionA.4. Element operationsA.5. Equality operationsA.6. GenerationA.7. GroupingA.8. JoinsA.9. PartitioningA.10. ProjectionA.11. QuantifiersA.12. FilteringA.13. Set-based operationsA.14. Sorting

Content preview from C# in Depth

Chapter 10. Extension methods

This chapter covers

Writing extension methods
Calling extension methods
Method chaining
Extension methods in .NET 3.5
Other uses for extension methods

I’m not a fan of inheritance. Or rather, I’m not a fan of a number of places where inheritance has been used in code that I’ve maintained, or class libraries I’ve worked with. As with so many things, it’s powerful when used properly, but it’s got a design overhead to it that is often overlooked and can become painful over time. It’s sometimes used as a way of adding extra behavior and functionality to a class, even when no real information is being added about the object—where nothing is being specialized.

Sometimes that’s appropriate—if objects of the new type should carry ...

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.

Read now

Unlock full access

More than 5,000 organizations count on O’Reilly

O’Reilly covers everything we've got, with content to help us build a world-class technology community, upgrade the capabilities and competencies of our teams, and improve overall team performance as well as their engagement.

Julian F.

Head of Cybersecurity

I wanted to learn C and C++, but it didn't click for me until I picked up an O'Reilly book. When I went on the O’Reilly platform, I was astonished to find all the books there, plus live events and sandboxes so you could play around with the technology.

Addison B.

Field Engineer

I’ve been on the O’Reilly platform for more than eight years. I use a couple of learning platforms, but I'm on O'Reilly more than anybody else. When you're there, you start learning. I'm never disappointed.

Amir M.

Data Platform Tech Lead

I'm always learning. So when I got on to O'Reilly, I was like a kid in a candy store. There are playlists. There are answers. There's on-demand training. It's worth its weight in gold, in terms of what it allows me to do.

Mark W.

Embedded Software Engineer

Publisher Resources

ISBN: 9781933988368Other Publisher Support Publisher Website Purchase Link

Cloud Computing

Data Engineering

Data Science

AI & ML

Programming Languages

Software Architecture

IT/Ops

Security

Design

Business

Soft Skills

C# in Depth

by Jonathan Skeet

Chapter 10. Extension methods

Become an O’Reilly member and get unlimited access to this title plus top books and audiobooks from O’Reilly and nearly 200 top publishers, thousands of courses curated by job role, 150+ live events each month,
and much more.