Refactor! Pro

Simplify and Restructure Your Code
Making it Easier to Read and Less Costly to Maintain

Refactor! Pro by DevExpress fuses a language-independent state-of-the-art code shaping engine with a revolutionary and highly-optimized user experience. Unlike other refactoring solutions that target the system architect, Refactor! Pro is designed to help all developers craft and sculpt their code with the speed and efficiency needed to meet their line of business demands.

What is Refactoring?

Refactoring describes the process of making many small changes to working code, improving the internal structure without altering the external behavior of that code.

As an analogy, consider the math statement 2*4*5*3*1, you can covert this to 1*2*3*4*5 without changing its meaning and from there into 5!. They all mean the same thing but are increasingly easier to read. Refactor! does the same thing but with working source code.

There was a time not too long ago when just for fun developers would actually engage in obfuscated code competitions to produce the most difficult to read code. Well unfortunately there is a lot of code out there that is not much more readable than that intentionally obfuscated code - which is where refactoring comes in. The goal of refactoring is to take working code that is harder to read than it needs to be, and tweak its structure to make it more readable and more easily maintained.

.NET languages have been designed to self-document and encourage the development of readable, maintainable code - but even these languages code can grow organically over time and become cluttered and overly complex. Refactor! Pro has numerous industry-first features that can help you take this complex code and make it easier to read and less costly to maintain.

Why Refactor! Pro

Refactor! Pro does something no other tool can claim to do: it brings the power of an entire suite of refactoring tools to bear with just one key ("One Key Refactoring") and it works directly on your code in your editor - so you'll never have to leave your code just to restructure it.

One Key Refactoring - Refactor! Pro by DevExpress

Figure 1. One Key Refactoring - press CTRL+~ at any point to see all available refactorings with a short description of each.

Refactor! is built upon a language neutral architecture that offers exactly the same functionality for Visual Basic .NET, C#, C++ and ASP.NET developers. Refactor! even includes extensibility features to allow developers to easily build language-independent refactorings that can be used internally or shared with a growing community of highly satisfied Refactor! Pro customers.

Before we describe to you just a few of the over 190 refactorings available within the product, let us assure you that everything you can do with Refactor! can be rolled back using the standard Visual Studio Undo/Redo mechanism. So you really have the freedom to explore with this tool - simply hit CTRL+Z (or whatever key Undo is bound to) if the refactoring is not what you expected.

Refactoring: Reorder Parameters

Change the order of parameters in a Method signature, while also updating all calls to this method. Great when you need to change the parameter declaration order so that the most important parameters appear first, which will improve the usability of the method.

"Reorder Parameters" is probably the best example of how Refactor! is different, because the entire process is extremely visual and happens right there in your code. Here is how you reorder your parameters. Simply move the text cursor into the declaration of a method with parameters and this refactoring will be available. You can see that it is available if you stay there for a moment, because the refactoring smart tag will show up with a list of all the refactorings available. But you don't need to wait for anything - just hit the "One Key Refactoring" key (CTRL+~) and now you can move all your parameters left and right simply using the left and right cursor keys.

Reorder Parameters is a cascading refactoring. It changes the method signature across a class hierarchy with virtual/overridden members, or among interface implementers. For more information see the cascading refactorings description below.

The Reorder Parameter Refactoring - Refactor! Pro by DevExpress

Figure 2. Reordering parameters directly upon code in the Editor - no modal dialogs to slow you down.

Refactoring: Rename

This refactoring renames a local variable, function, method, field, property, parameter, type, namespace, active CSS style, XAML namespace prefix, C++ global variable, or C++ macro and updates all references to the modified element.

Choosing meaningful identifier names is one of the simplest ways to improve the readability of your code - Refactor! makes this process trivial. You simply put the text cursor into the identifier, and hit the "One key refactoring" key (CTRL+~), and start changing your identifier. You will see all references to your identifier highlighted with a light green box. You can now cycle through each call using the TAB and SHIFT+TAB keys, and if you change any one - the others all reflect the change.

