NOTE: This extension works with Visual Studio 2022 for ARM. You can download a CodeRush version compatible with Visual Studio 2022 for x64 here, and with Visual Studio 2019 (and previous Visual Studio versions) here.

Download your free copy today!

DevExpress CodeRush is available free-of-charge. Register for your free copy at https://www.devexpress.com/coderush-free

CodeRush Feature Overview

Code Generation & Typing

Create new code more efficiently with CodeRush's intelligent code generation. Declare members in a single keypress. Surround code with try/catch or using blocks (again, in a single keypress).

• Write Boilerplate Code Faster and with Fewer Keystrokes
• Add Using Directives and Common Member Implementations Instantly
• Create Code Elements Intelligently Based on Usage
• Surround Selected Code with Popular Language Constructs
• Intelligently Create New Code Based on a Sample Selection

Learn more about Code Generation & Typing

Code Refactoring & Transformation

With over 100 refactorings and intelligent code providers, CodeRush delivers the power you need to easily change code, improving readability and the internal structure without changing external behavior.

Safely make changes to the API (add/remove parameters, add interface members, move members up the hierarchy) or update legacy code to support new language features. Focus more on code quality and functionality, and let CodeRush handle the routine changes to the code base.

Learn more about Code Refactoring & Transformation

Code Navigation & Search

Move through your code at warp speed. CodeRush includes innovative, powerful and exclusive tools that help you be exactly where you want to be in an instant, regardless of solution size.

Learn more about Code Navigation & Search

Code Style & Formatting

With a rich set of code style settings, you get to focus on code quality and functionality while CodeRush focuses on matching the style needed in the moment. And code style settings can be separately configured (if needed) for yourself, individual solutions, and your entire team.

You can format code, remove unused code, and sort and group members in a single action. You can do this for the active file or instantly clean up entire folders or projects. CodeRush gives you complete control over the entire process.

And if you like, CodeRush will clean up code automatically (to your specifications) when saving documents.

Whether it's Style Cop guidelines or any other style you prefer, CodeRush can organize your code and make it easier to read.

Learn more about Code Style & Formatting

Code Visualization & Readability

CodeRush can add code visualization features to Visual Studio, improving code quality and readability, and help you more easily create and debug code.

Features include:

• Highlight and Correct Misspelled Words in Code, Comments, and Strings
• Preview Expression Values In-place while Debugging
• Perform Common Tasks with Type Members with a Single Click
• Highlight Code Blocks and Region Boundaries
• Make Sure All Your Code Fits Onscreen with a Right Margin Indicator Line

Learn more about Code Visualization & Readability

Code Coverage & Testing

When it comes to Test Driven Development, CodeRush is the tool of choice. CodeRush's Test Runner is top of its class. It's the fastest test runner available for .NET. Run and debug a single test, or all tests in the solution. You can even focus on a group of related tests using the Sessions functionality. In-source icons let you run, debug, and see test run status directly from code. And it simply works across test frameworks without any configuration required.

NUnit, MSTest (VS Testing), xUnit, and MSpec tests all are working right out of the box. .NetCore (including .Net 5 and .Net 6), .Net Framework, and multi-target projects are also supported.

CodeRush Templates make it easier to create new tests with a simple keystroke, while Code Coverage helps your entire team find problem areas in the code. You can even reveal line-by-line coverage details if you like.

Learn more about Code Coverage & Testing

What's New in the latest version

Test Runner

CodeRush can now run xUnit.Net v3 tests.

Voice Support

Voice to Code - Alternate Input Modes

We have added alternate input modes using the Alt and Shift keys, which can now be optionally held down while talking to change how the individual spoken words are interpreted.

When the Alt key is pressed while dictating comments or strings, CodeRush switches to code-first mode, and will find and emit matching identifiers into the strings or comments you're dictating. So you can say "We need a descendant of a composite data bound control here" (holding Alt down while saying the bolded words) to get "We need a descendant of a CompositeDataBoundControl here" in your comment or string. The symbols referenced while holding down the Alt key must be in scope and visible/accessible from the comment or string dictated.

