Home > Articles > Programming > Visual Basic

  • Print
  • + Share This
Like this article? We recommend

Like this article? We recommend

Refactoring Code

Refactoring Code

Visual Basic 2015 introduces integrated code refactoring, which means that you can use the Light Bulb and quick actions to reorganize portions of your code in a better and cleaner way. The code analysis engine based on the .NET Compiler Platform can detect whether a piece of code can be refactored; if so, it provides proper suggestions based on the context. Let's walk through a number of built-in code refactorings in Visual Basic 2015.

Extract Method

A very common refactoring is Extract Method, which extracts a piece of code and uses it to generate a new, reusable method. To understand how this feature works, consider the following code, which calculates the area of a circle based on its radius:

Sub Calculation()
    Dim radius As Double = 3
    Dim circleArea As Double = radius * radius * Math.PI
End Sub

Instead of having a hard-coded calculation, it would be more useful to have a reusable method that receives the radius as an argument. To accomplish this goal, select radius * radius * Math.PI; then right-click this selection and choose Quick Actions. The Light Bulb will now show a quick action called Extract Method, showing a preview of how the code will be refactored, as demonstrated in Figure 9.

Figure 9 Code refactoring: Extracting a method.

If you accept this fix, your code will now look like this:

Sub Calculation()
    Dim radius As Double = 3
    Dim circleArea As Double = GetCircleArea(radius)
End Sub

Private Function GetCircleArea(radius As Double) As Double
    Return radius * radius * Math.PI
End Function

Now you have a new method that can be reused anywhere in your code, instead of having a hard-coded calculation. When you implement the change, notice that Visual Studio gives you the option of renaming the newly generated method. Renaming identifiers has been dramatically improved in Visual Basic 2015 and deserves a separate examination. The next section takes a closer look.

Inline Rename

If you wanted to rename an identifier in your code in previous editions of Visual Studio, you could right-click the identifier and perform the rename via a modal dialog. Although it worked properly, this approach had one limitation: It blocked the coding experience and made you lose focus on the code. In Visual Studio 2015, this experience has been rewritten so that you can rename identifiers directly in the active code editor window. To understand how this feature (called inline rename) works, let's focus on the GetCircleArea method generated with the Extract Method tool. Add a Console.Writeline statement in the Calculation method, with a comment as in the following code:

Sub Calculation()
    Console.WriteLine("Invoking GetCircleArea...")
    Dim radius As Double = 3
    Dim circleArea As Double = GetCircleArea(radius)
End Sub

'GetCircleArea calculates the area of a circle
Private Function GetCircleArea(radius As Double) As Double
    Return radius * radius * Math.PI
End Function

Now right-click GetCircleArea and then select Rename. At this point, the identifier will be highlighted in green, and you simply type the new name. Changes will be reflected to all invocations in your solution as you type. Inline Rename can also rename identifiers inside string literals and comments. By enabling the proper checkboxes, you can apply this change everywhere, as demonstrated in Figure 10, which shows GetCircleArea being renamed CalculateCircleArea everywhere.

Figure 10 Code refactoring: Inline rename.

This approach is very powerful because it is not limited to renaming objects and members, but also their occurrences inside comments and string literals.

Encapsulate Fields

In Visual Basic 2015, you can easily encapsulate fields into properties. To understand how this feature works, consider the sample code in Listing 2, which we will use to discuss several refactoring tools.

Listing 2—Sample class to demonstrate refactorings.

Class CircleHelper

    Private radius As Double

    Function CalculateCircleArea() As Double
        Dim result = radius * radius * Math.PI
        Return result
    End Function

    Sub New(radius As Double)
        Me.radius = radius
    End Sub
End Class

The class is very simple. Its constructor requires passing a value that will be stored inside a field and then used by CalculateCircleArea to return the area of a circle. (Of course, this implementation is intentional to demonstrate some of the new code editor features.) Right-click the Private radius As Double line, and then select Quick Actions. As Figure 11 shows, the code editor suggests encapsulating the field into a property. The first quick action also updates previous references to the field, in order to use the new property instead.

Figure 11 Code refactoring: Encapsulating a field.

The second quick action generates a property, but does not update references. If you apply the first suggestion, your code will look like this:

Class CircleHelper

    Private radius As Double

    Public Property Radius1 As Double
        Get
            Return radius
        End Get
        Set(value As Double)
            radius = value
        End Set
    End Property

    Function CalculateCircleArea() As Double
        Dim result = Radius1 * Radius1 * Math.PI
        Return result
    End Function

    Sub New(radius As Double)
        Me.Radius1 = radius
    End Sub
End Class

As you can see, a property has been generated, and all references have been updated.

Extract Interface

Another interesting refactoring is Extract Interface, which generates an interface starting from the public members of a class. Similarly to the previous example, you begin by right-clicking Class CircleHelper and then select Quick Actions. The Light Bulb will offer the Extract Interface action, with no preview. Click the quick action, and the Extract Interface dialog appears, showing the list of public members that will be part of the new interface, and providing an option to change the auto-generated interface name and code file (see Figure 12).

