Mark Miller

CodeRush Xpress for C# and Visual Basic inside Visual Studio 2008

Download CodeRush Xpress - free from Dev Express!

CodeRush Xpress is a powerful developer productivity tool from Dev Express. The product is free, licensed by Microsoft on behalf of all developers working in Visual Studio 2008 in all paid-for product skus (e.g., Standard, Professional, Team System). Note however that CodeRush Xpress will not load in the Express Editions of Visual Studio.

CodeRush Xpress includes features that support common developer tasks in the following areas:

FeatureSummary

CodeRush Xpress fully supports all language features of Visual Basic and C# in Visual Studio 2008. If a specific feature applies to only one of these two languages, it will be noted with one of these icons:

VB     C#  

More details on CodeRush Xpress functionality follow.

NavigateFeatures

Navigate

CodeRush Xpress includes seven powerful navigation features to make getting to that important location fast and easy.

Camel Case Navigation

You can move among the lowercase-to-uppercase transitions using Camel Case Nav.

To move right, hold down the Alt key and press the Right arrow key inside a camel case identifier.

CamelCaseRight

To move left, hold down the Alt key and press the Left arrow key inside a camel case identifier.

CamelCaseLeft

Camel Case Nav is useful when you want to rename an identifier and change the name in a manner that keeps a portion of the existing camel case identifier. For example, if an existing identifier was called "StartTasks" and you wanted to rename it to "StartFilteredTasks", you could use Camel Case Nav to instantly get the caret between the "Start" and "Tasks" parts before typing in the new part.

Collect Marker

Whenever a CodeRush Xpress feature takes you to a new place in the code, CodeRush Xpress drops a stack-based marker at the original location. You can return to the original location (collecting the marker and popping it off the stack) by pressing Escape (when no other tool tip windows or context menus are active).

CollectingMarkers

When you press Escape, CodeRush Xpress animates a small locator beacon around the marker. This locator beacon is useful when your eyes are looking elsewhere on the screen, especially if you work with a large monitor. CodeRush Xpress also attempts to shift the code vertically so its position is roughly equivalent to what it was when you last viewed it.

Structural Highlighting

Structural Highlighting helps you visually navigate the structure of the code. Matching delimiters are connected with low-contrast lines that are easy to read when this information is useful, and easy to ignore when your mind is on the code.

Structural Highlighting

Structural Highlighting is useful for understanding the flow of large methods or third-party C# code using a different leading brace position than you might otherwise work with.

Tab to Next Reference

You can quickly jump to the active identifier's next reference in the solution file by pressing the Tab key (as long as the caret is somewhere inside the identifier). All matching references (and declaration) to this identifier will be underlined and the selection will move to the next reference. Continuing to press the Tab key will cycle through all identifiers in the solution. Shift+Tab brings you back. You can also press Escape to return to the starting location (where the Tab to Next Reference feature was first invoked on this identifier).

TabToNextReference

Tab to Next Reference is useful when you want to quickly visit all references to a particular identifier or type.

Highlight All References

Highlight All References is visually similar to Tab to Next Reference, however it does not move the caret. Just press Ctrl+Alt+U to see all references to the active identifier.

HighlightAllReferences

Quick Navigation

Quickly find a type, member, class, field or variable using Quick Nav. Just press Ctrl+Shift+Q to bring up the Quick Navigation window.

You can filter the list by entering a portion of the identifier text you are looking for. If you hold down the Shift key and enter uppercase letters, you can find all identifiers named with those uppercase letters, as in the example below:

Quick Navigation - Smart Filtering

You can preview the target location by holding down the Ctrl key. To jump to the selected symbol, press Enter. To return to the starting location, press Escape.

Quick File Navigation

Quickly find and open any file in your solution. Just press Ctrl+Alt+F to bring up the Quick File Navigation window. The filtering mechanism in this window is similar to what we've just seen in the Quick Navigation window. Just enter a few letters from the file name. CodeRush Xpress will filter down the list. Use the Up and Down arrow keys to select the file you want to jump to, and press Enter to go there (or Escape to close the Quick File Navigation window and return to where you were).

QuickFileNavigation

SelectFeatures

Select

CodeRush Xpress includes five intelligent features for selecting code more efficiently.

Camel Case Select

If you need to select one or more words from inside a camel-case identifier, just use the Shift key along with the Camel Case Nav keys.

For example, to select from the caret to the start of the camel case part to the left, use Alt+Shift+Left.

CamelCaseSelect

Selection Increase

First, there is a command to increase the selection by logical blocks. For example, if the caret is inside an expression, you can quickly expand the selection so it entirely holds the expression. Being able to quickly define a selection around a logical block is useful for refactoring. You can also use it to quickly select code you want to move to another location. This command is bound to a shortcut: Alt+Shift+=.

Selection Reduce

If you accidentally overshoot the block you want to select, you can reduce the selection by logical blocks using Alt+Shift+-.

Intelligent Cut, Intelligent Copy, and Paste Replace

If you need to cut or copy an identifier to the clipboard, there's no need to select it with CodeRush Xpress. Just place the caret on the identifier and press the cut or copy key (e.g., Ctrl+X, Shift+Delete, Ctrl+C, or Ctrl+Insert). CodeRush Xpress will select the identifier before the cut or copy operation.