Inside dictated interpolated strings, you can use the Alt key to emit simple expressions (like "{nameof(PrintOrder)}" or "{myList.Count}" or "{selectedCustomer.Name}"). Curly braces are added automatically.

When the Alt key is held down while dictating code, CodeRush switches to new identifier mode, allowing you to dictate the name of a new identifier or method call. To indicate a method call, after saying the method name release the Alt key and say the word "with", followed by any optional dictated arguments to be passed to the method. For example saying "my new method with three and four" (holding Alt while saying the bolded words) will generate "MyNewMethod(3, 4)".

And you can use the Shift key to create strings. Words spoken while holding down the Shift key will create string literals in code, escape-quoted sequences of words inside strings, and quoted text in comments.

More Voice-to-Code Expressions Supported

The Voice to Code engine supports more expressions. All of these examples start by holding down the Ctrl key and speaking (after setting up for voice).

• New object creations with the spoken word "new":

  • you can say "my table gets new data table with table name" to get myTable = new DataTable(tableName) (assuming myTable, DataTable and tableName are all in scope)
  • you can say "type value gets new" will emit type value = new()

• Reference generic types using the spoken word "of" (and optionally "and"). Examples:

  • You can say "hash set of guid" to getHashSet<Guid>.
  • You can say "new dictionary of string and double" to getnew Dictionary<String, Double>().

• New variable declarations and method calls using the Alt input mode

  • you can say "my new person gets new person with name" (holding Alt while saying the bolded words) to get var myNewPerson = new Person(name) (assuming Person and name are both in scope)
  • You can say "hash set of guid processed orders gets new" (holding Alt to create a new identifier while saying "processed orders") to getHashSet<Guid> processedOrders = new().

• String literals using the Shift input mode

  • You can say "my data table gets new data table with orders" (holding Shift to create a string literal while saying "orders") to get myDataTable = new DataTable("Orders") -- (assuming DataTable is in scope)
  • You can type an open bracket ("[") to create an attribute above an NUnit test fixture and then say "category voice" (holding Shift while saying "voice") to get [Category("Voice")]

• Use Shift and Alt together. Sometimes you need to declare new variables and assign them a value in a single phrase. For example, you might want to create a new variable that's initialized to a string. You can say "my message gets hello world.", holding down the Alt key while saying "my message", and holding down the Shift key while saying "hello world". This will produce:

    var myMessage = "hello world."
  

• Simple constant and type matching patterns - "value is null", "value is not null", "value is 4", "value is not 4", "value is string", "value is not string" will generate code with the is pattern syntax or with an equality or inequality check (== or !=), depending on your Visual Studio settings for prefer pattern matching and prefer not pattern.

• Automatic indexing of indexable properties, collections, and arrays using the spoken word "of". Examples:

  • you can say "car list of 5" to get carList[5], -- (assuming carList is an indexable symbol in scope)
  • you can say "car list of my indexers of 7" to get carList[myIndexers[7]] -- (assuming carList and myIndexers are both indexable symbols in scope)

• Qualified namespaces and namespace aliases:

  • "system numerics vector three one" will produce System.Numerics.Vector3.One
  • "system console write line" will produce System.Console.WriteLine()
  • if the code contains a namespace alias (e.g., using WinMedia = System.Windows.Media;), you can reference and work with that alias. For example say "win media brushes cornflower blue" to get WinMedia.Brushes.CornflowerBlue.

• While most needed parens are handled automatically by the voice-to-code engine, you can now explicitly dictate parentheses. Insert an open paren using the spoken words "group" or "open paren", and later you can optionally insert the close paren using the spoken word "close". Examples:

  • "count is greater than two times group three plus four" produces count > 2 * (3 + 4). Notice that closing paren is optional - all unmatched open parens will be closed automatically when the code is generated.
  • "group two plus three close times four" produces (2 + 3) * 4. Here the closing paren was explicitly added.

