Stat	# Occurrences	Avg	StdDev	Max
Properties on Interfaces	1 Interfaces	0	0	0 properties on Asm:SimpleNote Interface:SimpleNote.IEngineOperationParams
Methods on Interfaces	1 Interfaces	0	0	0 methods on Asm:SimpleNote Interface:SimpleNote.IEngineOperationParams
Arguments on Methods on Interfaces	0 Methods	0	0	-1 arguments on
Public Properties on Classes	49 Classes	1.31	2.38	14 public properties on Asm:NDepend.CodeStructureContainer.NAssembly Class:SimpleNote.Properties.Settings
Public Methods on Classes	49 Classes	5.27	6.02	28 public methods on Asm:SimpleNote Class:SimpleNote.Properties.Settings
Arguments on Public Methods on Classes	258 Methods	0.71	0.85	4 arguments on Asm:SimpleNote Class:SimpleNote.DataModel+NotesRowChangeEventHandler Method:BeginInvoke(Object,DataModel+NotesRowChangeEvent,AsyncCallback,Object)
IL Instructions in non-abstract Methods	399 Methods	24.16	43.57	441 IL instructions in Asm:SimpleNote Class:SimpleNote.DataSourceWindow Method:acceptButton_Click(Object,RoutedEventArgs)
Cyclomatic complexity on non abstract Methods	399 Methods	1.19	3.51	CC = 39 for Asm:SimpleNote Type:SimpleNote.DataSourceWindow Method:acceptButton_Click(Object,RoutedEventArgs)

Assembly	# Types	# Abstract Types	# IL instruction	# lines of code	# lines of comment	% comment	Afferent Coupling	Efferent Coupling	Relational Cohesion	Instability	Abstractness	Distance
SimpleNote v1.0.2.0	53	1	9638	1306	393	23%	0	306	2.85	1	0.02	0.02

Assembly	Depends on...	Is referenced by...
SimpleNote v1.0.2.0	mscorlib v2.0.0.0 ; PresentationFramework v3.0.0.0 ; WindowsBase v3.0.0.0 ; System.Data v2.0.0.0 ; System.Data.DataSetExtensions v3.5.0.0 ; System v2.0.0.0 ; System.Windows.Forms v2.0.0.0 ; PresentationCore v3.0.0.0 ; System.Drawing v2.0.0.0 ; System.Core v3.5.0.0 ; System.Xml v2.0.0.0 ; Microsoft.VisualBasic v8.0.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 (NbLinesOfCode)</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE NbLinesOfCode > 30 ORDER BY NbLinesOfCode DESC
// METHODS WHERE NbLinesOfCode > 30 are extremely complex and 
// should be split in smaller methods 
// (except if they are automatically generated by a tool).
// See the definition of the NbLinesOfCode metric here http://www.ndepend.com/Metrics.aspx#NbLinesOfCode

// <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>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>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 shouldn't be too deep in inheritance tree </Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE DepthOfInheritance >= 6 ORDER BY DepthOfInheritance DESC 
// Branches too long in the derivation should be avoided.
// See the definition of the DepthOfInheritance metric here http://www.ndepend.com/Metrics.aspx#DIT
 
// You can discard specific classes with by-design high DepthOfInheritance with such condition for example:
// AND !DeriveFrom "System.Windows.Forms.Form" 

// <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>Nested types should not be visible</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE IsNested AND !IsPrivate AND !IsInFrameworkAssembly 

// A nested type is a type declared within the scope of another type. 
// Nested types are useful for encapsulating private implementation details of the containing type. 
// Used for this purpose, nested types should not be externally visible. Do not use externally 
// visible nested types for logical grouping or to avoid name collisions; instead, use 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>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>Boxing/unboxing should be avoided (Method)</Name>
WARN IF Percentage > 5 IN SELECT METHODS WHERE IsUsingBoxing OR IsUsingUnboxing 
// Thanks to generics, boxing and unboxing should be rare.

// <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>Potentially unused fields</Name>
WARN IF Count > 0 IN SELECT TOP 10 FIELDS WHERE 
 FieldCa == 0 AND  // Ca=0 -> No Afferent Coupling -> The field is not used in the context of this application.
 !IsPublic AND     // Although not recommended, public fields might be used by client applications of your assemblies.
 !IsLiteral AND    // The IL code never explicitely uses literal fields.
 !IsEnumValue AND  // The IL code never explicitely uses enumeration value.
 !NameIs "value__" // Field named 'value__' are relative to enumerations and the IL code never explicitely uses them.

// <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>Types that could be declared as 'private' in C#,  'Private' in VB.NET</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE CouldBePrivate

