Home > Store

More Effective C#: 50 Specific Ways to Improve Your C#, Rough Cuts

More Effective C#: 50 Specific Ways to Improve Your C#, Rough Cuts

Rough Cuts

  • Available to Safari Subscribers
  • About Rough Cuts
  • Rough Cuts are manuscripts that are developed but not yet published, available through Safari. Rough Cuts provide you access to the very latest information on a given topic and offer you the opportunity to interact with the author to influence the final publication.

Not for Sale

Description

  • Copyright 2009
  • Dimensions: 7" x 9-1/4"
  • Pages: 336
  • Edition: 1st
  • Rough Cuts
  • ISBN-10: 0-321-58047-8
  • ISBN-13: 978-0-321-58047-4

This is a working draft of a pre-release book. It is available before the published date as part of the Rough Cuts service.

“Shining a bright light into many of the dark corners of C# 3.0, this book not only covers the ‘how,’ but also the ‘why,’ arming the reader with many field-tested methods for wringing the most from the new language features, such as LINQ, generics, and multithreading. If you are serious about developing with the C# language, you need this book.”

–Bill Craun, Principal Consultant, Ambassador Solutions, Inc.

More Effective C# is an opportunity to work beside Bill Wagner. Bill leverages his knowledge of C# and distills his expertise down to some very real advice about programming and designing applications that every serious Visual C# user should know. More Effective C# is one of those rare books that doesn’t just regurgitate syntax, but teaches you how to use the C# language.”

–Peter Ritchie, Microsoft MVP: Visual C#

More Effective C# is a great follow-up to Bill Wagner’s previous book. The extensive

C# 3.0 and LINQ coverage is extremely timely!”

–Tomas Restrepo, Microsoft MVP: Visual C++, .NET, and Biztalk Server

“As one of the current designers of C#, it is rare that I learn something new about the language by reading a book. More Effective C# is a notable exception. Gently blending concrete code and deep insights, Bill Wagner frequently makes me look at C# in a fresh light–one that really makes it shine. More Effective C# is at the surface a collection of very useful guidelines. Look again. As you read through it, you’ll find that you acquire more than just the individual pieces of advice; gradually you’ll pick up on an approach to programming in C# that is thoughtful, beautiful, and deeply pleasant. While you can make your way willy-nilly through the individual guidelines, I do recommend reading the whole book–or at least not skipping over the chapter introductions before you dive into specific nuggets of advice. There’s perspective and insight to be found there that in itself can be an important guide and inspiration for your future adventures in C#.”

–Mads Torgersen, Program Manager, Visual C#, Microsoft

“Bill Wagner has written an excellent book outlining the best practices for developers who work with the C# language. By authoring More Effective C#, he has again established himself as one of the most important voices in the C# community. Many of us already know how to use C#. What we need is advice on how to hone our skills so that we can become wiser programmers. There is no more sophisticated source of information on how to become a first-class C# developer than Bill Wagner’s book. Bill is intelligent, thoughtful, experienced, and skillful. By applying the lessons from this book to your own code, you will find many ways to polish and improve the work that you produce.”

–Charlie Calvert, Community Program Manager, Visual C#, Microsoft

In More Effective C#, Microsoft C# MVP and Regional Director Bill Wagner introduces fifty brand-new ways to write more efficient and more robust software. This all-new book follows the same format as Wagner’s best-selling Effective C# (Addison-Wesley, 2005), providing clear, practical explanations, expert tips, and plenty of reali

Sample Content

Table of Contents

Introduction xiii

Chapter 1: Working with Generics 1

Item 1: Use Generic Replacements of 1.x Framework API Classes 4

Item 2: Define Constraints That Are Minimal and Sufficient 14

Item 3: Specialize Generic Algorithms Using Runtime Type Checking 19

Item 4: Use Generics to Force Compile-Time Type Inference 26

Item 5: Ensure That Your Generic Classes Support Disposable Type Parameters 32

Item 6: Use Delegates to Define Method Constraints on Type Parameters 36

Item 7: Do Not Create Generic Specialization on Base Classes or Interfaces 42

Item 8: Prefer Generic Methods Unless Type Parameters Are Instance Fields 46

Item 9: Prefer Generic Tuples to Output and Ref Parameters 50

Item 10: Implement Classic Interfaces in Addition to Generic Interfaces 56

Chapter 2: Multithreading in C# 63

Item 11: Use the Thread Pool Instead of Creating Threads 67

Item 12: Use BackgroundWorker for Cross-Thread Communication 74

Item 13: Use lock() as Your First Choice for Synchronization 78

Item 14: Use the Smallest Possible Scope for Lock Handles 86

Item 15: Avoid Calling Unknown Code in Locked Sections 90

Item 16: Understand Cross-Thread Calls in Windows Forms and WPF 93

Chapter 3: C# Design Practices 105

Item 17: Create Composable APIs for Sequences 105

Item 18: Decouple Iterations from Actions, Predicates, and Functions 112

Item 19: Generate Sequence Items as Requested 117

Item 20: Loosen Coupling by Using Function Parameters 120

Item 21: Create Method Groups That Are Clear, Minimal, and Complete 127

Item 22: Prefer Defining Methods to Overloading Operators 134

Item 23: Understand How Events Increase Runtime Coupling Among Objects 137

Item 24: Declare Only Nonvirtual Events 139

Item 25: Use Exceptions to Report Method Contract Failures 146

Item 26: Ensure That Properties Behave Like Data 150

Item 27: Distinguish Between Inheritance and Composition 156

Chapter 4: C# 3.0 Language Enhancements 163

Item 28: Augment Minimal Interface Contracts with Extension Methods 163

Item 29: Enhance Constructed Types with Extension Methods 167

Item 30: Prefer Implicitly Typed Local Variables 169

Item 31: Limit Type Scope by Using Anonymous Types 176

Item 32: Create Composable APIs for External Components 180

Item 33: Avoid Modifying Bound Variables 185

Item 34: Define Local Functions on Anonymous Types 191

Item 35: Never Overload Extension Methods 196

Chapter 5: Working with LINQ 201

Item 36: Understand How Query Expressions Map to Method Calls 201

Item 37: Prefer Lazy Evaluation Queries 213

Item 38: Prefer Lambda Expressions to Methods 218

<

Updates

Submit Errata

More Information