Home > Store

More Effective C# (Covers C# 6.0) (Includes Content Update Program): 50 Specific Ways to Improve Your C#

Register your product to gain access to bonus material or receive a coupon.

More Effective C# (Covers C# 6.0) (Includes Content Update Program): 50 Specific Ways to Improve Your C#

eBook (Watermarked)

  • This product currently is not for sale.
  • Includes EPUB, MOBI, and PDF
  • About eBook Formats
  • This eBook includes the following formats, accessible from your Account page after purchase:

    ePub EPUB The open industry format known for its reflowable content and usability on supported mobile devices.

    MOBI MOBI The eBook format compatible with the Amazon Kindle and Amazon Kindle applications.

    Adobe Reader PDF The popular standard, used most often with the free Adobe® Reader® software.

    This eBook requires no passwords or activation to read. We customize your eBook by discreetly watermarking it with your name, making it uniquely yours.

Not for Sale


  • Copyright 2018
  • Dimensions: 7" x 9-1/4"
  • Pages: 350
  • Edition: 1st
  • eBook (Watermarked)
  • ISBN-10: 0-13-457931-3
  • ISBN-13: 978-0-13-457931-3

You’re already a successful C# programmer. Bill Wagner’s More Effective C# will help you become an outstanding one. Fully up-to-date, it introduces fifty intermediate-to-advanced-level techniques for writing highly-efficient and robust C# software. Packed with new techniques and code updated for the language’s newest capabilities, it follows the same format as Wagner’s best-selling Effective C#: clear, practical explanations, expert tips, and plenty of realistic code samples.

Drawing on his unsurpassed C# experience, Wagner helps experienced C# developers choose the most effective solution when multiple options exist, and develop code that’s easier to understand, maintain, and improve. Wagner also uncovers practices that compromise performance or reliability and shows exactly how to avoid them. Each section contains specific, actionable guidelines, organized into “items”: short vignettes offering careful advice, concise technical explanations, and illuminating examples.

As you learn to make the most of C#’s most advanced innovations, also explore More Effective C#’s digital component, Bill Wagner’s Visual Studio Code Analyzer -- and discover even more opportunities to improve your code!

Sample Content

Table of Contents

Partial Table of Contents: To be updated
Item 2: Define Constraints That Are Minimal and Sufficient
Item 3: Specialize Generic Algorithms Using Runtime Type Checking
Item 4: Use Generics to Force Compile-Time Type Inference
Item 5: Ensure That Your Generic Classes Support Disposable Type Parameters
Item 6: Use Delegates to Define Method Constraints on Type Parameters
Item 7: Do Not Create Generic Specialization on Base Classes or Interfaces
Item 8: Prefer Generic Methods Unless Type Parameters Are Instance Fields
Item 10: Implement Classic Interfaces in Addition to Generic Interfaces
Item 11: Use the Thread Pool Instead of Creating Threads
Item 12: Use BackgroundWorker for Cross-Thread Communication
Item 13: Use lock() as Your First Choice for Synchronization
Item 14: Use the Smallest Possible Scope for Lock Handles
Item 15: Avoid Calling Unknown Code in Locked Sections
Item 16: Understand Cross-Thread Calls in Windows Forms and WPF
Item 17: Create Composable APIs for Sequences
Item 18: Decouple Iterations from Actions, Predicates, and Functions
Item 19: Generate Sequence Items as Requested
Item 20: Loosen Coupling by Using Function Parameters
Item 21: Create Method Groups That Are Clear, Minimal, and Complete
Item 23: Understand How Events Increase Runtime Coupling Among Objects
Item 24: Declare Only Nonvirtual Events
Item 25: Use Exceptions to Report Method Contract Failures
Item 26: Ensure That Properties Behave Like Data
Item 28: Augment Minimal Interface Contracts with Extension Methods
Item 29: Enhance Constructed Types with Extension Methods
Item 30: Prefer Implicitly Typed Local Variables
Item 31: Limit Type Scope by Using Anonymous Types
Item 33: Avoid Modifying Bound Variables
Item 34: Define Local Functions on Anonymous Types
Item 35: Never Overload Extension Methods
Item 36: Understand How Query Expressions Map to Method Calls
Item 37: Prefer Lazy Evaluation Queries
Item 38: Prefer Lambda Expressions to Methods
Item 39: Avoid Throwing Exceptions in Functions and Actions
Item 40: Distinguish Early from Deferred Execution
Item 41: Avoid Capturing Expensive Resources
Item 42: Distinguish Between IEnumerable and IQueryable Data Sources
Item 43: Use Single() and First() to Enforce Semantic Expectations on Queries
Item 44: Prefer Storing Expression<> to Func<>
Item 46: Give Partial Classes Partial Methods for Constructors, Mutators, and Event Handlers
Item 47: Limit Array Parameters to Params Arrays
Item 48: Avoid Calling Virtual Functions in Constructors Reviews
Item 50: Prefer Implicit Properties for Mutable, Nonserializable Data


Submit Errata

More Information

Unlimited one-month access with your purchase
Free Safari Membership