Assembly	# Types	# Abstract Types	# IL instruction	# lines of code	# lines of comment	% comment	Afferent Coupling	Efferent Coupling	Relational Cohesion	Instability	Abstractness	Distance
Dashboard.Domain v1.0.0.1	48	12	5275	527	25	4	15	83	1.35	0.85	0.25	0.1
Dashboard.Domain.IO v1.0.0.1	19	5	705	105	17	13	1	44	1.58	0.98	0.26	0.24
Dashboard.Data v1.0.0.1	20	4	1613	161	17	9	6	79	1.9	0.93	0.2	0.13
Dashboard.Charts v1.0.0.0	13	3	715	100	31	23	1	28	1.92	0.97	0.23	0.2
Dashboard.App v1.0.0.1	5	1	876	100	14	12	2	60	1.2	0.97	0.2	0.17
Dashboard.Tasks v1.0.0.1	5	0	740	48	17	26	0	26	0.8	1	0	0
Dashboard.Console v1.0.0.1	8	0	657	59	17	22	0	34	1.38	1	0	0

// <Name>Quick summary of methods to refactor</Name>

WARN IF Count > 0 IN SELECT TOP 10 METHODS /*OUT OF "YourGeneratedCode" */ WHERE 

                                           // Metrics' definitions
     (  NbLinesOfCode > 30 OR              // http://www.ndepend.com/Metrics.aspx#NbLinesOfCode
        NbILInstructions > 200 OR          // http://www.ndepend.com/Metrics.aspx#NbILInstructions
        CyclomaticComplexity > 20 OR       // http://www.ndepend.com/Metrics.aspx#CC
        ILCyclomaticComplexity > 50 OR     // http://www.ndepend.com/Metrics.aspx#ILCC
        ILNestingDepth > 4 OR              // http://www.ndepend.com/Metrics.aspx#ILNestingDepth
        NbParameters > 5 OR                // http://www.ndepend.com/Metrics.aspx#NbParameters
        NbVariables > 8 OR                 // http://www.ndepend.com/Metrics.aspx#NbVariables
        NbOverloads > 6 )                  // http://www.ndepend.com/Metrics.aspx#NbOverloads
     AND 

     // Here are some ways to avoid taking account of generated methods.
     !( NameIs "InitializeComponent()" OR
        // NDepend.CQL.GeneratedAttribute is defined in the redistributable assembly $NDependInstallDir$\Lib\NDepend.CQL.dll
        // You can define your own attribute to mark "Generated".
        HasAttribute "OPTIONAL:NDepend.CQL.GeneratedAttribute") 

// <Name>Methods too big (NbILInstructions)</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE NbILInstructions > 200 ORDER BY NbILInstructions DESC
// METHODS WHERE NbILInstructions > 200 are extremely complex and 
// should be split in smaller methods 
// (except if they are automatically generated by a tool).
// See the definition of the NbILInstructions metric here http://www.ndepend.com/Metrics.aspx#NbILInstructions

// <Name>Methods too complex (ILNestingDepth)</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE ILNestingDepth > 4 ORDER BY ILNestingDepth DESC
// METHODS WHERE ILNestingDepth > 4 are hard to understand and maintain. 
// METHODS WHERE ILNestingDepth > 8 is higher than 8 are extremely complex and should be split in smaller methods 
// (except if they are automatically generated by a tool). 
// See the definition of the NbILInstructions metric here http://www.NDepend.com/Metrics.aspx#ILNestingDepth

// <Name>Methods poorly commented (PercentageComment)</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE PercentageComment < 20 AND NbLinesOfCode > 10  ORDER BY PercentageComment ASC
// METHODS WHERE %Comment < 20 and that have at least 10 lines of code should be more commented.
// See the definition of the PercentageComment metric here http://www.ndepend.com/Metrics.aspx#PercentageComment

// <Name>Methods with too many parameters (NbParameters)</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE NbParameters > 5 ORDER BY NbParameters DESC
// METHODS WHERE NbParameters > 5 might be painful to call and might degrade performance. 
// You should prefer using additional properties/fields to the declaring type to handle 
// numerous states. Another alternative is to provide a class or structure dedicated to 
// handle arguments passing (for example see the class System.Diagnostics.ProcessStartInfo 
// and the method System.Diagnostics.Process.Start(ProcessStartInfo))
// See the definition of the NbParameters metric here http://www.ndepend.com/Metrics.aspx#NbParameters

// <Name>Types with too many methods</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE NbMethods > 20 ORDER BY NbMethods DESC
// TYPES WHERE NbMethods > 20 might be hard to understand and maintain 
// but there might be cases where it is relevant to have a high value for NbMethods. 
// For example, the System.Windows.Forms.DataGridView standard class has more than 1000 methods.
// See the definition of the NbMethods metric here http://www.ndepend.com/Metrics.aspx#NbMethods

