Want to learn more about C# ? Effective C# – is the book for you

Table of Contents

Chapter 1: C# Language Idioms

Item 1: 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: Understand the Relationships Among the Many Different Concepts of Equality

Item 7: Understand the Pitfalls of GetHashCode()

Item 8: Prefer Query Syntax to Loops

Item 9: Avoid Conversion Operators in Your APIs

Item 10: Use Optional Parameters to Minimize Method Overloads

Item 11: Understand the Attraction of Small Functions

Chapter 2: .NET Resource Management

Item 12: Prefer Member Initializers to Assignment Statements

Item 13: Use Proper Initialization for Static Class Members

Item 14: Minimize Duplicate Initialization Logic

Item 15: Utilize using and try/finally for Resource Cleanup

Item 16: Avoid Creating Unnecessary Objects

Item 17: Implement the Standard Dispose Pattern

Item 18: Distinguish Between Value Types and Reference Types

Item 19: Ensure That 0 Is a Valid State for Value Types

Item 20: Prefer Immutable Atomic Value Types

Chapter 3: Expressing Designs in C#

Item 21: Limit Visibility of Your Types

Item 22: Prefer Defining and Implementing Interfaces to Inheritance

Item 23: Understand How Interface Methods Differ from Virtual Methods

Item 24: Express Callbacks with Delegates

Item 25: Implement the Event Pattern for Notifications

Item 26: Avoid Returning References to Internal Class Objects

Item 27: Prefer Making Your Types Serializable

Item 28: Create Large-Grain Internet Service APIs

Item 29: Support Generic Covariance and Contravariance

Chapter 4: Working with the Framework

Item 30: Prefer Overrides to Event Handlers

Item 31: Implement Ordering Relations with IComparable<T> and IComparer<T>

Item 32: Avoid ICloneable

Item 33: Use the new Modifier Only to React to Base Class Updates

Item 34: Avoid Overloading Methods Defined in Base Classes

Item 35: Learn How PLINQ Implements Parallel Algorithms

Item 36: Understand How to Use PLINQ for I/O Bound Operations

Item 37: Construct Parallel Algorithms with Exceptions in Mind

Chapter 5: Dynamic Programming in C#

Item 38: Understand the Pros and Cons of Dynamic

Item 39: Use Dynamic to Leverage the Runtime Type of Generic Type Parameters

Item 40: Use Dynamic for Parameters That Receive Anonymous Types

Item 41: Use DynamicObject or IDynamicMetaObjectProvider for Data-Driven Dynamic Types

Item 42: Understand How to Make Use of the Expression API

Item 43: Use Expressions to Transform Late Binding into Early Binding

Item 44: Minimize Dynamic Objects in Public APIs

Chapter 6: Miscellaneous

Item 45: Minimize Boxing and Unboxing

Item 46: Create Complete Application-Specific Exception Classes

Item 47: Prefer the Strong Exception Guarantee

Item 48: Prefer Safe Code

Item 49: Prefer CLS-Compliant Assemblies

Item 50: Prefer Smaller, Cohesive Assemblies

About book: http://www.informit.com/store/product.aspx?isbn=0321658701

Advertisements

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s