O'Reilly logo

Stay ahead with the world's most comprehensive technology and business learning platform.

With Safari, you learn the way you learn best. Get unlimited access to videos, live online training, learning paths, books, tutorials, and more.

Start Free Trial

No credit card required

More Effective C# (Includes Content Update Program): 50 Specific Ways to Improve Your C#, 2nd edition

Book Description

In More Effective C#, Second Edition, world-renowned .NET expert Bill Wagner identifies and illuminates 50 intermediate-to-advanced techniques for writing exceptionally robust and well-performing C# 7.0 code. Reflecting the growing sophistication of the C# language and its development community, Wagner presents powerful new solutions to problems you’re likely to encounter every day.

 

Through three editions of Effective C#, Wagner’s clear explanations, expert tips, and realistic code examples have proven invaluable to hundreds of thousands of developers. With the publication of this title, Effective C#, Third Edition, and More Effective C#, Second Edition, have been completely reorganized to provide clear explanations, expert tips, and realistic code examples in a cohesive package for modern C#. More Effective C#, Second Edition, brings the same proven approach to the new features in C# 7.0, helping you perform familiar tasks more efficiently and effectively.

 

Drawing on his unsurpassed C# experience and key role on global C# standards committees, Wagner addresses object-oriented, functional, and service-oriented approaches to managing data with C#; better ways to express your intent to users and other programmers; and new opportunities to leverage powerful asynchronous and dynamic programming techniques.

  • Use properties instead of accessible data members (Item 1)
  • Distinguish between value and reference types (Item 4)
  • Understand relationships among multiple concepts of equality (Item 9)
  • Avoid conversion operators in your APIs (Item 11)
  • Understand how interface and virtual methods differ (Item 15)
  • Avoid overloading methods defined in base classes (Item 19)
  • Create method groups that are clear, minimal, and complete (Item 22)
  • Enable immediate error reporting in iterators and async methods (Item 26)
  • Use async methods for async work (Item 27)
  • Avoid thread allocations and context switches (Item 30)
  • Construct PLINQ parallel algorithms with exceptions in mind (Item 36)
  • Use the thread pool instead of creating threads (Item 37)
  • Use BackgroundWorker for cross-thread communication (Item 38)
  • Use the smallest possible scope for lock handles (Item 41)
  • Understand the pros and cons of dynamic programming (Item 43)
  • Make full use of the expression API (Item 46)
  • Minimize dynamic objects in public APIs (Item 47)

You’re already a successful C# programmer: this book will make you an outstanding one.

Register your product at informit.com/register for convenient access to downloads, updates, and corrections as they become available.

Table of Contents

  1. About This E-Book
  2. Title Page
  3. Copyright Page
  4. Dedication Page
  5. Contents at a Glance
  6. Contents
  7. Introduction
    1. Who Should Read This Book?
    2. About the Content
    3. Code Conventions
    4. Providing Feedback
    5. Acknowledgments
    6. About the Author
  8. 1. Working with Data Types
    1. Item 1: Use Properties Instead of Accessible Data Members
    2. Item 2: Prefer Implicit Properties for Mutable Data
    3. Item 3: Prefer Immutability for Value Types
    4. Item 4: Distinguish Between Value Types and Reference Types
    5. Item 5: Ensure That 0 Is a Valid State for Value Types
    6. Item 6: Ensure That Properties Behave Like Data
    7. Item 7: Limit Type Scope by Using Tuples
    8. Item 8: Define Local Functions on Anonymous Types
    9. Item 9: Understand the Relationships Among the Many Different Concepts of Equality
    10. Item 10: Understand the Pitfalls of GetHashCode()
  9. 2. API Design
    1. Item 11: Avoid Conversion Operators in Your APIs
    2. Item 12: Use Optional Parameters to Minimize Method Overloads
    3. Item 13: Limit Visibility of Your Types
    4. Item 14: Prefer Defining and Implementing Interfaces to Inheritance
    5. Item 15: Understand How Interface Methods Differ from Virtual Methods
    6. Item 16: Implement the Event Pattern for Notifications
    7. Item 17: Avoid Returning References to Internal Class Objects
    8. Item 18: Prefer Overrides to Event Handlers
    9. Item 19: Avoid Overloading Methods Defined in Base Classes
    10. Item 20: Understand How Events Increase Runtime Coupling Among Objects
    11. Item 21: Declare Only Nonvirtual Events
    12. Item 22: Create Method Groups That Are Clear, Minimal, and Complete
    13. Item 23: Give Partial Classes Partial Methods for Constructors, Mutators, and Event Handlers
    14. Item 24: Avoid ICloneable Because It Limits Your Design Choices
    15. Item 25: Limit Array Parameters to params Arrays
    16. Item 26: Enable Immediate Error Reporting in Iterators and Async Methods Using Local Functions
  10. 3. Task-Based Asynchronous Programming
    1. Item 27: Use Async Methods for Async Work
    2. Item 28: Never Write async void Methods
    3. Item 29: Avoid Composing Synchronous and Asynchronous Methods
    4. Item 30: Use Async Methods to Avoid Thread Allocations and Context Switches
    5. Item 31: Avoid Marshalling Context Unnecessarily
    6. Item 32: Compose Asynchronous Work Using Task Objects
    7. Item 33: Consider Implementing the Task Cancellation Protocol
    8. Item 34: Cache Generalized Async Return Types
  11. 4. Parallel Processing
    1. Item 35: Learn How PLINQ Implements Parallel Algorithms
    2. Item 36: Construct Parallel Algorithms with Exceptions in Mind
    3. Item 37: Use the Thread Pool Instead of Creating Threads
    4. Item 38: Use BackgroundWorker for Cross-Thread Communication
    5. Item 39: Understand Cross-Thread Calls in XAML Environments
    6. Item 40: Use lock() as Your First Choice for Synchronization
    7. Item 41: Use the Smallest Possible Scope for Lock Handles
    8. Item 42: Avoid Calling Unknown Code in Locked Sections
  12. 5. Dynamic Programming
    1. Item 43: Understand the Pros and Cons of Dynamic Typing
    2. Item 44: Use Dynamic Typing to Leverage the Runtime Type of Generic Type Parameters
    3. Item 45: Use DynamicObject or IDynamicMetaObjectProvider for Data-Driven Dynamic Types
    4. Item 46: Understand How to Use the Expression API
    5. Item 47: Minimize Dynamic Objects in Public APIs
  13. 6. Participate in the Global C# Community
    1. Item 48: Seek the Best Answer, Not the Most Popular Answer
    2. Item 49: Participate in Specs and Code
    3. Item 50: Consider Automating Practices with Analyzers
  14. Index