Overview | Pricing & Licensing | Evals & Downloads | Compatibility | Publisher Details | Reviews | Support Forum | Summary

Our regular prices are shown below. Please logon to see your discounted prices.

Refactor! Pro for .NET v2011 vol 1 (V11.1.5)

Refactor! Pro for .NET and CodeRush for Visual Studio.NET v2011 vol 1 (V11.1.5)

Our prices include ComponentSource technical support and, for most downloadable products, an online backup and a FREE upgrade to the new version if it is released within 30 days of your purchase.  All sales are made on our standard Terms and Conditions and subject to our Return Policy. Please contact us if you require any licensing option not listed, including volume licensing and previous versions.

Our regular prices are shown above. Please logon to see your discounted prices.

What's new in Refactor! Pro v2011 vol 1? - The following new refactorings are now available:

• Convert to Point - Consolidates selected numeric parameters into a Point object.
• Convert to Tuple - Consolidates selected parameters into a Tuple object.
• Inline Method - Replaces method calls with that method's body. If you apply the refactoring to a method call, it replaces only that call. But, if you apply Inline Method to a method declaration, it replaces all calls to that method.
• Inline Method (and delete) - Replaces method calls with that method's body, and deletes the original method. If you apply the refactoring to a method declaration, it replaces all calls to that method. The refactoring is also available for a method call, if there are no more calls to that method.
• Use Named Arguments - Converts a method call with positional arguments into a named-argument call.

What's new in Refactor! Pro v2010 vol 2?

• New Refactorings - The following refactorings are now available:
• Convert to Constant - Converts the variable declaration into a constant declaration.
• Make Read-only - Makes the field read-only.
• Set Image Dimensions - Instantly sets the Width and Height attributes to an img tag, according to actual size of the source image.

What's new in Refactor! Pro v2010 vol 1?

• Full Support for Visual Studio 2010 and .NET Framework Client Profile

What’s new in Refactor! Pro v2009 vol 3?

• Unit Test Runner - The CodeRush Unit Test Runner executes your unit tests, navigates through tests, and facilitates test results processing.

What’s new in Refactor! Pro v2009 vol 2?

Faster Performance - A new symbol cache, built the first time you open a solution, improves the speed of subsequent solution parses dramatically. Now the speed to go from opening a solution to being able to refactor anywhere in that code base increases by 200%-500% for large solutions.

Additional performance enhancements

• First startup after install is now significantly faster - plug-in profile data now ships with the install and the plug-in profiling step is no longer part of the first startup. 
• Background parsing, if running, is now suppressed during a solution build. 
• Plug-in loader engine performance has been improved.
• The time to find all references has been reduced.
• Code issue checking time has been reduced.
• Incremental parser performance has been improved.
• Visual element painting time has been reduced.
• Availability checks for code providers are now executed in less time.

Reduced Memory Consumption - CodeRush 9.2 uses dramatically less memory. Project symbols are now cached, and only loaded when needed. Recently-accessed members are kept in memory, while stale members are aggressively released. As a result, customers with large solutions can expect reductions in overall memory consumption by 100MB-200MB.

Manual Load and Unload - Normally CodeRush loads on startup, and unloads when Visual Studio shuts down. CodeRush 9.2 adds the ability to defer loading to another time after startup, and also adds the ability to unload CodeRush while Visual Studio remains running. This may be useful for developers running into memory issues (e.g., very large solutions open in many instances of Visual Studio). You can defer the CodeRush startup time to a time of your choosing on the CodeRush Startup options page. Check the "Load manually" checkbox and restart. The next time Visual Studio starts, there will be a DevExpress menu item with a single entry, "Load". Selecting this entry will load CodeRush and any other third-party plug-ins that rely upon the DXCore.

Settings Merge on Upgrade – DexExpress introduce a new XML storage engine for CodeRush settings. This settings engine is backwards compatible - customer settings stored in the older INI files are merged with new settings stored in XML files (the INI files are not deleted). This engine will allow DevExpress to enhance default settings without losing customer changes.