Refactoring: Extract Method

The most sophisticated of all class based refactorings is probably "Extract Method". This refactoring allows you to select a piece of code from inside a method and extract it outside into a method of its own - while leaving a call to that new method in the code the method came from.

You are probably already several steps ahead of us in how to activate this refactoring by now; You simply select some code, put the text cursor in the code, hit the "One Key Refactoring" key (CTRL+~), and now you have a new method containing your block of code, with a call where that code came from.

Consider this example code which calculates the volume of a cylinder. Suppose we decide to extract the code that calculates the area of a circle to a method of its own, for later reuse. To do this all we do is select the specific block of code and hit the "One key Refactoring" (CTRL+~), the code is cut from the source method, and we are prompted for a location for the target method.

Target Picker - Refactor! Pro by DevExpress

Figure 6. You can place the extracted method precisely using the red Target Picker.

Once we have chosen the location for the new method, Refactor! calculates how many parameters need to be passed, creates some default names for the new method and any parameters, generates the code for the new method and calls it, and finally invokes the "Rename" refactoring in case we wish to override any of the default names chosen.

Figure 7. The fully extracted method - Refactor has determined parameters to pass and even come up with a meaningful name.

You know there is actually an even faster way to extract. Select the code - Cut the code - Paste it outside the Method but inside the class and Refactor! will extract the method for you automatically.

Notice that the method name and the call are both linked with green boxes - the "Extract Method" has automatically invoked the "Rename" refactoring for you. Also if there are any variables referenced outside as well as inside the block you selected, then Refactor! will automatically give your new method the appropriate parameters to pass in that data and if needed pass it back.

Refactoring: Cascading Refactorings

Some refactorings relate to cascading refactorigs. They apply member signature changes across a class hierarchy with virtual/overridden members, or among interface implementers. Cascading refactorings can also be automatically applied throughout a combination of interface implementers and class hierarchies tied together by a class that both belongs to the hierarchy and implements an interface, when the member being refactored is virtual/overridden in the class hierarchy and also declared in the interface. Availability for these cascading refactorings includes all member references (e.g., method calls and property references) in addition to the member’s declaration. For example, you can add a parameter to a method when the caret is on a method call instead of having to go to the method declaration.

Cascading Refactorings - CodeRush by DevExpress

Figure 8. Cascading Refactorings - affect all related members across a class hierarchy with virtual/overridden members, or among interface implementers.