Once you have an identifier on the clipboard, you can move the caret to a different identifier and replace it with the one on the clipboard using Ctrl+B. This Paste Replace command will select the identifier at the caret before pasting in the contents of the clipboard.

If you need to cut or copy a larger structure, such as a for loop, a try/finally block, a member or a class, just place the caret at the start of the block you want to copy and press the cut or copy key. CodeRush Xpress will select the entire block before cutting or copying the block to the clipboard.

DeclareFeatures

Declare

CodeRush Xpress includes powerful features to intelligently declare classes, members, fields, local variables and so much more.

Consume-first Declaration

The consume-first declaration features of CodeRush Xpress are a quick way to generate the code you need. It starts with a call or a reference to something that doesn't exist yet (the consumption code). Just move the caret to the reference that needs to be declared and press the CodeRush key (Ctrl+` by default). CodeRush Xpress will do the rest, declaring the missing member, type, enum, or variable.

Consume-first declaration is useful because it gets you thinking in terms of developers who would consume the code you write. This can improve the quality of the code and make it easier for developers to work with your code. Consume-first declaration is also almost always an essential component of Test Driven Development (TDD).

However one of the most significant benefits of consume-first declaration is the efficiency gain -- you can quickly craft the code you need significantly faster than doing the same by hand.

To illustrate, let's look at a practical example. Often developers will use Intellisense to discover the return type of an unfamiliar method call or property, by entering that expression right inside the code, like this:

UsingIntellisenseToGetReturnType

Typically what happens next is the developer's eyes move to the front of the tool tip and note the type (circled in red above). Then the developer accepts the suggestion and moves the caret to the beginning of the line to enter a variable declaration of the correct type (e.g., a variable of type "Module[]" in this example).

Overall there's a great deal of caret movement and typing involved just to declare a variable. To save a little time, some developers avoid specifying the type to implicitly declare variables (using the var keyword in C#, for example), thus avoiding the discovery and text entry costs associated with explicit declaration.

Fortunately, CodeRush Xpress makes it easy to explicitly declare variables in a way that exploits the power of Visual Studio's Intellisense and is likely to be highly compatible with how you already work:

  1. Create the expression fragment on an empty line using Intellisense or simply typing the expression by hand.

    TypeExpression 

    CSharpSmall If you're working in C#, there is no need to end the expression with a semi-colon.
  2. With the caret at the end of the line, press the CodeRush key (Ctrl+`) and select "Declare Local" from the menu. CodeRush Xpress will generate the local variable declaration and select the variable so you can give it a meaningful name:

    DeclaredLocal 

So the steps behind exploiting consume-first features are:

  1. Write the call or reference to the member, type or variable that doesn't exist, OR enter an expression on an empty line (as in the example above).
  2. Place the caret on the part that doesn't exist.
  3. Press the CodeRush key (Ctrl+`). If a menu appears select the item you want to declare. For methods and properties, you may also see a horizontal red line appear (called the Target Picker) that allows you to select the insertion point for that member. Just use the up and down arrow keys to select the ideal location and press Enter to insert the declaration.
  4. Sometimes CodeRush Xpress will shift the view or take you to another file, to show you the code just inserted. This allows you to rename or edit the newly-declared code. When you're satisfied with the declaration you can press Escape to collect the marker and return to where you started.

More details on specific consume-first declaration features follow:

Declaring Members

Want to add a member to a type? Just write the code as you would like it to appear. If it's a method, pass in the parameters you need (tip: if you're passing in parameters that are undeclared, declare those first before declaring the method). Place the caret on the member and press the CodeRush key.

Here are the consume-first member declarations you get with CodeRush Xpress:

  • Declare Constructor
  • Declare Method
  • Declare Property
  • Declare Property (auto-implemented)
  • Declare Property (with backing field)
  • Declare Getter
  • Declare Setter
  • Declare Event Handler

Declaring Types

To declare a new type, add a reference to it. Usually when you want a new type, you also want a constructor for it. So it's usually most efficient to enter the constructor call like on an empty line:

NewTypeExpression

At this point you can press the CodeRush key (Ctrl+`) to declare a new local variable as we've seen before. You can also place the caret on the "FileLogger" text and press the CodeRush key to declare a class or struct.

Here are the consume-first type declarations you get with CodeRush Xpress:

  • Declare Class
  • Declare Delegate
  • Declare Enum
  • Declare Enum Element
  • Declare Interface
  • Declare Struct

Declaring Variables

As we've already seen, declaring variables to represent an expression on a line is easy. Another way to declare variables is to simply place the caret on a reference to the variable name in an assignment, as in the "_StartTime" text in the assignment below:

FieldDeclaration

Press the CodeRush key (Ctrl+`) and select the declaration you'd like. A preview hint will let you see the changes to the code before you commit.

DeclareStartTime

Here are the consume-first variable declarations you get with CodeRush Xpress:

  • Declare Field
  • Declare Local
  • Declare Local (implicit)

Create Method Contract

Often inside methods, before you work with the parameters, you need to verify that those parameters are valid. Developers typically select one of three mechanisms to ensure the data coming in is correct:

  • Throw an exception
  • Call Debug.AssertXxxx()
  • Exit the method