// <Name>Types with too many fields</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE NbFields > 20 AND !IsEnumeration ORDER BY NbFields DESC
// TYPES WHERE NbFields > 20 AND !IsEnumeration might be hard to understand and maintain 
// but there might be cases where it is relevant to have a high value for NbFields. 
// For example, the System.Windows.Forms.Control standard class has more than 200 fields. 
// The value of the metric NbFields might be a better indicator of complex type.
// See the definition of the NbFields metric here http://www.ndepend.com/Metrics.aspx#NbFields

// <Name>Types with poor cohesion (LCOM)</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE LCOM > 0.8 AND NbFields > 10 AND NbMethods >10 ORDER BY LCOM DESC
// TYPES WHERE LCOM > 0.8 AND NbFields > 10 AND NbMethods >10 might be problematic. 
// However, it is very hard to avoid such non-cohesive types. The LCOMHS metric
// is often considered as more efficient to detect non-cohesive types.
// See the definition of the LCOM metric here http://www.ndepend.com/Metrics.aspx#LCOM

// <Name>Types with poor cohesion (LCOMHS)</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE LCOMHS > 0.95 AND NbFields > 10 AND NbMethods >10 ORDER BY LCOMHS DESC
// TYPES WHERE LCOMHS > 1.0 AND NbFields > 10 AND NbMethods >10 should be avoided. 
// Note that this constraint is stronger than the constraint 
// TYPES WHERE LCOM > 0.8 AND NbFields > 10 AND NbMethods >10. 
// See the definition of the LCOMHS metric here http://www.ndepend.com/Metrics.aspx#LCOMHS

// <Name>Assembly should not contain namespaces dependency cycles</Name>
WARN IF Count > 0 IN SELECT TOP 10 ASSEMBLIES WHERE ContainsNamespaceDependencyCycle
// Dependency cycles between namespaces must be avoided 
// in order to have a levelized and comprehensive design.
// More info available on the screencast 'Reduce the complexity' http://s3.amazonaws.com/NDependOnlineDemos/NDependReducingComplexity_viewlet_swf.html
// You can also read this article http://www.theserverside.net/tt/articles/showarticle.tss?id=ControllingDependencies

// <Name>Type should not have too many responsabilities (Efferent Coupling)</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE TypeCe > 50 ORDER BY TypeCe DESC 
// The Efferent Coupling (TypeCe) for a particular type is the number of types 
// it directly depends on. Notice that types declared in tier assemblies are taken into account. 

// Types that depends on too many others type (more than 50) are complex and have
// more than one responsability. They are good candidate for refactoring.

// More information available in this article:
// http://codebetter.com/blogs/patricksmacchia/archive/2008/02/15/code-metrics-on-coupling-dead-code-design-flaws-and-re-engineering.aspx

// <Name>A stateless type might be turned into a static type</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE 
  SizeOfInst ==0 AND 
  NbInterfacesImplemented == 0 AND // To be accurate, this constraint doesn't take 
                                   // account of types that implement some interfaces.
  !IsStatic AND 
  !IsGeneric AND 
  !IsInterface 
// It indicates stateless types that might eventually be turned into static classes.
// See the definition of the SizeOfInst metric here http://www.ndepend.com/Metrics.aspx#SizeOfInst

// <Name>Class with no descendant should be sealed if possible</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE 
  IsClass AND 
  NbChildren ==0 AND 
  !IsSealed AND 
  !IsStatic 
  // AND !IsPublic   : You might want to add this condition if you are developping a framework
  //                   with classes that are intended to be sub-classed by your clients.
  ORDER BY NbLinesOfCode

// <Name>Classes that are candidate to be turned into Structures</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE 
  IsClass AND
  SizeOfInst <= 16 AND    // Structure instance must not be too big, else it degrades performance.
  NbChildren == 0 AND     // Must not have children
  DepthOfInheritance == 1 // Must derive directly from System.Object
  // AND IsSealed    : You might want to add this condition to restreint the set.
  // AND IsImmutable : Structures should be immutable type.
  // AND !IsPublic   : You might want to add this condition if you are developping a framework
  //                   with classes that are intended to be sub-classed by your clients.

// <Name>Avoid namespaces with few types</Name>
WARN IF Count > 0 IN SELECT TOP 10 NAMESPACES WHERE NbTypes < 5 ORDER BY NbTypes ASC 

// Make sure that there is a logical organization to each of your namespaces, 
// and that there is a valid reason for putting types in a sparsely populated 
// namespace. Namespaces should contain types that are used together in most 
// scenarios. When their applications are mutually exclusive, types should be 
// located in separate namespaces

