CodeRush Love

Scott Hanselman has been posting recently about his love for CodeRush. I couldn't agree more.

For nearly a year, I'd been using a combination of Visual Assist and C# Refactory. Both are useful, though sometimes rough around the edges tools, and I loved the productivity they added. An evening spent customizing VA's code expansions paid big dividends.

Then CodeRush shipped and I figured I'd give it a go. It came as a part of the DevExpress .NET subscription, so it was there for the installing. I installed the initial release build, played with it for an evening, and then uninstalled it. It was feature-rich, had a million settings in its Options dialog, and would clearly take some time to get productive with.

But I kept an eye out and read the CR group in the DevExpress newsgroups. About 6 weeks or so ago, I decided to give it another shot, based on all the excitement I was reading in the newsgroups. I figured I'd force myself to use it for a week, during which I'd shut down VA and C# Refactory, and then make a decision. At first I was slowed down and had to check the built-in User's Guide regularly. By the end of the week, though, it was clear I wasn't going back.

While many tools provide templates/code expansion, I've yet to find one that does all that CR does. For starters, it's templates are context aware. They behave differently depending on what you're doing, what's selected, etc. The 'r' key for example, has these expansions:

  • In an empty method, hit 'r' and space and you get return;
  • In a method/accessor that contains code, it looks at local variables, finds one that matches the type to be returned, and provides that:  return localVar;
  • If I select a number of lines of code and hit 'r', it's completely different -- the selected code gets #region/#endregion tags and the cursor is in place to name the new region. This doesn't fall into the "templates" category, but gives you an idea of how context-aware CR is.

Now imagine that for most keys and key-combinations on the keyboard.

Beyond templates, there are things like visualization tools -- each return statement has an arrow that you can hover over and it animates an arrow to the end of the code block you'll return from. Ditto for all
other flow-control statements -- throw, break, continue, and so on. Regions get painted with lines that run the width of the editor to make it easy to see the blocks. And it's all very polished looking.

As you type, CR provides suggestions via "Intellassist", meaning you only type variable/member names once and it gets suggested as you type later on. Think "in-line Intellisense".

Then there's "Smart Paste" when you paste something into the editor, CR looks at what it's pasting and
can paste something else altogether (all regex driven). While I haven't dug too deeply into this yet, it's clearly a powerful capability. The one I have used is with this scenario: Create a private field in your code (private int _someValue;) and copy it to the clipboard. Move down a line and paste it. You get:

 

public int SomeValue
{
    get { return _someValue
; }
    set { _someValue = value
; }
}

(note: I've customized this layout slightly from the default)

There's a configurable QuickNavigation window you get with CTRL+. -- you tell it what to show (based on members, types, and access/scope), how widely to look (solution, project, namespace, file, etc), and then start typing characters -- as you type, the matching symbols are displayed. You can use the arrows to select candidates (or keep typing) and ENTER takes you to the selected symbol. Very fast.

Smart Brackets/Parens auto-closes opening brackets and parens for you. If you're inside parens, it can optionally ignore additional closing parens... it has a "smart" semi-colon feature that recognizes that you're inside the parens and puts the semi-colon on the right of the closing paren. Evenworks with embedded parens.

Markers are VS.NET Bookmarks on steroids. Drop them wherever you want and ESC will take you to them in the order you dropped them. As it jumps you to a marker, you get a cool "targeting" visualization that draws your eye right to the correct place. Most of the templates/expansions CR provides have markers embedded in them... as an example, the 'tc' expansion creates a try{}-catch{} blocks, puts your cursor at the correct place for the first line of 'try' code, and each block has a marker. Enter your 'try' code, hit ESC, and you jump right to the correct place in the catch block to provide that code.

Even further, it has a CRAZY-RICH plugin architecture that lets you dive in and create your own CodeRush plugins to do virtually whatever you want with code. I've not touched that at all (yet), but I'm hoping for some cool stuff down the road. I imagine we'll see lots of refactoring plugins before long.

Despite the goodness, there are a few things I wish for:

I don't care for the Help/Online Doc they provide -- the content itself is great, but the format doesn't work for me. It's basically a custom VS.NET tool window that provides a treeview for the contents (including search) and then the contents themselves in another pane. I think they did it because it lets them provide links from the doc right to the CR user interface, but I'd still prefer it built into the standard "MSDN Docs" library (which the DevExpress UI components actually do). I also wish there was a PDF of the user's guide so I could print it and flip through it without having the guide window taking up screen space.

The auto-complete/template stuff doesn't work quite the way Visual Assist did -- basically, VA looks at everything in the current context and provided an intellisense-like listbox that narrowed as you type. The CRapproach is to provide an in-line suggestion that changes as subsequent characters rule out other suggestions -- the point being you only see one suggestion at a time.

Also, VA displayed tooltips near the cursor when something you typed matched the macro that would expand a code block. For example, if you type 'if' with VA running, you get a tooltip that shows an if{} block nearby. You can continue typing to ignore it or hit ENTER to have it expand and create the full block for you. With CR, I haven't found a way to have it tell me when I've typed a template shortcut, so I have to guess. I often typed 'pu' and + SPACE, expecting it to expand to 'public', and instead I get:

 

private uint _propertyName;
public uint PropertyName
{
  get
  }
    return _propertyName;
  }
  set
  {
    _propertyName = value;
  }
}

CTRL+Z/Undo takes care of this and then I remembered that it's 'pub' that creates 'public' (it's now habit). And in fairness, it's all totally configurable so you don't have to get an unexpected expansion more than once. Still, it'd be cool if there was an indicator somewhere that let you know what a template would expand to -- or maybe a mini-guide window somewhere that could serve as a quick reference. Currently, you have to go into the Options dialog and search the hierarchy of templates. Do-able, but it's an extra step.

These are all small nits and the configuration options let you get around most very easily... so the features and productivity gain FAR outweigh any downside. In fact, the only REAL downside here is the learning curve. You just have to spend time trying things in the Options dialog, going back to the editor to check it out, and so on. Spending time in the online doc helps a lot as well, though I did wish for a 1-2 page quick-start guide that provided the basic features or the most common template shortcuts. Force yourself to really use this for a day, though, and you'll see some gains... the cool thing is that you'll "discover" new features for a long time to come.

Anyway, they have an evaluation download so you don't need me to babble on any longer. Go get it and see what you think.