Declaring Fields and Locals

Using the new Alt input mode combined with all new supported expressions, you can now easily dictate field and local declarations. Some of supported patterns include:

• "type reference variable name"
• "type reference variable name gets expression"
• "type reference variable name gets new"

Remember, the Alt key needs to be held down while saying the new variable name.

For example, you can say "queue of task task queue gets new" to get Queue<Task> taskQueue = new()

Overall quality improvements

We improved the Voice to Code engine to produce higher quality results when speaking naturally.

For example, when you say "count is less than zero or greater than five", CodeRush produces count < 0 || count > 5.

Notice that the word count only appears once in the spoken phrase but appears twice in the generated code. CodeRush infers the missing subject in conjoined clauses and explicitly includes it in the corresponding code as needed.

The Voice-to-Code engine also includes a higher degree of type validation for arguments, assignments, and binary expressions when mapping spoken words to code.

For example, if your code contains phonetic ambiguity in the form of two similarly-sounding symbols (e.g,. int myLocalWon and string myLocal1) variables, and you say "my local one gets 42", the engine produces myLocalWon = 42, because the right side of assignment is an integer, and ambiguity is resolved by using the variable that can accept an integer assignment (int myLocalWon).

Voice Commands

In this release we added and enhanced voice commands:

• "View Designer" opens a designer view for the current document.
• "View Code" opens a code view for the current document.
• "Identify Monitors" reveals ID numbers for all your monitors. You can use these numbers with the Show Me command to place Visual Studio tool windows on a specified monitor.
• "Show Me ToolWindowName {on DislayId {at Position}}" opens the specified Visual Studio tool window on the specified monitor and position. DislayId can be a display number (use the "Identify Monitors" voice command to see the numbers) or it can be a relative location to your main monitor (e.g., Left, Top, Right, Bottom-Right, etc). Position can be one of Left, Right, Top, Bottom, Top-right, Top-left, Bottom-left, Bottom-right). Examples:
  • "Show me solution explorer on main" will maximize the Solution Explorer on the primary monitor.
  • "Show me watch 1 on 3 at top right" places the Watch 1 window on monitor 3 in the top right quarter of the screen.
  • "Show me C# interactive on left at top" places the C# Interactive window on the left monitor in the top half of the screen.
  • "Show me watch 1 on 3 at left" places the Watch 1 window (if debugging) on monitor 3 in the left half of the screen.
  • "Show me copilot on right at right" places the GitHub Copilot Chat window on the right monitor aligned to the right half of the screen.
  • "Show me task list here" places the Task List window on the monitor containing the mouse cursor, aligned with the mouse position (full screen, half screen, or quarter screen depending on where the mouse is on that screen).

Templates

We added a number of new string providers you can use when creating custom templates:

• «?ProjectRelativeFilePath» returns the path (relative to the project folder) for the active file.
• «?ProjectRelativeFileName» returns the file path and name (relative to the project folder) for the active file.
• «?DefaultProjectNamespace» returns the default project namespace for the active project.
• «?DefaultNamespace» returns the default namespace for the active file using the project's default namespace and the file's relative location to the project folder.
• «?Substring(text, start, length)» calculates a substring from the specified text, starting index, and an optional length.

Resolved Issues

T1260973 - Code Templates - Parametrized string provider used as an InFormatter for a link does not work

T1262897 - XAML Formatting - Single quote (') characters are removed from attribute values

T1253910 - Spell Checker - High memory and CPU usage in a big solution

T1247886 - Code Issues - Invalid code analysis warning when analyzing potential null reference in the "is { } pattern" expression

T1266846 - General - CodeRush 24.1.5 causes an error in the 'Diagnostic analyzer runner' when using Visual Studio 17.12.3

Read more about new CodeRush features