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

    SmartDuplicateLine

     

    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:

    DecomposeParameter

     

    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)

      DecomposeParameter
    • 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.

    ReorderParametersCallingSite

     

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

    SpaceExpand

     

    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:

    ShowArrayContents

     

    2. Color swatch preview at debug time:

    ShowColorSwatches

     

    3. Font preview at debug time:

    ShowFontFamily

     

    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.

    Pricing

    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.

    Navigation

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

    JumpToEverything

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

      VectorMemborIcons

    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:

    Shortcuts

  • 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
      {
        a,
        e,
        i,
        o,
        u
      }

    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:

    KeyPressedChart3

     

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

    02-Aug-2016
    1:00 PM
    Your time zone: GMT -4
    Other time zones
  • CodeRush for Roslyn (Preview), version 16.1.5

    We’re releasing this preview of CodeRush for Roslyn (CRR) a few weeks early, because we want to get feedback on a new configuration feature before we release. It’s the CodeRush Setup Wizard, and it’s available when you first start CodeRush.

    The Setup wizard guides you through important CodeRush configuration choices, and looks like this:

    SetupWizardNumKeys

    Each page has a Learn More link, which takes you to a video talking about the options on that page of the setup wizard.

    Running the setup wizard is optional, however we highly recommend it, even for experienced CodeRush developers, especially if you’re interested in optimizing your coding efficiency (e.g., getting more code with fewer keystrokes).

    You can bring up the Setup Wizard from the CodeRush menu.

    The CodeRush for Roslyn preview is available on the Visual Studio Gallery. Try it and let us know what you think.

  • CodeRush for Roslyn (Preview), version 16.1.4

    First, a quick update on where we are and how we got here: About a year ago I announced that the CodeRush team had been working on a new project, CodeRush for Roslyn. A new version of CodeRush that relied upon the Roslyn engine instead of our own parser. The architectural shift yielded two primary benefits:

    • Significantly Faster Performance:

      SolutionOpenTimes_5B02F3E5[1]

    • Significantly Lower Memory Use:

      MemoryUse_44DB2064[1]

    And developers are reporting similar results on twitter:

    SolutionOpenTimesCensored

    In the last year we’ve ported hundreds of features from CodeRush Classic, maintaining our focus and priority on faster performance and low memory use. During this time CodeRush for Roslyn (Preview) has been available as a free download from the Visual Studio Gallery, and we received valuable feedback from our customers. Thank you for that.

    In this release, version 16.1.4, we get a step closer to the first official release. In July we expect to make one more preview available, and shortly after that we expect to ship.

    Here are the new features in 16.1.4 (Preview):

    Target Picker

    Now you can quickly select the target location for new methods, events, properties, fields, and constants. Just press the up and down arrows to move the target picker up and down, and press Enter to declare at the specified location.

    TargetPicker

    Reference Filtering

    The Reference window now lets you optionally filter results by usage - Read, Write, or Instantiation:

    ReferenceFiltering

    Jump to Implementation

    Now you can jump to the implementation of ancestor overrides and implemented interfaces, available through the “Implemented API” option in the Jump To menu:

    JumpToImplementedAPI

    XAML Enhancements

    • The Optimize Namespace References refactoring is now available for XAML namespaces:

      Optimize
    • Templates for XAML are now shipping:

       XamlTemplates

    New Refactorings and Code Providers

    • Add Missing Constructors – Adds the default constructor and all constructors specified by parent types to the current class.
    • Add to Interface – Adds a member to an interface that is already implemented by the current class.
    • Declare Field/Property with Initializer – Generates a field of the appropriate type for the selected parameter.
    • Introduce Format Item – Creates a new String.Format item from a selected string part.
    • Move Declaration Near Reference – Moves a local variable declaration to the line of code that is closest to its first usage.
    • Move Initialization to Declaration – Combines separate variable declaration and initialization statements into a single statement.
    • Split Initialization From Declaration – Separates a single-statement variable declaration and initialization into two separate declaration and initialization statements. This refactoring is useful for conditional initialization, or when you want to widen the scope of the declaration.

    Other Improvements

    • The Code Issues window can now show Visual Studio code analysis results instantly without refreshing the list.
    • The Spell Checker now reports misspelled words in the Code Issues window.
    • You can now export your Roslyn settings and import settings from CodeRush Classic using the CodeRush | Support | Import and Export Settings… command.

    Try it Yourself

    Give CodeRush for Roslyn (Preview) a try. The preview edition is free. Let us know what you think, and what we can do to make the experience better.

  • CodeRush for Roslyn 1.0.11 (preview) is Available

    As we’re in the final stretch for the first official CodeRush for Roslyn release, today we offer what may be our final pre-release for you to test-drive. Here’s what’s new and improved in this version:

    Code Analysis

    In this version we introduce code analysis through the Code Issues window, showing potential logic errors and code smells found in the code. Just open your solution, bring up the Code Issues window, and click Refresh to analyze your code.

    CodeIssues

    Code Style

    Code Style gets an update with new options for:

    • Implicit/explicit declaration of local variables
    • Visibility modifiers (always specify or remove if possible)
    • Prefer CLR type name or language-specific keywords (e.g., int, string, bool)
    • Use this/me qualifier for members

    Styles are applied automatically when executing refactorings or expanding CodeRush templates. We have also linked the following code cleanup providers to the code style rules:

    • Apply variable declaration style
    • Apply built-in type style
    • Apply ‘this’ qualifier style
    • Apply visibility style

    And we’ve added new naming conventions for newly-declared identifiers.

    XAML Navigation

    Two new XAML navigation providers:

    • Go to Source – Opens the resource dictionary for the active reference when you press F12.
    • Find Usages – Helps you quickly navigate to a particular resource reference.

    JumpToXamlReference

    JumpToXamlLocations 

    Settings Import/Export

    In this version you can import/export your CodeRush for Roslyn settings.

    Test Sessions

    The Test Runner now supports multiple test sessions:

    Test Sessions

    This is a convenient way to group collections of related tests and run them independently. Just right-click on one of the test or fixture icons in the tree list and choose “Add to session”.

     

    Standalone Decompiler

    The Decompiler is now its own standalone executable, which means you can use the Decompiler outside of Visual Studio. The executable is located in the "Decompiler" folder inside the CodeRush for Roslyn Extension folder (which typically has a uniquely generated folder name). To find this folder quickly, from Visual Studio use the CodeRush | Support | Extension Folder... menu item.

    Decompiler

    Navigation

    Symbol and File navigation windows are more responsive. When they appear start typing for what you are looking for and they’ll populate with entries matching your filter.

    The navigation windows also include a few minor visual tweaks to improve clarity.

    CollectingItems

    Refactorings and Code Providers

    We have added the following refactorings and code providers:

    • Convert to Constant – convers a variable or field into a constant.
    • Create Backing Store – converts an auto-implemented property to a property that encapsulates a private field (the field backing store is created automatically).

    Organize Members now allows you to configure the amount of line breaks between groups and between members. In this release it is also possible to configure Organize Members so that it removes existing line breaks.

    Debug Visualizer

    The Expression Map has been ported from CodeRush Classic:

     ExpressionTree
    Also, strings containing long file paths are now trimmed so that the beginning and end of the path are always visible.

    IntelliRush

    • Argument insertion can now be disabled for method calls created by IntelliRush.
    • Optional parameters are no longer inserted into method calls.
    • Constructor overloads are now listed in the IntelliRush overloads menu:

    ConstructorOverloads

    Smart Semi-colon

    It’s finally here. The feature that gives C# developers the smallest gain, hundreds of times a day. With this C# feature enabled, CodeRush for Roslyn automatically places a semi-colon at the end of the expression when a semi-colon is manually typed inside an expression.

    Other Improvements

    • Code view sections in both the Decompiler and Code Coverage windows include line numbers.
    • Selection Embedding is now available from the “light bulb” menu, which can be invoked using the Ctrl+~ or Ctrl+. hotkeys.
    • The languages supported by Code Templates and Selection Embeddings has been extended. You can now define custom code templates and embeddings for XAML, XML, HTML, JavaScript, CSS and F# languages.
    • The CodeRush menu gains the following items:
      • Support
        • CodeRush Logs (used to quickly open the logs folder in Windows Explorer)
        • Extension Folder (used to quickly open the root extension folder in Windows Explorer)
      • Shortcuts (opens the shortcuts options page)
      • Code Templates (opens the code templates options page)

    Give it a Try

    Download the latest CodeRush for Roslyn preview from the Visual Studio Gallery. Try it out and let us know what you think.

1
2 3 4 5 6 7 8 9 10
LIVE CHAT

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 info@devexpress.com or call us at +1 (818) 844-3383

FOLLOW US

DevExpress engineers feature-complete Presentation Controls, IDE Productivity Tools, Business Application Frameworks, and Reporting Systems for Visual Studio, along with high-performance HTML JS Mobile Frameworks for developers targeting iOS, Android and Windows Phone. 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-2016 Developer Express Inc.
All trademarks or registered trademarks are property of their respective owners