// <Name>Avoid empty interfaces</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE IsInterface AND NbMethods == 0

// Interfaces define members that provide a behavior or usage contract. The functionality described by 
// the interface can be adopted by any type, regardless of where the type appears in the inheritance
// hierarchy. A type implements an interface by providing implementations for the interface's members.
// An empty interface does not define any members, and as such, does not define a contract that can be implemented.

// If your design includes empty interfaces that types are expected to implement, you are probably using
// an interface as a marker, or a way of identifying a group of types. If this identification will occur 
// at runtime, the correct way to accomplish this is to use a custom attribute. Use the presence or absence 
// of the attribute, or the attribute's properties, to identify the target types. If the identification must
// occur at compile time, then using an empty interface is acceptable.

// <Name>Declare types in namespaces</Name>
WARN IF Count > 0 IN SELECT NAMESPACES WHERE NameIs "" AND !IsInFrameworkAssembly 

// Types are declared within namespaces to prevent name collisions, and as a way of organizing related types 
// in an object hierarchy. Types outside any named namespace are in a global namespace that cannot be referenced in code.
// If an anonymous namespace can be found, it means that it contains types outside of namespaces.

// <Name>Assemblies with poor cohesion (RelationalCohesion)</Name>
WARN IF Count > 0 IN SELECT TOP 10 ASSEMBLIES WHERE RelationalCohesion < 1.5 OR RelationalCohesion > 4.0

// As classes inside an assembly should be strongly related, 
// the cohesion should be high. On the other hand, a value which is too high may 
// indicate over-coupling. A good range for RelationalCohesion is 1.5 to 4.0.
// See the definition of the RelationalCohesion metric here http://www.ndepend.com/Metrics.aspx#RelationalCohesion

// <Name>Instances size shouldn't be too big (SizeOfInst)</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE SizeOfInst > 64 ORDER BY SizeOfInst DESC
// TYPES WHERE SizeOfInst > 64 might degrade performance (depending on the number of 
// instances created at runtime) and might be hard to maintain. 
// However it is not a rule since sometime there is no alternative 
// (the size of instances of the System.Net.NetworkInformation.SystemIcmpV6Statistics 
// standard class is 2064 bytes).
// See the definition of the SizeOfInst metric here http://www.ndepend.com/Metrics.aspx#SizeOfInst

// <Name>Potentially unused methods</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE 
 MethodCa == 0 AND            // Ca=0 -> No Afferent Coupling -> The method is not used in the context of this application.
 !IsPublic AND                // Public methods might be used by client applications of your assemblies.
 !IsEntryPoint AND            // Main() method is not used by-design.
 !IsExplicitInterfaceImpl AND // The IL code never explicitely calls explicit interface methods implementation.
 !IsClassConstructor AND      // The IL code never explicitely calls class constructors.
 !IsFinalizer                 // The IL code never explicitely calls finalizers.

// <Name>Fields should be declared as private</Name>
WARN IF Count > 0 IN SELECT TOP 10 FIELDS WHERE 
 !IsPrivate AND 
 // These conditions filter cases where fields doesn't represent state that should be encapsulated. 
 !IsInFrameworkAssembly AND 
 !IsGeneratedByCompiler AND 
 !IsSpecialName AND 
 !IsInitOnly AND 
 !IsLiteral AND 
 !IsEnumValue

// <Name>Methods that could be declared as 'internal' in C#,  'Friend' in VB.NET</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE CouldBeInternal

// <Name>Methods that could be declared as 'private' in C#,  'Private' in VB.NET</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE CouldBePrivate

// <Name>Types that could be declared as internal</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE CouldBeInternal

// <Name>Fields that could be declared as internal</Name>
WARN IF Count > 0 IN SELECT TOP 10 FIELDS WHERE CouldBeInternal

// <Name>Fields that could be declared as 'private' in C#,  'Private' in VB.NET</Name>
WARN IF Count > 0 IN SELECT TOP 10 FIELDS WHERE CouldBePrivate

// <Name>Fields should be marked as ReadOnly when possible</Name>
WARN IF Count > 0 IN SELECT FIELDS WHERE IsImmutable AND !IsInitOnly

// A field that matches the condition IsImmutable is a field that is assigned only by constructors of its class.
// For an instance field, this means its value will remain constant throught the lifetime of the object.
// For a static field, this means its value will remain constant throught the lifetime of the program.
// In both cases, such field can safely be marked with the C# readonly keyword (ReadOnly in VB.NET).

// The condition IsInitOnly matches fields that are marked with the C# readonly keyword (ReadOnly in VB.NET).

