SubMain Community

CodeIt.Right to sim-ship with Visual Studio 11!

SubMain.Blog() — Thu, 05 Apr 2012 07:49:00 GMT

We posted earlier that on 2/29 when Microsoft announced the Visual Studio 11 Beta, SubMain was one of the first partners with CodeIt.Right product that provided full support for the new VS Beta. We currently are running private Beta program for our GhostDoc product that is also VS11 Beta compatible. We are happy to announce that SubMain is one of the partners to sim-ship (Simultaneously Ship) our products together with the Visual Studio 11 RTM! You will be able to enjoy fully compatible version of...(read more)

Released: CodeIt.Right v2.0

SubMain.Blog() — Wed, 04 Apr 2012 21:46:00 GMT

We are excited to announce the release of CodeIt.Right v2.0 - new major version that takes our code quality product to the whole new level. This version introduces new major feature – Instant Code Review – that enables developers to get code quality feedback in real time as they type and refactor code smells right at their introduction. We also added new Personal Edition of the product. Here is the high level new feature list: Instant Code Review feature – get code quality feedback as you code and...(read more)

CodeIt.Right v2.0 Beta is available as part of the VS11 Beta Bundle

SubMain.Blog() — Wed, 29 Feb 2012 12:56:00 GMT

As part of the Visual Studio Industry Partner (VSIP) program we have released VS11 Beta compatible version of CodeIt.Right on the ComponentSource website that hosts VS11 Beta Bundle products. And we are very proud that our flagship product is one of the very first VS11 compatible products available as part of the VS11 Beta Bundle on the day of VS11 Beta launch – February 29, 2012! Please follow the instructions below to receive the virtual bundle of CodeIt.Right and Visual Studio 11 Beta: Go to the...(read more)

CodeIt.Right v2.0 Beta Available Now!

SubMain.Blog() — Sat, 26 Nov 2011 01:05:01 GMT

The BETA for CodeIt.Right has arrived and this is our new major version of the code quality product: Instant Code Review feature – get code quality feedback as you code and refactor on the spot! Visual Studio 11 support Multiple categories for a rule Multi-select in Violations Report XAML Parser 8 new Silverlight/WPF/XAML rules 27 new ASP.NET/Security rules Profile Editor - filter for selected/unselected rules Option to require exclude comments and more Focus on coding – we will help you with quality...(read more)

Retiring PrettyCode.Print and StudioTools; CodeSpell to be merged into GhostDoc Pro

SubMain.Blog() — Wed, 24 Aug 2011 23:47:02 GMT

PrettyCode.Print and StudioTools no longer fit our strategic corporate direction to deliver best code quality tools on the market. Discontinuing these products enables us to reinvest the efforts into our flagship products and offer even better code quality tools. We will be releasing new greatly enhanced versions of our existing products as well as new products over the next six months. For a sneak peek of what’s coming please see our Product Feedback board. PrettyCode.Print PrettyCode.Print for...(read more)

Released: TestMatrix v3.1.11190

SubMain.Blog() — Fri, 22 Jul 2011 00:29:00 GMT

We released TestMatrix v3.1 which adds support for xUnit testing framework, code editor Smart Tags, better VS2010 integration, command line version enhancements and other improvements. What's new in TestMatrix v3.1: Added support for xUnit testing framework Added code editor Smart Tags to run/debug test or group of tests Added test result "paintings" in VS2010 editor which were omitted in the first VS2010 compatible release and now they are back. Added a "No Coverage" warning in the command line...(read more)

What does GhostDoc 'Document This' do?

Serge B. — Thu, 16 Dec 2010 12:05:00 GMT

(This post is slightly edited version of the Introduction page in GhostDoc Help file)

What does GhostDoc do?

GhostDoc installs a new command - "Document This" into Visual Studio code editor context menu. When editing a source file, you simply navigate cursor into the language element you want to document (or in front of it, in the same text line), and call the "Document This" command by either pressing the hotkey you assigned to the command GhostDoc setup or using the context menu. GhostDoc analyses insert an XML documentation comment, much like typing "///" in front of a language element, but with a major difference: for specific language elements like methods and properties, GhostDoc attempts to generate large parts of the actual documentation (for other language elements like e.g. enums and their values, an empty summary will be generated).

If a class member is an interface implementation or override of a base class member, GhostDoc will use the existing documentation, regardless of where the interface or base class comes from. So basically what this means that you can re-use tons of documentation that Microsoft wrote - just remember the last time you've implemented IEnumerable and thought about how to comment the GetEnumerator() method.