Support for Preprocessor Directives - Conditional compiler directives are now supported.

Background Processing Progress Bar - CodeRush now shows progress for background parsing and symbol loading as you open a new solution. This progress bar is essentially your countdown to the moment when you can refactor instantly anywhere in the code. Note that you can work normally with Visual Studio before the background parse process ends. Closing this window does not break the background parsing process.

DXCore Version Switcher - The DXCore Version Switcher lets you switch among several versions of DevExpress IDE Tools installed side-by-side.

What’s new in Refactor! Pro v2009 vol 1?

User Experience Improvements - Added a document bar hinting feature. It allows for quick navigation to code issues and displays issue preview hints so that you can immediately highlight and fix issues. Version 2009 vol 1 also introduces several new actions used for keyboard interaction. The following new actions allow you to navigate though issues and manage them.

What’s new in Refactor! Pro V3.x?

Refactor! Pro 3.0 adds 27 new refactorings, including 15 dedicated to ASP.NET, 3 for XAML, and 9 for C#, VB, C++, and, as an early experience option, we've added refactoring support for JavaScript.

New source code refactorings in this 3.0 release:

• Consolidate Using Statements
• Convert to Auto-implemented Property (convert all)
• Convert to Built-in Type
• Convert to Create & Set
• Convert to Initializer
• Convert to IsNothing
• Convert to System Type
• Expand Lambda Expression
• Inline Alias

New XAML refactorings in this 3.0 release:

• Extract to XAML Resource
• Extract to XAML Resource (replace all)
• Replace with XAML Resource

New ASP.NET refactorings in this 3.0 release:

• Add AssociatedControlID Attribute
• Add RunAt Attribute
• Convert to Pixels
• Convert to Points
• Convert to Skin
• Extract Script
• Make Id Unique
• Merge Styles
• Move Style Attributes to External CSS
• Move Style Attributes to Theme
• Move Style Attributes to Theme (use SkinId)
• Reorder Attributes
• Set CssClass
• Split Style
• Toggle ViewState

What's new in Refactor! V2.5x?