// <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>Complex methods should be 100% covered by tests</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS /*OUT OF "YourGeneratedCode" */ WHERE 
     // These metrics' definitions are available here: http://www.ndepend.com/Metrics.aspx#MetricsOnMethods
     (  NbILInstructions > 200 OR 
        ILCyclomaticComplexity > 50 OR 
        ILNestingDepth > 4 OR
        NbParameters > 5 OR 
        NbVariables > 8 OR
        NbOverloads > 6 ) AND 
     !PercentageCoverage < 100

// To run this constraint properly coverage data must be gathered from NCover™ or Visual Studio™ Coverage.
// This can be done in VisualNDepend throught the menu: Coverage -> Import Coverage Files
// This can be done at analysis time throught the menu: Project Properties -> Analysis -> Code Coverage
// More information on how to import coverage data here:
// http://www.ndepend.com/Coverage.aspx

// <Name>Complex methods should be 100% covered by tests</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS /*OUT OF "YourGeneratedCode" */ WHERE 
     // These metrics' definitions are available here: http://www.ndepend.com/Metrics.aspx#MetricsOnMethods
     (  NbILInstructions > 200 OR 
        ILCyclomaticComplexity > 50 OR 
        ILNestingDepth > 4 OR
        NbParameters > 5 OR 
        NbVariables > 8 OR
        NbOverloads > 6 ) AND 
     !PercentageCoverage < 100

// To run this constraint properly coverage data must be gathered from NCover™ or Visual Studio™ Coverage.
// This can be done in VisualNDepend throught the menu: Coverage -> Import Coverage Files
// This can be done at analysis time throught the menu: Project Properties -> Analysis -> Code Coverage
// More information on how to import coverage data here:
// http://www.ndepend.com/Coverage.aspx

// <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>Methods name should begin with an Upper character</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE 
 !NameLike "^[A-Z]" AND 
 !(IsClassConstructor OR IsConstructor OR 
 IsPropertyGetter  OR IsPropertySetter OR
 IsIndexerGetter OR IsIndexerSetter OR
 IsEventAdder OR IsEventRemover OR
 IsOperator) AND !IsGeneratedByCompiler AND !IsInFrameworkAssembly
// The name of a regular method should begin with an Upper letter.

// <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 fields with name too long</Name>
WARN IF Count > 0 IN SELECT TOP 10 FIELDS WHERE 
  NameLike "^[^\<]{35,}.*$" AND 
  !IsInFrameworkAssembly 
// The regex matches fields with name longer than 35 characters.
// Field Name doesn't contain the type and namespace prefix, FullName does.

// <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>Types should not extend System.ApplicationException</Name>
WARN IF Count > 0 IN SELECT TYPES WHERE
  DepthOfDeriveFrom "OPTIONAL:System.ApplicationException" == 1 AND
  !IsInFrameworkAssembly

// For .NET Framework version 1, it was recommended to derive new exceptions from ApplicationException. 
// The recommendation has changed and new exceptions should derive from System.Exception or one of its 
// subclasses in the System namespace.

// <Name>Move P/Invokes to NativeMethods class</Name>
WARN IF Count > 0 IN SELECT METHODS WHERE
  !IsInFrameworkAssembly AND
  HasAttribute "OPTIONAL:System.Runtime.InteropServices.DllImportAttribute" AND
  !FullNameLike "NativeMethods."

// Platform Invocation methods, such as those marked with the System.Runtime.InteropServices.DllImportAttribute 
// attribute, or methods defined by using the Declare keyword in Visual Basic, access unmanaged code. 
// These methods should be in one of the following classes:
//
//     - NativeMethods - This class does not suppress stack walks for unmanaged code permission. 
//       (System.Security.SuppressUnmanagedCodeSecurityAttribute must not be applied to this class.) 
//       This class is for methods that can be used anywhere because a stack walk will be performed.
//
//     - SafeNativeMethods - This class suppresses stack walks for unmanaged code permission. 
//       (System.Security.SuppressUnmanagedCodeSecurityAttribute is applied to this class.) 
//       This class is for methods that are safe for anyone to call. Callers of these methods are not 
//       required to do a full security review to ensure that the usage is secure because the methods
//       are harmless for any caller.
//
//     - UnsafeNativeMethods - This class suppresses stack walks for unmanaged code permission. 
//       (System.Security.SuppressUnmanagedCodeSecurityAttribute is applied to this class.) 
//       This class is for methods that are potentially dangerous. Any caller of these methods must do
//       a full security review to ensure that the usage is secure because no stack walk will be performed.