.NET Tools
Essential productivity kit for .NET and game developers
Put it down in layman’s terms – code smells series
This post is part of a 10-week series by Dino Esposito (@despos) around a common theme: code smells and code structure.
So far in this series about code smells, we’ve made the point that keeping the language of the code close to the language of the business is crucial to reducing misunderstandings and speeding up development. Naming classes, methods, and sparse values appropriately is part of the job. Today, let’s look at bringing the code even closer to the business language!
In this series:
- Sharpen your sense of (code) smell
- The simple case of special string types
- Join data items that want to go together
- Easy conversions and readability
- Put it down in layman’s terms
- Every method begins with “new”
- Dependency injection doesn’t strictly require frameworks
- Super SuperClasses
- Null pointers: an opportunity, not an exception
- You ain’t gonna use it!
A very common scenario in nearly all types of code is checking the value of a variable against a fixed range of values, mostly constants. In modern programming languages, the enum type is the artifact used to declare a list of named integer constants.
public enum RoomState
{
Unknown = 0,
Available = 1,
Occupied = 2
}
While the value of any constant is an integer, an expression that evaluates to any of the constants is of a type that inherits from System.Enum. In the code snippet, it is RoomState. Enum values are typically assigned to variables or evaluated in conditional statements.
if (state == RoomState.Occupied)
{
Console.WriteLine("Room not available");
}
Even when all you need to do is check a value against a constant, you never know what can happen next as the code base grows. Turning explicit constants into enum values is a good first step.
Checking values using the == operator doesn’t help readability, even when names are chosen properly and in full respect of the ubiquitous language of the business domain. Again, ad-hoc methods come to the rescue! We can make our code more explicit by adding a couple of methods.
Here’s a sample Room class with a State property expressed via an enum type.
public class Room
{
public RoomState State { get; private set; }
public bool IsOccupied()
{
return State == RoomState.Occupied;
}
public bool IsAvailable()
{
return State == RoomState.Available;
}
// More methods
}
To programmatically check the state of the room, you can go with plain if statements. However, using ad-hoc methods makes the result much easier to read.
if (room.IsOccupied())
{
Console.WriteLine("Room is not available");
}
Finding code with structural search
Let’s say that you developed much of your code using plain comparison via the == operator. There might be hundreds of occurrences to find and fix. Is there a quick way to find all of them in a single (and reliable) shot?
Well, ReSharper allows you to do that in a rather comfortable way! You can make use of structural search. From the ReSharper | Find menu, we can Search with Pattern.
ReSharper’s Search with Pattern looks for all expressions that match the specified code pattern. In this case, you may want to make sure that $var$ (the placeholder for the left-hand side of the comparison) is an expression of type System.Enum or any derived type.
Once the pattern is defined, you can run the search and explore results. All that remains to do is to go through each occurrence and apply the necessary fixes – either manually or by using structural replace.
A wrapper method doesn’t just make your code easier to read, but also hides the details of the comparison being made. Depending on the complexity of the code you are writing, it might not really be far-fetched that at some point the comparison becomes a more sophisticated operation. Now is the time to fix them. The sooner, the better! Your future self will thank you.
Next week, we will look at new vs. factory methods and where it makes sense to use them.
Download ReSharper 2018.1.2 or Rider 2018.1.2 and give them a try. They can help spot and fix common code smells! Check out our code analysis series for more tips and tricks on automatic code inspection with ReSharper and Rider.
Subscribe to a monthly digest curated from the .NET Tools blog:
