About the Book
"This book really demonstrates Bill's strengths as a writer and programmer. In a very short amount of time, he is able to present an issue, fix it and conclude it; each chapter is tight, succinct, and to the point."
—Josh Holmes, Independent Contractor
"The book provides a good introduction to the C# language elements from a pragmatic point of view, identifying best practices along the way, and following a clear and logical progression from the basic syntax to creating components to improving your code writing skills. Since each topic is covered in short entries, it is very easy to read and you'll quickly realize the benefits of the book."
—Tomas Restrepo, Microsoft MVP
"The book covers the basics well, especially with respect to the decisions needed when deriving classes from System.Object. It is easy to read with examples that are clear, concise and solid. I think it will bring good value to most readers."
—Rob Steel, Central Region Integration COE & Lead Architect, Microsoft
"Effective C# provides the C# developer with the tools they need to rapidly grow their experience in Visual C# 2003 while also providing insight into the many improvements to the language that will be hitting a desktop near you in the form of Visual C# 2005."
—Doug Holland, Precision Objects
"Part of the point of the .NET Framework—and the C# Language, in particular—is to let the developer focus solving customer problems and deliver product, rather than spending hours (or even weeks) writing plumbing code. Bill Wagner's Effective C#, not only shows you what's going on behind the scenes, but shows you how to take advantage of particular C# code constructs. Written in a dispassionate style that focuses on the facts—and just the facts—of writing effective C# code, Wagner's book drills down into practices that will let you write C# applications and components that are easier to maintain as well as faster to run. I'm recommending Effective C# to all students of my .NET BootCamp and other C#-related courses."
—Richard Hale Shaw, www.RichardHaleShawGroup.com
C#'s resemblances to C++, Java, and C make it easier to learn, but there's a downside: C# programmers often continue to use older techniques when far better alternatives are available. In Effective C#, respected .NET expert Bill Wagner identifies fifty ways you can start leveraging the full power of C# in order to write faster, more efficient, and more reliable software.
Effective C# follows the format that made Effective C++ (Addison-Wesley, 1998) and Effective Java (Addison-Wesley, 2001) 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 value types to assemblies, exceptions to reflection. Along the way, he shows exactly how to avoid dozens of common C# performance and reliability pitfalls. You'll learn how to:
Use both types of C# constants for efficiency and maintainability, see item 2
Use immutable data types to eliminate unnecessary error checking, see item 7
Avoid the C# function that'll practically always get you in trouble, see item 10
Minimize garbage collection, boxing, and unboxing, see items 16 and 17
Take full advantage of interfaces and delegates, see items 19 though 22
Create CLS compliant assemblies that use noncompliant C# language features, see item 30
Improve reliability and maintainability by creating small, cohesive assemblies, see item 32
Leverage the full power of .NET's runtime diagnostics, see item 36
Know when—and when not—to use reflection, see items 42 and 43
Preview the major enhancements in C# 2.0, see item 49
You're already a successful C# programmer—this book can help you become an outstanding one.
Bill Wagner is co-founder of and .NET consultant for SRT Solutions. A nationally recognized independent expert on .NET, he has been a regular contributor to ASP.NET Pro Magazine, Visual Studio Magazine, and the .NET Insight newsletter. In addition to being a Microsoft Regional Director, he is also active in the Southeast Michigan .NET User Group and the Ann Arbor Computing Society. He is author of The C# Core Language Little Black Book (The Coriolis Group, 2002).
© Copyright Pearson Education. All rights reserved.
Table of Contents:
Introduction.
1. C# Language Elements.
Item 1 - Always 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 - Distinguish Between Value Types and Reference Types.
Item 7 - Prefer Immutable Atomic Value Types.
Item 8 - Ensure That 0 Is a Valid State for Value Types.
Item 9 - Understand the Relationships Among ReferenceEquals(),static Equals(), instance Equals(), and operator==.
Item 10 - Understand the Pitfalls of GetHashCode().
Item 11 - Prefer foreach Loops.
2. .NET Resource Management.
Item 12 - Prefer Variable Initializers to Assignment Statements.
Item 13 - Initialize Static Class Members with Static Constructors.
Item 14 - Utilize Constructor Chaining.
Item 15 - Utilize using and try/finally for Resource Cleanup.
Item 16 - Minimize Garbage.
Item 17 - Minimize Boxing and Unboxing.
Item 18 - Implement the Standard Dispose Pattern.
3. Expressing Designs with C#.
Item 19 - Prefer Defining and Implementing Interfaces to Inheritance.
Item 20 - Distinguish Between Implementing Interfaces and Overriding Virtual Functions.
Item 21 - Express Callbacks with Delegates.
Item 22 - Define Outgoing Interfaces with Events.
Item 23 - Avoid Returning References to Internal Class Objects.
Item 24 - Prefer Declarative to Imperative Programming.
Item 25 - Prefer Serializable Types.
Item 26 - Implement Ordering Relations with IComparable and Icomparer.
Item 27 - Avoid Icloneable.
Item 28 - Avoid Conversion Operators.
Item 29 - Use the new Modifier Only When Base Class Updates Mandate It.
4. Creating Binary Components.
Item 30 - Prefer CLS-Compliant Assemblies.
Item 31 - Prefer Small, Simple Functions.
Item 32 - Prefer Smaller, Cohesive Assemblies.
Item 33 - Limit Visibility of Your Types.
Item 34 - Create Large-Grain Web APIs.
5. Working with the Framework.
Item 35 - Prefer Overrides to Event Handlers.
Item 36 - Leverage .NET Runtime Diagnostics.
Item 37 - Use the Standard Configuration Mechanism.
Item 38 - Utilize and Support Data Binding.
Item 39 - Use .NET Validation.
Item 40 - Match Your Collection to Your Needs.
Item 41 - Prefer DataSets to Custom Structures.
Item 42 - Utilize Attributes to Simplify Reflection.
Item 43 - Don't Overuse Reflection.
Item 44 - Create Complete Application-Specific Exception Classes.
6. Miscellaneous.
Item 45 - Prefer the Strong Exception Guarantee.
Item 46 - Minimize Interop.
Item 47 - Prefer Safe Code.
Item 48 - Learn About Tools and Resources.
Item 49 - Prepare for C# 2.0.
Item 50 - Learn About the ECMA Standard.
Index.
About the Author :
Introduction. 1. C# Language Elements. Item 1 - Always 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 - Distinguish Between Value Types and Reference Types. Item 7 - Prefer Immutable Atomic Value Types. Item 8 - Ensure That 0 Is a Valid State for Value Types. Item 9 - Understand the Relationships Among ReferenceEquals(),static Equals(), instance Equals(), and operator==. Item 10 - Understand the Pitfalls of GetHashCode(). Item 11 - Prefer foreach Loops. 2. .NET Resource Management. Item 12 - Prefer Variable Initializers to Assignment Statements. Item 13 - Initialize Static Class Members with Static Constructors. Item 14 - Utilize Constructor Chaining. Item 15 - Utilize using and try/finally for Resource Cleanup. Item 16 - Minimize Garbage. Item 17 - Minimize Boxing and Unboxing. Item 18 - Implement the Standard Dispose Pattern. 3. Expressing Designs with C#. Item 19 - Prefer Defining and Implementing Interfaces to Inheritance. Item 20 - Distinguish Between Implementing Interfaces and Overriding Virtual Functions. Item 21 - Express Callbacks with Delegates. Item 22 - Define Outgoing Interfaces with Events. Item 23 - Avoid Returning References to Internal Class Objects. Item 24 - Prefer Declarative to Imperative Programming. Item 25 - Prefer Serializable Types. Item 26 - Implement Ordering Relations with IComparable and Icomparer. Item 27 - Avoid Icloneable. Item 28 - Avoid Conversion Operators. Item 29 - Use the new Modifier Only When Base Class Updates Mandate It. 4. Creating Binary Components. Item 30 - Prefer CLS-Compliant Assemblies. Item 31 - Prefer Small, Simple Functions. Item 32 - Prefer Smaller, Cohesive Assemblies. Item 33 - Limit Visibility of Your Types. Item 34 - Create Large-Grain Web APIs. 5. Working with the Framework. Item 35 - Prefer Overrides to Event Handlers. Item 36 - Leverage .NET Runtime Diagnostics. Item 37 - Use the Standard Configuration Mechanism. Item 38 - Utilize and Support Data Binding. Item 39 - Use .NET Validation. Item 40 - Match Your Collection to Your Needs. Item 41 - Prefer DataSets to Custom Structures. Item 42 - Utilize Attributes to Simplify Reflection. Item 43 - Don't Overuse Reflection. Item 44 - Create Complete Application-Specific Exception Classes. 6. Miscellaneous. Item 45 - Prefer the Strong Exception Guarantee. Item 46 - Minimize Interop. Item 47 - Prefer Safe Code. Item 48 - Learn About Tools and Resources. Item 49 - Prepare for C# 2.0. Item 50 - Learn About the ECMA Standard. Index.
