Sunday, January 21, 2007

Effective C#: 50 Specific Ways to Improve Your C#

Title:Effective C#: 50 Specific Ways to Improve Your C#
Author: Bill Wagner
Publisher: Addison Wesley Professional
Format: Paper; 336 pp
ISBN-10: 0321245660
ISBN-13: 9780321245663
Published: 12/03/2004

C# is the premier language for .NET development, and is currently the fastest growing programming language. It is already being used by 29% of professional programmers, with that percentage expected to continue increasing rapidly. It is still a relatively new language, however, and developers are still looking for resources to enable them to use it better. Effective C# covers C# from a practical perspective, and provides insight into using the language more efficiently. The reader will get information based on years of practical C# experience in real world settings. The format of the book is the same that has proven immensely popular in other books in Scott Meyers' series. The author has a devoted following from his regular C# columns in Visual Studio Magazine. Every serious C# developer will keep this book close at hand, to return to again and again for advice.
Table of Contents

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.


Sample Chapter:Chapter 2 Item 18 - Implement the Standard Dispose Pattern
Amazon Link: Effective C#: 50 Specific Ways to Improve Your C# (Effective Software Development)

No comments: