stylecopplus Wiki Rss Feed

New Comment on "How to Create StyleCop Custom Rule"

NickyPhun — Thu, 12 Jul 2012 04:43:47 GMT

Hi! i am using C# Visual 2010 Express, however i tried the step on above, the custom rules doesn't show on the Stylecop V4.7 Setting List, even i changed the XML to embeded. kindly advice is there any other ways to resolve this?

Updated Wiki: Compatibility Issues

shuruev — Sun, 08 Apr 2012 05:06:09 GMT

Compatibility Issues

Natively Supported Version

As you may already know, StyleCop is released with strong-named core assemblies.
That is why only one StyleCop version can be natively supported at one time.

Currently natively supported StyleCop version is 4.7.17.0.
It means if you are using StyleCop 4.7.17.0, StyleCop+ will work as is, without any additional efforts.

Of course, I am always trying to keep StyleCop+ up to date.
However, it is possible to make StyleCop+ with other StyleCop versions using assembly binding.
But you should understand that it will only work as long as StyleCop API is not changed.

Understanding Assembly Binding

Assembly bindings are special instructions in .NET configuration files which say "Hey, use this version of this assembly instead of that version".
There are two ways where to define them.

1. You could define assembly bindings in global .NET configuration file and it will affect the behaviour of all .NET applications on this machine.

As a result, bindings will work for all cases described below, e.g. using StyleCop from Visual Studio, running it as MSBuild task, or just working with Settings Editor.
But you should pay attention that each .NET version has its own configuration file.
For example, Visual Studio 2010 will use one from .NET 4.0, while Settings Editor will use the other from .NET 3.5.
So you could have to update them both.

2. You could setup assembly binding for the specific application that uses StyleCop.

