In this screencast I cover some of the cool features I found in the SlickEdit Versioning Toolbox. The toolbox is a commercial product, but it is only $49 so I think it is a pretty good deal.

It is a shame that what has become such a standard features in most applications is notably missing in Visual Studio.

I personally struggle with spelling and have in the past resorted to copying and pasting text into Microsoft Word, into Google or using the ASP.NET spell checker add-in . The main weaknesses of the ASP.NET spell checker add-in is that it relies on a recent version of Microsoft Office being installed and does not check .resx files.

I recently found Component One’s IntelliSpell, a new add-in for spell checking source code and other files from within Visual Studio 2005/2008 resolves these issues.

There are two versions available; Community Edition which is free and allows you to spell check one file at a time and Professional Edition which lets you check your entire solution and contains additional features.

Once installed IntelliSpell is found under the Tools menu in your IDE from which you can choose to check the active file, project, solution or select a file. Although you have to actively choose to spell check a file or set of files it can easily be bound to a shortcut key or added to a toolbar.

When checking the document words are highlighted with a colored underline in the same manor as they are in Microsoft Word or Firefox. The misspelled words also appear in the task list which allows you to quickly sort through all the spelling mistakes.

To correct a word, as with other applications, you have the ability to right click on the incorrect word and select from a list of suggested alternatives. You also have the ability to add to Dictionary or Ignore all. Although these are standard spell check features they are particularly useful as standard programming terms such a Guid and enum (which may appear in comments) are not included by default in the dictionary.

You can customize the use of IntelliSpell through the options screen. This allows you to choose which parts of the documents you wish to spell check (such as all comments, xml comment and resx files), the dictionary language, the maximum number of suggestions, and much more.

Overall I have found this is to be a very fast and well designed add-in that has saved me time and improved the spelling in my applications. The IntelliSpell add-in can be download from http://www.componentone.com/SuperProducts/IntelliSpell/

Guest Contribution by John Kilmister

I love seeing more affordable add-ins that are a great value. SlickEdit recently announced a set of add-ins that are both priced at $49 and both provide a number of compelling features. In this article I am going to cover some of the highlights of the Editing Toolbox.

Aliases and Acronyms

