• Features
• Design Rules
• Error Handling Rules
• Naming Convention Rules
• .NET Usage Rules
• Performance Rules
• Threading Rules 

Feature
IDE Integration
Source code analysis
Assembly analysis
ASPX/ASP.NET Support
Rule Management
Configurable rules
Custom Rules
Rule scoping
Exclude violation
Violation correction
Integrated Help
Sample Code

Rules
Abstract Types Should Not Have Public Constructors
Do Not Allow Inheritance Of Custom Attributes
Public Fields should be Converted to Public Properties

Rules
Handled Exceptions should be published
Specific call requires a try/catch block
Method requires tracing implementation
ArgumentException should be used if invalid parameters are passed.
Do not create methods that throw IndexOutOfRangeException
Do not create methods that throw System.Exception
Do not create methods that throw System.NullReferenceException
Do not create methods that throw System.Runtime.InteropServices.ExternalException
Do not create methods that throw System.SystemException
Localize strings for any exception messages
Test for Null argument before referencing
Re-throw should not throw with argument.
Exception class names must end in the word "Exception"
Exception classes Must Be Marked Serializable
Should not inherit directly from System.Exception
Should not inherit indirectly from System.SystemException
Use the three common constructors when creating Exception classes

Rules
Namespace name should be Pascal case.
Interface types should start with capital letter I and be Pascal case.
Struct types should use Pascal case.
Class types should be Pascal case.
Delegate types should use Pascal case.
Enumerations should use Pascal case.
Attributes should use Pascal case and end in "Attribute".
Collections should end in "Collection".
Read-only collections should end in "Collection".
Event should be Pascal case.
Event arguments should be end in "EventArgs".
Property should be Pascal case.
Method should be Pascal case.
Public fields should Pascal case.
Private type fields should use camel case.
Constant should use Pascal case.
Protected type fields should be camel case.
Internal type fields should be camel case.
Method parameters should be camel case.
Variables should be camel case.
Classes of type Form should end in "Form".
Classes of type Forms.UserControl should end in "Control".
Field name of type ArrayList should end in "ArrayList".
Field name of type Button should end in "Button".
Field name of type Hashtable should end in "Hashtable".
Field name of type ListBox should end in "ListBox".
Field name of type ComboBox should end in "ComboBox".
Field name of type DataGrid should end in "DataGrid".
Field name of type TextBox should end in "TextBox".
Private fields should not use prefixes of 'm','_' or 'm_'.
Private fields should use 'm' prefix.
Private fields should use 'm_' prefix.
Private fields should use underscore prefix.

Rules
ISerializable Types Should be Marked Serializable
ISerializable Type must implement serializable constructor
Objects that implement ISerializable implement Add/GetValue for all fields
Unused Method Argument

Rules
Test For Empty Strings Using String Length

Rules
Reference to a static variable should be synchronized using a thread lock.
The update of a variable should be synchronized using Threading.Interlocked operations.
Redundant Locking exists.
Optimize the update synchronization of a variable by using Threading.Interlocked operations instead of a lock.
A logical block of unsynchronized static variable references has been detected and should be synchronized using a lock.
Releasing a lock in any other location than a 'finally' section of try/finally block may create threading issues.
The released lock was not the last lock acquired. Locks acquired last should be released first.
A lock on the same object has already been acquired.
A lock has been acquired but has not been released.
A lock has been released in multiple places.
Avoid calling static methods that call static methods on the same class.
Avoid providing static methods that alter static state.
Use thread pooling classes to optimize multi-threaded applications.
Do not terminate other threads using Thread.Abort.
Lock Must not be Obtained on a Value Type.
Excessive locking - lock contained inside a loop.
Large number of statements protected by a lock.
Excessive nesting of locks.
Excessive portion of class is synchronized.
Excessive synchronized calls into same class.