Effective C#: 50 Specific Ways to Improve Your C# (Paperback)

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.