Regardless of which one of these you prefer, CodeRush Xpress makes it easy to build this contract code. Just move the caret to the start of the method, like this:

 CreateMethodContract1

Then press the CodeRush key (Ctrl+`). The Create Method Contract menu will appear, allowing you to select the ideal mechanism for validating any parameters that are without validation code.

CreateMethodContract2

The preview hint shows you exactly what you're going to get. Create Method Contract makes the process of ensuring parameters are valid fast and easy.

Duplicate Line

Duplicate line lets you create a new line of code based on an existing line of code. You can duplicate variable declarations, constants, and method calls. The shortcut is Shift+Enter. For example, if the caret is on a declaration like this in C#:

DuplicateLine1

Pressing Shift+Enter will create a duplicate declaration that looks like this:

DuplicateLine2 

Now it's simply a matter of typing in the new field name. Note that the Camel Case features , shown above, may be useful here if you want to change only a portion of the name (for example, changing _StartTime to _EndTime would be easy with Camel Case Nav and Camel Case Select).

RefactorFeatures   

Refactor

Refactoring is a powerful way to improve the quality and flexibility of your code, without changing program behavior. Well-refactored code costs less to maintain, is easier to extend, and is a more valuable asset than code that is allowed to accumulate technical debt (also referred to as design debt).

CodeRush Xpress includes over 50 refactorings, and nearly all work in both C# and Visual Basic. A few refactorings are available in only a single language due to features of that particular language.

VBSmall  For example, Inline With Statement and Create With Statement are both available in Visual Basic.

CSharpSmall Similarly, refactorings to Add Block Delimiters and Remove Block Delimiters are only available in C#.

In some cases CodeRush Xpress provides wrappers for existing refactorings in either language. These wrappers ensure a more complete experience, making all refactorings contextually available in one location, accessed from a single keystroke (Ctrl+`). In many cases wrappers will also implement a preview hint, so you can see the impact of the changes before you commit. Wrappers are indicated in the refactoring menu with a Visual Studio icon, as in the Rename and Reorder Parameters refactorings appearing in the refactoring menu below:

  Wrappers

In this section you'll find descriptions for all refactorings shipping inside CodeRush Xpress, arranged in the following categories:

Changing Signatures
Conditionals
Declaration & Initialization
Expressions
Interfaces
Lambda Expressions & Anonymous Methods
Loops & Blocks
Properties & Fields
Moving/Extracting Methods
Resource Files & Strings
Types
Visibility

Consult the Visual Studio help after installing CodeRush Xpress for additional details and example code in both C# and Visual Basic demonstrating these refactorings in action.

Changing Signatures

Add Parameter

Adds a new parameter to a method declaration and updates all calls accordingly.
  AddParameter

Create Overload

Creates an overloaded method similar to the one at the caret, with fewer parameters. Applying this refactoring leads to an interactive phase where you can select which parameters to exclude from the new overload. XML doc comments are updated appropriately. You can even create overloads of constructors, as shown in the screen shot below:
  CreateOverload

Decompose Parameter

Replaces a single parameter with one or more new parameters, each standing in for a property access on the original parameter. For example, consider the code below:

  DecomposeParameter0

In the first constructor, only a single property of the parentGrid parameter, Children, is accessed inside the code (and aside from this property reference, parentGrid is never referenced or assigned to directly in the code). So we can replace this parameter with a parameter of the same type as the property referenced. The preview hint for Decompose Parameter shows the impact of this change:

  DecomposeParameter 
After applying this refactoring, all calls to the method are updated. The final code looks like this:

  DecomposeParameter2

Promote to Parameter

Removes all references to the local declaration or field from the method, replacing it with a parameter. Calling code is adjusted to pass in the promoted field or expression.

CSharpSmall
In C#, CodeRush Xpress simply adds a preview hint wrapper around the existing refactoring.

PromoteToParameter 
VBSmall 
In Visual Basic the refactoring is available as well, however in this case CodeRush Xpress actually implements the refactoring instead of handing off to the language service:

PromoteToParameterVB

Remove Unused Parameter

Removes an unused parameter from a method declaration and updates all calls accordingly.

VBSmall
In Visual Basic this refactoring is only available on parameters that are not referenced within the method:

RemoveUnusedParamter

CSharpSmall
In C# the Remove Unused Parameter refactoring is not available, however there is a wrapper for the built-in C# refactoring Remove Parameters, and that wrapper is available when the caret is on any parameter:

RemoveParameters

When you select the Remove Parameters, CodeRush Xpress calls the built-in C# refactoring, which allows you to select the parameters to remove:

RemoveParametersBuiltInUI 
Note: The image above is a dialog from Visual Studio and is not part of CodeRush Xpress.

Reorder Parameters

Reorders parameters in the current method, and then updates calling code to reflect the new order.

CSharpSmall
In C#, this refactoring hands control over to the existing C# implementation of Reorder Parameters:

ReorderParametersCS
Note: The image above is a dialog from Visual Studio and is not part of CodeRush Xpress.

VBSmall
In Visual Basic, the application of this refactoring leads to an interactive phase where parameters can be rearranged using the CodeRush Xpress in-source UI. A hint appears revealing available shortcuts in the interactive mode.

ReorderParametersVB 

Safe Rename

