SubMain Community

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)

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

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

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)

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
	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."

SubMain acquires GhostDoc

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

SubMain maintains GhostDoc as a free tool for .NET developers; releases new version; seeks input from the community on product enhancements

Kirkland, WA, June 1, 2009 - An agreement between SubMain and Roland Weigelt, author of GhostDoc, will place future development of GhostDoc in the hands of SubMain. GhostDoc (http://submain.com/ghostdoc) is the popular XML Comments and documentation helper tool which SubMain will continue to maintain as a free product.

"I'm happy to transfer GhostDoc to SubMain," says Roland. "SubMain has extensive experience with similar projects and can use their development team expertise to evolve the tool."

Serge Baranovsky, President of SubMain, understands the importance of GhostDoc to the .NET community and welcomes ideas on the product improvement.

"We are very excited about taking over the future of an excellent tool such as GhostDoc," says Serge. "We have great respect for what Roland has done. The tool is very easy to use and it just works! We are committed to maintaining this wonderful free tool; we welcome the community feedback and suggestions."

SubMain has a track record of supporting the development community: publishing SmartOutline for .NET, the company's own free development tool; a free 100+ page .NET Coding Guidelines eBook; vbCity.com, a VB and .NET developer community, which it founded 10 years ago; dev.net.ua, which it founded in the last 5 years, the premier Ukrainian .NET developer community; and VBFeeds, an aggregation service for Visual Basic related blogs and publications.

SubMain would also like to announce today the availability of the new version of GhostDoc (v2.5) which improves user setup experience, adds support for Visual Studio 2010 Beta 1 and full support for Visual Basic.

Additionally, today SubMain is making available a new version of CodeIt.Right (http://submain.com/codeit.right) that adds IntelliComment feature based on the GhostDoc algorithm and offers improved and automated generation of XML Comments.

For more on the agreement, please see the interview with Roland Weigelt and Serge Baranovsky - What's in the shop for GhostDoc? (http://submain.com/ghostdoc/future)

About SubMain

SubMain, a Division of vbCity.com LLC, makes productivity tools for .NET developers. The company's flagship product CodeIt.Right helps developers across the globe to follow team standards and best practices, improve code security and performance, find potential issues early in the development cycle. SubMain is a Microsoft Certified Partner.

Media Contact

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

How to Backup and Restore Visual Studio settings

Serge B. — Sun, 31 May 2009 06:57:00 GMT

If you need to preserve your Visual Studio settings, there is a tool built into VS that allows to backup and restore the settings. In this tutorial we are assuming that you are saving a copy of ALL settings to use by you personally as a backup.

Make a backup

In Visual Studio use Tools / Import and Export Settings… menu to open Import and Export Settings Wizard.
Select Export selected environment settings and click Next.
To include ALL settings make sure the All Settings box is checked. Then click Next.
Choose the file name for the settings backup file.
Then click Finish. The wizard will store settings in the file.

Restore from a backup

Use Tools / Import and Export Settings… menu to open Import and Export Settings Wizard.
Select Export selected environment settings and click Next.
Choose whether you want to make backup current settings.
Choose your backup and click Next.
To include ALL settings make sure the All Settings box is checked. Then click Finish.
The wizard will restore settings from the backup.

Released: CodeIt.Right version 1.6.09139 - now fully compatible with VS2010 Beta 1!

SubMain.Blog() — Tue, 19 May 2009 10:08:02 GMT

As you may know yesterday Microsoft released VS2010 Beta 1 to MSDN Subscribers. The Beta will also be publicly available for the rest of the world on Wednesday. This is long expected and very exciting new version of Visual Studio; and we here at SubMain are fully prepared to support the new shiny version! While some companies make a big deal posting screenshots of the upcoming VS2010 versions and announcing availability of previews for their products within a month, we at SubMain have been working...(read more)