Stat	# Occurrences	Avg	StdDev	Max
Properties on Interfaces	6 Interfaces	1.33	1.7	5 properties on Microsoft.Xna.Framework.IProxyProcessHandler
Methods on Interfaces	6 Interfaces	4.17	2.41	9 methods on Microsoft.Xna.Framework.Graphics.IGraphicsDeviceService
Arguments on Methods on Interfaces	25 Methods	0.56	0.5	1 arguments on Microsoft.Xna.Framework.Graphics.IGraphicsDeviceService.add_DeviceCreated(EventHandler)
Public Properties on Classes	377 Classes	1.92	5.45	67 public properties on Microsoft.Xna.Framework.Graphics.RenderState
Public Methods on Classes	377 Classes	6.46	12.48	135 public methods on Microsoft.Xna.Framework.Graphics.RenderState
Arguments on Public Methods on Classes	2434 Methods	0.93	1.4	11 arguments on Microsoft.Xna.Framework.Graphics.Texture3D.SetData<T>(Int32,Int32,Int32,Int32,Int32,Int32,Int32,T[],Int32,Int32,SetDataOptions)
IL Instructions in non-abstract Methods	5428 Methods	23.68	43.4	746 IL instructions in Microsoft.Xna.Framework.Gjk.UpdateDeterminant(Int32)
Cyclomatic complexity on non abstract Methods	5428 Methods	2.08	2.8	CC = 57 for Microsoft.Xna.Framework.Graphics.Texture.GetExpectedByteSizeFromFormat(SurfaceFormat)

Assembly	# Types	# Abstract Types	# IL instruction	# lines of code	# lines of comment	% comment	Afferent Coupling	Efferent Coupling	Relational Cohesion	Instability	Abstractness	Distance
Microsoft.Xna.Framework v3.1.0.0	765	16	128527	0	0	0	0	183	3.01	1	0.02	0.02