One feature set I particularly enjoy are the Aliases and Acronyms. Acronyms are simple code expansions, you can type a couple of characters and then hit Ctrl+` and it will fill out the entire word. It kind of like a micro-code snippet but it is much easier to use than the built in code snippets in Visual Studio. An example aliases is "cxn" which will expand into SqlConnection. This isn’t a ground-breaking feature but it can be very useful, especially since it is easy to create additional aliases:

Aliases are basically the same idea, but they work inside of the Open File dialog. For instance you can type up in the open file dialog and then Ctrl+Space and it will fill in the path to your user profile. This is much better than typing out "C:\Documents and Settings\James Avery" or hunting through the file system with your mouse. You can also set your own if you have common paths you constantly have to navigate to.

Regex Evaluator

A couple years back I took a pass at writing an add-in to evaluate regular expressions, but it has fallen by the wayside. I am glad I didn’t put too much time into it because the Editing Toolbox provides a slick Regex Evaluator. Not only can you test your regular expressions but you can also search RegExLib.com. It also includes a nice quick reference to common regular expressions and a way to save frequently used regular expressions in your own library:

These are just two of the features I enjoy, the editing toolbox includes much more:

• Quick Profiling – A way to use trace statements to perform quick code profiling, useful for loops and small profiling jobs but not a replacement for a full featured trace tool.
• Code Navigation – Quickly jump to symbol definitions and uses.
• Comments – The add-in makes it easy to wrap comments, change comments to blocks, and reflow comments.
• Icon Extractor – Makes it easy to pull icons from existing applications.
• Code Annotations – A simple way to store comments, tasks, and bug information without modifying your source file.
• Auto Code Doc Viewer – The Auto Code Doc Viewer generates and lets you quickly view the documentation generated from your inline XML based comments.

Overall I think the add-in is definitely worth the $49 and provides a number of features I haven’t seen in competing add-ins. One of the most pleasant surprises is how solid the add-in is. I have gotten used to many add-ins being unstable and causing the IDE to slow down or crash, I didn’t experience any of this with SlickEdit.

Check out the SlickEdit Editing Toolbox.

-James

Disclaimer: SlickEdit provided me with a free copy of the add-in and are an advertiser with my advertising network The Lounge.

Classify is a Visual Studio add-in that contains a number of different features, mostly focused on VB.NET development, but some that can be used by C# developers as well.

Scan-Collapse (VB.NET Only)

Probably the most compelling of the features Classify includes is Scan-Collapse. When you work with classes and namespaces you get used to being able to collapse the class or namespace into a single line using the small plus-minus next to the declaration. The Scan-Collapse feature adds this same functionality to other similar pieces of code. Here you can see a simple piece of code:

If (_i = 12) Then

If (_d = 14) Then

End If

End If

After running Scan-Collapse you would now see this:

You can now expand and collapse If blocks just like they were classes or namespaces. Classify will also collapse any Switch or Try statements.

If you would rather not collapse all these statements in your code you can simply put the cursor on a single If line and click the Collapse Code Block button which would collapse just that single code block.

Generate Accessors (VB.NET + C#)

Classify will also generate property accessors for your private member variables. There are two different functions for this. The first, Accessors->Clipboard will generate the accessors and then copy them to the clipboard. The second, Generate Accessors, will generate the accessors and place them in your document.

Wrap in Region  (VB.NET + C#)

Classify can be used to wrap code inside of a region by simple selecting the text you want to include in the region and then clicking the Regionize button. Classify will insert the Region code and then place the cursor over the name of the region.

Classify also includes additional functionality to work with SQL statements and tables.

Download

CodeKeep is a simple code snippet management add-in that allows you to quickly submit and use snippets from the CodeKeep online repository.

CodeKeep is a simple code snippet management add-in that allows you to
quickly submit and use snippets from the CodeKeep online repository.
There are two main functions to working with CodeKeep.

Adding Snippets

Anytime you write a piece of code that you have a feeling you will need
again in the future, might as well add it to CodeKeep so you can
quickly find it and use it in the future. To add a snippet to CodeKeep
you simply have to select that code in the IDE, right-click, and then
select Send to CodeKeep as seen here.

You then get to add a description and some usage notes about the piece
of code, as well as what language your code is written in. (CodeKeep
loves all languages equally)

Searching

Now that you have a bunch of snippets loaded in to CodeKeep it’s time
to use them (as well as all the snippets other people have added).
Simply naviage to Tools -> CodeKeep -> Search and you will see
the following screen.

Through the search interface you can view all of your snippets or
search through all of the publically available snippets based on their
title, description, usage, and based on the language of the snippet.
Once you find what you are looking for you can quickly copy and paste
it into your code.

CodeKeep also includes a great web interface so you can also access and
manage your snippets from the web (and not worry about where to store
your snippets since they are available from everywhere)

Download

SharpTools from Morrison Schwartz gives developers a framework for easily developing add-ins for Visual Studio .NET 2003.  SharpTools also comes with a number of very handy tools as part of the basic install package.

SharpTools from Morrison Schwartz gives developers a framework for easily developing add-ins for Visual Studio .NET 2003. SharpTools also comes with a number of very handy tools as part of the basic install package.

Developers can rapidly tack on new functionality by creating plug-ins for SharpTools. Note that SharpTools is itself an add-in to Visual Studio. Developers extend SharpTools via plug-ins to SharpTools, not by creating new add-ins to Visual Studio. This means you’ll always be running your tools within SharpTools – and you’ll need to deploy SharpTools to any systems you want to run your new tools on.

Plug-ins are quickly spun up by creating a new C# SharpTool Wizard project, added during SharpTools installation.

As shown below, a one-screen wizard prompts you for a couple options.

The plug-in then creates a new project complete with references and a fairly complete class for your plug-in. Obviously, you’ll still need to wire up your widget’s functionality, but all the interfacing to Visual Studio .NET has been handled already. SharpTools also comes with a fair number of already built plug-ins. Perhaps the most useful of these tools is the Code Library for storing documentation and code in a database. The database can be a local MSDE or SQL instance, or you can connect and share data with other developers via a central SQL server database.

A neat feature is keyword support, whereby snippets or documentation can be inserted directly into the VS editor by typing the keyword and then CTRL-ENTER. Former Emacs users might remember abbreviation mode when thinking of this SharpTool functionality. The library comes already populated with quite a few snippets and an example of using the library for storing documentation.

Another feature is a tool for generates strongly-typed collections. A dialog lets you select which class to use, asks for access specifiers, and checks if you want the collection to raise events for various actions.

The tool creates a new class with a great amount of functionality and documentation built in. This snippet below shows a partial class generated from a simple business entity:

There are quite a few other simpler tools included in SharpTools’ default install. You can search Google for a highlighted term or phrase, zip the entire solution into one archive, capture screen shots of your application (but only during execution, not design), and add copyright notice (or headers) to all files in a project.

Folks with a background in Win32 development will appreciate the Win32 to .NET mapping tool. This lets you browse through the Win32 API and see what parts of the Framework are applicable. Additionally, there’s a database manager for MSDE instances, something Microsoft left out of the distribution.

Another tool let you view DataSet objects during debugging sessions, much like VS2005’s visualizers. There’s also an RSS Reader tool which will let you read RSS feeds from within Visual Studio.

The binaries for SharpTools are free for download and installation, but donations via PayPay are encouraged. The source code is available for $50. There’s also a group of forums for discussing SharpTools. The forums are actively supported by developers from Morrison Schwartz.

Oliver Sturm’s CR Electric Editing plugin, based on the DXCore plugin framework, brings Emacs functionality to Visual Studio.

Developers with a background in any of the Emacs variants may remember the helpful “electric editing” features some of the various modes offered. Electric characters do handy formatting as they’re typed into the code editor. For example, braces ({,}) and semi-colons (;) cause the current line to correctly indent, then add a newline with the cursor at the correct indentation level.

Oliver Sturm’s CR Electric Editing plugin, based on the DXCore plugin framework, brings the same functionality to Visual Studio. Electric Editing also gives you “hungry” deletes of whitespaces, deleting all whitespaces to the left of the carat in one fell swoop. This eases the nuisance of cleaning up after you’ve accidentally hit Return and are left with the caret five indents in.

Electric deletes do the same thing, and will work across multiple lines. Additionally “hints” show exactly what whitespace will be deleted when the cursor is at an end or beginning of a line. The hints are very unobtrusive, and their color can be changed via DXCore’s Options menu. The figure below shows whitespace hints in red (the default color is a much more pleasant light blue).

An additonal great feature of Electric Editing is Emacs-like scrolling, where scrolling starts when your cursor is several lines below the top of the screen. (Or above the bottom of the screen if you’re heading south.)

Electric Editing is very flexible with its configuration options. You control what’s deleted, when it’s deleted, and how long hints delay before showing up – or at all. You can also set where the scroll point offset is from the top or bottom of the screen. Sturm has a great walk-through of configuration options here on his blog.

DXCore and Electric Editing both work on Visual Studio .NET 2003. DXCore’s installation claims “experimental” support for Visual Studio .NET 2005; however, Sturm’s blog notes the last several versions of his plugin have been tested under VS 2005 Beta 2.

Installation of both DXCore and Electric Editing is very simple. Install DXCore, then copy Electric Editing’s DLL to DXCores’ plugin directory. In my case, that’s C:\Program Files\Developer Express Inc\DXCore for Visual Studio .NET\1.1\Bin\Plugins

CR Electric Editing may not seem like a sexy, all-powerful plugin, but it’s right in line with the Emacs and Unix mindset: write a tool that does one or a few things very well. Electric Editing does just that by enhancing a small portion of the editing experience.

The CR_Documentor plug-in allows you to view XML comments as rendered comments right inside of the IDE.

XML comments in C# and Visual Basic 2005 enable developers to create clear documentation of software classes. Keeping the XML comments right in the source helps mitigate documentation disconnects when a developer changes something in existing code – at least if they change the comments as they’re updating the code.

These XML comments can be extracted out to a separate XML file during the build process by selecting a project’s property pages and checking the “XML Documentation File” option on the “Build” tab. By default the resulting XML file lands in the build’s output directory.

This XML file can then be used to create any number of separate help files including Windows Help (chm), HTML help, or MSDN-style help. Developers can use simple XSL transforms or a tool like NDoc to produce the documentation.

However, this requires a separate build step which can be a nuisance when all you’re trying to do is verify you’ve got a <see> reference correct.

Travis Illig has helped out by porting Lutz Roeder’s “Documentor” application into the DXCore framework. This enables developers to see rendered documentation from a window directly within the Visual Studio IDE.

[NOTE: DXCore, from Developer Express, is the framework behind their popular CodeRush productivity booster. DXCore is freely available, but only for personal use.]

Download Illig’s plugin, exit all Visual Studio instances, and drop the dll file into DXCore’s plugin directory (“C:\Program Files\Developer Express Inc\DXCore for Visual Studio .NET\1.1\Bin\Plugins” on my system.) After restarting Visual Studio you’ll see the “Documentor” option under the DevExpress -> Tool Windows menu. A separate dockable window appears in the IDE.

One hitch with the plugin is that text in separate files loaded via the <include> tag aren’t pulled in and rendered; however, text clearly notes this and shows the file location and XPath parameter.

This window renders documentation in HTML format any time you have the cursor in an XML comment. Links via <see> and <seealso> are properly displayed, although inactive, and <code> sections are formatted just as they would be in “real” documentation.

CR_Documentor has a number of useful configuration options available through the Documentor section of the DevExpress -> Options dialog. You can select between MSDN and NDoc’s tag sets, determine how to handle undefined tags, replace tabs in <code> sections with spaces, and toggle the toolbar off and on in the Documentor window.

CR_Documentor is a great little tool: it’s simple and does one thing very well. It’s a very handy add-in if you’re using CodeRush or DXCore.

Travis Illig, creator of the CR_Documentor plugin recently passed on some news about his plugin.  He’s updated it to provide support for the <include> tag — the only tag that was previously unsupported.  You can find his updated plugin at his blog.

As a side note, Travis said he solved the problem in part by using System.Web.Caching outside of a web context.

Easily maintain order in your directive blocks.

We software developers often fixate on odd bits and pieces of our craft. You don’t agree? Go out and try to convince a number of your colleagues that your current brace placement style should be altered.  Didn’t get a fight there?  What about how many white spaces should be used for indentation, and whether you should use tabs instead of plain spaces.  Even better, how about a comment on the closing brace of a block noting what block is being closed, a la:

if (foo == bar)

{

   Console.Write(“Foobar”);

} // end if foo==bar

Nicole Calinoiu’s fixation is the order of import/using statements in code files. As with any great developer, Calinoiu created a tool to ease the pain of the fixation.  Calinoiu’s ImportSorter, an addin for Visual Studio 2005 works so well that Calinoiu was awarded Third Place in Larkware’s 2005 Programming Contest.

ImportSorter installs easily and adds a configuration option to Visual Studio’s Tools menu, plus a sort option to the context menu in supported code editor windows.  The context menu’s sort option will fix up mangled orders even after Visual Studio has automatically added in a new directive or two.  Imports and using statement sorting works for C#, J#, and VB.NET.

Calinoiu created a very flexible rule system for ImportsSorter.  Sorting is controlled by groups of namespaces such as System, Microsoft, and user-specific namespaces.  Both simple namespaces (System, e.g.) and compound namespaces (System.IO) can be listed, enabling great control over how the using/imports block is sorted.  Blank lines can be injected between groups for better visual appearance.

Calinoiu’s very clear documentation doesn’t bother going into details on the rule configuration’s effect on sorting order, but rather lists example configurations and outputs.  For example, in the project I’m currently working on, I use various Microsoft namespaces, NUnit, and namespaces specific to the solution I’m working on.  The configuration shown in the following example results in the directive block displayed below the dialog.

using System;
using System.Collections.Generic;
using System.Text;

using NUnit.Framework;

using nUGSoft.Entities;
using nUGSoft.Entities.Errors;
using nUGSoft.Entities.Validation;

Any number of configurations can be set, giving you exact control over how your using/imports directive block is formatted.

Calinoiu’s tool is another small, concise, handy widget which does its job really, really well.

Download

Roy Osherove has released a very handy set of Regular Expression Visualizers for Visual Studio 2005.

Visualizers are one of the most helpful additions to debugging in Visual Studio 2005. Visualizers allow you to create your own customized display for any data type.  You’re able to tweak or completely rework how a data type is displayed.  Think back to how difficult it is to dig through a DataSet in Visual Studio 2003, then compare that to the easy navigation of DataSet objets in Visual Studio 2005.  Behold the Power Of Visualizers!

Roy Osherove has released a very handy set of Regular Expression Visualizers for Visual Studio 2005.  Installation, as with all custom Visualizers, is simply a matter of adding the files to your VS 2005’s profile folder, normally located in your home directory under “My Documents\Visual Studio 2005\Visualizers”.

Restart Visual Studio, then create a pattern in a snippet and test out the visualizer.  Straight from Roy’s example:

string pattern ="(aa|bb)";

Regex r = new Regex(pattern);

MatchCollection m = r.Matches(pattern);

Console.WriteLine(m); // BREAK HERE!

Run this in a debugger session, breaking on the Console.WriteLine statement.  You’re now able to select the MatchCollection variable ‘m’ with Osherove’s handy Visualizer as shown below.

The next image shows how this simplistic pattern measures up as displayed in the “Matches” tab.

The “Pattern Desc.” tab shows an English version of what the RegEx in question captures.  (Microsoft’s Eric Gunnerson wrote the descriptive text.)