Effective C#, Addison-Wesley
Microsoft .NET Framework, ASP.NET, Visual C# (CSharp, C Sharp, C-Sharp) Developer Training, Visual Studio
|
Contents |
C# Online.NET Book Review
I loved Effective Java by Bloch; because, it was so darned directed, practical, and useful. In fact, it is within arms reach of me at this moment. Effective C# by Wagner is going into the same bookshelf right beside it.
This type of book is a sort of FAQ for veteran developers. You need to have written a lot of code and made a lot of mistakes to truly appreciate these little books. Or, you could read it first and avoid the trials and tribulations. These books comprise essays of best practices and tips and tricks loosely organized into catch-all headings. They are not great literature. They are not beautifully written. They are, simply, immediately applicable. Each item is a more or less self-contained topic which makes you think and changes the code you write in the future.
A better title might have been Performant C#; because, the book is all about best practices of maintainability, reuse, and performance derived from hard-won knowledge and experience of trade-offs. The author peers inside the mechanism and, often, uses disassembled compiler output to prove his points—sometimes to a fault.
This treasured volume would be a terrible first or only C# book. It is for professionals or those who aspire to be professionals. It is not a perfect book in the sense that it has some editing errors, some organization problems, some contradictory examples, and some non-transparent passages. However, it is perfect in the sense that it is "what you need" (Twilight Zone: "What You Need", season 1, episode 12).
The book is ostensibly for .NET 1.1;but, the author is obviously aware of .NET 2.0 and references it often. Two points should be made about this. Firstly, the 2.0 changes would not invalidate the 1.1 advice. Secondly, when and if a 2.0 sequel is written, it will cover different topics and you will want to own it, too.
Bottom line
Effective C# will change how you code and make you a better programmer.
From the back cover
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.
About the author(s)
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).
Table of Contents (abbreviated)
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.
