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 for 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 pidai~s. 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：暂无简介

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 leanup.
　　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.