Supported Refactorings
Add AssociatedControlID AttributeAdd Block DelimitersAdd Contract
Add End TagAdd ParameterAdd RunAt Attribute
Add ValidatorAdd to InterfaceBoolean to Enum
Break Apart ArgumentsBreak Apart AttributesBreak Apart Parameters
Case to ConditionalChange TagCollapse Accessors
Collapse GetterCollapse SetterCombine Conditionals (nested)
Combine Conditionals (parallel)Compress AssignmentCompress to Lambda Expression
Compress to Null Coalescing OperationCompress to Ternary ExpressionConcatenate Strings
Conditional to CaseConsolidate Conditional BlocksConsolidate Using Statements
Convert Color to HEXConvert Color to Named ColorConvert Color to RGB
Convert to Auto-implemented PropertyConvert to Auto-implemented Property (convert all)Convert to Built-in Type
Convert to ConstantConvert to InitializerConvert to Is Nothing
Convert to ParallelConvert to PixelsConvert to Point
Convert to PointsConvert to SizeConvert to Skin
Convert to System TypeConvert to TupleCreate Backing Store
Create Case Blocks from EnumCreate Multi-variable DeclarationCreate Overload
Create Setter MethodCreate With StatementDecompose Initializer
Decompose ParameterEncapsulate DowncastEncapsulate Event
Encapsulate FieldEncapsulate Field (read-only)Encapsulate Method
Encapsulate PropertyExecute Statements in ParallelExecute Statements in Serial
Expand AccessorsExpand AssignmentExpand Getter
Expand Null Coalescing OperationExpand SetterExpand Ternary Expression
Expand Lambda ExpressionExtract ContentPlaceHolderExtract ContentPlaceHolder (and create master page)
Extract Function (outside of class)Extract InterfaceExtract Method
Extract Method to TypeExtract PropertyExtract Script
Extract String to ResourceExtract String to Resource (replace all)Extract Style (Class)
Extract Style (id)Extract to XAML ResourceExtract to XAML Resource (replace all)
Extract to XAML TemplateExtract UserControlExtract XML Literal to Resource
Flatten ConditionalFor to ForEachForEach to For
Initialize ConditionallyInline AliasInline Constant
Inline DelegateInline Format ItemInline Macro
Inline MethodInline Method (and delete)Inline Recent Assignment
Inline ResultInline TempInline With Statement
Introduce AliasIntroduce Alias (replace all)Introduce Constant
Introduce Constant (local)Introduce ForEach ActionIntroduce Format Item
Introduce LocalIntroduce Local (replace all)Introduce Parameter Object
Introduce Result VariableIntroduce Setter Guard ClauseIntroduce Using Statement
Line-up ArgumentsLine-up AttributesLine-up Parameters
Lock to Try/FinallyMake ExplicitMake Explicit (and Name Anonymous Type)
Make ExtensionMake ID UniqueMake Implicit
Make Member Non-staticMake Member StaticMake Read-only
Merge StylesMethod to PropertyMove Declaration Near Reference
Move Initialization to DeclarationMove Method to HeaderMove Method to Source File
Move Style Attributes to CSSMove Style Attributes to External CSSMove Style Attributes to Theme
Move Style Attributes to Theme (use SkinID)Move to Code-behindMove Type to File
Move Type to NamespaceName Anonymous MethodName Anonymous Type
Optimize Namespace ReferencesPromote to ParameterProperty to Method
Pull Member UpReduce VisibilityRemove Assignments to Parameter
Remove AttributeRemove Block DelimitersRemove Empty Handler
Remove End TagRemove ParameterRemove Private Setter
Remove Redundant CallRemove Redundant ConditionalRemove Redundant Constructor
Remove Redundant Delegate CreationRemove Redundant DestructorRemove Redundant Qualifier
Remove Redundant Type SpecificationRemove Setter Guard ClauseRemove Tag
Remove Type QualifierRemove Type Qualifier (replace all)Rename
Rename File to Match TypeRename Type to Match FileReorder Attributes
Reorder ParametersReplace Temp with QueryReplace with Alias
Replace with ConstantReplace with LocalReplace with XAML Resource
Reverse BooleanReverse ConditionalSafe Rename
Set CssClassSet Image DimensionsSimplify Expression
Sort Namespace ReferencesSplit ConditionalSplit Conditional (and duplicate else block)
Split Initialization from DeclarationSplit Multi-variable DeclarationSplit String
Split StyleSplit Temporary VariableSplit Using Statement
Split With StatementSurround with TagSurround with Update Panel
Toggle ViewStateUse Environment.NewLineUse Equality Operator
Use Explicit Notation Use IsNullOrEmptyUse IsNullOrEmpty
Use Named ArgumentsUse Short NotationUse String.Compare
Use String.FormatUse StringBuilderUse Const
Use typedefUsing to Try/FinallyWiden Scope
Widen Scope (promote constant)Widen Scope (promote to field)

Refactor! Pro offers Visual Studio .NET developers a suite of integrated tools to help simplify code and make it infinitely easier to maintain - Tools that are surfaced on your code in the editor, for immediate access rather than the traditional solution of modal dialogs that simply slow you down and take you away from your code. Refactor! Pro is the only tool that makes refactorings readily accessible without unwanted speed-bumps, reducing the risk and cost associated with improving the structure and maintainability of your code.


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, along with high-performance HTML JS Mobile Frameworks for developers targeting iOS, Android and Windows Phone. Whether using WPF, Silverlight, ASP.NET, WinForms, HTML5 or Windows 8, DevExpress tools help you build and deliver your best in the shortest time possible.

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