// <Name>Structures should be immutable</Name>
WARN IF Count > 0 IN SELECT TYPES WHERE IsStructure AND !IsImmutable AND !IsInFrameworkAssembly

// It is deemed as a good practice to make your structure immutable.
// An object is immutable if its state doesn’t change once the object has been created. 
// Consequently, a structure is immutable if its instances are immutable.
// Immutable types naturally simplify code by limiting side-effects.
// See some explanations on immutability and how NDepend supports it here:
// http://codebetter.com/blogs/patricksmacchia/archive/2008/01/13/immutable-types-understand-them-and-use-them.aspx

// <Name>Instance fields should be prefixed with a 'm_'</Name>
WARN IF Count > 0 IN SELECT TOP 10 FIELDS WHERE 
  !NameLike "^m_" AND 
  !IsStatic AND 
  !IsLiteral AND 
  !IsGeneratedByCompiler  AND 
  !IsSpecialName AND 
  !IsEventDelegateObject 

// This naming convention provokes debate.
// Don't hesitate to customize the regex of NameLike to your preference.

// <Name>Static fields should be prefixed with a 's_'</Name>
WARN IF Count > 0 IN SELECT TOP 10 FIELDS WHERE 
  !NameLike "^s_" AND 
  IsStatic AND 
  !IsLiteral AND 
  !IsGeneratedByCompiler AND 
  !IsSpecialName AND 
  !IsEventDelegateObject  

// This naming convention provokes debate.
// Don't hesitate to customize the regex of NameLike to your preference.

// <Name>Avoid methods with name too long</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS 
  WHERE NameLike "^[^\<\(]{35,}.*$" AND 
        !IsExplicitInterfaceImpl AND !IsInFrameworkAssembly 
// The regex matches methods with name longer than 35 characters.
// Method Name doesn't contain the type and namespace prefix, FullName does.
// The regex computes the method name length from the beginning until the first open parenthesis or first lower than (for generic methods).
// Explicit Interface Implementation methods are discarded because their names are prefixed with the interface name.

// <Name>Avoid types with name too long</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE 
  NameLike "^[^\<]{35,}.*$" AND 
  !IsNested AND !IsInFrameworkAssembly 
// The regex matches types with name longer than 35 characters.
// Type Name doesn't contain the namespace prefix, FullName does.
// The regex computes the type name length from the beginning until the end or the first lower than (for generic types).
// Nested types are discarded because their names are prefixed with outer type's name.

// <Name>Mark assemblies with CLSCompliant</Name>
WARN IF Count > 0 IN SELECT ASSEMBLIES WHERE 
  !HasAttribute "OPTIONAL:System.CLSCompliantAttribute" AND
  !IsFrameworkAssembly 

// The Common Language Specification (CLS) defines naming restrictions, data types, 
// and rules to which assemblies must conform if they are to be used across programming languages.
// Good design dictates that all assemblies explicitly indicate CLS compliance with 
// CLSCompliantAttribute. If the attribute is not present on an assembly, the assembly is not compliant.

// <Name>Do not raise too general exception types</Name>
WARN IF Count > 0 IN SELECT METHODS WHERE 
  // The following exception types are too general to provide sufficient information to the user:
  ( ( DepthOfCreateA "OPTIONAL:System.Exception" == 1 OR 
      DepthOfCreateA "OPTIONAL:System.ApplicationException" == 1 OR 
      DepthOfCreateA "OPTIONAL:System.SystemException" == 1 )
    // Test for non-constructor, else this constraint would warn 
    // on ctor of classes that derive from these exception types.
    AND !IsConstructor )

// <Name>Don't create threads explicitely</Name>
WARN IF Count > 0 IN SELECT METHODS WHERE 
  CreateA "OPTIONAL:System.Threading.Thread"

// Prefer using the thread pool instead of creating manually your own thread.
// Threads are costly objects. 
// They take approximately 200,000 cycles to create and about 100,000 cycles to destroy.  
// By default they reserve 1 megabyte of virtual memory for its stack and use 2,000-8,000 cycles for each context switch.
// As a consequence, it is preferrable to let the thread pool recycle threads.

// Creating custom thread can also be the sign of flawed design, where tasks and threads have affinity.
// It is preferrable to code tasks that can be ran on any thread.

// <Name>Don't use Thread.Abort()</Name>
WARN IF Count > 0 IN SELECT METHODS WHERE 
  IsDirectlyUsing  "OPTIONAL:System.Threading.Thread.Abort()" OR
  IsDirectlyUsing  "OPTIONAL:System.Threading.Thread.Abort(Object)" 

// Usage of Thread.Abort() is dangerous.
// More information on this here:
// http://www.interact-sw.co.uk/iangblog/2004/11/12/cancellation