The object programs that live best and longest are those with shorts methods. Programmers new to objects often feel that no computation ever takes place, that object programs are endless sequences of delegation.
Since the early days of programming people have realized that the longer a procedure is, the more difficult it is to understand. Modern OO languages have pretty much eliminated overhead of in-process calls.There is still overhead to the reader of the code because you have to switch context to see what sub procedure does. But the real key to making it easy to understand small method id good naming. If you have a good name for a method you don't need to look at the body.
A heuristic we follow is that whenever we feel that need to comment something, we write a method instead. Such a method contains the code that was commented but is named after the intention of the code rather than how it does it. This is also the way to refactor "Comments" code smell.
Ninety-nine percentage of the time, all you have to do to shorten a method is Extract Method . Find parts of the method that seem to go nicely together and make a new method.
If you have a method with lots of parameters and temporary variable the you can follow the approach I mentioned in another article
Refactoring Long Parameter List:
I have already written an article on refactoring long parameter list : http://ciintelligence.blogspot.com/2015/09/code-smells-long-parameter-list.html . If you've tried that, and you still have too many temps and parameters, its time to get out the heavy artillery Replace Method with Method Object.
Extract Method :
Extract method is one of the most common refactoring I do. I look at a method that is too long or look at code that needs a comment to understand its purpose. I then turn that fragment of code into its own method.
- Create a new method, and name it after the intention of the method ( name it by what it does, not by how it does it)
- Copy the extracted code from the source method into the new target method.
- Scan the extracted code for references to any variables that are local in scope to the source method. These are local variables and parameters to the method.
- See whether any temporary variables are used only within this extracted code. If s, declare them in the target method as temporary variables.
- Look to see whether any of these local-scope variables are modified by the extracted code. If one variable is modified, see whether you can treat the extracted code as a query and assign the result to the variable concerned. if this is awkward, or if there is more than one such variable, you can't extract the method as it stands. You may need to use Split Temporary Variable and try again. You can eliminate temporary variables with Replace Temp with Query.
- Pass into the target method as parameters local-scope variables that are read from the extracted code.
- Compile when you have dealt with all the call-scoped variables
- Replace the extracted code in the source method with a call to the target method.
- Compile and test.
Example using Resharper:
Here is the initial code with we are going to refactor. Things to notice here PrintOwing function, has some comments to understand what is the purpose of following portion of code. This is Comments Code Smell. These are the places we can apply Extract Method.
- Example for extracting method without any arguments:
Using ReSharper Extract Method we can easily move the code in method so that we do not require to comment the code but the important thing is to give proper name of the extracted method so that we do not need to go inside the method to understand the reason of the code. The shortcut for Extract Method in Resharper is Ctrl+Alt + M or (Ctrl R, M)
It will ask to give name of the method. As the method is printing banner so the name of the method could be as
- Extracting Method for Local Variable
ReSharper is intelligent enough to understand the local variable used inside code. So it will automatically take local variable as parameter to the extracted method. Here as example, outstanding variable is used for print detail . We can use same Extract Method refactoring from Resharper without any modification.
The outstanding variable is passed as argument inside PrintDetails method automatically.
- Extract Method and Reassigning a local variable
This refactoring needs to organize the code little so that it can declare local variable inside method and pass the result as return value. outstanding value is generated inside calculate outstanding portion of code. First task will be to take outstanding variable close to calculation.
As the outstanding variable is moved just before calculation. So doing extract method on calculation section Resharper will automatically return the result of the calculation and reassign to a local variable.
- Final Code after Refactoring
The code which need to be commented, are moved to methods using Extract Method. This replace long method code into small methods sequence. As because the extracted method names are self explanatory so we do not need to go inside each code to understand what is the purpose of the method.
Output this refactoring changed PrintOwing method into three line of code which do same operation and code need less effort to understand what this PrintOwing is doing.