• Convert to Auto-Implemented Property - Removes the backing store and converts a property to an auto-implemented property. (C# 3.0 only)
• Create Backing Store - Converts an auto-implemented property to a conventional property with a backing store. (C# 3.0 only)
• Extract String to Resource - Extracts the string at the caret into a resource file.
• Extract XML Literal to Resource - Extracts this embedded XML literal to a resource file. (VB 9.0 only)
• Inline Constant - Replaces a constant reference with its defined value, removing the constant declaration if there are no other references to it.
• Introduce Alias - Introduces a new file-scoped alias for the current type or namespace name and replaces it with the newly-created alias.
• Introduce Alias (replace all) - Introduces a new file-scoped alias for the current type or namespace and replaces all references to it in the current file with the newly-created alias.
• Introduce Constant (local) - Declares a new local constant, initialized to the value of the string or number at the caret.
• Make Explicit - Converts the implicitly-typed local variable to a variable with an explicit type. (C# 3.0 and VB 9.0 only)
• Make Explicit (and Name Anonymous Type) - Converts the implicitly-typed local variable to a variable with an explicit type, creates a named type to represent the expression on the right, and replaces the anonymous type with a newly-declared type. (C# 3.0 and VB 9.0 only)Other anonymous types in this project having the same shape will also be replaced by the new type.
• Make Implicit - Converts an explicitly-typed variable declaration to an implicit one. (C# 3.0 and VB 9.0 only)
• Remove Redundant Assignment - Removes redundant initialization of a variable.
• Rename Type to Match File - Renames the type to match the file name, updating references as necessary.
• Widen Scope (promote to constant) - Moves the local constant declaration out of the member and up to the type, replacing all matching values in the type with a reference to the constant.

What’s new in Refactor V2.2.x?

• Add Parameter - New refactoring: Adds a new parameter to a method declaration and updates all calls accordingly
• Add Validator - New refactoring: Adds one or more selected Validators to the active input control (the control containing the caret). [ASP .NET only]
• Boolean to Enum - New refactoring: Converts a Boolean type to an enumeration, updating client code if necessary
• Break Apart Parameters - New refactoring: Places each parameter on a separate line
• Create Method Stub - New refactoring: Generates a method for the selected call, with appropriate parameters and return result
• Extract ContentPlaceHolder - New refactoring: Moves the selected content from a .master page to a new .aspx file, placing it inside tags, and inserts a new tag at the extraction point inside the master page. [ASP .NET only]
• Extract ContentPlaceHolder (and create master page) - New refactoring: Moves the content that is outside of the selection (in the active .aspx page) to a new master page, inserting a tag to reference the extracted content, and then wraps the selection in the aspx page with tags and adds a MasterPageFile attribute to link to the new master page. [ASP .NET only]
• Extract Function (outside of class) - New refactoring: Moves selected code into a new function within the enclosing namespace. [C++ only]
• Extract Style (class) - New refactoring: Converts an inline style to a named class style. [ASP .NET only]
• Extract Style (id) - New refactoring: Converts an inline style to a named id style. [ASP .NET only]
• Move Method to Header - New refactoring: Moves a method from a source file into the class declaration (in the header file). [C++ only]
• Move Method to Source File - New refactoring: Move a method's implementation to a source file and create a declaration in the header file. [C++ only]
• Move Style Attributes to CSS - New refactoring: Moves styling attributes from the active control to a new CSS class and applies the class to the control. [ASP .NET only]

Simplify your .NET Code

• To perform an extract method, just select the block of code you want to extract, and press the Refactor Key
• To reorder parameters, place the cursor on the type of the parameter and press the Refactor Key
• To create a method overload, place the cursor at the start of the method declaration and press the Refactor Key
• To reverse a conditional or replace a nested conditional with a guard clause, place the cursor on the "if" keyword and press the Refactor Key

Refactor is one of the only code simplification and refactoring tools able to provide so much functionality with just one key.

Say Goodbye to Modal Speed Bumps
Developers need tools that help them concentrate on producing code. Complex modal user interfaces, code preview windows, and distracting popup dialogs slow you down. With Refactor, nothing gets between you and your code. All Refactor UI is grafted onto the surface of the editor. So if you need to reorder parameters to a method, you'll actually see the parameters move in the code.
Refactor is one of the only refactoring and code simplification tools to ship without any modal interface to slow you down.

Cut and Paste Refactoring
Much of refactoring is simply about moving code from one location to another. Refactor exploits the clipboard to allow you to initiate refactorings simply by cutting from one location and pasting at a target location. Let's say you need a new, small method derived from a chunk of a large, unwieldy method. These large complicated code blocks can be daunting to even highly-skilled coders but with Refactor you can simply cut out a chunk from the big method and paste it where you want the new method to appear.
Refactor is one of the only refactoring and code simplification tools to use cut and paste as an entry point to refactoring.

Refactoring Smart Tags
While you work, Refactor analyzes the code, looking for opportunities to simplify. When a refactoring is available, you'll see a refactoring smart tag appear below the identifier at the caret or near the selected code block. Just click the smart tag to see which refactorings are available.

Multiple Language Support
Refactor is designed to be completely language neutral, just like Visual Studio .NET. While refactor currently supports Visual Basic and C#, the remarkable thing is that the refactorings are all coming from a single code base. There is no language-specific C# or VB code in the product. That means when the CodeRush Core Engine gains support for a new programming language, Refactor will too.
Refactor! is one of the only refactoring and code simplification tools that supports both Visual Basic and C#

Extensibility
Refactor! was built upon the DXCore for Visual Studio .NET extensibility framework, and exposes additional interface that developers can easily exploit to create their own custom refactorings and code simplification tools. Note: CodeRush is not required to be able to use Refactor!
Refactor is one of the only refactoring and code simplification tools with built in extensibility