Mark Miller
  • CodeRush for Roslyn 17.1.4 is Available

    Another sub-30-day sprint, another release. Here’s what’s new in this version of CodeRush for Roslyn:


    • Drop Marker gets enhanced, gaining the ability to mark and restore selections (in addition to caret positions). Useful when you have the selection you want but then realize you need to do something else first before you modify/cut/copy/delete the selection. Just drop a marker, move the caret to wherever you want to be, and when you’re ready press Escape to restore the selection. Also useful for presenters who want to need do quickly highlight code.

    • Jump to File and Jump to Symbol both gain a new Recent Items section.


    Refactorings and Code Providers

    We widened the accessibility of many refactorings and code providers, making them available when the caret is anywhere on the line containing the relevant code you want to change. Providers with broader accessibility include:

    • Collapse/Expand
    • Compress/Expand ternary expression
    • Flatten Conditional
    • Reverse conditional
    • Use Expression Body

    Unit Testing

    In this release we have excluded the PhantomJS library from the install, allowing you to specify the path to your preferred PhantomJS library. If the PhantomJS library is not found, the Jasmine Test Runner prompts you to install it through npm or NuGet.

    Code Generation

    • You can now choose where you’d like CodeRush to place newly-generated type declarations. Locations include: Above the active type, Below the active type, or In a newly-created file. Use the Editor | <Language> | Code Actions | Code Actions Settings options page to change this option.
    • You can now configure naming conventions for generic types.

    Install the Latest Version Today

    You can download and install the latest version of CodeRush for Roslyn from the Visual Studio Marketplace. Give it a try and let us know what you think.

  • CodeRush for Rosyln 16.2.8 is Available

    Another sprint, another release of CodeRush for Roslyn. You might have noticed we’ve stepped up our update frequency, with sprint/release cycles occurring in 30 day intervals.

    Here’s what’s new in this release:

    This release introduces the Declare menu, a quick and easy way to add needed code to your types.


    These declarations are now available:

    • Automatic Constructor generation (which also automatically initializes selected members).

      Just select the type’s members that you want to initialize, and press Enter. Some of the Declare providers have additional options, which can be accessed by tapping the Ctrl key. For example, with the Constructor UI, tapping the Ctrl key will offer options for constructor visibility, as well as an option to generate properties.


      So given this starting point:


      The generated code for this provider might look something like this:


    • Delegate Members is useful when you want to surface a field’s or property’s members up to the active type. This provider creates members that wrap around the contained field’s or property’s members. For example, if your type contains a generic List of strings (as a field or property), like this:


      Delegate Members can wrap that List’s Count property in its own property, as well as its indexing methods in delegating methods, surfacing these members in your class, like this:


      Which would generate code looking something like this:


      Delegate Members makes object composition easy.
    • IDisposable Implementation generates the Dispose pattern, disposing the specified fields and properties. For example, given this starting point:


      And these options:


      The generated code would look something like this:

    • Equality Members generates two Equals methods and a GetHashCode override, and can optionally generate equality/inequality operator overloads.

    • Override Members overrides virtual and abstract methods. For example, given the following code:


      And with the caret inside the CellPos3D class, pressing Alt+Insert to bring up the Declare window, and then setting these options:


      The following code is generated:

    • Properties and Read-only Properties generate properties for the selected fields. For example, given the following code:


      And these options:


      The following code is generated:

    • Comparison Members generates a CompareTo implementation, individually comparing the specified fields, and optionally implements the IComparable<T> and IComparable interfaces. For example, given this starting code:


      And these options:


      The following code is generated:

    • Missing Members implements any interface members missing from the active class. For example, given the following starting code:


      And with the caret inside CellPos3D, applying the Missing Members provider with these options:


      will generate the following code:


    You get the idea. To try out the new Declare features, just position the caret inside the class you want to modify and press Alt+Insert.

    Clipboard History

    Version 16.2.8 introduces the Clipboard History list, providing complete visual access to your ten most-recent clipboard operations. Instantly paste with the Ctrl+number shortcut. Filter through the list just by entering the text you’re looking for. Ctrl+Shift+V brings up the Clipboard History list.


    Jasmine Test Runner (beta)

    In this release, we’re introducing the beta version of the Jasmine Test Runner for JavaScript and TypeScript. This feature, in its current state, should be considered a technical preview, but you can already run Jasmine tests with it using the CodeRush Test Runner window. This beta works with the following restrictions:

    • Test discovery is not implemented yet. Every file with unit tests should reference the Jasmine framework (e.g., contain the following string at the beginning: “/// <reference path=‘path/to/jasmine.js’ />”).
    • Currently all of the project’s JS files will appear in the Test Runner. You can Ctrl+click to multi-select the test files you want to run, or you can right-click a file and add it to a new or existing Test Runner session, allowing you to easily run all tests in all files held by that session at once.
    • Test Debugging and Code Coverage are not yet implemented.


    More C# 7 and VB 15 Syntax Support

    The following features have gained new capabilities to more deeply support the latest language features, including:

    • Debug Visualizer now supports for the new switch language features.

    • Smart Duplicate Line now supports binary literals and digit separators.

    • Expand Method, Expand Property, Expand Getter and Expand Setter refactorings all now support the new language features.

    Other Improvements

    • Asynchronous extension loading, so CodeRush for Roslyn loads even faster.
    • Paste Replace Word (default shortcut is Ctrl+B) is now available in XAML markup.
    • Added support for directories and projects in the Jump To File window.
    • Implement IDisposable code provider implements the dispose pattern in your types.
    • Encapsulate Property wraps a field’s properties (declared by the field’s type) in new properties declared in the active class/struct.

    You can get the latest what’s new list and a list of corrected issues here.

    Give it a Try!

    We encourage you to download CodeRush for Roslyn and give it a try.

    As always, we thank you for your continued support and feedback. Let us know what we can do to make your coding experience even better.

  • CodeRush for Roslyn 16.2.7 is Available

    Today Team CodeRush completed another 45-day sprint, releasing version 16.2.7 of CodeRush for Roslyn. This shiny new version includes C# 7 support, new refactorings, and code declaration tools.

    C# 7 Syntax


    We have updated a number of features to support the new C# 7.0 language spec. The Expand\Compress Ternary refactorings, the Smart Return (‘r’ template), and our Declare providers have all been updated to exploit new language features.

    New Code Style Rules

    You can now choose one of three styles for placing new namespace reference imports/using declarations: place new imports/using references at the top of the file, place new imports/using statements inside the active namespace, or use fully qualified type names.


    New XAML Features

    XAML developers get two new refactorings: Convert Nested Element to Attribute and Convert Attribute to Nested Element. These refactorings move attribute from a XAML tag to become a child element (and vice versa, moving a child element up to become an attribute of the parent tag). These refactorings can improve XAML readability when there are excessive complicated attributes or when the nesting level gets excessively deep.


    Also, for the C# & VB code behind the XAML, we’ve added two new code providers to make it easier to declare properties in classes that implement the INotifyPropertyChanged interface (more details below).

    Refactorings and Code Providers

    In addition to the new C# 7.0 upgrades mentioned above, we have improved and broadened a number of existing code gen/mod features, including:

    • Use Expression Body now works on constructors, destructors, getters and setters.
    • Move Type to Namespace and Extract String to Resource are now more organized and easier to execute with the new Code Actions sub-menu.

    • Two new Code Providers, Introduce Change Notification and Convert to Property with Change Notification make implementing the INotifyPropertyChanged interface for the active property effortless.

    Consolidated Install

    To simplify the installation experience across multiple versions of Visual Studio, we now have a single CodeRush for Roslyn installer designed to install CodeRush to all supported IDE versions at once, available through the DevExpress Download Manager.


    Give CodeRush a Try

    You can get the latest version of CodeRush for Roslyn from the Visual Studio Marketplace.

    If you’re an existing customer, we thank you for your business. We are working hard to keep CodeRush fast & lean while we continue to ship powerful and intelligent features every 45 days.

    If you’re thinking about giving CodeRush a try, we encourage you to install CodeRush today. We expect you���ll find it a powerful addition to Visual Studio, and one that’s easy to use.

    As always, let us know what you think!

  • What’s New in CodeRush for Roslyn v.16.2.5

    Team CodeRush continues our 45-day sprint/release cycle, and we have some treats for you in this update.

    All-new Symbol Naming Assistant

    This is a brand new feature designed to help you quickly name new symbols (members, variables, and parameters).

    The Naming Assistant window automatically opens when you start typing a new symbol name. The suggestion list is filtered as you type, and you can use a subset of the letters in the symbol you want to filter quickly. For example, in the screencast below, typing “mb” filters the suggestions to only show “modelBuilder”.



    Code Metrics Are Back

    Code Metrics were a popular feature in CodeRush Classic, and we’re pleased to announce the feature has been ported to CodeRush for Roslyn.

    Code Metrics reveal the complexity of each member, using one of three popular metrics (Cyclomatic Complexity, Maintenance Complexity, or Line Count).

    You can enable the feature on the Editor\All Languages\Code Metrics options page:


    Once enabled, metrics will appear to the left of the member declaration:


    You can select a different metric with the mouse, by clicking the metric number and using the menu:



    The CodeRush Decompiler gets some improvements. Anonymous methods now appear inline, nullable types are listed with the “?” modifier (e.g., “int?” instead of “Nullable<int>”), and XML documentation comments now appear in decompiled code.


    The References Window now lets you jump quickly among references. When the window is open, press F8 to jump to the next item and press Shift+F8 to jump to the previous item. Also, you can now use the Jump To dialog to navigate through all currently open files.


    Two new refactorings:

    • Move Type to Namespace changes the namespace of the active type and updates all references.
    • Introduce Using Statement replaces object creation and dispose code blocks with a using statement, improving code readability and ensuring locally-used objects are properly disposed.

    Smart Duplicate Line

    Now, when duplicating items in collection initializers and in parameter lists, commas are added automatically if needed.

    New Visualizations

    Two improvements to make it easier to understand what’s happening in your code:

    • Region Painting, which implements a low-contrast visual representation of **#region** directives, reducing visual noise where regions are used:


    • Output Window Highlighting, where errors and warnings in the Output window can be emphasized with saturation, making it easier to recognize important messages faster.


    We also addressed a number of reported issues. As always, we welcome your feedback.

    You can download the latest version of CodeRush for Roslyn from the Visual Studio Marketplace. Give it a try and let us know what you think!

  • CodeRush for Roslyn, v. 16.2.3 is Available

    Continuing our 45-day sprint/release cycle, today we release another update to CodeRush for Roslyn. Highlights of this release include powerful new refactorings & code providers, along with enhancements to Smart Duplicate Line.

    New Refactorings and Code Providers

    • Convert to Function – Allows you to easily convert a method that returns void into a function that returns the appropriate type (matching the type of the expression returned). I find myself frequently using this refactoring because it's fast, smart, and I can invoke it from inside the method (with the caret on a return statement). There’s no need to reach for the mouse or move the caret up to the declaration. Here’s what it looks like:

    • Convert to Procedure – This code provider is the opposite of Convert to Function. It converts a method that returns a value of any type to a proc that returns void (or a Sub in VB).
    • Extract Interface – This refactoring creates an interface based on the public members of the active class, and modifies the active class so it implements the extracted interface. 
    • Widen Scope (promote to field) - Use this to move a local variable declaration from inside a method body out to become a private field of the parenting class.

    Smart Duplicate Line Gets Smarter

    In our last release, we introduced Smart Duplicate Line (Shift+Enter). This feature is a real time saver, allowing you to create new lines of code modeled on existing lines of code. Smart Duplicate Line (SDL) looks for patterns in the surrounding code, and attempts to predict the parts you’re likely to change. As a result, SDL is great for declaring constants, enum elements, properties, and POCOs.

    In this release, we make SDL even smarter.

    For starters, SDL now works in XAML:


    And SDL now recognizes (and increments) patterns of numeric primitives of type integer, double, decimal, octal, float, and hex:

    SDL - Enums Hex

    And SDL can cycle through enum elements in the code automatically:

    SDL - enum cycle

    SDL is one of my favorite new features. Be sure to try it out (Shift+Enter) and let us know what you think, and also send us your suggestions for how we can make it even smarter.

    Other Enhancements

    • Paste Replace Word – Replaces the identifier under caret with the one on the clipboard in a single keystroke. Press Ctrl+B when the caret is on an identifier to immediately replace it with the contents on the clipboard.
    • Navigation features now support XAML bindings.
    • We added submenu support to the Code Actions menu, offering contextually-related actions (e.g., contract actions, spelling suggestions, etc.) in a single submenu (thereby cleaning up the main Code Actions menu).

    • We have added the ability to collect a marker and immediately paste clipboard contents at the target location using a single keystroke (Shift+Esc).
    • We have added a menu item allowing you to clear all markers dropped in the document.
    • You can now group Code Issues and References by folder containing the source code file.


    We also addressed a number of reported issues. As always, we welcome your feedback.

    You can always download the latest version of CodeRush for Roslyn from the Visual Studio Marketplace. Give it a try and let us know what you think!

  • CodeRush for Roslyn, v. 16.1.9 is Available

    Today DevExpress releases version 16.1.9 of CodeRush for Roslyn. This update resolves a number of reported issues, and adds support for Visual Studio 2017 RC.

    As always, you can download the latest version from the Visual Studio Gallery. And let us know what you think.

  • CodeRush for Roslyn update, version 16.1.8

    The 16.1.8 CodeRush for Roslyn update contains important new productivity features for Visual Studio.

    Smart Duplicate Line

    This is a feature you’ll definitely want to play with. Smart Duplicate Line duplicates the active line, and inserts Text Fields into the duplication to make modification easier. The feature learns your preferences as you use it, so it gets smarter (and saves you more work) over time.

    To use Smart Duplicate Line, place the caret on any line and press Shift+Enter.

    Here are a few examples of Smart Duplicate Line:



    Decompose Parameter

    This is a refactoring we’ve had in CodeRush Classic, but we’ve just now ported it to CodeRush for Roslyn. This is a very powerful refactoring that allows you to easily change the types of the parameters passed into a method, which can make the method is more widely accessible, promoting reuse.

    For example, you might have a method that accepts a large high-level class called “Person”, but inside that method you only access the Age property of that person. Decompose Parameter can simplify that method so it only accepts a numeric Age parameter, and update all calling locations.

    Here’s another example. I have a method called GetDistance that accepts two System.Windows.Points, but that parameter type ties the method down to a particular platform. To make this code more flexible and encourage reuse, we can apply Decompose Parameter to both of those Points, turning those parameters into doubles, so this method can be called from any app running on any platform:



    XAML Features

    • XAML Code Formatting
    • Import All Types (declares all necessary namespace references needed by the XAML file)

    Refactorings, Code Providers, and Code Formatters

    • Break Apart or Line Up both Parameters and Arguments – either collapses a list of method parameters or passed-in arguments into a single line, or breaks them apart into separate lines (one for each parameter or argument).
    • Remove Type Qualifier – removes the explicit namespace definition from symbol usage and adds the corresponding namespace reference to the file's using/imports list. You can use it on a single identifier, on all identifiers in the current file, or as a code cleanup rule.
    • Decompose Parameter (discussed above and shown below)

    • Extract String to Resource – Adds a string literal to an existing RESX file (creating the new RESX if necessary), and replaces the string with the resource link. You can also optionally extract all string literals within a method or accessor.
    • Declare Parameter – Adds the selected identifier to the method signature and updates all usages.

    Unit Testing

    Code Coverage now supports .NET Core test cases.

    Give It a Try

    As always, thanks for your support.

    You can grab a shiny new install of CodeRush for Roslyn from the Visual Studio Gallery. CodeRush for Roslyn starts at US$49 for the community support edition. A CodeRush license entitles you to a never-expiring product with a full year’s worth of updates. Updates happen approximately every 45 days.

    If you already have CodeRush for Roslyn installed you can check the CodeRush About box for version – make sure it’s at least 16.1.8. If it’s lower, use Visual Studio’s Tools | Extensions and Updates dialog to get the latest updates.

    You can see our full What’s New release history here.

  • 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:

    CRR vs CRC

    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:

    CRR vs CRU

    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:


3 4 5 6 7 8 9 10

Chat is one of the many ways you can contact members of the DevExpress Team.
We are available Monday-Friday between 7:30am and 4:30pm Pacific Time.

If you need additional product information, write to us at or call us at +1 (818) 844-3383


DevExpress engineers feature-complete Presentation Controls, IDE Productivity Tools, Business Application Frameworks, and Reporting Systems for Visual Studio, Delphi, HTML5 or iOS & Android development. Whether using WPF, ASP.NET, WinForms, HTML5 or Windows 10, DevExpress tools help you build and deliver your best in the shortest time possible.

Copyright © 1998-2018 Developer Express Inc.
All trademarks or registered trademarks are property of their respective owners