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

Kobo ebook | December 3, 2004

byBill Wagner

not yet rated|write a review

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.

Pricing and Purchase Info

$48.49 online
$62.98 list price (save 23%)
Available for download
Not available in stores

From the Publisher

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

From the Jacket

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

Format:Kobo ebookPublished:December 3, 2004Publisher:Pearson EducationLanguage:English

The following ISBNs are associated with this title:

ISBN - 10:0321630165

ISBN - 13:9780321630162

Customer Reviews of Effective C#: 50 Specific Ways to Improve Your C#

Reviews

Extra Content

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.