Assembly	Depends on...	Is referenced by...
Microsoft.Xna.Framework v3.1.0.0	mscorlib v2.0.0.0 ; System v2.0.0.0 ; Microsoft.VisualC 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 (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 (ILCyclomaticComplexity)</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE ILCyclomaticComplexity > 40 ORDER BY ILCyclomaticComplexity DESC
// METHODS WHERE ILCyclomaticComplexity > 20 are hard to understand and maintain.
// METHODS WHERE ILCyclomaticComplexity > 40 are extremely complex and should be split 
// in smaller methods (except if they are automatically generated by a tool).
// See the definition of the ILCyclomaticComplexity metric here http://www.ndepend.com/Metrics.aspx#ILCC

// <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 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>Methods with too many local variables (NbVariables)</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE NbVariables > 15 ORDER BY NbVariables DESC
// METHODS WHERE NbVariables > 8 are hard to understand and maintain.
// METHODS WHERE NbVariables > 15 are extremely complex and should be split in 
// smaller methods (except if they are automatically generated by a tool).
// See the definition of the Nbvariables metric here http://www.ndepend.com/Metrics.aspx#Nbvariables

// <Name>Methods with too many overloads (NbOverloads)</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE NbOverloads > 6 ORDER BY NbOverloads DESC
// METHODS WHERE NbParameters > 6 might be a problem to maintain and provoke higher coupling than necessary. 
// This might also reveal a potential misused of the C# and VB.NET language that since C#3 and VB9 support 
// object initialization. This feature helps reducing the number of constructors of a class.
// See the definition of the NbOverloads metric here http://www.ndepend.com/Metrics.aspx#NbOverloads

// <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>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>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>Empty static constructor can be discarded</Name>
WARN IF Count > 0 IN SELECT METHODS WHERE IsClassConstructor AND NbLinesOfCode == 0

// <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 (Type)</Name>
WARN IF Percentage > 5 IN SELECT TYPES 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>Potentially unused types</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE 
 TypeCa == 0 AND     // Ca=0 -> No Afferent Coupling -> The type is not used in the context of this application.
 !IsPublic AND       // Public types might be used by client applications of your assemblies.
 !NameIs "Program"   // Generally, types named Program contain a Main() entry-point method and this condition avoid to consider such type as unused code.

// <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 'protected' in C#,  'Protected' in VB.NET</Name>
WARN IF Count > 0 IN SELECT TOP 10 METHODS WHERE CouldBeProtected

// <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 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>Abstract base class should be suffixed with 'Base'</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE 
  IsAbstract AND 
  IsClass AND
  DepthOfInheritance == 1 AND // equivalent to:   DepthOfDeriveFrom "System.Object" == 1
  !NameLike "Base$"

// <Name>Types name should begin with an Upper character</Name>
WARN IF Count > 0 IN SELECT TOP 10 TYPES WHERE 
 !NameLike "^[A-Z]" AND     // The name of a type should begin with an Upper letter.
 !IsGeneratedByCompiler AND // Except if it is generated by compiler or ...
 !IsInFrameworkAssembly     // ... if it is declared in a framework assembly.

// <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 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>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>Enum Storage should be Int32</Name>
WARN IF Count > 0 IN SELECT FIELDS WHERE 
  NameIs "value__" AND 
  !IsOfType "OPTIONAL:System.Int32" AND
  !IsInFrameworkAssembly

// An enumeration is a value type that defines a set of related named constants. By default, 
// the System.Int32 data type is used to store the constant value. Even though you can change 
// this underlying type, it is not necessary or recommended for most scenarios. Note that there 
// is no significant performance gain in using a data type smaller than Int32. If you cannot 
// use the default data type, you should use one of the CLS-compliant integral types, Byte, 
// Int16, Int32, or Int64, to ensure that all of the enumeration's values are representable in 
// CLS-compliant programming languages.

// <Name>Do not raise reserved exception types</Name>
WARN IF Count > 0 IN SELECT METHODS WHERE 
  // The following exception types are reserved and should be thrown only by the Common Language Runtime:
  ( DepthOfCreateA "OPTIONAL:System.ExecutionEngineException" == 1 OR 
    DepthOfCreateA "OPTIONAL:System.IndexOutOfRangeException" == 1 OR 
    DepthOfCreateA "OPTIONAL:System.NullReferenceException" == 1 OR
    DepthOfCreateA "OPTIONAL:System.OutOfMemoryException" == 1 OR
    DepthOfCreateA "OPTIONAL:System.StackOverflowException" == 1 OR 
    DepthOfCreateA "OPTIONAL:System.InvalidProgramException" == 1 OR 
    DepthOfCreateA "OPTIONAL:System.AccessViolationException" == 1 OR
    DepthOfCreateA "OPTIONAL:System.CannotUnloadAppDomainException" == 1 OR
    DepthOfCreateA "OPTIONAL:System.BadImageFormatException" == 1 OR 
    DepthOfCreateA "OPTIONAL:System.DataMisalignedException" == 1 )

// <Name>P/Invokes should be static and not be visible</Name>
WARN IF Count > 0 IN SELECT METHODS WHERE
  !IsInFrameworkAssembly AND
  (HasAttribute "OPTIONAL:System.Runtime.InteropServices.DllImportAttribute") AND
  ( IsPublic OR 
    !IsStatic)

// Methods marked with the DllImportAttribute attribute (or methods defined using the 
// Declare keyword in Visual Basic) use Platform Invocation Services to access unmanaged 
// code. Such methods should not be exposed. Keeping these methods private or internal 
// ensures that your library cannot be used to breach security by allowing callers access 
// to unmanaged APIs they could not call otherwise.

// <Name>NativeMethods class should be static and internal</Name>
WARN IF Count > 0 IN SELECT TYPES WHERE
  !IsInFrameworkAssembly AND
  ( NameIs "NativeMethods" OR
    NameIs "SafeNativeMethods" OR
    NameIs "UnsafeNativeMethods") AND
  IsPublic OR
  !IsStatic 

// Native Methods' classes are declared as internal (Friend, in Visual Basic) and static.

// <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