Effective C#, 2nd Edition

C# has matured over the past decade: It’s now a rich language with generics, functional programming concepts, and support for both static and dynamic typing. This palette of techniques provides great tools for many different idioms, but there are also many ways to make mistakes. In Effective C#, Second Edition, respected .NET expert Bill Wagner identifies fifty ways you can leverage the full power of the C# 4.0 language to express your designs concisely and clearly.

Effective C#, Second Edition, follows a clear format that makes it indispensable to hundreds of thousands of developers: clear, practical explanations, expert tips, and plenty of realistic code examples. Drawing on his unsurpassed C# experience, Wagner addresses everything from types to resource management to dynamic typing to multicore support in the C# language and the .NET framework. Along the way, he shows how to avoid common pitfalls in the C# language and the .NET environment. You’ll learn how to

• Use both types of C# constants for efficiency and maintainability (see Item 2)
• Employ immutable data types to promote multicore processing (see Item 20)
• Minimize garbage collection, boxing, and unboxing (see Items 16 and 45)
• Take full advantage of interfaces and delegates (see Items 22 though 25)
• Make the most of the parallel framework (see Items 35 through 37)
• Use duck typing in C# (see Item 38)
• Spot the advantages of the dynamic and Expression types over reflection (see Items 42 and 43)
• Assess why query expressions are better than loops (see Item 8)
• Understand how generic covariance and contravariance affect your designs (see Item 29)
• See how optional parameters can minimize the number of method overloads (see Item 10)

You’re already a successful C# programmer–this book will help you become an outstanding one.

Table of Contents

Chapter 1 C# Language Idioms
Item 1: Use Properties Instead of Accessible Data Members
Item 2: Prefer readonly to const
Item 3: Prefer the is or as Operators to Casts
Item 4: Use Conditional Attributes Instead of #if
Item 5: Always Provide ToString()
Item 6: Understand the Relationships Among the Many Different Concepts of Equality
Item 7: Understand the Pitfalls of GetHashCode()
Item 8: Prefer Query Syntax to Loops
Item 9: Avoid Conversion Operators in Your APIs
Item 10: Use Optional Parameters to Minimize Method Overloads
Item 11: Understand the Attraction of Small Functions

Chapter 2 .NET Resource Management
Item 12: Prefer Member Initializers to Assignment Statements
Item 13: Use Proper Initialization for Static Class Members
Item 14: Minimize Duplicate Initialization Logic
Item 15: Utilize using and try/finally for Resource Cleanup
Item 16: Avoid Creating Unnecessary Objects
Item 17: Implement the Standard Dispose Pattern
Item 18: Distinguish Between Value Types and Reference Types
Item 19: Ensure That 0 Is a Valid State for Value Types
Item 20: Prefer Immutable Atomic Value Types

Chapter 3 Expressing Designs in C#
Item 21: Limit Visibility of Your Types
Item 22: Prefer Defining and Implementing Interfaces to Inheritance
Item 23: Understand How Interface Methods Differ from Virtual Methods
Item 24: Express Callbacks with Delegates
Item 25: Implement the Event Pattern for Notifications
Item 26: Avoid Returning References to Internal Class Objects
Item 27: Prefer Making Your Types Serializable
Item 28: Create Large-Grain Internet Service APIs
Item 29: Support Generic Covariance and Contravariance

Chapter 4 Working with the Framework
Item 30: Prefer Overrides to Event Handlers
Item 31: Implement Ordering Relations with IComparable and IComparer
Item 32: Avoid ICloneable
Item 33: Use the new Modifier Only to React to Base Class Updates
Item 34: Avoid Overloading Methods Defined in Base Classes
Item 35: Learn How PLINQ Implements Parallel Algorithms
Item 36: Understand How to Use PLINQ for I/O Bound Operations
Item 37: Construct Parallel Algorithms with Exceptions in Mind

Chapter 5 Dynamic Programming in C#
Item 38: Understand the Pros and Cons of Dynamic
Item 39: Use Dynamic to Leverage the Runtime Type of Generic Type Parameters
Item 40: Use Dynamic for Parameters That Receive Anonymous Types
Item 41: Use DynamicObject or IDynamicMetaObjectProvider for Data-Driven Dynamic Types
Item 42: Understand How to Make Use of the Expression API
Item 43: Use Expressions to Transform Late Binding into Early Binding
Item 44: Minimize Dynamic Objects in Public APIs

Chapter 6 Miscellaneous
Item 45: Minimize Boxing and Unboxing
Item 46: Create Complete Application-Specific Exception Classes
Item 47: Prefer the Strong Exception Guarantee
Item 48: Prefer Safe Code
Item 49: Prefer CLS-Compliant Assemblies
Item 50: Prefer Smaller, Cohesive Assemblies