NOTE: This extension works with Visual Studio 2019 (and previous Visual Studio versions). You can download a CodeRush version compatible with Visual Studio 2022 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

CodeRush 25.1 introduces AiGen and AiFind — AI-powered tools that help you generate, modify, and navigate code using natural language. These features are built right into CodeRush (and by extension, Visual Studio) and deliver fast, cost-effective AI assistance right inside your editor.

➡️ Full Blog Post is here.

Getting Started

You'll need:

• An OpenAI API key for AI features
• An Azure Cognitive Services Speech API key if you want to use voice input

➡️ Setup instructions are here.

You can issue prompts by:

• Voice: Double-tap and hold the right Ctrl key while you speak (it's a quick tap and then holding the key down while speaking)
• Text: Press Caps+G (or assign a shortcut to the AiGenFromPrompt command)

AiGen — Generate & Modify Code with Natural Language

Example: Creating a New Class

In a new C# project, start with the caret inside the code editor. Double-tap and hold the right Ctrl key and say:

"I need a new customer class that holds name, address, and phone number."

Release the Ctrl key when you're done speaking. After a few seconds, AiGen will create the new class and add it to your project. It should look something like this:

	public class Customer
	{
		public string Name { get; set; }
		public string Address { get; set; }
		public string PhoneNumber { get; set; }
	}

Example: Implementing INotifyPropertyChanged

Now let's implement the INotifyPropertyChanged interface. With the caret inside the new Customer class, double-tap and hold and say:

"Let's implement INotifyPropertyChanged"

After a few seconds I get this:

public class Customer : INotifyPropertyChanged {
	public event PropertyChangedEventHandler? PropertyChanged;

	private string _name;
	public string Name {
		get => _name;
		set {
			if (_name != value) {
				_name = value;
				OnPropertyChanged(nameof(Name));
			}
		}
	}

	private string _address;
	public string Address {
		get => _address;
		set {
			if (_address != value) {
				_address = value;
				OnPropertyChanged(nameof(Address));
			}
		}
	}

	private string _phoneNumber;
	public string PhoneNumber {
		get => _phoneNumber;
		set {
			if (_phoneNumber != value) {
				_phoneNumber = value;
				OnPropertyChanged(nameof(PhoneNumber));
			}
		}
	}

	protected virtual void OnPropertyChanged(string propertyName)
	{
		PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
	}
}

Perfect. All the properties have been modified and now properly trigger the PropertyChanged event.

Example: Initializing Fields

Let's make sure all these string fields are correctly initialized. With the caret inside the Customer class, double-tap and hold and say:

"I want all these string properties to be initialized to String.Empty

At this point it's likely AiGen will either update all the field declarations individually or create a new constructor that looks something like this:

public Customer() {
	_name = string.Empty;
	_address = string.Empty;
	_phoneNumber = string.Empty;
}

Example: Indirect Requests

You can even ask for code changes in an indirect manner. For example, in this class, try something like this:

"I noticed this OnPropertyChanged() method accepts a parameter which is the property name and we're passing that in every time we call it. But I'm wondering if there's a way to determine the name of the property from the call stack and have it automatically set."

So in this case, we're asking for an improvement but we're only describing it in general terms. AiGen responds with the following changes to the OnPropertyChanged() method:

Example: Updating Calling Sites

If you're following along with these examples and AiGen updated the OnPropertyChanged() method signature but failed to update the calling sites (which is a simpler, but still valid approach), try this:

"There are a number of calls to OnPropertyChanged() where we're passing in an argument, but that argument is no longer needed because of the new attribute we added."

And AiGen proceeds to update the calls, removing the unnecessary argument:

The AiGen Navigator (along with shortcuts F7 and F8) let you navigate through the changes.

AiFind — Natural Language AI Search

AiFind brings semantic AI-powered search to Visual Studio. Some examples of prompts that lead to an AiFind search:

"I'm looking for all methods that work with or change the customer list."

"Show me all the controls that do not have a style."

"I want to see all the methods that may have a security issue."

"Show me all public members missing XML doc comments."

AiFind highlights matching elements in the active file, and the Navigator helps you review each one.

AiGen & AiFind Notes

• AI-generated code may not always be correct.
• AiGen is great at making changes to a single file (or a designer and its code behind), but for reliable code changes involving many files at once (like a member signature change), refactoring tools generally produce better results.
• AiGen changes can be undone/redone in a single step ? no need to manually track multiple edits.
• AiFind currently works within the active file only.
• C# and XAML are supported in this release.
• Support for additional languages is expected in future releases.
• You can provide additional context to AiGen and AiFind by copying another class to the clipboard and using the word "clipboard" in your prompt. This is useful when I want AI to produce code involving the active class and the one of the clipboard (like setting up data binding, creating factories, etc.).

Changes to Default Options

Two changes to default options in this release.

Updated AI Model

The default AI model is now "gpt-4o". You can change this on CodeRush's IDE?Cognitive?General options page.

Disabled Expression Dictation

We disabled Expression Dictation by default (to reduce potential collision/confusion with the new AiGen/AiFind features). You can re-enable this on the IDE?Cognitive?General options page

Read more about new CodeRush features