CodeRush for Roslyn, v1.0.5

The CodeRush team, continuing its 45-day or less release pace, is ready to bring you the latest update to CodeRush for Roslyn, version 1.0.5.

Our previous release, CodeRush for Roslyn v1.0.4, included new refactorings, code providers, text commands, and test runner and code coverage support. You can download the latest version of CodeRush for Roslyn from the Visual Studio Gallery.

Zero Bug Policy

The team has a zero-bug policy, which essentially means we resolve all reported issues before we write new features. And so in this release, v1.0.5, we’ve prioritized quality and performance over new/ported functionality, resolving over 200 issues, including:

  • Templates:
    • Expansions in split views
    • Corrected context to prevent unintended expansions inside XML doc comments and interpolated strings
    • Corrected a number of template expansion issues in Visual Basic
  • Exceptions when editing code
  • Performance issues:
    • Toggle Comment
    • Test Runner in large files with a huge number of test cases
  • An edge case out-of-memory exception
  • Edge case deadlocks on solution open/close and Test Runner build
  • Edge case crashes (when rename is invoked in navigation link, or when double-clicking tests in the Test Runner)

Other feature areas receiving improvements in this release:

  • Code Cleanup
  • Code Coverage
  • Code Providers
  • IntelliRush
  • Linked Identifiers
  • Refactorings
  • References tool window
  • Shortcuts
  • Tab to Next Reference
  • Text Fields
  • Test Runner

We also added hundreds of test cases to help ensure these issues never appear again.

New in v1.0.5:

We added the following new features in v1.0.5:

  • CodeRush now updates test run progress on the Windows taskbar.

  • The Test Runner filter now shows the full path to each test, so you can easily find the test you are looking for even if you have tests with identical names in different test fixtures.
  • We added the "Add Else Statement" and “Declare Interface” code providers.
  • Smart Constructor, Declare Class, Declare Property, and Declare Property (with field) are now available for Visual Basic developers.

Give it a Try

Give the 1.0.5 version a try and let us know what you think. You can download CodeRush for Roslyn from the Visual Studio Gallery.

CodeRush for Roslyn v1.0.4

CodeRush for Roslyn (CRR) v1.0.4 is now available. This free preview version expires on 4 September 2015.

Here’s a list of what’s new in version 1.0.4.

New TextCommands:

  • Smart Return, used in the r and lr templates.
  • Smart Constructor (C#), used in the cc template.
  • ForEach, used in the sw and asm templates.

New Editor Features:

New Refactorings and CodeProviders:

VB Support added for:

Unit Test Runner enhancements:

  • Performance improvements.
  • Ability to exclude selected categories when running all tests.

Code Coverage enhancements:

  • Navigate from code to the corresponding Code Coverage tree node.

  • Active method highlighting inside the Code Coverage code view window.

Download it, try it out, let us know what you think.

IntelliRush Hierarchical Filtering

In CodeRush Classic 15.1 and in CodeRush for Roslyn we added the ability to filter Intellisense members by the class where they are declared.

Here’s how it works. To show this in action, I created a new Windows Universal App, and opened the MainPage.xaml.cs file. Inside the constructor, I typed “this.”

Here’s what I see:


That’s about 165 entries. That’s a lot to wade through. I can reduce the list if I have an idea of where to look in the hierarchy.

With IntelliRush’s new Hierarchical Filtering, this is easy. I tap the Ctrl key…


On the right I see “Hierarchy”.

So I press the letter “h” and I see the class hierarchy listed on the right, from MainPage (the type of the “this” reference) up to Object


Now, if I know the class I want to see members from, I can simply press the number associated with that class. For example, if I only want to see members from the FrameworkElement class shown in this list, I simply press the number 4 from the hint, and my list of 165 members drops to 34:


If I want to slice the class hierarchy to include a range of classes, for example UIElement and up, I can do the following:

  1. Tap Ctrl
  2. Press h

    The Hierarchy hint displays:


    UIElement is number 5. So if I want to see members declared in UIElement and all its ancestors, all I need to do is…
  3. Press Shift+5

And with those three keystrokes IntelliRush shows only the entries declared in UIElement and up:


Shift + the class number shows members declared in the specified class and above.
Ctrl + the class number shows members declared in the specified class and below.

On most keyboards the Shift key is above the Ctrl key, so you may find their position (Shift above, Ctrl below) helpful in remembering which modifier key to hit.

The active class is always numbered zero, which allows for some useful shortcuts to keep in mind:

Member Scope To filter, tap Ctrl, press H, and then:
Active class only 0
Parent class only 1
Active & parent classes only Ctrl+1
Parent class and above Shift+1
All classes (resets an active filter) Shift+0

Combining Filters

You can combine a hierarchical filter with a member kind filter. Only want to see events declared in the active class or its ancestor? Easy. First, apply a hierarchical filter to isolate members to only the ancestry you’re interested in. Next, apply the member kind filter you want (e.g., tap Ctrl, then press E, to only see events).

Try it Out

IntelliRush’s Hierarchical Filtering is available in both CodeRush Classic 15.1 and CodeRush for Roslyn 1.0.

CodeRush for Roslyn (preview)

So the entire team has been working hard on CodeRush for Roslyn. This endeavor is huge: Hundreds, if not thousands of language-based features, replacing our core engine with Roslyn’s core engine, and porting tens of thousands of test cases.

Based on what we’ve seen so far, the end results, extremely efficient use of memory, even faster performance, and more, appear to justify the effort.

The Plan

The DevExpress 15.1 release includes two CodeRush products:

  1. CodeRush Classic 15.1 (previously known as simply CodeRush). This is the same CodeRush we’ve shipped for years. It includes the full feature set, however 15.1 will not include support for C# 6 and VB 14 language features.
  2. CodeRush for Roslyn (CRR) 1.0 preview. CRR will not include the full CodeRush 14.2 feature set (more details below), however it will include full support for C# 6 and VB 14 language features (and beyond).

The Future of CodeRush Classic

At some point in the future, when we have ported the entire CodeRush Classic feature set to CRR, we intend to deprecate CodeRush Classic. We will continue to support and fix issues in CodeRush Classic for some time beyond this deprecation point, however CodeRush Classic is unlikely to ever get support for new language features (e.g., C# 6, VB 14, and beyond).

Which CodeRush Should I Use?

If you’re working in Visual Studio 2015 with the new language features in C# or VB, you should install CodeRush for Roslyn. If you rely on CodeRush Classic features that haven’t been ported yet, you’ll need CodeRush Classic. If you need both, you can install and use both (more on this in later posts).


There are three significant benefits you can expect from CodeRush for Roslyn:

Massive Reduction in Memory Consumption

Refactoring tools need to understand the code. And to refactor and find references quickly, you need to parse the solution source. And that means memory. The bigger the solution, the more memory you need. In CodeRush Classic and in competing tools which have decided not to support Roslyn, the memory required is essentially doubled as the Visual Studio host is also parsing and storing similar results. Owners of huge solutions were hit hard when using tools like CodeRush Classic. With CodeRush for Roslyn, this doubling-up memory waste is a now thing of the past.

To see this savings in action, we created two benchmarks using the following hardware and software:

Machine: Intel® Core™ i7-363QM CPU, 2.40 GHz, 8GB RAM, SSD HD 
OS: Windows 8.1 Enterprise 64-bit

  • Visual Studio v14.0.22823.1 D14REL
  • CodeRush for Roslyn v0.9
  • Competing Product v9.1

Solutions Tested:


  1. Memory.

    Prep: Open solution. Build. Close all documents. Only Solution Explorer and Properties windows are active. Close solution. Close Visual Studio.

    Memory Test: Start Visual Studio, open solution, wait until devenv.exe process CPU usage falls to 0. Calculate managed memory using VSIX plug-in.

  2. Performance.

    Prep: Open Visual Studio with Start Page opened. Wait until all extensions are successfully loaded.

    Performance Test: Click the solution link the solution in the Recent tab and start the timer. Stop the timer when the solution loading progress bar is complete. For VS and CodeRush the progress bar appears in the Solution Explorer. Competing products may place a progress bar in the lower-left corner of the VS status bar.

At DevExpress we have a policy of not mentioning competing products on our site, so I can’t reveal the name of the product we compared CodeRush to. However I can tell you the version number of the competing product we tested was 9.1, and I can tell you the competing product is one that has previously announced they would not exploit the Roslyn engine (which means you would expect their memory usage to be noticeably higher than Visual Studio’s).

Results of the memory tests:


For the small solution, DotNetOpenAuth, CodeRush uses only 6MB.

For the medium-sized solution, Orchard, CodeRush uses 13MB.

And for the large solution, opening the source code to Roslyn itself, CodeRush uses 55MB.

Faster Performance

Not only was CodeRush Classic storing essentially the same results as Visual Studio was, it was also parsing the same code a second time (just like some competing tools still do). That waste stops with CodeRush for Roslyn. Every feature works noticeably faster and feels snappier, while CRR adds only 0-2 seconds to solution-open times:


Better Language Support

Expect CodeRush for Roslyn to immediately understand and support new C# and VB language features as they are released by the Visual Studio team.

Support for Languages Beyond C# and VB

CodeRush for Roslyn will include parsers and code generators from the CodeRush Classic engine for any languages that Roslyn doesn’t support yet, including XAML, CSS, HTML, and XML. As Roslyn adds support for these languages, We’ll update CRR accordingly to exploit the new support, which should result in additional memory reduction and faster performance.

What’s really exciting, is that as the Visual Studio team and third parties move new languages under the Roslyn engine, you can expect CodeRush for Roslyn to understand those as well. There may be some changes required on our side to support the new languages, however the effort is a small fraction of what it was before Roslyn.

The Preview is Free

Today we’re releasing an early preview of CodeRush for Roslyn on the Visual Studio Gallery. We intend to release updates every four weeks as we approach the final release. The install is VSIX-based, which means updates are quick and easy and can happen from inside Visual Studio.

What’s New

In addition to a port of CodeRush classic features (see below for details), CodeRush for Roslyn also includes two new features.

IntelliRush Hierarchical Filtering

In this release IntelliRush gets a great new feature, Hierarchical Filtering. This lets you slice up the Intellisense hierarchy to only see entries from specified classes in the ancestry.



Code Coverage

The Code Coverage window shows which lines of code are covered by test cases and which are not.


Features Ported from CodeRush Classic

Features included in the CodeRush for Roslyn (preview):



We Need Your Feedback

Let us know what you love, what you’re missing, and what you’d like changed. When CodeRush for Roslyn is published (awaiting final approval from the powers that be), it will be available here.

What’s New in CodeRush 14.2


IntelliRush is the big feature in this release. IntelliRush enhances Visual Studio’s Intellisense, most importantly adding the ability to easily filter the list.

You can filter to see extension methods only:


You can filter to see regular methods only:


You can filter to see properties only:


You can filter to see only enums:


You can filter to see only namespaces:


You can filter to see only interfaces:


To filter, just tap the Ctrl key. The filter hint will appear:


Then simply press the letter of the filter you want to apply. For more on IntelliRush, see this post.

Debug Visualizer

We continue to invest in and polish the Debug Visualizer. New in 14.2:

Dead Path De-emphasis has been moved out of beta and is now a first class feature. Code paths that will not be executed, determined as you step through the code, are rendered in a reduced contrast.

For example, in the code below, the instruction pointer is on the switch statement, but it has not been evaluated yet. However DV gives you a peek into the future and shows you exactly which case statement execution will flow to:


Syntax highlighting is still visible in the dead code path. Dead code paths are now detected in more scenarios, including dead if or else branches, dead case statements and dead catch statements.

Exception Filters in Visual Basic are now supported, with the filter value and associated Boolean icon clearly visible.

Exception Variable Preview in all catch statements, even when the exception variable is not declared.

Smoother Animation, keeps important information right where you are already looking.

Behind the scenes, we updated the DV engine. It is more performant, and we improved JavaScript analysis.

Spell Checking Member Names

You can optionally check member names. To turn the option on, go into the Editor\Spell Checker options page, and check the “Name of members” checkbox:


Once enabled, member names are all checked for correct spelling. Spelling issues are highlighted:


To correct or ignore the spelling anomaly, place the caret inside the misspelled portion, press the CodeRush key (e.g., Ctrl+` – Control plus the back tick key is the default.


Correct the spelling mistake, and the member name is instantly updated everywhere.


You can also add commonly used abbreviations to the dictionary. For example, in the code above, “ctx” is highlighted as not found. That’s an abbreviation I use for ContextProviders I drop on the design surface. So I can easily add that to the dictionary so I’ll never see that again.


Other Improvements

  • We’ve also improved the Decompiler, Jump to Declaration (with Partial Classes), and we’ve added automatic updates for CodeRush if you download and install from the Visual Studio Gallery. Here’s your complete list of What’s New in CodeRush 14.2.

If you’d like to see all this in action, watch my What’s New in CodeRush 14.2 webinar scheduled for 5 December 2014 at 10:00am.

More Posts