Safely renames non-private methods and properties by creating a duplicate member to preserve the old signature, calling the renamed member from the old member. The old member is hidden from Intellisense and marked "Obsolete". References to the old member will generate compiler warnings directing developers to the new renamed member.

  SafeRename0
After applying this refactoring, CodeRush Xpress selects and links the method name for an easy rename.

  SafeRename1

Safe rename is useful if you want to change the signature of a public or protected method referenced by code outside of your solution (e.g., on a developer's machine in another part of the world making calls to your API). For example, after performing the Safe Rename on the code shown above, we can next apply Remove Parameter to the unused deprecatedData in the FindPlayers method, cleaning up its signature without breaking any code that calls the now-obsolete FindAllThePlayers method.

Conditionals

Combine Conditionals

Combines nested conditionals to into a binary expression performing a logical AND operation. For example, "if (e1) if (e2)" becomes "if (e1 && e2)". This refactoring is the opposite of Split Conditional. This refactoring can also combine two or more neighboring conditionals with identical bodies into a single conditional statement where each conditional expression is logically OR’d.

Here's an example where nested conditionals can be combined:

  CombineConditionalsAnd

And here's an example where neighboring conditionals with identical bodies can be combined:

CombineConditionals

Combine conditionals will also remove any redundancy that might appear in the newly combined expression. For example, notice in the preview hint for the following how the reference to the hasQualified parameter appears only once:

  CombineConditionals2

Compress to Ternary Expression

Converts an if/else conditional with assignments in each branch into a ternary expression. This refactoring is the opposite of Expand Ternary Expression.

CompressToTernaryExpression

Expand Ternary Expression

Converts a ternary expression into an if/else block. This refactoring is the opposite of Compress to Ternary Expression.

  Before:

  column = cellPosition == CellPosition.Last ? _NumColumns - 1 : 1;

  After:

  if (cellPosition == CellPosition.Last)
    column = _NumColumns - 1;
  else
    column = 1;

Flatten Conditional

Unindents all or a portion of the conditional statement. This refactoring applies one of the following refactorings: Replace Nested Conditional with Guard Clause, Remove Redundant Else, or Reverse Conditional followed by Remove Redundant Else. Flatten conditional can also recognize “if (E) return true; else return false;” and convert all of this to simply “return E;”.

Here's one example for Flatten Conditional, where an indented code block (the last one of a method) becomes unindented by reversing the conditional and exiting the method:

FlattenConditional

Here's another example preview hint for Flatten Conditional, where an else keyword and the corresponding braces are removed, unindenting the contents of the block:


FlattenConditional2

 

Reverse Conditional

Inverts the logic in this conditional statement and swaps the If and Else blocks.

ReverseConditional

Split Conditional

Two behaviors:

  1. Converts a conditional with a binary expression performing a logical AND operation into nested conditionals. For example, in C#, "if (e1 && e2)" becomes "if (e1) if (e2)".

      Before:
       if (fileName != null && fileName != String.Empty)
         PlayInCell(fileName, column, row);


      After:
       if (fileName != null)
         if
    (fileName != String.Empty)
           PlayInCell(fileName, column, row);

  2. Converts a conditional with a binary expression performing a logical OR operation into neighboring conditionals.

      Before:
       if (fileName == null || fileName == String.Empty)
         return;


      After:
       if (fileName == null)
         return;
       if (fileName == String.Empty)
         return;

Declaration & Initialization

Convert to Initializer

Converts a default constructor call immediately followed by object initialization into an object initializer.

  ConvertToInitializer

Decompose Initializer

Converts an object initializer to a default constructor call followed by object initialization. Available when the caret is on type reference in the constructor call.

  Before:
 
  MediaPlayerPro mediaPlayerPro = new MediaPlayerPro { NumColumns = 3, StartingFolder = @"C:\Images" };

  After:
 
DecomposeInitializer

   Note the variable name is linked up after decomposing the initializer, allowing for a quick rename if desired.

Make Explicit

Converts an implicitly-typed local variable to a variable with an explicit type.

  MakeExplicit

Make Explicit (and Name Anonymous Type)

Converts an 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. Other anonymous types in this project having the same shape will also be replaced by the new type.

  MakeExplicitAndNameAnonymousType

Make Implicit

Converts an explicitly-typed variable declaration to an implicit one.

  MakeImplicit

Move Declaration Near Reference

Moves the declaration statement for a local variable near its first reference.

  MoveDeclarationNearReference
This refactoring is sometimes useful in preparing a block of code for Extract Method (if a selected block contains the variable declaration, the variable won't need to be passed in as a input parameter).

Move Initialization to Declaration

Combines a local variable's declaration with its first initialization.
  MoveInitializationToDeclaration

Name Anonymous Type

Replaces the anonymous type with a newly-declared type.

  NameAnonymousType
Additionally, other anonymous types in this project having the same shape (matching property names of the same types) will be replaced by the new type. For example, watch what happens when you apply this refactoring the first anonymous type assigned to the variable superCar1 below:

  Before:
  var superCar1 = new { MaxSpeed = 250, Driver = "Speed" };
  var superCar2 = new { MaxSpeed = 250, Driver = "Racer X" };

  After:
  var superCar1 = new SuperCar(250, "Speed");
  var superCar2 = new SuperCar(250, "Racer X");

The anonymous type assigned to superCar2 is also replaced by the new type.

Remove Assignments to Parameter

Removes assignments to value parameters, declaring a new local at the first assignment.

  RemoveAssignmentsToParameter

Split Initialization from Declaration

Breaks an initialized declaration for a local variable into a declaration and a separate initialization statement.

  Before:
  string[] files = System.IO.Directory.GetFiles(_StartingFolder);

  After:
  string[] files;
  files = System.IO.Directory.GetFiles(_StartingFolder);

Split Temporary Variable

Splits a local variable which has too many assignments, declaring a new local at the first new assignment following the first reference. In this example where the local variable "i" has multiple assignments and references, the preview hint shows a new variable named "splitI" will be introduced, and all subsequent references to "i" will be replaced with the new splitI variable.

SplitTemp 

Expressions

Inline Temp

Replaces all references to a local variable with its initial value.

  InlineTemp2

Introduce Constant

Declares a new constant, initialized to the value of the string or number at the caret.
IntroduceConstant

Introduce Constant (local)

Declares a new local constant, initialized to the value of the string or number at the caret.

Introduce Local

Creates a new local variable initialized to the selected expression. Replaces the selection with the new variable.

  IntroduceLocal
After applying this refactoring, the new local variable name is selected and linked up...

  AfterIntroduceLocal
So it is easy to rename...

  AfterIntroduceLocal2

Introduce Local (replace all)

Creates a new local variable initialized with the selected expression. Replaces the expression everywhere it appears inside the code block with the new variable.

  IntroduceLocalReplaceAll

Simplify Expression

Resolves an expression to its simplest form. Simplify Expression will remove redundancy such as extra parentheses and sub-expressions that have no impact on the outcome of the evaluation. For example, consider the redundancy in the expression in the method below:

    SimplifyExpression0
To simplify this, select the expression and press the CodeRush key (Ctrl+`). The preview hint shows how the expression will be simplified. Notice that we lose the redundant reference to the hasQualified parameter, and we also lose an extra pair or parens, resulting in a cleaner expression that is easier to read.


 SimplifyExpression

Interfaces

Extract Interface

Extracts an interface based on public members in a class.

Lambda Expressions & Anonymous Methods

Compress to Lambda Expression

CSharpSmall This refactoring is only available in C#.

Converts an anonymous method to an equivalent lambda expression.

  CompressToLambdaExpression

Expand Lambda Expression

CSharpSmall This refactoring is only available in C#.

Converts a lambda expression to an equivalent anonymous method.

Inline Delegate

CSharpSmall This refactoring is only available in C#.

Inlines the delegate, creating an anonymous method. If there are no other references to the delegate method, it is removed.

  InlineDelegate

Name Anonymous Method

CSharpSmall This refactoring is only available in C#.

Creates a new delegate method from an anonymous method which does not access any local variables from the parenting method body.

NameAnonymousMethod 
After applying this refactoring the method names will be linked up allowing you to easily rename the new method.

Loops & Blocks

Add Block Delimiters

CSharpSmall This refactoring is only available in C#.

 

Embeds a child statement inside brace delimiters.

  Before:
  if (files == null)
    files = Directory.GetFiles(_StartingFolder);

  After:
  if (files == null)
  {
    files =
Directory
.GetFiles(_StartingFolder);
  }

Create With Statement

VBSmall This refactoring is only available in Visual Basic.

Creates a Visual Basic With statement for the specified instance within the selection.

  CreateWithStatement

If more than one qualifying instance exists, a sub menu will allow you to select the instance to become the subject of the With statement.

Inline With Statement

VBSmall This refactoring is only available in Visual Basic.

Inlines the object reference of a Visual Basic With statement into all dot-references.

  InlineWithStatement

Remove Block Delimiters

CSharpSmall This refactoring is only available in C#.

Removes unnecessary brace delimiters in C#.

  Before:
  if (files == null)
  {
    files = Directory.GetFiles(_StartingFolder);
  }

  After:
  if (files == null)
    files = Directory.GetFiles(_StartingFolder);

Properties & Fields

Convert to Auto-implemented Property

CSharpSmall This refactoring is only available in C#.

Removes the backing store and converts the active property to a C# auto-implemented property. Available when the caret is on the property name.

  ConvertToAutoImplementedProperty

Convert to Auto-implemented Property (convert all)

CSharpSmall This refactoring is only available in C#.

Converts all properties in the active C# type to auto-implemented properties, removing the associated backing store fields.

ConvertToAutoImplementedPropertyConvertAll

Create Backing Store

CSharpSmall This refactoring is only available in C#.

Converts a C# auto-implemented property to a conventional property with a backing store.

  Before:
  public string StartingFolder { get; private set; }

  After:
  private string _StartingFolder;
  public string StartingFolder
  {
   get
   {
    return _StartingFolder;
   }
   private set
   {
    _StartingFolder = value;
   }
  }

 

 

Encapsulate Field

Encapsulates a field into a read-write property and replaces all occurrences of this field with the newly declared property. In C# control is passed to the built-in refactoring that encapsulates fields. In Visual Basic CodeRush Xpress implements this refactoring.

Encapsulate Field (read only)

Encapsulates a field into a read-only property and replaces all read-references to this field with the newly declared property.

Method to Property

Creates a property from the current method.

  Before:
  public string GetStartingFolder()
  {
    return _StartingFolder;
  }

  After:
  public string StartingFolder
  {
    get
    {
     
return _StartingFolder;
    }
  }

Property to Method(s)

  For read-only properties:
    Converts the property into a function.
  For write-only properties: 
    Converts the property into a method (or Sub in Visual Basic).
  For read/write properties: 
    Converts the property into two methods, creating a new function for the getter, and a new method for the setter.

 

Moving/Extracting Methods

 

Extract Method

Creates a new method from the selected code block. The selection is replaced with appropriate calling code to invoke the newly-declared method.

CSharpSmall In C# control is passed to the built-in refactoring that extracts methods.  VBSmall In Visual Basic CodeRush Xpress implements this refactoring.

ExtractMethod

Extract Method to Type

Creates a new method from the selected code block and moves it to the specified type, updating the selected code block appropriately. The selection is replaced with suitable calling code to invoke the newly-declared method through an instance of the target type. This refactoring is useful when you have a block of code that references several properties or methods on a variable of a type that is declared elsewhere in your solution.

  ExtractMethodToType

After extracting the code block above, the new method looks like this:

  ExtractMethodToType1

And the calling site looks like this:

         ExtractMethodToType2 

Extract Property

Creates a new property from the selected code block. The selection is replaced with appropriate code to reference the newly-declared property.

  ExtractProperty
After extraction the property name is selected and linked up for an easy rename.

  ExtractProperty2

Replace Temp with Query

Replaces each reference to this local variable with a call to an extracted method, which returns the initial value assigned to this local.

  ReplaceTempWithQuery

Resource Files & Strings

 

Extract String to Resource

Extracts the string at the caret into a resource file.

  ExtractStringToResource
After extracting the string, the resource identifier is selected and linked for an easy rename.

  ExtractStringToResource2

This refactoring is useful if you have text that needs to be translated into one or more target languages. Placing all text that needs translation into a resource file makes it possible to change and add foreign language support without changing the code.

Extract String to Resource (replace all)

Extracts all matching strings in the file to a resource file.

Extract XML Literal to Resource

VBSmall This refactoring is only available in Visual Basic.

Extracts the active embedded XML literal to a resource file.

  ExtractXMLLiteralToResource 

After the extraction the resource identifier is selected and linked up for an easy rename.

  ExtractXMLLiteralToResource2 

Use String.Format

Converts a composed string expression into a single String.Format call.

UseStringFormat

Notice in the preview hint how the formatting arguments passed to the ToString calls in the original expression (e.g., "listPrice.ToString("c")") are properly converted to the appropriate format strings (e.g., "{0:c}").

This refactoring is useful if you have concatenated display text such as this that needs to be translated into another language. Complete sentences are more effectively translated than sentence fragments, as they can be grammatically rearranged as is sometimes necessary with translation, without touching the code.

Use StringBuilder

Replaces the selected string concatenation operations with corresponding method calls on a local StringBuilder instance. For example, consider the following code:

             UseStringBuilder0 
To change these string concatenation operations to equivalent code that works uses a StringBuilder, just select the text to convert and press the CodeRush key (Ctrl+`).

UseStringBuilder1

The preview hint gives you an idea of the changes this refactoring will apply to the code. Old string concatenation operations ("+=") are updated.

          UseStringBuilder2
Notice also the intelligent changes applied to the second line that had previously called String.Format. That call has been converted to an AppendFormat call.

Types

Move Type to File

Creates a new file with the same name as the type at the caret, adds the file to the project, and then moves the type to that file, along with any leading comments, attributes, and XML doc comments. This refactoring is available when the caret is on a type declaration and the file contains two or more types.

  MoveTypeToFile 
After applying this refactoring, the type is moved to a new file with a matching name, and added to the active project:

  MoveTypeToFile2

The new file is activated so you can work in that file if needed. As always, when a feature in CodeRush Xpress takes you away from where you started, you can get back to the original location by pressing Escape.

Visibility

Widen Scope

Moves a variable declaration up (out) in scope, increasing the area where it can be referenced within the method.

WidenScope

Widen Scope (promote 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.

Widen Scope (promote to field)

Converts a local variable to a field variable.

  WidenScopePromoteToField

More Information

Documentation on all the features of CodeRush Xpress, including samples in both C# and Visual Basic, can be found in the Visual Studio help after installing. Just select the Help | Contents menu item:

HelpContents

The help also includes sample animations for C# and Visual Basic, so you can see the features in motion.

HelpAnimations

Download CodeRush Xpress - free from Dev Express!

Published Jun 25 2009, 01:00 PM by
Filed under:
Bookmark and Share

Comments

Brandon Truong

This is awesome. Just what i need. Something works like Resharper but free :)

June 25, 2009 8:41 PM

Dew Drop – June 26, 2009 | Alvin Ashcraft's Morning Dew

Pingback from  Dew Drop – June 26, 2009 | Alvin Ashcraft's Morning Dew

June 26, 2009 9:41 AM

jake

is there anywhere i can get a side aby side comparison with coderush 9? @brabdon, like resharper? really? really? consider footprint. like saying mysql is just like postgresql!! codersh xpress is getting there but there is not, should not, be resharper but the full coderush plus refactor

June 27, 2009 12:50 AM

RRaveen

You are articles are nice and excellent concepts , i would like request one help from you. i have launched new .net programming website www.codegain.com. Could you able publish your article in codegain.com also.I expecting good responds from you.you can send reply to info@codegain.com.

Thank you

RRaveen

codegain.com

June 28, 2009 11:25 AM

DotNetKicks.com

You've been kicked (a good thing) - Trackback from DotNetKicks.com

June 29, 2009 6:13 AM

Twitted by RoryBecker

Pingback from  Twitted by RoryBecker

June 29, 2009 9:15 AM

まさるblog

CodeRush Xpressの使い方をまとめたblogエントリ紹介

June 29, 2009 4:01 PM

まさるblog

CodeRush Xpressの使い方をまとめたblogエントリ紹介

June 29, 2009 4:42 PM

Milan

Great summary. Just a small notice - when I tried to use it, I've following 2 problems:

- doesn't work correctly with my national keyboard - for example AltGr+F should be "[", but it is not - and you can imagine that [] are useful :)

- it is not possible to change colors - and as I'm using dark background, it is not visible :(

If this 2 problems are fixed, I'll start to use it immediatelly.

Best regards,

Milan

June 29, 2009 4:52 PM

Mikhail Strebkov

Milan - ctrl+shift+alt+O - configure that stuff.

CodeRush rocks! :) Good article

June 30, 2009 3:10 AM

Free CodeRush Xpress for C# and Visual Basic inside Visual Studio 2008 « Jasper Blog

Pingback from  Free CodeRush Xpress for C# and Visual Basic inside Visual Studio 2008 « Jasper Blog

June 30, 2009 3:26 AM

Milan

Mikhail - thanks! (for others - the main is: "Shortcuts" page - click on Alt button ("Distinguish between left and right "Alt" keys")

Best regards,

Milan

June 30, 2009 4:56 AM

mgroves

Too bad it doesn't work in VS 2003

June 30, 2009 8:43 AM

Mark Miller (DevExpress)

mgroves:

CodeRush Xpress only works in VS 2008, however the full version of CodeRush works in VS 2003, VS 2005, and VS 2008....

June 30, 2009 1:48 PM

Dash Technical Notes

CodeRush Xpress for C# and Visual Basic inside Visual Studio 2008 - Mark Miller

June 30, 2009 2:26 PM

Jose R. Guay Paz

Mark Miller from DevExpress just posted an incredible article on CodeRush Xpress. Here is a part of it

June 30, 2009 10:47 PM

DevExpress CodeRush Xpress for C# & VB.NET | Nexo IT - Information Technology News

Pingback from  DevExpress CodeRush Xpress for C# & VB.NET | Nexo IT - Information Technology News

July 1, 2009 12:10 AM

Stefano Ricciardi

Awsome. Can't wait go give it a try!

July 1, 2009 8:39 AM

Dash Technical Notes

CodeRush Xpress for C# and Visual Basic inside Visual Studio 2008

July 1, 2009 9:38 AM

DevExpress CodeRush Xpress for C# & VB.NET | I love .NET!

Pingback from  DevExpress CodeRush Xpress for C# & VB.NET | I love .NET!

July 1, 2009 11:23 AM

Friday Links #58 | Blue Onion Software *

Pingback from  Friday Links #58 | Blue Onion Software *

July 2, 2009 9:31 PM

Peter

Sorry, I've never used Coderush before and I didn't find the instructions above very clear.

The instructions above make constant reference to a caret. What is the "caret"?

July 3, 2009 9:33 AM

Peter

Lol. Nothing was happening for me when I tried Ctrl+`, I thought maybe "the caret" was something special I didn't know about. I found this info on the difference between the CURSOR and the CARET:

Inside Windows, there is a large terminology problem. So many different things all need to get their own names, so we can program with them, and keep everything straight. A perfect example of this is the difference between the cursor and the caret. The cursor is the graphical image that represents the mouse. It can either be an arrow for pointing, a hand, an hourglass, or an I-shaped text selector. The caret, on the other hand, is the blinking object that is used to enter text. When you type, the letter appears at the caret, and the caret moves forward by 1 space. It is important to keep these terms straight, because if you confuse them inside your program, you could have a lot of debugging to do.

July 3, 2009 10:52 AM

Geoff

I am using VS 3.5 sp1.

When I typed in Ctrl+`, the consume-first declaration did not work. A menu should have appeared but didn't. Why is this?

July 7, 2009 10:26 AM

PressReleases

Available to all C# and Visual Basic Developers – CodeRush Xpress is the free productivity tool that

July 9, 2009 10:23 AM

Microsoft App Development » Blog Archive » Free Visual Studio 2008 Productivity and Efficiency Tools by DevExpress

Pingback from  Microsoft App Development  » Blog Archive   » Free Visual Studio 2008 Productivity and Efficiency Tools by DevExpress

July 13, 2009 1:01 PM

Twitter Trackbacks for CodeRush Xpress for C# and Visual Basic inside Visual Studio 2008 - Mark Miller [devexpress.com] on Topsy.com

Pingback from  Twitter Trackbacks for                 CodeRush Xpress for C# and Visual Basic inside Visual Studio 2008 - Mark Miller         [devexpress.com]        on Topsy.com

August 31, 2009 9:25 AM

Jim Spence

There is a vertical bar next to editor's scroll bar that is filled with warnings about "Redundant this qualifier."  I know "this" is redundant, but I want to keep it.

How do remove that vertical bar and it's griping?

September 4, 2009 3:54 PM

BarbecueGuy

I absolutely love this product. I'm forced to use it because my employer will not pay for the full version; and I can't justify to my wife why I should pay for a tool that my employer should be purchasing for me.

I have had some issues with it, though.  For example, several of the features, such as, the method contract feature simply do not work for me. I get no indicator of possible actions, and pressing Ctrl + ` results in nothing happening.

I highly recommend this product!

September 10, 2009 5:34 PM

Alex Skorkin (DevExpress Support)

Hi BarbecueGuy,

>>>

For example, several of the features, such as, the method contract feature simply do not work for me.

<<<

We've addressed this issue in the B150048 (www.devexpress.com/issue=B150048) report. You're welcome to download the available public fix from this report. For any other issues please contact support@devexpress.com - they'll be happy to assist you.

September 11, 2009 4:54 AM

David

I tried "Tab to Next Reference" but it is not working. Tab key will break a variable to two parts. Not sure why. If the variable is referenced or used beyond the current screen in a class with a lengthy codes, will the next tab shift the screen down?

September 12, 2009 12:28 AM

Mark Miller (DevExpress)

Hi David,

Please contact suppport@devexpress.com about the Tab to Next Reference issue. To answer your question, yes, pressing the Tab key will shift the view and open files if necessary to take you through all the references in the solution.

September 12, 2009 11:00 AM

Jason

The Quick Nav feature does not work for me (dialog never pops up). I even tried adding a second keyboard shortcut... that didn't work either. Quick File Nav and everything else I've tried works, but not Quick Nav. Any ideas?

September 21, 2009 12:19 PM

Sachin

I have been using CodeRush Express with Visual Studio 2008 and have noticed that right-click in the code window takes about 10-odd seconds to respond back and present the context-sensitive menu.

The CPU usage also jumps to 75% - 80% during this waiting time.

Repititive clicks on the same piece of code (look-up information supposedly should be cached) yield identical slow responses.

Uninstalling CodeRush Express (sadly), resolves the issue and the response times are back to couple of seconds for the right-click.

Any ideas /help?

November 30, 2009 9:58 AM

Mark Miller

Hi Sachin,

Please contact support@devexpress.com with details to help us reproduce.

November 30, 2009 4:32 PM

Steven Elliott

Installing CRX in VS2008 Standard blew out my toolbar button for Axialis IconWorkshop. The toolbar is still there but the button is missing.

March 8, 2010 2:51 PM

Mark Miller (DevExpress)

Hi Steven,

I'm pretty sure this is a Visual Studio bug, but contact support@devexpress.com to be sure. That is the best place for resolving issues like this.

March 9, 2010 2:37 PM

CodeRush Xpress for C# and Visual Basic inside Visual Studio 2010 « Geek Mythologies

Pingback from  CodeRush Xpress for C# and Visual Basic inside Visual Studio 2010 « Geek Mythologies

May 12, 2010 9:13 AM

Greg Hibbard

Hi Mark...

Can someone tell me what advantage there is to purchase CodeRush?  I am using CodeRush Express for VS2010 VB.Net.  I can see the advantage for C# but is the same advantage for VB.Net?

June 30, 2010 8:41 PM

Mark Miller (DevExpress)

Hi Greg,

The full version of CodeRush adds over 100 refactorings, a code metrics window, code template technology (like Visual Studio's code snippets on steroids), more code-creation tools, more visualization tools, more navigation tools, a full-featured test runner, and many more useful features. Additionally the full version of CodeRush includes support for languages other than C# and Visual Basic, like ASP.NET, XAML, Javascript, and C++.

More detail:

community.devexpress.com/.../differences-between-coderush-xpress-and-coderush.aspx

rorybecker.blogspot.com/.../coderush-vs-coderush-xpress.html

July 1, 2010 9:25 AM

Paul Griffin

I've just D/Led Coderush Express to give it a try, but whenever I try to start VS2008 is complains "Package Load failure" for "DXCore" and "Refactor!"

I have tried running the repair installation, but with no change. Any bright ideas what I am doing wrong?

July 21, 2010 11:18 AM

Thanigaimani Thirumalai

Very Nice article. Learned a lot. Thank you

February 17, 2011 7:25 AM

Tauheedul Ali

I've just started using the tool, it's really easy to use. Great article.

January 23, 2012 10:18 AM

About Mark Miller (DevExpress)

Mark Miller is a C# MVP with strong expertise in decoupled design, plug-in architectures, and great UI. Mark is Chief Architect of the IDE Tools division at Developer Express, and is the visionary force behind productivity tools like CodeRush and Refactor!, as well as the DXCore extensibility layer for Visual Studio. Mark is a popular speaker at conferences around the world and has been writing software for over two decades.
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-2017 Developer Express Inc.
All trademarks or registered trademarks are property of their respective owners