In the cases where no existing documentation can be used, GhostDoc attempts to analyze the code element name. Under certain conditions (we'll get to that later) GhostDoc actually does very good job. Often enough the results are not accurate or even plain silly, but on average correcting the mistakes/problems in the generated documentation takes less time than writing the whole comment from scratch.

But how can a tool with virtually no understanding of the English language generate often pretty accurate documentation? Well, the basic idea is pretty simple: GhostDoc assumes that your code follows Microsoft's Design Guidelines for Class Library Developers:

you are using PascalCasing or camelCasing to write identifier names consisting of multiple words
your method names usually start with a verb
you do not use abbreviations in identifier names

If you follow these rules, for example, use "ClearCache()" instead of "Clrcch()", and choose more or less self-documenting identifier names, there's a good chance for GhostDoc to split the identifier names into words, tweak and/or shuffle the words a little and produce a comment that, while not being perfect, gives you a head start on the way to a good documentation.

As already mentioned, GhostDoc does not really understand English identifier names, nevertheless it attempts to apply certain rules to increase the quality of the generated comments:

Handling of verbs (GhostDoc assumes the first word of a method name is a verb): Add -> Adds, Do -> Does, Specify –> Specifies
"Of the" reordering (using trigger words like "width", "height", "name", etc.): ColumnWidth -> Width of the column
Combined with special handling of specific prefix words: MaximumColumnWidth -> "Maximum width of the column" instead of "Width of the maximum column"
Automatic detection of acronyms consisting of consonants (Html -> HTML), combined with a list-based approach for other acronyms (Gui –> GUI)
Use of a list of words where that should not be headed by a "the" (AddItem -> Adds the item, but BuildFromScratch -> Builds from scratch)

Here's example of what GhostDoc is able to do: If you a method "DetermineInputCacheSize", GhostDoc will create the summary "Determines the size of the input cache." If you want to see more examples, take a look at the demo project.

Since the quality of the comment depends on the identifier name and its structure, using GhostDoc for a longer period of time actually teaches writing consistent and self-documenting identifier names, which is definitely a nice added bonus.

What doesn't GhostDoc do?

GhostDoc cannot do miracles, and the way it generates documentation may not work well with your personal style. If you are not following the Microsoft Guidelines, you will most likely run into problems.

When GhostDoc is able to re-use documentation from interfaces and base class members, it simply copies the comments over. It does not check whether the comment still applies, which, for example, becomes obvious when you document an override of the ToString method of System.Object. The generated summary is "Returns a System.String that represents the current System.Object." (<see> tags omitted for clarity), where it should read "Returns a System.String that represents the current MyNamespace.MyClass.". A developer quickly figures out that in this case, System.Object has to be replaced, but a tool like GhostDoc cannot (at least not without an extensive code analysis).

Intentionally, GhostDoc is not a tool for creating the complete documentation for a given source file in one go. You can only document one member at a time, because you always have to check and extent the results of each auto-generated comment to make it clear and actually useful.

What is GhostDoc Pro?

GhostDoc Pro is an enhanced version of the product that gives you complete control over your XML Comment content and layout as well as automates XML Comment generation via batch actions.

The Pro version has all features of GhostDoc and adds:

T4 based XML Comment templates - total control over your XML documentation content and style
Document Type - generates XML comments for entire type/class
Document File - generates XML comments for entire file

Version 4 of GhostDoc adds comment and code Spell Checking, XML Comment Preview/HTML Doc generation, StyleCop compliant comments and Exception Documentation among other features.

Holiday Offer: Complimentary Software Assurance and Licence Protection + Save up to 30%!

SubMain.Blog() — Fri, 10 Dec 2010 01:15:00 GMT

SubMain is proud to spread the holiday cheer by offering customers best savings of the year with free 1 year of Software Assurance and Support, free lifetime License Protection and great savings on multiple license purchases. Get Software Assurance and Support absolutely free! From now until January 7, purchase any new CodeIt.Right licenses and receive 1 year of Software Assurance and Support subscription at no additional cost . Normally priced at $100 per user ($150 per user for Enterprise Edition),...(read more)

Released: GhostDoc and GhostDoc Pro v3.0.10340

SubMain.Blog() — Thu, 09 Dec 2010 12:55:00 GMT

Today we are announcing the release of GhostDoc v3.0 - a new major release of the product. This version includes product usability and menu changes, adds many new features - menus, configuration rules, configuration options. It also features new error logging to improve troubleshooting of GhostDoc issues. The new version introduces GhostDoc Pro Edition - enhanced version of the product that gives users complete control over your XML Comment content and layout as well as automates XML Comment generation...(read more)

Released: TestMatrix v3.0.10299

SubMain.Blog() — Tue, 26 Oct 2010 15:15:05 GMT

We are happy to announce the release of TestMatrix v3.0 - new major version focused on product stability and performance improvements, full VS2010 and .NET 4.0 support, command line version and the latest versions of unit testing frameworks! New in v3.0: Improved support for VS2010 Added support for .NET Framework 4.0 Enabled Command Line version for Continuous Integration/Automated Build process Updated to support the latest versions of unit testing frameworks - NUnit 2.5.x, MbUnit 2.4, csUnit 2.6,...(read more)

Update: CodeIt.Right v1.9.10111 and New Setup for TestMatrix

SubMain.Blog() — Wed, 21 Apr 2010 12:19:05 GMT

We published two updates this morning: CodeIt.Right v1.9.10111 - both Standard and Enterprise editions. This is a minor update, primarily bug fixes. Not a required update unless you are experiencing some rule issues or unhandled errors this update might fix. New setup for TestMatrix - we have created a brand new setup for TestMatrix to replace the often confusing "silent" version. New setup experience is very much the same as all our other products. Version hasn't of the product hasn't changed....(read more)

Community: CodeIt.Right and CruiseControl.NET; File Header Template for StyleCop

SubMain.Blog() — Tue, 06 Apr 2010 20:46:04 GMT

We are added 2 new community contributions to our Tutorials page. Paulo Morgado posted a great template for CodeIt.Right Code File Header correction action that automatically generates file header compliant with StyleCop Rules. You can find the template source in Paulo's blog post CodeIt.Right Code File Header Template For StyleCop Rules Craig Sutherland has done a great job integrating CodeIt.Right with CruiseControl.NET . Here is CodeIt.Right violations report in CC.NET - great to see Craig took...(read more)

SubMain acquires Exact Magic's TestMatrix, CodeSpell and StudioTools

Serge B. — Tue, 09 Mar 2010 06:32:00 GMT

SubMain will continue development of TestMatrix, CodeSpell and StudioTools; adds to Code Quality developer tools Suite.

Kirkland, WA, March 9, 2010 - SubMain announced today that it has acquired TestMatrix, the popular Visual Studio .NET extension for unit testing and code coverage, as well as CodeSpell and StudioTools from Exact Magic Software.

"I'm happy to place TestMatrix and our other .NET products in the hands of SubMain," says Duane Fields, Managing Partner at Exact Magic Software, the original owner and developer of TestMatrix. "Like their other acquisitions, SubMain will take good care of our TestMatrix and take it to the next level."

TestMatrix (http://submain.com/testmatrix) adds support for unit testing, code coverage analysis, and test profiling to Visual Studio, seamlessly incorporating these critical development practices directly into the coding process itself; CodeSpell (http://submain.com/codespell) adds real-time, intelligent detection and correction of misspellings to Visual Studio; and StudioTools (http://submain.com/studiotools) is a rich collection of Visual Studio enhancements.

"TestMatrix has a well-deserved reputation for making test driven development painless and convenient by enabling unit testing tasks an integral part of the programming experience, not an occasional external exercise," says Serge Baranovsky, President of SubMain. "It fits SubMain's code quality tools line-up perfectly and we are proud to serve the .NET community by continuing the development of this valuable tool."

SubMain has a track record for acquiring products, enhancing and integrating them in the product offering. Most recently, SubMain purchased GhostDoc and continues to improve and maintain it as a free tool for the .NET community.

About SubMain

SubMain, a Division of vbCity.com LLC, makes code quality tools for .NET developers. The company's flagship product CodeIt.Right (http://submain.com/codeit.right) helps developers across the globe to follow team standards and best practices, improve code security and performance and find potential issues early in the development cycle.

About Exact Magic Software, LLC

Exact Magic Software, LLC specializes in building native applications for the Apple iPhone iPad, and iPod Touch. The company has shipped dozens of applications, but is best known for its top selling applications Weather Radar, Business Phone Numbers, and Infinite Maze.

Media Contact

Wendy Cavens
Director of Marketing, SubMain
Tel: 1(800) 936-2134
Email: wendyc@submain.com

SubMain acquires Exact Magic's TestMatrix, CodeSpell and StudioTools

SubMain.Blog() — Tue, 09 Mar 2010 00:03:02 GMT

As announced earlier today we just closed the acquisition of the popular unti testing and code coverage product TestMatrix , as well as CodeSpell and StudioTools . We, SubMain, will continue to maintain and enhance these products. TestMatrix adds support for unit testing, code coverage analysis, and test profiling to Visual Studio, seamlessly incorporating these critical development practices directly into the coding process itself; CodeSpell adds real-time, intelligent detection and correction of...(read more)

Released: CodeIt.Right v1.9.10053

SubMain.Blog() — Thu, 25 Feb 2010 16:31:00 GMT

Today we released update for CodeIt.Right Standard and Enterprise Editions - v1.9.10053. As part of our 2010 Product Roadmap , this version changes include significantly improved performance, support for GlobalSuppressions, new rules and bug fixes. New in CodeIt.Right v1.9.10053: Major performance improvements throughout the rule base Added support for GlobalSuppressions - syntax is the same as the VSTS GlobalSuppressions file. This new feature is supported in both Standard and Enterprise editions....(read more)

2010 Product Roadmap

SubMain.Blog() — Tue, 23 Feb 2010 09:13:00 GMT

Code Quality developer tools is the direction we've been following since the introduction of CodeIt.Right and we are taking this commitment to the next level in 2010 with two new products and new features for our existing products. One of the new products to be released in 2010 will assist in unit testing, code coverage and test code profiling; the second new product will be complementary to CodeIt.Right. All three products together will comprise our new Code Quality Suite. Additionally, we will...(read more)

How CodeIt.Right is better than FxCop?

Serge B. — Thu, 04 Feb 2010 06:52:00 GMT

The biggest benefit of CodeIt.Right is the automatic code correction and refactoring to patterns. The alternative is you could manually spend hours or even days on some pesky violations rather CodeIt.Right do the work for you in a matter of minutes.

You can also choose to follow Microsoft Guidelines or you own custom standards, group rule sets into profiles, generate your custom standard documentation, efficiently work with existing/legacy projects, avoid false positives.

The Enterprise Edition adds Team features, Code Metrics, Statistics, enhanced reporting.

CodeIt.Right FxCop

Instant Code Review Real-time code analysis provides instant feedback to developers in the Visual Studio Editor and fixes issues on the spot N/A

Scans and analyzes source code Runs on compiled assemblies (you have to compile code to use it)

Correction Corrects violations and code smells automatically N/A

Refactoring to patterns Automatically implements and corrects most common coding patterns like Dispose/Finalize, ISerializable, Custom Serialization, etc N/A

Visual Studio Integration Natively integrates into Visual Studio IDE; quick navigation to the violation source code; highlights modifications in the editor; safe Undo/Redo. Basic/Command line

ASP.NET ASPX/ASCX/ASMX pages, in-page code, code behind source Only compiled code behind assemblies

Local variables/constants Includes rules that are targeting local variables/constants and any data that is present in the source code Not possible in FxCop - the data is lost in the MSIL

Follow your own standards Includes Microsoft Guidelines and best industry practices out of the box. Allows to define your own standard to follow - tweak the rule set to your needs without having to write custom rules (which is an option too). For example, go as crazy as enforce Hungarian naming conventions; or convert existing project with Hungarian notation to the new MS style conventions. Strictly enforces Microsoft Guidelines - inflexible and enforces the set with no options to configure

Define custom rule set Profiles - configure multiple rule subsets and quickly switch between them. Share profiles between the Team members or (EE) push them to the Team. N/A

Rule Instances Introduces Rule Instances - multiple instances of a single rule that are configured (via rule Properties) to your Team needs Only allows to turn off specific rule, cannot configure/tweak

Reducing noise (false positives)

Exclude violation in Project

Exclude violation in source code

Exclude Violation, Rule, File, Project

Exclude code regions

Custom Profiles

Override default rule severity, target, scope, etc

Exclude violation in Project

Exclude violation in source code

Severity Threshold Unique feature - Severity Threshold - allows to concentrate on most critical violations first and drill down from most severe issues to simple warnings. N/A

Scan entire solution, project, folder or individual file Scan projects only

Create own guidelines documentation Generate Team Guidelines document within a mouse click, with description, code samples, etc - based on your custom configured Profile N/A

Team features (EE) separate modules to (a) author / configure team standards and (b) run analysis and correction based on the team standard configured by Team Lead/Architect; publish and push (share) Team standard configuration to the Team members; Team usage statistics N/A

Reporting Flexible reporting/pivot that can be exported and printed N/A

Code Metrics Available (EE); can be exported, printed, emailed N/A

Command line output Violations, Code Metrics (EE) Violations only

Command line filtering Solution, Project, Profile, Severity Threshold Project, Assembly

Command line delivery File, Send via email File only

Command line integration Command line tool, MsBuild and NAnt tasks Command line tool

Update delivery Rule Library auto-update - get new rules when we publish them
N/A

	CodeIt.Right	FxCop
Instant Code Review	Real-time code analysis provides instant feedback to developers in the Visual Studio Editor and fixes issues on the spot	N/A
	Scans and analyzes source code	Runs on compiled assemblies (you have to compile code to use it)
Correction	Corrects violations and code smells automatically	N/A
Refactoring to patterns	Automatically implements and corrects most common coding patterns like Dispose/Finalize, ISerializable, Custom Serialization, etc	N/A
Visual Studio Integration	Natively integrates into Visual Studio IDE; quick navigation to the violation source code; highlights modifications in the editor; safe Undo/Redo.	Basic/Command line
ASP.NET	ASPX/ASCX/ASMX pages, in-page code, code behind source	Only compiled code behind assemblies
Local variables/constants	Includes rules that are targeting local variables/constants and any data that is present in the source code	Not possible in FxCop - the data is lost in the MSIL
Follow your own standards	Includes Microsoft Guidelines and best industry practices out of the box. Allows to define your own standard to follow - tweak the rule set to your needs without having to write custom rules (which is an option too). For example, go as crazy as enforce Hungarian naming conventions; or convert existing project with Hungarian notation to the new MS style conventions.	Strictly enforces Microsoft Guidelines - inflexible and enforces the set with no options to configure
Define custom rule set	Profiles - configure multiple rule subsets and quickly switch between them. Share profiles between the Team members or (EE) push them to the Team.	N/A
Rule Instances	Introduces Rule Instances - multiple instances of a single rule that are configured (via rule Properties) to your Team needs	Only allows to turn off specific rule, cannot configure/tweak
Reducing noise (false positives)	Exclude violation in Project Exclude violation in source code Exclude Violation, Rule, File, Project Exclude code regions Custom Profiles Override default rule severity, target, scope, etc	Exclude violation in Project Exclude violation in source code
Severity Threshold	Unique feature - Severity Threshold - allows to concentrate on most critical violations first and drill down from most severe issues to simple warnings.	N/A
	Scan entire solution, project, folder or individual file	Scan projects only
Create own guidelines documentation	Generate Team Guidelines document within a mouse click, with description, code samples, etc - based on your custom configured Profile	N/A
Team features	(EE) separate modules to (a) author / configure team standards and (b) run analysis and correction based on the team standard configured by Team Lead/Architect; publish and push (share) Team standard configuration to the Team members; Team usage statistics	N/A
Reporting	Flexible reporting/pivot that can be exported and printed	N/A
Code Metrics	Available (EE); can be exported, printed, emailed	N/A
Command line output	Violations, Code Metrics (EE)	Violations only
Command line filtering	Solution, Project, Profile, Severity Threshold	Project, Assembly
Command line delivery	File, Send via email	File only
Command line integration	Command line tool, MsBuild and NAnt tasks	Command line tool
Update delivery	Rule Library auto-update - get new rules when we publish them	N/A

Download trial copy of CodeIt.Right today and see the difference yourself!

XML Comment template: IntelliComment or XML Comment Stub?

Serge B. — Fri, 29 Jan 2010 00:39:00 GMT

One of the very helpful and important rules that we added in the past few months is the one that finds members that missing XML documents when these are required - General / Type, Member -> Should have XML comments (Externally visible types and members should have XML comments).

One of the most frequently asked question about the rule is why some users are not seeing the missing XML comment violation on select project. There are two possible reasons for that:

The rule will only trigger violation on public and protected members in its default configuration. If you choose to have it validate private and/or static members, you will need to edit the rule's Scope property to include those as well.
The option to generate XML documentation is turned OFF in your project. In this case the rule doesn't the missing XML comment violation to reduce false positives since the project setting state it does not need XML documentation.

To turn the option to generate documentation ON, in C# project, go to project Properties -> Build -> XML documentation file

In VB project, go to project Properties -> Compile -> Generate XML documentation file

In the spirit of CodeIt.Right the rule offers two automatic correction options - IntelliComment and XML Comment Stub. In the default configuration these are fairly similar, the difference is that IntelliComment will fill in the generated XML Comment using data from our GhostDoc engine, while the Stub template will create an empty XML Comment Stub.

Here is example generated by IntelliComment template

    /// <summary>
    /// Determines the size of the page buffer.
    /// </summary>
    /// <param name="initialPageBufferSize">Initial size of the page buffer.</param>
    /// <returns></returns>
    /// <remarks></remarks>
    public int DeterminePageBufferSize(
                           int initialPageBufferSize) {

        // Implement the method here
        return 1;

    }

And example generated by XML Comment Stub template

    /// <summary>
    ///  
    /// </summary>
    /// <param name="initialPageBufferSize"> </param>
    /// <returns></returns>
    /// <remarks></remarks>
    public int DeterminePageBufferSize(
                           int initialPageBufferSize) {

        // Implement the method here
        return 1;

    }

So, the rule offers two correction option - it is up to you to pick which template works best for your project.

I notice that I keep using the word "template" when describing the two correction options. That is because these are true T4 templates that you can customize to fit your team requirements.

Here is default IntelliComment template:

<#@ template language="C#" #>
<#
    CodeElement codeElement = Context.CurrentCodeElement;
#>
/// <summary>
/// <#= codeElement.XmlComment.SummaryTagText #>    
/// </summary>
<#
    if(codeElement.HasTypeParameters) 
    {
        foreach(TypeParameter typeParameter in codeElement.TypeParameters) {
#>
/// <typeparam name="<#= typeParameter.Name #>"><#= typeParameter.XmlComment.TypeParamTagText #></typeparam>
<#
        }
    }
    
    if(codeElement.HasParameters) 
    {
        foreach(Parameter parameter in codeElement.Parameters) {
#>
/// <param name="<#= parameter.Name #>"><#= parameter.XmlComment.ParaTagText #></param>
<#
        }
    }
    
    if(codeElement.HasReturnType) {
#>
/// <returns><#= codeElement.XmlComment.ReturnsTagText #></returns>
<#
    }
    
    if(codeElement.IsProperty) {
#>
/// <value><#= codeElement.XmlComment.ValueTagText #></value>
<#
    }    
    
    if(codeElement.IsMember) {
#>
/// <remarks></remarks>
<#
    }    
#>

As you can see it is very much self-explanatory and you can customize it to your needs. For example, in combination with the CodeIt.Right Global Properties feature, we can have <reviewed/> and <copyright/> data automatically when we add the following at the very end of the template:

/// <reviewed><#= Context.GetGlobalProperty("UserName") #></reviewed>
/// <copyright><#= Context.GetGlobalProperty("CompanyName") #> Copyright <#= System.DateTime.Now.Year.ToString() #></copyright>

Pretty powerful stuff, huh?

Released: CodeIt.Right Enterprise v1.9.09355

SubMain.Blog() — Tue, 22 Dec 2009 22:55:00 GMT

New version of CodeIt.Right Enterprise Edition - build 1.9.09355 - is available for download now. This version introduces new feature Merge Profiles that allows to compare and merge user configured profiles, enhances VSTS integration with the new "Add WorkItem" feature, adds command line version parameters and ability to load/unload CodeIt.Right in the menu and Add-In Manager. This update is free for all users who are current on their Software Assurance and Gold Support Subscription New in CodeIt.Right...(read more)

5+1=3 or 10+1=6 Promotion - Save up to 50%!

SubMain.Blog() — Mon, 14 Dec 2009 16:01:03 GMT

For two weeks - December 15 to December 29th - we are running the best volume license promotion we have had to date! This promotion is aimed at small and medium businesses. 5+1=3 6 Standard Edition licenses for the price of 3: 5 user licenses + 1 server license + 1 Year maintenance subscription = $1050 Learn More » 10+1=6 11 Enterprise Edition licenses for the price of 6: 10 user licenses + 1 server license + 1 Year maintenance subscription = $4500 Learn More » Hurry and save money - this offer will...(read more)

Tutorial: Extending Existing Rules

Serge B. — Thu, 29 Oct 2009 08:05:00 GMT

You already know how you can create new custom rules using CodeIt.Right SDK, of not, you may want to read this article first.

In this tutorial we will show how to extend existing rules using the new SDK features introduced in CodeIt.Right v1.8.09300. The new technique is to derive the custom rule from a base rule and override only the methods that need to be modified.

Let's extend the rule "Avoid single line If statement" (RuleID: CD0002; base class AvoidSingleLineIfStatement) in the Coding Style category:

The base rule above will trigger a violation when find a code pattern like this:

if (x > 0) y = 0;

When the rule default correction action "Split If block into a multiline statement" is used it will modify the code into:

if (x > 0)
{
y = 0;
}

That is what comes in the box.

Our team may have an internal guideline that requires a single line conditional to be split into two lines without the squiggly brackets:

if (x > 0)
y = 0;

Hey, not all teams are created equal :)

In this case correction option that comes with the base rule AvoidSingleLineIfStatement is not very useful and we need to extend the rule with our custom correction.

So, let's start.

We will skip the list of required referenced assemblies - you will find them in the complete code sample at the end of the post.

Declare new class that inherits from the base rule class:

namespace CustomRuleLibrary.CodingStyle  
{  
    [Serializable]  
    [ModificationDate("10/14/2009")]  
    [Category("CustomRuleLibrary.CodingStyle")]  
    public class AvoidSingleLineIfStatement2 : AvoidSingleLineIfStatement  
    { 

In the code above we also set the Category attribute to "CustomRuleLibrary.CodingStyle" so we could easier find the custom in the Profile.

We override ID property and use GUID for the new RuleID value. Some of the CodeIt.Right functions, for example, help pages are handled differently for custom rules. Using GUID for RuleID hits CodeIt.Right that the rule is custom.

        public override string ID  
        {  
            get  
            {   
                // Override the RuleID value with own GUID (recommended)      
                return "6C832235-0B02-4227-911A-156F0B1FAC71";  
            }  
        }  

Property AutoCorrectionOptions needs to be overridden to add new correction action "Split If block into a multiline statement without block":

        /// <summary>      
        /// Returns list of auto correction options      
        /// </summary>      
        public override string[] AutoCorrectionOptions  
        {  
            get  
            {  
                IMethodInfo methodInfo = Element as IMethodInfo;  
                if (methodInfo != null)  
                {  
                    // Get the base class list of available corrections      
                    string[] baseOptions = base.AutoCorrectionOptions;  
                    string[] options = (string[])Array.CreateInstance(typeof(string), baseOptions.Length + 1);  
                    // Add new correction action to the list      
                    Array.Copy(baseOptions, 0, options, 0, baseOptions.Length);  
                    options[options.Length - 1] = "Split \"If\" block into a multiline statement without block";  
    
                    return options;  
                }  
    
                return new string[] { };  
            }  
        } 

The base rule correction option:

Our custom rule correction options with the new action added in the AutoCorrectionOptions above:

Now we implement our new custom correction action just the way we like it to work:

        /// <summary>      
        /// Implementation of our custom correction action       
        /// </summary>      
        private bool Correct_1(IElementInfo elementInfo)  
        {  
            IMethodInfo methodInfo = Element as IMethodInfo;  
            if (methodInfo != null)  
            {  
                StatementCollection statements = RuleUtilities.GetMethodStatements(methodInfo);  
                IStatement statement = SearchForSingleLineIfStatement(statements);  
                if (statement != null)  
                {  
                    string codeToInsertAfter = Environment.NewLine;  
                    string codeToInsertBefore = Environment.NewLine;  
    
                    IRegion ifBlockRegion = GetIfBlockRegion(statement);  
                    if (ifBlockRegion != null)  
                    {  
                        string ifBlockText = GetIfBlockText(statement, ifBlockRegion);  
                        if (ifBlockText != null)  
                        {  
                            methodInfo.ReplaceCodeBlock(ifBlockRegion,  
                                codeToInsertBefore + ifBlockText + codeToInsertAfter);  
    
                            return true;  
                        }  
                    }  
                }  
            }  
    
            return false;  
        } 

And we tie it all together in the method Correct - for correction action with index 0 we execute the base rule correction and for the index 1 (that we added) execute method Correct_1 that implements our custom correction:

        /// <summary>      
        /// Execute the specified correction action      
        /// </summary>      
        /// <param name="correctionOptionIndex">Index of the correction action</param>      
        public override bool Correct(int correctionOptionIndex)  
        {  
            bool result = base.Correct(correctionOptionIndex);  
    
            switch (correctionOptionIndex)  
            {  
                case 0:  
                    // For correction action 0 execute the base class correction      
                    return result;  
                case 1:  
                    // For correction action 1 execute our custom correction      
                    return Correct_1(Element);  
    
                default:  
                    break;  
            }  
    
            return false;  
        } 

And we are done!

The final steps are to compile the new rule, drop the assembly to Program Files\SubMain\CodeIt.Right\Rules\ and we can now add the rule to a profile:

Here is the complete code for our custom rule:

using System;     
using System.IO;     
using System.Collections;     
using System.Collections.Specialized;     
using System.Runtime.Serialization;     
using System.Globalization;     
    
using SubMain.CodeObjectModel.Reflection;     
using SubMain.Core.Services;     
using SubMain.CodeItRight.Sdk;     
using SubMain.CodeItRight.Sdk.Core.Collections;     
using SubMain.CodeItRight.Sdk.Core.Reflection;     
using SubMain.CodeItRight.Sdk.Core.Rules;     
using SubMain.CodeItRight.Sdk.Core.Utils;     
using SubMain.CodeItRight.Sdk.Rules;     
using SubMain.CodeItRight.Sdk.Utils;     
using SubMain.CodeItRight.Rules.CodingStyle;     
    
namespace CustomRuleLibrary.CodingStyle     
{     
    [Serializable]     
    [ModificationDate("10/14/2009")]     
    [Category("CustomRuleLibrary.CodingStyle")]     
    public class AvoidSingleLineIfStatement2 : AvoidSingleLineIfStatement     
    {     
        /// <summary>     
        /// Returns list of auto correction options     
        /// </summary>     
        public override string[] AutoCorrectionOptions     
        {     
            get     
            {     
                IMethodInfo methodInfo = Element as IMethodInfo;     
                if (methodInfo != null)     
                {     
                    // Get the base class list of available corrections     
                    string[] baseOptions = base.AutoCorrectionOptions;     
                    string[] options = (string[])Array.CreateInstance(typeof(string), baseOptions.Length + 1);     
                    // Add new correction action to the list     
                    Array.Copy(baseOptions, 0, options, 0, baseOptions.Length);     
                    options[options.Length - 1] = "Split \"If\" block into a multiline statement without block";     
    
                    return options;     
                }     
    
                return new string[] { };     
            }     
        }     
    
        /// <summary>     
        /// Implementation of our custom correction action      
        /// </summary>     
        private bool Correct_1(IElementInfo elementInfo)     
        {     
            IMethodInfo methodInfo = Element as IMethodInfo;     
            if (methodInfo != null)     
            {     
                StatementCollection statements = RuleUtilities.GetMethodStatements(methodInfo);     
                IStatement statement = SearchForSingleLineIfStatement(statements);     
                if (statement != null)     
                {     
                    string codeToInsertAfter = Environment.NewLine;     
                    string codeToInsertBefore = Environment.NewLine;     
    
                    IRegion ifBlockRegion = GetIfBlockRegion(statement);     
                    if (ifBlockRegion != null)     
                    {     
                        string ifBlockText = GetIfBlockText(statement, ifBlockRegion);     
                        if (ifBlockText != null)     
                        {     
                            methodInfo.ReplaceCodeBlock(ifBlockRegion,     
                                codeToInsertBefore + ifBlockText + codeToInsertAfter);     
    
                            return true;     
                        }     
                    }     
                }     
            }     
    
            return false;     
        }     
    
        public override string ID     
        {     
            get     
            {  
                // Override the RuleID value with own GUID (recommended)     
                return "6C832235-0B02-4227-911A-156F0B1FAC71";     
            }     
        }  
    
        /// <summary>     
        /// Execute the specified correction action     
        /// </summary>     
        /// <param name="correctionOptionIndex">Index of the correction action</param>     
        public override bool Correct(int correctionOptionIndex)     
        {     
            bool result = base.Correct(correctionOptionIndex);     
    
            switch (correctionOptionIndex)     
            {     
                case 0:     
                    // For correction action 0 execute the base class correction     
                    return result;     
                case 1:     
                    // For correction action 1 execute our custom correction     
                    return Correct_1(Element);     
    
                default:     
                    break;     
            }     
    
            return false;     
        }     
    
    }     
}     

Released: CodeIt.Right version 1.8.09300 - now compatible with VS2010 Beta 2!

SubMain.Blog() — Wed, 28 Oct 2009 01:57:01 GMT

Today we are releasing new version of CodeIt.Right - build 1.8.09300. This version features complete ASP.NET support, it is compatible with VS2010 Beta 2 (in addition to VS2008, VS2005, VS2003), Add Rule dialog improvements - "Hide Rules in the Profile" and "Quick Search", 10+ new rules including new category "CodingStyle". Those of you who are using CodeIt.Right with very large solutions may know of the memory limitation issue for the tools that live in the Visual Studio address space, aka "Out...(read more)

How to Assign Visual Studio Shortcut for GhostDoc

Serge B. — Thu, 02 Jul 2009 00:03:00 GMT

Sometimes you may reset default GhostDoc shortcut in Visual Studio or want to assign your own custom shortcut.

Here is how you do that:

In Visual Studio go to Tools -> Options, then select Environment -> Keyboard
Filter commands by "GhostDoc" in the Show commands containing text box
Select Tools.SubMain.GhostDoc.DocumentThis in the list
Select "Text Editor" in the Use new shortcut in drop down
Choose the hotkey you want to invoke the DocumentThis command (Ctrl+Shift+D in this example)
Press Assign and OK to close the dialog and save. You are all set.

While you are in the Options dialog you may want also assign shortcut to another less known but very useful GhostDoc command Rebuild Documentation. This command will rebuild your existing XML comment using the changed signature information. Be careful with this command though - it will reset your custom edited XML comment. In the example below we assigned command RebuildDocumentation to sequence Ctrl+Shift+D, Ctrl+Shift+R

SubMain acquires GhostDoc, releases new version, integrates it with CodeIt.Right

SubMain.Blog() — Mon, 01 Jun 2009 15:25:00 GMT

As announced earlier today we just closed the acquisition of the popular XML Comment helper tool GhostDoc. We, SubMain, will continue to evolve the tool and distribute it as a free product . We are also announcing today the availability of the new version of GhostDoc v2.5.09150 which improves the user setup experience, adds support for Visual Studio 2010 Beta 1 and full support for Visual Basic. Additionally, today we are making available a new version of CodeIt.Right (v1.6.09151) that adds the IntelliComment...(read more)

What's in the shop for GhostDoc?

Serge B. — Mon, 01 Jun 2009 07:25:00 GMT

SubMain Director of Marketing Wendy Cavens interviewed Serge Baranovsky and Roland Weigelt about the recent announcement of SubMain's acquisition of GhostDoc, which the company will continue to offer as a free product.

Roland Weigelt is working as a Software Developer at Comma Soft AG in Bonn, Germany. In his spare time he is the leader of the local .NET user group "Bonn-to-Code.Net" (pun intended) and also enjoys writing software as a hobby. Among his hobby projects is GhostDoc, one of the most popular tools for .NET developers.

Serge Baranovsky is President of SubMain. He has extensive programming experience and is a recognized community leader and founder of vbCity Developer Community. Serge is a Microsoft MVP and ASP Insider.

WendyC:: "To start with, please explain what is GhostDoc?"
RolandW:: "GhostDoc is a Visual Studio extension that generates XML documentation comments for methods and properties based on their type, parameters, name, and other contextual information. "
SergeB:: "What is also great about GhostDoc that when generating documentation for class derived from a base class or for interface implementation (e.g. .NET Framework or your custom framework), GhostDoc will use the documentation that Microsoft or the framework vendor has already written for the base class or interface."
WendyC:: "Roland, GhostDoc regularly made it on the lists of essential .NET developer tools, and was listed as #2 on "10 Must-Have Add-Ins" in MSDN Magazine. Please describe how you came up with the idea."
RolandW:: "I've always stressed high importance of writing good API documentation for my code starting in my C programming years as a student in the early 90's. For me this is also a check for the quality of a method - if I'm not able to explain in a few sentences what it does, there may be something wrong with the method to begin with.

With .NET and its long identifier naming style I often felt that writing this kind of documentation was a bit dull. Many times, in order to write an actually helpful piece of additional information, I first had to repeat in the summary almost exactly what the name of the method or property was already saying. One day in November 2003 I was so tired with documenting Boolean properties ("Gets or sets a value indicating whether ...") that I wrote a macro to help me with some of the repetitive tasks.

What followed were a few half-hearted false starts to turn this into a more general tool, until the announcement of Roy Osherove's Visual Studio Add-in competition in spring 2004 motivated me to turn my experiments into a fully-featured add-in that would be useful to others. In the end the hard work paid off; GhostDoc won the competition. Even though the feature set of GhostDoc 1.0 was limited (for instance, re-using existing documentation didn't make it until version 1.3), it turned out to be a success almost immediately."
WendyC:: "What has your experience been since?"
RolandW:: "Working on GhostDoc has always been both rewarding and frustrating. Visual Studio Extensibility in general is not without problems and even though things got a bit better with each version of Visual Studio, there were many roadblocks that took a lot of time to circumvent.

On the other hand, it's always amazing at conferences or user group meetings when people recognize my name, come up to me and tell me that GhostDoc is one of the first tools they install on a new developer machine. And last but not least I'm a GhostDoc user myself so I benefit from this tool everyday! "
WendyC:: "How did this deal come about?"
SergeB:: "Our CodeIt.Right product has a feature that enforces XML Comments where required and automatically adds a comment stub. Some time ago I demoed this feature to Scott Hanselman and he suggested it would be great to integrate this with GhostDoc and have the comment content generated based on the name. So I contacted Roland, we met at the last PDC to discuss the integration options; one thing led to another and I offered to buy GhostDoc. That seemed to me like an easy way to integrate! "
RolandW:: "The offer from SubMain came at a crucial point of time when I had to make a decision on the future development of GhostDoc. Other activities besides GhostDoc were already eating up my spare time, and it was clear that going open source wouldn't magically reduce my workload immediately.

Having full-time developers take GhostDoc to the next level seemed like the best solution. Serge and I were on the same page that a free-of-charge version of GhostDoc should be available in the future. From my experience of working with the people at SubMain in the recent weeks I can say that this was the right decision."
WendyC:: "Serge, what are the plans of how GhostDoc will evolve?"
SergeB:: "The future of GhostDoc starts today - we just released a new version of the tool with improved user setup experience, added support for Visual Studio 2010 Beta 1 and full support for Visual Basic. We also added IntelliComment feature to our CodeIt.Right product based on the GhostDoc algorithm - the version of this tool is also available today.

As for the future, you know, the usual product life stuff - bug fixing, feature enhancements. We have our own ideas and also are encouraging the community to give us feedback. "
WendyC:: "Roland, will you continue to be involved with GhostDoc?"
RolandW:: "I will continue using GhostDoc both at work and at home every day; and I will definitely keep track of what the guys at SubMain are up to; and I will do what every GhostDoc user should do - swamp them with feature requests! "
SergeB:: "Over the last few weeks of the transition our team has enjoyed working with Roland and we look forward to his continued feedback. We also hope that the community at large will do so as well."