Refactoring in C#
To accomplish any functionality in an application, every developer has a unique style. Some of them write effective and less complex codes while some write more complex ones.
But, there has to be a standard that needs to be maintained so that the code is flexible and readable enough to make enhancements easily. However, the standard that needs to be followed is at the organizational level.
Whenever the code is developed, there can be just two scenarios - either it meets the expected standard or it doesn’t. In the latter case, it is necessary to modify the code to make it adhere to the standard without altering its functionality.
Also, when the developers encounter any technical issues such as memory leaks and slow processing, it is important for them to analyze the code and refactor it to improve the code and make sure the problem is being addressed. But what is refactoring and when exactly to refactor? This blog answers all such questions for you.
Table of contents
- What is Refactoring?
- When to Refactor?
- Different ways to Refactor
- Conclusion
What is Refactoring?
Refactoring is the process of improving the performance, readability, and complexity of the code by altering its internal structure and external behavior. In other words, it is an efficient technique for cleaning up the code in a controlled manner.
Refactor is not rewriting the code, as the crux of the code (i.e functionality) remains the same. It rather alters the way it has been implemented to meet the standard. For example, a simple refactoring would be renaming a variable to make it into a readable format.
It is a continuous process like the development task. As and when the new functionality is introduced, there is a possibility for the code to be refactored. So, when the code is checked in, it is necessary to look for code smells and fix them.
To the naked eye, it would be difficult to identify all the code smells. So to make it easier, some applications can be installed as extensions in Visual Studio. This then provides suggestions on what could be refactored. This makes the developer and Peer reviewer job much easier.
Let's now see in detail when to refactor.
When to Refactor?
It is always recommended to look for code smells right after every development task has been completed. This ensures that the work is evenly distributed to the developers. But, when the project is not ready to concentrate on Non-Functional Requirements, then it is ideal to perform refactoring when a new set of major feature changes are made. It will be easy to develop a product on top of the cleaned-up code.
Similarly, it is also recommended to make the NFR changes, as soon as the code goes to production. This again ensures that there will be some breathing space for developers and the task can be accomplished on time.
Different ways to Refactor
Extracting as a separate method
Consider a method that exists and contains a lot of functionalities. This makes it quite difficult for the programmers to read as the method is highly complex. So, it is necessary to break the method into different pieces so that the functionality remains intact but at the same time, it makes it easier for the programmers to read it.
Here is an example -
The below image has a complex method. Now let's see how to extract the method separately from it.
Note: The below method has been deliberately made complex by adding a lot of unnecessary functionalities. The purpose of this exercise is to just explain how refactoring reduces these unwanted complexities in a code. Kindly ignore the logic of the actual code.
To extract the method separately, select the lines of code that need to be extracted as a separate method. Right-click and choose “Quick Action and Refactorings…” in the options given.
On selecting it, the Extract method option shows a preview of how the new method would be created.
Remove unused directives
As we have seen, we refer to multiple in-built and external packages to accomplish tasks. Often there are chances that the code has unused directives at the top of the class file.
Though the directives will be loaded only when the feature from it is being consumed inside the class, it is good to clean up the Usings, so that the file looks cleaner.
Extracting Interfaces
Interfaces contribute to creating loosely coupled code. While we refactor, we figure out that the code is tightly coupled and needs to be refactored to a loosely coupled code.
To do so, an interface has to be created which will be inherited by the class. Since the class has a lot of methods, you have to make it easier to create the interface with all the methods. To do so navigate to the Quick Actions and Refactoring…. after selecting a class, an option to create an interface appears.
Renaming variables
Imagine that a global variable is present inside a class, and it is being used throughout it (class). But, the naming of the variable doesn't sound right. So we need to rename the variable to a proper one so that it sounds meaningful.
Since the variable is being used in multiple, we need a better approach than to replace it one by one. IN other words, we need a way to replace the variable name in one shot. Luckily, there is an option available in Visual studio for that.
Select the variable that needs to be renamed, then press Ctrl + R, Ctrl + R. This now enables the option to type the new variable.
After we apply the changes, the renaming would have applied in all the places.
Conclusion
Remember, there are lot many refactoring techniques available in C# that are not discussed in this post. This post has been created just to show you what Refactoring is and how it helps to make the code reach the set standard and more readable.