Your SlideShare is downloading. ×
Automating C# Coding Standards using StyleCop and FxCop
Upcoming SlideShare
Loading in...5

Thanks for flagging this SlideShare!

Oops! An error has occurred.


Saving this for later?

Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime - even offline.

Text the download link to your phone

Standard text messaging rates apply

Automating C# Coding Standards using StyleCop and FxCop


Published on

As organizations grow they usually seek to build a set of coding standards to enforce uniformity and increase the maintainability of their code base. Unfortunately, this often creates a lot of churn …

As organizations grow they usually seek to build a set of coding standards to enforce uniformity and increase the maintainability of their code base. Unfortunately, this often creates a lot of churn in the code review process for simple style issues. This presentation was a session I gave at St. Louis Day of .NET 2010 and talks about how to automate many of the coding standards using two readily available tools.

Published in: Technology

  • Be the first to comment

No Downloads
Total Views
On Slideshare
From Embeds
Number of Embeds
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

No notes for slide


  • 1.
    • James Hare – Application Architect, Scottrade
  • 2. What are Coding Standards?
    • A set of rules or guidelines used when writing the source code of a computer program.
    • Generally dictates:
      • Safety mandates to avoid introducing errors.
      • Style mandates to increase maintainability.
      • Security mandates to avoid vulnerabilities.
      • Efficiency mandates to help increase performance.
    • Standards may be enforced through code reviews or may simply be “suggestions”.
  • 3. Standards: Like or Dislike?
  • 4. But, Isn’t Programming Art?
    • This always has been an interesting point of contention.
      • On one extreme development can be thought of as a work of art and any source that reaches a logically correct result is acceptable and everything else is just “style.”
      • The other extreme believes that programming is purely a mechanical process and there is only a limited number of correct answers.
      • Which is correct?
  • 5. Reality Lies In Between
    • It may be more accurate to say developers are more like artisans (crafters) than artists, though containing elements of both.
      • An artist has a wide range of forms they can adhere to and much is dependent on the interpretation of the viewer.
      • In contrast, artisans tend to construct or design for a purpose, and while there are some elements of style in construction, if it fails to achieve its purpose effectively , it is a failure.
  • 6. The “Art” of Sorting
    • Take sorting, for example.
      • Both Bubble sort and Quick sort are valid sorts on a set of data.
      • Bubble sort has a complexity of O(n 2 ) and Quick sort is O(n log n).
      • Assuming sorting 1 million elements and each check takes 1 µs, roughly this would be:
        • Bubble Sort: 11 days
        • Quick Sort: 19 seconds
      • Both sort data, but one is clearly more useful.
  • 7. Standardizing an “Art”
    • While there are many ways to solve a given problem, there should be guidelines for effective construction.
    • These guidelines are similar to building codes used in building construction to ensure safety and quality.
    • These guidelines form the basis for coding standards and are best compiled from group consensus and industry best practices.
  • 8. Enforcing Standards
    • Standards should be enforced to promote safety, efficiency, and maintainability.
    • Standards can be enforced through Code Reviews, but these tend to be applied with varying levels of adherence.
    • It’s much better to attempt to automate as much of your standards as possible so that the code is judged more objectively.
  • 9. Benefits of Automation
    • Standards are applied objectively since only analyzes the source or assembly.
    • Just plain faster than trying to catch standards violations manually.
    • Code authors don’t feel personally attacked.
    • Frees more reviewer time since won’t have to waste as much time in code reviews.
    • Frees more time for developers since code spends less time and iterations in review.
  • 10. Standards Automation Tools
    • There are two primary tools from Microsoft:
      • StyleCop – Analyzes source files to determine if source code is correctly formatted.
      • FxCop (Static Code Analysis) – Analyzes assemblies to determine if code is constructed safely and optimally.
    • These tools overlap in some of their base rules but both have their strengths.
    • Other third party and Microsoft tools exist, but beyond this presentation’s scope.
  • 11. StyleCop
    • Analyzes source files and not compiled code.
    • Great for checking elements such as:
      • Spacing
      • Comments
      • File composition
      • Naming
    • Cannot easily check type hierarchies or program structure.
    • Available at
  • 12. Configuring StyleCop
    • If you have StyleCop installed, you can have Settings.StyleCop files for each project if you want to vary styles per project.
    • Will take the first Settings.StyleCop file it finds from working directory on up the path.
    • Default will be the Settings.StyleCop file in c:program filesMicrosoft StyleCop…
    • Various configurations can make harder to enforce uniform rules, though, so use with caution.
  • 13. Configuring StyleCop
    • You can configure which base rules you want active by using StyleCopSettingsEditor.exe.
    • Let’s take a minute to look at the rules…
  • 14. Configuring StyleCop
    • You can also get to StyleCop settings in Visual Studio directly by right-clicking a project.
    • This creates local copy of rules, use cautiously.
  • 15. Running StyleCop
    • You can run StyleCop from VS or MSBuild.
    • Has no native command-line interface, but one exists at sourceforge called StyleCopCmd .
  • 16. StyleCop Results
    • Shows in Error List window, can turn on “Warnings as Errors” in VS if you want to break builds on violations.
  • 17. Suppressing a Rule
    • Most rules are good all the time, sometimes not.
  • 18. On Suppressing Rules
    • It’s better to keep a rule even if it only applies 95% of the time and force developers to suppress the rule for the one-off exceptions.
    • This puts a SuppressMessage attribute in code which must be justified and prevents viewing the exception to the rule as a precedent for ignoring the rule.
    • If code reviewer disagrees, can be debated.
    • Turning off rules should be avoided unless the rule is invalid most or all of the time.
  • 19. Custom StyleCop Rules
    • StyleCop rules are fairly easy to write.
    • Create class library that references the StyleCop assemblies:
      • Located in c:program filesMicrosoft StyleCop…
        • Microsoft.StyleCop.dll
        • Microsoft.StyleCop.Csharp.dll
    • Add a CS (C# source file) for new analyzer.
    • Add an XML file for rule configuration.
  • 20. Custom StyleCop Rules
    • In the CS file, create an analyzer that inherits from SourceAnalyzer and has class attribute also named SourceAnalyzer for C# files.s
  • 21. Custom StyleCop Rules
    • In the CS file, override AnalyzeDocument and perform your checks.
  • 22. Custom StyleCop Rules
    • When you see your violation, call the method AddViolation and give it a rule name and args:
  • 23. Custom Style Cop Rules
    • Then, in the XML file, define the rule and message. Make sure XML file has same name as class name and is Embedded Resource.
  • 24. Custom StyleCop Rules
    • Then, build the custom assembly.
    • Place custom assembly in:
      • C:Program FilesMicrosoft StyleCop …
    • You should now see custom rules in the StyleCopSettingsEditor.
    • If you don’t see custom rules, check that the XML file:
      • Is an embedded resource
      • Has same filename as the class name (minus extensions)
    • Let’s look at the code more closely…
  • 25. StyleCop for ReSharper
    • JetBrains’s ReSharper is an Visual Studio IDE plug-in that adds a lot of refactoring and aids.
    • StyleCop for ReSharper is a ReSharper plug-in that allows for dynamic checking of StyleCop rules as you type.
    • Will highlight rule violations with squiggle just like other ReSharper hints.
    • Let’s look at how this appears in the IDE.
  • 26. FxCop (aka VS Code Analysis)
    • Great for checking elements such as:
      • Non-spacing style issues (naming, etc).
      • Code safety and performance issues
      • Type hierarchy issues
      • Analysis of database objects
    • Cannot check source style such as spacing.
    • Already baked into Visual Studio 2008/10.
    • Can also be used as a stand-alone.
  • 27. Running FxCop Stand-Alone
    • Start  Programs  Microsoft FxCop
    • Create new project, add targets, and Analyze!
  • 28. Running FxCop From Visual Studio
    • Right click on project or solution and choose Run Code Analysis:
    • Let’s look at an example analysis.
  • 29. Suppressing FxCop Errors
    • Just like in StyleCop, you can suppress one-off exceptions to the rules.
    • Can insert manually or automatically from the error list in Visual Studio.
  • 30. Custom FxCop Rules
    • Create a Class Library in Visual Studio.
    • Add references to FxCop assemblies:
      • From C:Program FilesMicrosoft FxCop…
        • FxCopCommon.dll
        • FxCopSdk.dll
        • Microsoft.Cci.dll
        • Microsoft.VisualStudio.CodeAnalysis
    • Add a CS file for the new rule.
    • Add an XML file for the rule definition.
  • 31. Custom FxCop Rules
    • In CS file create class that inherits from BaseIntrospectionRule :
  • 32. Custom FxCop Rules
    • In CS File, override Check to check rule.
  • 33. Custom FxCop Rule
    • XML file is Embedded and contains rule detail:
    • Remember filename must be same as passed to base constructor of BaseIntrospectionRule.
  • 34. Custom FxCop Rules
    • To use custom rule, use CTRL+R or Project  Add Rules in FxCop.
    • You can verify by clicking on rules tab:
  • 35. Summary
    • Automating code standards can be very useful for getting rid of a lot of the “noise” in code reviews and allowing reviewers to concentrate on logic bugs.
    • Automated code standards take the personal side out of enforcing style, safety, and performance.
    • Custom rules can be used in FxCop and StyleCop to allow for your own rules.
  • 36. Questions?
    • Blog:
    • Email:
      • [email_address]
    • Twitter: