CodeRush for Roslyn, v16.1.7

Today CodeRush for Roslyn v16.1.7 is available. Team CodeRush continues its 45-day sprint & release cycle.

This release adds a few new features, and addresses a number of customer-reported issues.

My favorite new feature in this release is the availability of Reorder Parameters. This extremely efficient refactoring is now available at method calls, multi-dimensional indexed property references, and object creation expressions. So you can be anywhere in your code, and see a method call with arguments in non-intuitive places, and reorder that call’s parameters immediately, and CodeRush for Roslyn will update the declaration and all references automatically.



Another nice addition is the return of being able to use the Spacebar to expand/collapse regions:



And we improved the performance of the IntelliRush experience.


We also discovered three undocumented features we added to the Debug Visualizer back in version 1.0.12, which you may have already experienced.

1. Array contents preview at debug time:



2. Color swatch preview at debug time:



3. Font preview at debug time:



Download CodeRush for Roslyn from the Visual Studio Gallery, and let us know what you think.

Updates every 45 days.

CodeRush for Roslyn 16.1.6 - Official Release

It’s Here

Team CodeRush has worked for over a year building CodeRush for Roslyn, and we’ve dedicated ourselves to creating the fastest, lightest, most powerful add-in for Roslyn. Here are a few of our accomplishments:

  • CodeRush loads in about three seconds or less.
  • CodeRush consumes significantly less memory than competing tools with similar functionality (about 200MB less for most projects).
  • CodeRush still appears to have the world’s fastest test runner.
  • We continue to approach a maximally efficient code writing experience.

This past year the team obsessed over performance, working to create a tool that maximizes productivity without getting in your way. I think we did that, and I’m interested to see if you agree.

Killer Features that made it into this release:

Differences Between CodeRush for Roslyn and CodeRush Classic

Here’s an overview of the major differences between CodeRush for Roslyn and CodeRush Classic:


So if you’re working in C# or VB in Visual Studio 2015 or higher, then CodeRush for Roslyn will make sense for you.

If you’re working in older versions of Visual Studio, or if most of your work is in JS, HTML, or XAML, CodeRush Classic may right be for you.


There are two ways to purchase CodeRush for Roslyn. If you need first-class DevExpress support, or if you also need CodeRush classic, then you’ll want to purchase CodeRush Ultimate.

If support from the community is all you need and you’re working in VS 2015 and up, then get CodeRush for Roslyn, Community Support Edition.

Both options are summarized below:


Note that regardless of which option you purchase, that purchase price entitles you to one year’s worth of free product updates. And speaking of updates…

Release Schedule

If you followed the CodeRush for Roslyn pre-release, you know that Team CodeRush pushed out updates every 45 days. And we plan to continue that 45-day sprint cycle, so you can expect to get the latest features, refactorings, updates, and every 45 days. Eight times a year.

What’s New

Here’s what’s new in the 16.1.6 release:

Code Analysis

  • You can now run Code Analysis for the active project or file separately.
  • The Code Analysis report now includes information about source files.
  • You can now reconfigure Code Analysis without restarting Visual Studio.
  • We have added the ability to check naming conventions continuously in background.
  • Performance has been improved.


  • ‘The new Jump to Everything navigation provider allows you to jump to any file and symbol in the solution.


Refactorings and Code Providers

  • Convert to System Type/Built-in Type lets you easily switch between CLR types and their keyword aliases.
  • Split String divides a string into two at the caret position. You can also divide one string into three concatenated strings - just select the portion you want to break out before applying this refactoring.
  • Reorder Parameters changes method parameter order, without any dialogs to slow you down. The method signature and all references are updated. This is the fastest, most effortless way to reorder parameters.
  • Visual Studio's Rename refactoring is now accessible from the refactoring menu. 
  • We have added the ability to sort Light Bulb menu items (refactorings and code providers) based on their most recent usage in the given context.
  • You can now optionally hide redundant Light Bulb menu items provided by Visual Studio if these features overlap more efficient CodeRush functionality. For example, if this option is selected, when CodeRush's "Declare Method" is available, Visual Studio's "Generate method stub" menu item will be hidden.

Test Runner

In this release, we are introducing beta support for .NET Core tests. Now you can run and debug .NET Core tests, created with NUnit, xUnit or MSTest frameworks.

  • Test Runner output in Visual Studio's Output window now shows the filter applied to the test run:
  • You can now optionally show or hide the Test Runner and Code Coverage items appearing in Visual Studio context menus.
  • Visual Studio's status bar now displays the currently running test.
  • Testing results in Visual Studio's Output window are now grouped by project.
  • Tests can now be grouped by file path.
  • A number of minor usability issues were corrected/improved.

Other Improvements

  • If you have new and old versions of CodeRush for Roslyn installed, the Extension Cleaner will detect this and offer to clean up the older versions.
  • The Code Cleanup options page has been redesigned, showing before & after code samples, so you can more easily see what each option performs.
  • Member Icons are now in vector format, so they look sharp and clear regardless of the color scheme, display resolution or editor window scale.


Give It a Try

Download the CodeRush for Roslyn from the Visual Studio Gallery and let us know what you think.

CodeRush for Roslyn Shortcut Cheat Sheet

Just in time for the final release, here is your CodeRush for Roslyn Shortcut Cheat Sheet:


Code Snippets on Steroids + Jet Fuel

CodeRush for Roslyn, 16.1 - Code Template Example

CodeRush is well-known for its code templates, guided by a set of easy-to-learn rules for writing code quickly. In our port to Roslyn, we kept CodeRush’s unrivaled code template technology and worked to amp up developer efficiency everywhere we could.

Code templates are like code snippets – they offer a shorter path between thought and actual code. They are like a compression mechanism for writing code. So your mind and your fingers do less work, and it takes less time to turn your ideas into working code.

For example, let’s say we want to create a new public enum called “Vowels”, with five elements, “a”, “e”, “i”, “o”, and “u”. Something like this:

  public enum Vowels

To create this by hand in C# it takes 11 keystrokes to enter those six names (“Vowels”, “a”, “e”, etc.) and another 27 keystrokes to create the syntax that makes it an enum:

  1. p
  2. u
  3. b
  4. l
  5. i
  6. c
  7. Space
  8. e
  9. n
  10. u
  11. m
  12. Space
  13. V
  14. o
  15. w
  16. e
  17. l
  18. s
  19. Enter
  20. Shift+
  21.          [    // for “{“ on a US keyboard
  22. Enter
  23. a
  24. ,
  25. Enter
  26. e
  27. ,
  28. Enter
  29. i
  30. ,
  31. Enter
  32. o
  33. ,
  34. Enter
  35. u
  36. Shift+
  37.          ]    // for “}“ on a US keyboard
  38. Enter

We could use Visual Studio’s code snippets to improve our efficiency, saving 10 keystrokes. Nice. In this case it still takes 11 keystrokes to enter “Vowels”, “a”, “e”, etc., and another 17 keystrokes to create the code that makes it a syntactically correct enum:

  1. p         // wait for Intellisense to suggest “public” – if it doesn’t you have more typing
  2. Tab     // expands VS snippet
  3. Space
  4. e         // wait for Intellisense to suggest “enum” – if it doesn’t you have more typing
  5. Tab     // expand “enum”
  6. Tab     // expand enum snippet
  7. V
  8. o
  9. w
  10. e
  11. l
  12. s
  13. Enter  // moves caret into enum
  14. a
  15. ,
  16. Enter
  17. e
  18. ,
  19. Enter
  20. i
  21. ,
  22. Enter
  23. o
  24. ,
  25. Enter
  26. u
  27. Down Arrow
  28. Enter

So using Visual Studio code snippets seems to improve the developer experience. We eliminate the need to hold the Shift key down when pressing the brace keys (simplifying our task and lowering cognitive load), but we’re still required to hit that comma key, which is small and requires more precision to hit (and is a more error prone key to hit) than the much larger Enter key, for example.

Now compare the code snippet experience with CodeRush template expansion, which looks like this (11 keys to name the elements, plus 8 keys to create the syntax):

  1. e
  2. Tab      // …or Space, depending on your settings. Either way, this expands the public enum template instantly.
  3. V
  4. o
  5. w
  6. e
  7. l
  8. s
  9. Enter   // moves caret into enum
  10. a
  11. Enter   // comma added automatically
  12. e
  13. Enter   // comma added automatically
  14. i
  15. Enter   // comma added automatically
  16. o
  17. Enter   // comma added automatically
  18. u
  19. ;        // smart semicolon ends the enum declaration and moves the caret outside

In all three approaches we are creating the exact same code. And each example demands a different level of developer effort.

So for each of these approaches, the minimum number of keys needed to declare only the syntax (e.g., no element names) are summarized in the chart below:



Using CodeRush’s “e” template to quickly create enums.

Wrap Up & Benefits

This gives you an idea of the kind of compression we’re talking about when you use CodeRush templates to write code syntax. In many of the CodeRush templates, including the enum template discussed here, we have achieved what we believe is the most optimally efficient way to write code. Fewest keystrokes. Lightest cognitive load.

There are a number of reasons why you might want to be able to write more code with less work:

  • Your fingers do less work. Less strain over the course of a lifetime may increase the longevity of your hands.
  • Typing fewer keys means fewer opportunities to introduce mistakes. Fewer mistakes means less time wasted correcting.
  • You can write code faster. Useful when you’re pair programming, competing in a hackathon, or presenting/coding live in front of your team or an audience.
  • Writing code faster also shortens the feedback loop between idea and realization, which can lead to a higher quality design.
  • The more experience you get writing code, the better you get. If you write more code in less time, your experience will come at a faster rate.

If you’re already using Visual Studio snippets, that’s a good sign. It shows you value getting more done with less effort.

Note that CodeRush templates tend to be more than twice as efficient as Visual Studio’s snippets. So if efficiency, longevity or coding speed is important to you – and you’re not using CodeRush templates – you might want to take a closer look.

Speaking of closer looks, Paul Usher has a CodeRush for Roslyn webinar on 2 August 2016. Check it out.

CodeRush for Roslyn Webinar

A shiny new CodeRush for Roslyn release is imminent. It’s fast, lightweight, and feature-rich.

Check out what’s new, get a tour, and see how easy it is to get started with the new setup wizard.

See how you can increase developer productivity and efficiency. Get more done in less time, with fewer keystrokes a lower cognitive load.

Click the button below to register:

1:00 PM
Your time zone: GMT -4
Other time zones
More Posts