Figure 12 Code refactoring: Extracting an interface.

If you click OK, the resulting interface will look like the following:

Interface ICircleHelper
    Property Radius1 As Double
    Function CalculateCircleArea() As Double
End Interface

It requires implementing the public property and method extracted from the original class. In addition, Visual Studio has automatically updated the CircleHelper class to implement the new interface. Your original code now looks like the following:

Class CircleHelper
    Implements ICircleHelper

    Private radius As Double

    Public Property Radius1 As Double Implements ICircleHelper.Radius1
        Get
            Return radius
        End Get
        Set(value As Double)
            radius = value
        End Set
    End Property

    Function CalculateCircleArea() As Double Implements ICircleHelper.CalculateCircleArea
        Dim result = Radius1 * Radius1 * Math.PI
        Return result
    End Function

    Sub New(radius As Double)
        Me.Radius1 = radius
    End Sub
End Class

Introduce Temporary Variable

A new refactoring technique for both Visual Basic and C#, Introduce Temporary Variable removes unnecessary variable declarations. To understand how it works, consider the latest definition of the CalculateCircleArea method:

Function CalculateCircleArea() As Double Implements ICircleHelper.CalculateCircleArea
    Dim result = Radius1 * Radius1 * Math.PI
    Return result
End Function

If you right-click the result variable and enable the Light Bulb, Visual Studio suggests removing the variable declaration and returning the result directly (see Figure 13).

Figure 13 Code refactoring: Inline temporary variable.

If you accept the suggestion, the code will look like this:

Function CalculateCircleArea() As Double Implements ICircleHelper.CalculateCircleArea
    Return Radius1 * Radius1 * Math.PI
End Function

This is a cleaner way of writing the same code, with one less line.

Introduce Local Variable

Another new refactoring technique for Visual Basic and C#, Introduce Local Variable, allows for simplifying complex code by adding local variables. Consider this new version of the CalculateCircleArea function, which takes an argument of type Object and performs the proper conversion to Double:

Function CalculateCircleArea(radius As Object) As Double
    Dim circleArea As Double =
    Convert.ToDouble(radius) * Convert.ToDouble(radius) * Math.PI
    Return circleArea
End Function

If you select the first Convert.ToDouble(radius) invocation and enable the Light Bulb, you will see that two refactoring options are available: Introduce local for Convert.ToDouble(radius) and Introduce local for all occurrences of Convert.ToDouble(radius). As you can easily understand, the first option fixes the code only on the selected occurrence, whereas the second option fixes the code on all occurrences of the method invocation. The preview will be useful to understand possible fixes, as represented in Figure 14.

Figure 14 Code refactoring: Introduce local variable.

If you select the second option, your code will look like this:

Function CalculateCircleArea(radius As Object) As Double
    Dim v As Double = Convert.ToDouble(radius)
    Dim circleArea As Double =
    v * v * Math.PI
    Return circleArea
End Function

You have simplified a complex expression into a more readable block. When you apply for a local variable, Inline Rename is automatically invoked, and you can choose a different name for the local variable.

Introduce Constant and Introduce Local Constant

The Introduce Constant and Introduce Local Constant refactoring options allow for replacing hard-coded values with constants, which can be at the class level (Introduce Constant) or within a method body (Introduce Local Constant). To understand how this feature works, consider the following code:

Module Module1
    Sub Main()
        Dim result = CalculateCircleArea(1.5)
    End Sub

    Private Function CalculateCircleArea(radius As Double) As Double
        Return radius * radius * Math.PI
    End Function
End Module

Here you have an invocation to the CalculateCircleArea method, passing a numeric value as an argument. If you select such a numeric value and enable the Light Bulb, you will get the following options (see Figure 15 for a sample preview):

  • Introduce constant for '1.5'
  • Introduce constant for all occurrences of '1.5'
  • Introduce local constant for '1.5'
  • Introduce local constant for all occurrences of '1.5'

Figure 15 Code refactoring: Introduce constant.

The first and second options respectively introduce a constant at the class level for the selected occurrence, and for all occurrences of the numeric value. The third and fourth options respectively introduce a constant within the method body for the selected occurrence, and for all occurrences of the numeric value. The following code demonstrates the result of the first option:

Module Module1
    Private Const V As Double = 1.5

    Sub Main()
        Dim result = CalculateCircleArea(V)
    End Sub

    Private Function CalculateCircleArea(radius As Double) As Double
        Return radius * radius * Math.PI
    End Function
End Module

Notice that when you apply the refactoring, Inline Rename appears and allows you to specify a different name for the constant.

Organize Imports

Visual Basic 2015 easily allows for reorganizing the Imports directive. Earlier, in the section introducing the Light Bulb, we saw an example removing redundant Imports directives. The code editor also offers commands to sort Imports directives and to both sort Imports and remove redundant directives. All these commands are available by right-clicking any Imports directive, inside a group called Organize Imports in the context menu.

  • + Share This
  • 🔖 Save To Your Account