Abstract types should not have constructors

Assemblies should have valid strong names

Avoid empty interfaces

Avoid excessive parameters on generic types

Avoid namespaces with few types

Avoid out parameters

Collections should implement generic interface

Consider passing base types as parameters

Declare event handlers correctly

Declare types in namespaces

Default parameters should not be used

Define accessors for attribute arguments

Do not catch general exception types

Do not declare protected members in sealed types

Do not declare static members on generic types

Do not declare virtual members in sealed types

Do not declare visible instance fields

Do not expose generic lists

Do not hide base class methods

Do not nest generic types in member signatures

Do not overload operator equals on reference types

Do not raise exceptions in unexpected locations

Do not pass types by reference

Enum storage should be Int32

Enumerators should be strongly typed

Enums should have zero value

Exceptions should be public

Generic methods should provide type parameter

ICollection implementations have strongly typed members

Implement IDisposable correctly

Implement standard exception constructors

Indexers should not be multidimensional

Interface methods should be callable by child types

Lists are strongly typed

Mark assemblies with AssemblyVersionAttribute

Mark assemblies with CLSCompliantAttribute

Mark assemblies with ComVisibleAttribute

Mark attributes with AttributeUsageAttribute

Mark enums with FlagsAttribute

Members should not expose certain concrete types

Move P/Invokes to NativeMethods class

Nested types should not be visible

Override methods on comparable types

Overload operator equals on overloading add and subtract

Properties should not be write only

Provide ObsoleteAttribute message

Replace repetitive arguments with params array

Static holder types should be sealed

Static holder types should not have constructors

String URI overloads call System.Uri overloads

Types should not extend certain base types

Types that own disposable fields should be disposable

Types that own native resources should be disposable

URI parameters should not be strings

URI properties should not be strings

URI return values should not be strings

Use events where appropriate

Use generic event handler instances

Use generics where appropriate

Use integral or string argument for indexers

Use properties where appropriate

Validate arguments of public methods