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

31,691
views

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

0 Comments
14 Likes
Statistics
Notes
  • Be the first to comment

No Downloads
Views
Total Views
31,691
On Slideshare
0
From Embeds
0
Number of Embeds
8
Actions
Shares
0
Downloads
595
Comments
0
Likes
14
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 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 http://stylecop.codeplex.com/
  • 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.
    • http://stylecopforresharper.codeplex.com/
    • 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:
      • http://www.BlackRabbitCoder.net
    • Email:
      • [email_address]
    • Twitter:
      • http://twitter.com/BlkRabbitCoder