To do this, you must locate its configuration file (or create it if it's absent) and make corresponding changes.

How to Update Configuration File

The following table shows most typical examples of where configuration file is located:

Use Case	Configuration File
Global .NET 2.0 / 3.0 / 3.5 configuration	C:\Windows\Microsoft.NET\Framework\v2.0.50727\Config\Machine.config
^{- Will setup assembly bindings for all .NET 2.0 / 3.0 / 3.5 applications}
Global .NET 4.0 configuration	C:\Windows\Microsoft.NET\Framework\v4.0.30319\Config\Machine.config
^{- Will setup assembly bindings for all .NET 4.0 applications}
Visual Studio 2008	C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe.config
^{- Running StyleCop from Visual Studio 2008}
Visual Studio 2010	C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe.config
^{- Running StyleCop from Visual Studio 2010}
MSBuild	C:\Windows\Microsoft.NET\Framework\v2.0.50727\MSBuild.exe.config
^{- Running StyleCop from MSBuild task}	^{* Please pay attention which MSBuild version you want to use}
Standalone Settings Editor	C:\Program Files\StyleCop 4.5\StyleCopSettingsEditor.exe.config
^{- Double-click on Settings.StyleCop file}	^{* You might need to create this file manually}

In order to setup assembly bindings, you should add the following instructions to the configuration file:

<runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
        <dependentAssembly>
            <assemblyIdentity name="StyleCop" publicKeyToken="f904653c63bc2738" />
            <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="???" />
        </dependentAssembly>
        <dependentAssembly>
            <assemblyIdentity name="StyleCop.CSharp" publicKeyToken="f904653c63bc2738" />
            <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="???" />
        </dependentAssembly>
        <dependentAssembly>
            <assemblyIdentity name="StyleCop.CSharp.Rules" publicKeyToken="f904653c63bc2738" />
            <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="???" />
        </dependentAssembly>
    </assemblyBinding>
</runtime>

Attribute oldVersion contains the version being redirected (i.e. StyleCop versions that StyleCop+ is trying to load).
Attribute newVersion describes which version to use instead (i.e. your StyleCop version).

Examples

Using StyleCop+ with StyleCop 4.5.12.0 in Visual Studio 2010

Locate file C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe.config and add the following lines:

...
<configuration>
    ...
    <runtime>
        ...
        <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
            ...
            <dependentAssembly>
                <assemblyIdentity name="StyleCop" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.12.0" />
            </dependentAssembly>
            <dependentAssembly>
                <assemblyIdentity name="StyleCop.CSharp" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.12.0" />
            </dependentAssembly>
            <dependentAssembly>
                <assemblyIdentity name="StyleCop.CSharp.Rules" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.12.0" />
            </dependentAssembly>
            ...
        </assemblyBinding>
        ...
    </runtime>
    ...
</configuration>

Using StyleCop+ with StyleCop 4.5.11.0 in standalone Settings Editor

Create file C:\Program Files\StyleCop 4.5\StyleCopSettingsEditor.exe.config with the following contents:

<?xml version="1.0"?>
<configuration>
    <runtime>
        <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
            <dependentAssembly>
                <assemblyIdentity name="StyleCop" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.11.0" />
            </dependentAssembly>
            <dependentAssembly>
                <assemblyIdentity name="StyleCop.CSharp" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.11.0" />
            </dependentAssembly>
            <dependentAssembly>
                <assemblyIdentity name="StyleCop.CSharp.Rules" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.11.0" />
            </dependentAssembly>
        </assemblyBinding>
    </runtime>
</configuration>

Updated Wiki: Quick Start Guide

shuruev — Sun, 08 Apr 2012 05:05:54 GMT

Quick Start Guide

Typical Installation

If you are using the most recent version of StyleCop the installation would be extremely simple.
Just download binary file StyleCopPlus.dll and place it in your StyleCop folder.

Don't forget to unblock the file after downloading (right-click then choose Properties).

Compatibility Issues

Currently StyleCop+ natively supports StyleCop version 4.7.17.0.
If you are using other StyleCop version, please read about compatibility issues to find out how to make StyleCop+ work with it.

Editing Settings

As soon as StyleCop+ is installed correctly, you should see new "StyleCop+" tab appeared in settings dialog.
This tab contains settings page for configuring all StyleCop+ features.

Need Help?

In case of StyleCop+ does not work please make sure that you have read about compatibility issues.
If documentation does not help, feel free to publish a post with the description of your problem.

Updated Wiki: Home

shuruev — Sun, 08 Apr 2012 05:05:03 GMT

_{StyleCop+ 1.8 has just been released!}

What is StyleCop+?

StyleCop+ is a plug-in that extends original StyleCop features.
It offers you a variety of rules for building C# code style that best suits your needs.

Key features:

Advanced Naming Rules
More Custom Rules
Extended Original Rules (experimental feature)

Please read full StyleCop+ documentation for more detailed information, such as quick start guide or rules reference.

Advanced Naming Rules

StyleCop+ contains rich and flexible naming rules that are intended to completely replace all original Naming Rules (SA13xx).

They allow specifying separate naming rules for each code entity - namespaces, classes, interfaces, methods... etc.
As a result, you can build any style you need, whether it is "m_field" style, "_field" style, or any other.

Rich variety of entities
- For example, you can specify separate rules for private event handlers (buttonStart_Click) or unit test methods (Setting_Null_Throws_Exception).
Several naming templates for each entity
- Make your style more flexible or add some exceptions to the basic rules.
Usage of naming macros
- Most popular naming styles are available (PascalCasing, camelCasing, ALL_UPPER... etc.)
Abbreviations support
- Specify the abbreviations you want to use, e.g. ID or OK.
Checking name endings for derived classes
- For example, you could ensure that all classes derived from Exception are named like ...Exception.

~~Read more about Advanced Naming Rules in documentation.~~ (this page is not ready yet)

More Custom Rules

StyleCop+ offers more custom rules for making your style tougher.
Most of them have flexible settings, configured through user-friendly UI.
And a small example illustrates what this rule is about.

Please send new rule proposals, if your code style needs more checks.
If they are common enough, they will likely be added as soon as possible.

~~Read more about More Custom Rules in documentation.~~ (this page is not ready yet)

Extended Original Rules (experimental feature)

StyleCop+ also contains rules that are based on the original ones, but work in a bit diferent way.
They may remove some restrictions, or add more options for customizing original checking behavior.

For example, original SA1509 rule prohibits using a blank line before opening curly bracket.
But sometime people want to use constructions like this:

// some statements
...

{
    int a; // declaration of local variables required to set value of f1
    ...
    this.f1 = ...;
}

{
    int a; // declaration of local variables required to set value of f2
    ...
    this.f2 = ...;
}

StyleCop+ has its own rule - SP1509, which behaves like SA1509, but doesn't throw a violation on such "nested code blocks".
In other cases, SP1509 rule works exactly as original SA1509 rule.

Note that StyleCop+ doesn't have its own code which looks like original SA1509 check - it really executes original StyleCop's SA1509 check, but analyzes the result in its own way.

~~Read more about Extended Original Rules in documentation.~~ (this page is not ready yet)

New Comment on "How to Create StyleCop Custom Rule"

shuruev — Wed, 04 Apr 2012 05:21:04 GMT

For now, yes that is true.

New Comment on "How to Create StyleCop Custom Rule"

savirpe — Tue, 03 Apr 2012 08:47:54 GMT

Hi ! It seems that it works only with .NET 3.5 not 4.0 ?

Updated Wiki: How to Create StyleCop Custom Rule

shuruev — Sun, 18 Mar 2012 16:28:39 GMT

How to Create StyleCop Custom Rule

This article gives simple step-by-step guide which could be useful for learning how to create own StyleCop rules.

Consider downloading the complete Visual Studio project if needed.

Step 1. Create a project

Create a new Visual Studio class library project targeting .NET 3.5.

Step 2. Add references

Add references to the following binaries (can be found in StyleCop installation folder):

StyleCop
StyleCop.CSharp

Step 3. Add analyzer class

After adding references, create a new class for StyleCop analyzer.

Analyzer could be understood as an "engine" containing several rules with similar behavior.
There could be several analyzers in one custom rules assembly.

Put the following code into your analyzer class:

using StyleCop;
using StyleCop.CSharp;

namespace MyCustomRules
{
	/// <summary>
	/// Custom analyzer for demo purposes.
	/// </summary>
	[SourceAnalyzer(typeof(CsParser))]
	public class MyCustomAnalyzer : SourceAnalyzer
	{
		/// <summary>
		/// Extremely simple analyzer for demo purposes.
		/// </summary>
		public override void AnalyzeDocument(CodeDocument document)
		{
			CsDocument doc = (CsDocument)document;

			// skipping wrong or auto-generated documents
			if (doc.RootElement == null || doc.RootElement.Generated)
				return;

			// check all class entries
			doc.WalkDocument(CheckClasses);
		}

		/// <summary>
		/// Checks whether specified element conforms custom rule CR0001.
		/// </summary>
		private bool CheckClasses(
			CsElement element,
			CsElement parentElement,
			object context)
		{
			// if current element is not a class then continue walking
			if (element.ElementType != ElementType.Class)
				return true;

			// check whether class name contains "a" letter
			Class classElement = (Class)element;
			if (classElement.Declaration.Name.Contains("a"))
			{
				// add violation
				// (note how custom message arguments could be used)
				AddViolation(
					classElement,
					classElement.Location,
					"AvoidUsingAInClassNames",
					classElement.FriendlyTypeText);
			}

			// continue walking in order to find all classes in file
			return true;
		}
	}
}

Step 4. Add analyzer definition file

Each analyzer should be provided with an XML file containing rule definition.
Create a new XML file:

named exactly as analyzer class
specify build action as "Embedded Resource"

Put the following content into your analyzer definition file:

<?xml version="1.0" encoding="utf-8" ?>
<SourceAnalyzer Name="My Custom Rule">
	<Description>
		Custom rule for demo purposes.
	</Description>
	<Rules>
		<Rule Name="AvoidUsingAInClassNames" CheckId="CR0001">
			<Context>Do not use 'a' letter in {0} names.</Context>
			<Description>Fires when 'a' letter is used in class name.</Description>
		</Rule>
	</Rules>
</SourceAnalyzer>

Step 5. Build and deploy

You custom rules are almost ready.
Build the library, and copy output file to the StyleCop installation directory.

Step 6. Check how it works

Exit Visual Studio and run it again.
Now your custom rules should be loaded and could be seen in StyleCop settings editor.

You can also make sure that rules are actually executed.

Updated Wiki: How to Create StyleCop Custom Rule

shuruev — Sun, 18 Mar 2012 16:27:57 GMT

How to Create StyleCop Custom Rule

This article gives simple step-by-step guide which could be useful for learning how to create own StyleCop rules.

Consider downloading the complete Visual Studio project if needed.

Step 1. Create a project

Create a new Visual Studio class library project targeting .NET 3.5.

Step 2. Add references

Add references to the following binaries (can be found in StyleCop installation folder):

StyleCop
StyleCop.CSharp

Step 3. Add analyzer class

using StyleCop;
using StyleCop.CSharp;

namespace MyCustomRules
{
	/// <summary>
	/// Custom analyzer for demo purposes.
	/// </summary>
	[SourceAnalyzer(typeof(CsParser))]
	public class MyCustomAnalyzer : SourceAnalyzer
	{
		/// <summary>
		/// Extremely simple analyzer for demo purposes.
		/// </summary>
		public override void AnalyzeDocument(CodeDocument document)
		{
			CsDocument doc = (CsDocument)document;

			// skipping wrong or auto-generated documents
			if (doc.RootElement == null || doc.RootElement.Generated)
				return;

			// check all class entries
			doc.WalkDocument(CheckClasses);
		}

		/// <summary>
		/// Checks whether specified element conforms custom rule CR0001.
		/// </summary>
		private bool CheckClasses(
			CsElement element,
			CsElement parentElement,
			object context)
		{
			// if current element is not a class then continue walking
			if (element.ElementType != ElementType.Class)
				return true;

			// check whether class name contains "a" letter
			Class classElement = (Class)element;
			if (classElement.Declaration.Name.Contains("a"))
			{
				// add violation
				// (note how custom message arguments could be used)
				AddViolation(
					classElement,
					classElement.Location,
					"AvoidUsingAInClassNames",
					classElement.FriendlyTypeText);
			}

			// continue walking in order to find all classes in file
			return true;
		}
	}
}

Step 4. Add analyzer definition file

Each analyzer should be provided with an XML file containing rule definition.
Create a new XML file:

named exactly as analyzer class
specify build action as "Embedded Resource".

Put the following content into your analyzer definition file:

<?xml version="1.0" encoding="utf-8" ?>
<SourceAnalyzer Name="My Custom Rule">
	<Description>
		Custom rule for demo purposes.
	</Description>
	<Rules>
		<Rule Name="AvoidUsingAInClassNames" CheckId="CR0001">
			<Context>Do not use 'a' letter in {0} names.</Context>
			<Description>Fires when 'a' letter is used in class name.</Description>
		</Rule>
	</Rules>
</SourceAnalyzer>

Step 5. Build and deploy

You custom rules are almost ready.
Build the library, and copy output file to the StyleCop installation directory.

Step 6. Check how it works

Exit Visual Studio and run it again.
Now your custom rules should be loaded and could be seen in StyleCop settings editor.

You can also make sure that rules are actually executed.

Updated Wiki: How to Create StyleCop Custom Rule

shuruev — Sun, 18 Mar 2012 16:22:16 GMT

How to Create StyleCop Custom Rule

This article gives simple step-by-step guide which could be useful for learning how to create own StyleCop rules.

Consider downloading the complete Visual Studio project if needed.

Step 1. Create a project

Create a new Visual Studio class library project targeting .NET 3.5.

Step 2. Add references

Add references to the following binaries (can be found in StyleCop installation folder):

StyleCop
StyleCop.CSharp

Step 3. Add analyzer class

using StyleCop;
using StyleCop.CSharp;

namespace MyCustomRules
{
	/// <summary>
	/// Custom analyzer for demo purposes.
	/// </summary>
	[SourceAnalyzer(typeof(CsParser))]
	public class MyCustomAnalyzer : SourceAnalyzer
	{
		/// <summary>
		/// Extremely simple analyzer for demo purposes.
		/// </summary>
		public override void AnalyzeDocument(CodeDocument document)
		{
			CsDocument doc = (CsDocument)document;

			// skipping wrong or auto-generated documents
			if (doc.RootElement == null || doc.RootElement.Generated)
				return;

			// check all class entries
			doc.WalkDocument(CheckClasses);
		}

		/// <summary>
		/// Checks whether specified element conforms custom rule CR0001.
		/// </summary>
		private bool CheckClasses(
			CsElement element,
			CsElement parentElement,
			object context)
		{
			// if current element is not a class then continue walking
			if (element.ElementType != ElementType.Class)
				return true;

			// check whether class name contains "a" letter
			Class classElement = (Class)element;
			if (classElement.Declaration.Name.Contains("a"))
			{
				// add violation
				// (note how custom message arguments could be used)
				AddViolation(
					classElement,
					classElement.Location,
					"AvoidUsingAInClassNames",
					classElement.FriendlyTypeText);
			}

			// continue walking in order to find all classes in file
			return true;
		}
	}
}

Step 4. Add analyzer definition file

Each analyzer should be provided with an XML file containing rule definition.
Create a new XML file:

named exactly as analyzer class
specify build action as "Embedded Resource".

Put the following content into your analyzer definition file:

<?xml version="1.0" encoding="utf-8" ?>
<SourceAnalyzer Name="My Custom Rule">
	<Description>
		Custom rule for demo purposes.
	</Description>
	<Rules>
		<Rule Name="AvoidUsingAInClassNames" CheckId="CR0001">
			<Context>Do not use 'a' letter in {0} names.</Context>
			<Description>Fires when 'a' letter is used in class name.</Description>
		</Rule>
	</Rules>
</SourceAnalyzer>

Step 5. Build and deploy your rules

You custom rules are almost ready. Build the library, and copy output file to the StyleCop installation directory.

Updated Wiki: How to Create StyleCop Custom Rule

shuruev — Sun, 18 Mar 2012 16:12:46 GMT

How to Create StyleCop Custom Rule

This article gives simple step-by-step guide which could be useful for learning how to create own StyleCop rules.

Consider downloading the complete Visual Studio project if needed.

Step 1. Create a project

Create a new Visual Studio class library project targeting .NET 3.5.

Step 2. Add references

Add references to the following binaries (can be found in StyleCop installation folder):

StyleCop
StyleCop.CSharp

Step 3. Add analyzer class

using StyleCop;
using StyleCop.CSharp;

namespace MyCustomRules
{
	/// <summary>
	/// Custom analyzer for demo purposes.
	/// </summary>
	[SourceAnalyzer(typeof(CsParser))]
	public class MyCustomAnalyzer : SourceAnalyzer
	{
		/// <summary>
		/// Extremely simple analyzer for demo purposes.
		/// </summary>
		public override void AnalyzeDocument(CodeDocument document)
		{
			CsDocument doc = (CsDocument)document;

			// skipping wrong or auto-generated documents
			if (doc.RootElement == null || doc.RootElement.Generated)
				return;

			// check all class entries
			doc.WalkDocument(CheckClasses);
		}

		/// <summary>
		/// Checks whether specified element conforms custom rule CR0001.
		/// </summary>
		private bool CheckClasses(
			CsElement element,
			CsElement parentElement,
			object context)
		{
			// if current element is not a class then continue walking
			if (element.ElementType != ElementType.Class)
				return true;

			// check whether class name contains "a" letter
			Class classElement = (Class)element;
			if (classElement.Declaration.Name.Contains("a"))
			{
				// add violation
				// (note how custom message arguments could be used)
				AddViolation(
					classElement,
					classElement.Location,
					"AvoidUsingAInClassNames",
					classElement.FriendlyTypeText);
			}

			// continue walking in order to find all classes in file
			return true;
		}
	}
}

Updated Wiki: How to Create StyleCop Custom Rule

shuruev — Sun, 18 Mar 2012 16:11:58 GMT

How to Create StyleCop Custom Rule

This article gives simple step-by-step guide which could be useful for learning how to create own StyleCop rules.

Consider downloading the complete Visual Studio project if needed.

Step 1. Create a project

Create a new Visual Studio class library project targeting .NET 3.5.

Step 2. Add references

Add references to the following binaries (can be found in StyleCop installation folder):

StyleCop
StyleCop.CSharp

Step 3. Add analyzer class

After adding references, create a new class for StyleCop analyzer.

Cannot resolve image macro, invalid image name or id.

Analyzer could be understood as an "engine" containing several rules with similar behavior.
There could be several analyzers in one custom rules assembly.

Put the following code into your analyzer class:

using StyleCop;
using StyleCop.CSharp;

namespace MyCustomRules
{
	/// <summary>
	/// Custom analyzer for demo purposes.
	/// </summary>
	[SourceAnalyzer(typeof(CsParser))]
	public class MyCustomAnalyzer : SourceAnalyzer
	{
		/// <summary>
		/// Extremely simple analyzer for demo purposes.
		/// </summary>
		public override void AnalyzeDocument(CodeDocument document)
		{
			CsDocument doc = (CsDocument)document;

			// skipping wrong or auto-generated documents
			if (doc.RootElement == null || doc.RootElement.Generated)
				return;

			// check all class entries
			doc.WalkDocument(CheckClasses);
		}

		/// <summary>
		/// Checks whether specified element conforms custom rule CR0001.
		/// </summary>
		private bool CheckClasses(CsElement element, CsElement parentElement, object context)
		{
			// if current element is not a class then continue walking
			if (element.ElementType != ElementType.Class)
				return true;

			// check whether class name contains "a" letter
			Class classElement = (Class)element;
			if (classElement.Declaration.Name.Contains("a"))
			{
				// add violation
				// (note how custom message arguments could be used)
				AddViolation(
					classElement,
					classElement.Location,
					"AvoidUsingAInClassNames",
					classElement.FriendlyTypeText);
			}

			// continue walking in order to find all classes in file
			return true;
		}
	}
}

Updated Wiki: How to Create StyleCop Custom Rule

shuruev — Sun, 18 Mar 2012 15:51:46 GMT

How to Create StyleCop Custom Rule

This article gives simple step-by-step guide which could be useful for learning how to create own StyleCop rules.

Consider downloading the MyCustomRules.zip if needed.

Step 1. Create a project

This...

Updated Wiki: How to Create StyleCop Custom Rule

shuruev — Sun, 18 Mar 2012 15:51:06 GMT

How to Create StyleCop Custom Rule

This article gives simple step-by-step guide which could be useful for learning how to create own StyleCop rules.

Consider downloading the Cannot resolve file macro, invalid file name or id. if needed.

Step 1. Create a project

This...

Updated Wiki: Running StyleCop from Your Code

shuruev — Sun, 18 Mar 2012 15:48:07 GMT

Running StyleCop from Your Code

This is a very simple example of how StyleCop could be run from your code.

Create Console Application

Create C# console application targeting .NET 3.5 or .NET 4.0 (full version, not "Client Profile").

Add references to the following binaries (can be found in StyleCop installation folder):

StyleCop
StyleCop.CSharp
StyleCop.CSharp.Rules

Use source code below as an example:

using System;
using StyleCop;

namespace StyleCopRun.Simple
{
	/// <summary>
	/// Simple example for running StyleCop environment.
	/// </summary>
	public class Program
	{
		/// <summary>
		/// Main program entry.
		/// </summary>
		public static void Main(string[] args)
		{
			string projectPath = @"D:\TestProject\";
			string filePath = @"D:\TestProject\Class1.cs";

			StyleCopConsole console = new StyleCopConsole(
				null,
				false,
				null,
				null,
				true);

			CodeProject project = new CodeProject(
				0,
				projectPath,
				new Configuration(null));

			console.Core.Environment.AddSourceCode(project, filePath, null);

			console.OutputGenerated += OnOutputGenerated;
			console.ViolationEncountered += OnViolationEncountered;
			console.Start(new[] { project }, true);
			console.OutputGenerated -= OnOutputGenerated;
			console.ViolationEncountered -= OnViolationEncountered;
			console.Dispose();

			Console.WriteLine("Press any key to exit...");
			Console.ReadKey();
		}

		/// <summary>
		/// Handles generated output.
		/// </summary>
		private static void OnOutputGenerated(
			object sender,
			OutputEventArgs e)
		{
			Console.WriteLine(e.Output);
		}

		/// <summary>
		/// Handles encountered violations.
		/// </summary>
		private static void OnViolationEncountered(
			object sender,
			ViolationEventArgs e)
		{
			Console.WriteLine(
				"{0}: {1}",
				e.Violation.Rule.CheckId,
				e.Message);
		}
	}
}

Run Your Application

After running it should display a console with some output:

Updated Wiki: Running StyleCop from Your Code

shuruev — Sun, 18 Mar 2012 15:46:37 GMT

Running StyleCop from Your Code

This is a very simple example of how StyleCop could be run from your code.

Create Console Application

Create C# console application targeting .NET 3.5 or .NET 4.0 (full version, not "Client Profile").

Add references to the following binaries (can be found in StyleCop installation folder):

StyleCop
StyleCop.CSharp
StyleCop.CSharp.Rules

Use source code below as an example:

using System;
using StyleCop;

namespace StyleCopRun.Simple
{
	/// <summary>
	/// Simple example for running StyleCop environment.
	/// </summary>
	public class Program
	{
		/// <summary>
		/// Main program entry.
		/// </summary>
		public static void Main(string[] args)
		{
			string projectPath = @"D:\TestProject\";
			string filePath = @"D:\TestProject\Class1.cs";

			StyleCopConsole console = new StyleCopConsole(
				null,
				false,
				null,
				null,
				true);

			CodeProject project = new CodeProject(
				0,
				projectPath,
				new Configuration(null));

			console.Core.Environment.AddSourceCode(project, filePath, null);

			console.OutputGenerated += OnOutputGenerated;
			console.ViolationEncountered += OnViolationEncountered;
			console.Start(new[] { project }, true);
			console.OutputGenerated -= OnOutputGenerated;
			console.ViolationEncountered -= OnViolationEncountered;
			console.Dispose();

			Console.WriteLine("Press any key to exit...");
			Console.ReadKey();
		}

		/// <summary>
		/// Handles generated output.
		/// </summary>
		private static void OnOutputGenerated(object sender, OutputEventArgs e)
		{
			Console.WriteLine(e.Output);
		}

		/// <summary>
		/// Handles encountered violations.
		/// </summary>
		private static void OnViolationEncountered(object sender, ViolationEventArgs e)
		{
			Console.WriteLine("{0}: {1}", e.Violation.Rule.CheckId, e.Message);
		}
	}
}

Run Your Application

After running it should display a console with some output:

Updated Wiki: Running StyleCop from Your Code

shuruev — Sun, 18 Mar 2012 15:45:03 GMT

Running StyleCop from Your Code

This is a simple example of how StyleCop could be run from your code.

Create Console Application

Create C# console application targeting .NET 3.5 or .NET 4.0 (full version, not "Client Profile").

Add references to the following binaries (can be found in StyleCop installation folder):

StyleCop
StyleCop.CSharp
StyleCop.CSharp.Rules

Use source code below as an example:

using System;
using StyleCop;

namespace StyleCopRun.Simple
{
	/// <summary>
	/// Simple example for running StyleCop environment.
	/// </summary>
	public class Program
	{
		/// <summary>
		/// Main program entry.
		/// </summary>
		public static void Main(string[] args)
		{
			string projectPath = @"D:\TestProject\";
			string filePath = @"D:\TestProject\Class1.cs";

			StyleCopConsole console = new StyleCopConsole(null, false, null, null, true);
			CodeProject project = new CodeProject(0, projectPath, new Configuration(null));

			console.Core.Environment.AddSourceCode(project, filePath, null);

			console.OutputGenerated += OnOutputGenerated;
			console.ViolationEncountered += OnViolationEncountered;
			console.Start(new[] { project }, true);
			console.OutputGenerated -= OnOutputGenerated;
			console.ViolationEncountered -= OnViolationEncountered;
			console.Dispose();

			Console.WriteLine("Press any key to exit...");
			Console.ReadKey();
		}

		/// <summary>
		/// Handles generated output.
		/// </summary>
		private static void OnOutputGenerated(object sender, OutputEventArgs e)
		{
			Console.WriteLine(e.Output);
		}

		/// <summary>
		/// Handles encountered violations.
		/// </summary>
		private static void OnViolationEncountered(object sender, ViolationEventArgs e)
		{
			Console.WriteLine("{0}: {1}", e.Violation.Rule.CheckId, e.Message);
		}
	}
}

Run Your Application

After running it should display a console with some output:

Updated Wiki: Documentation

shuruev — Sun, 18 Mar 2012 15:22:46 GMT

StyleCop+ Documentation

Installation and Usage

Key Features

~~Advanced Naming Rules~~ (this page is not ready yet)
~~More Custom Rules~~ (this page is not ready yet)
~~Extended Original Rules~~ (this page is not ready yet)
Warnings

Rules Reference

Updated Wiki: How to Create StyleCop Custom Rule

shuruev — Sun, 18 Mar 2012 15:18:49 GMT

How to Create StyleCop Custom Rule

This article gives simple step-by-step guide which could be useful for learning how to create own StyleCop rules.

Step 1. Create a project

This...

Updated Wiki: How to Create Custom Rule

shuruev — Sun, 18 Mar 2012 15:14:54 GMT

How to Create Custom Rule

This article gives simple step-by-step guide which could be used for creating own StyleCop rules.

Step 1. Create a project

This...

Updated Wiki: Compatibility Issues

shuruev — Thu, 23 Feb 2012 15:15:16 GMT

Compatibility Issues

Natively Supported Version

As you may already know, StyleCop is released with strong-named core assemblies.
That is why only one StyleCop version can be natively supported at one time.

Currently natively supported StyleCop version is 4.7.11.0.
It means if you are using StyleCop 4.7.11.0, StyleCop+ will work as is, without any additional efforts.

Of course, I am always trying to keep StyleCop+ up to date.
However, it is possible to make StyleCop+ with other StyleCop versions using assembly binding.
But you should understand that it will only work as long as StyleCop API is not changed.

Understanding Assembly Binding

Assembly bindings are special instructions in .NET configuration files which say "Hey, use this version of this assembly instead of that version".
There are two ways where to define them.

1. You could define assembly bindings in global .NET configuration file and it will affect the behaviour of all .NET applications on this machine.

2. You could setup assembly binding for the specific application that uses StyleCop.

To do this, you must locate its configuration file (or create it if it's absent) and make corresponding changes.

How to Update Configuration File

The following table shows most typical examples of where configuration file is located:

Use Case	Configuration File
Global .NET 2.0 / 3.0 / 3.5 configuration	C:\Windows\Microsoft.NET\Framework\v2.0.50727\Config\Machine.config
^{- Will setup assembly bindings for all .NET 2.0 / 3.0 / 3.5 applications}
Global .NET 4.0 configuration	C:\Windows\Microsoft.NET\Framework\v4.0.30319\Config\Machine.config
^{- Will setup assembly bindings for all .NET 4.0 applications}
Visual Studio 2008	C:\Program Files\Microsoft Visual Studio 9.0\Common7\IDE\devenv.exe.config
^{- Running StyleCop from Visual Studio 2008}
Visual Studio 2010	C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe.config
^{- Running StyleCop from Visual Studio 2010}
MSBuild	C:\Windows\Microsoft.NET\Framework\v2.0.50727\MSBuild.exe.config
^{- Running StyleCop from MSBuild task}	^{* Please pay attention which MSBuild version you want to use}
Standalone Settings Editor	C:\Program Files\StyleCop 4.5\StyleCopSettingsEditor.exe.config
^{- Double-click on Settings.StyleCop file}	^{* You might need to create this file manually}

In order to setup assembly bindings, you should add the following instructions to the configuration file:

<runtime>
    <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
        <dependentAssembly>
            <assemblyIdentity name="StyleCop" publicKeyToken="f904653c63bc2738" />
            <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="???" />
        </dependentAssembly>
        <dependentAssembly>
            <assemblyIdentity name="StyleCop.CSharp" publicKeyToken="f904653c63bc2738" />
            <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="???" />
        </dependentAssembly>
        <dependentAssembly>
            <assemblyIdentity name="StyleCop.CSharp.Rules" publicKeyToken="f904653c63bc2738" />
            <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="???" />
        </dependentAssembly>
    </assemblyBinding>
</runtime>

Examples

Using StyleCop+ with StyleCop 4.5.12.0 in Visual Studio 2010

Locate file C:\Program Files\Microsoft Visual Studio 10.0\Common7\IDE\devenv.exe.config and add the following lines:

...
<configuration>
    ...
    <runtime>
        ...
        <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
            ...
            <dependentAssembly>
                <assemblyIdentity name="StyleCop" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.12.0" />
            </dependentAssembly>
            <dependentAssembly>
                <assemblyIdentity name="StyleCop.CSharp" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.12.0" />
            </dependentAssembly>
            <dependentAssembly>
                <assemblyIdentity name="StyleCop.CSharp.Rules" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.12.0" />
            </dependentAssembly>
            ...
        </assemblyBinding>
        ...
    </runtime>
    ...
</configuration>

Using StyleCop+ with StyleCop 4.5.11.0 in standalone Settings Editor

Create file C:\Program Files\StyleCop 4.5\StyleCopSettingsEditor.exe.config with the following contents:

<?xml version="1.0"?>
<configuration>
    <runtime>
        <assemblyBinding xmlns="urn:schemas-microsoft-com:asm.v1">
            <dependentAssembly>
                <assemblyIdentity name="StyleCop" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.11.0" />
            </dependentAssembly>
            <dependentAssembly>
                <assemblyIdentity name="StyleCop.CSharp" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.11.0" />
            </dependentAssembly>
            <dependentAssembly>
                <assemblyIdentity name="StyleCop.CSharp.Rules" publicKeyToken="f904653c63bc2738" />
                <bindingRedirect oldVersion="4.5.0.0-4.5.99.99" newVersion="4.5.11.0" />
            </dependentAssembly>
        </assemblyBinding>
    </runtime>
</configuration>