Refactoring is an essential process to keep code clean and elegant while it evolves. IDE's offer common refactorings (although somewhat short of those prescribed in Fowler's excellent Refactoring
book and way short of the overall goals explained in Kerievsky's Refactoring).
One limitation of existing tools is that they can only update references within your solution. When you are refactoring a shared library this is a problem, especially if it is your public API to the outside world.
We need to introduce metadata to document how the API has evolved and extend the tools to generate and understand this metadata.
Let's take a look at a few of the refactoring in Visual Studio and see how they could be documented using the .NET metadata mechanism of choice, attributes.
Rename
Starting simple lets we had a property named Reference:
public string Reference {
get { return id; }
}
We are going to rename Reference to StockCode for the 1.1.0.0 release. The tool could introduce a stub for backward compatibility whilst also marking it with metadata giving us:
[DeprecatedRefactorRename("StockCode", "1.1.0.0")]
public string Reference {
get { return StockCode; }
}
public string StockCode {
get { return id; }
}
The library is both binary and source compatible but with a little IDE work they could get a warning that Reference is now StockCode and given the choice of updating all the references in their project.
Nice. Let's try a few more:
Remove Parameters
public bool AddStock(int quantity, DateTime arrival, StorageBin location) {
...
}
We are switching to a managed warehouse and so we no longer need to know where items are stored so we refactor and remove the StorageBin.
[DeprecatedParameterRemoved("location", "1.1.0.0.")]
public bool AddStock(int quantity, DateTime arrival, StorageBin location) {
return AddStock(quantity, arrival);
}
public bool AddStock(int quantity, DateTime arrival) {
...
}
Reorder Parameters
[DeprecatedParametersReordered("arrival, quantity", "1.1.0.0.")]
public bool AddStock(int quantity, DateTime arrival) {
return AddStock(arrival, quantity);
}
public bool AddStock(DateTime arrival, int quantity) {
...
}
Move Method
Existing tools offer little support for MoveMethod because they haven't considered how to refactor the references. It is difficult to retain binary compatibility unless the class has a reference to class that now has the method we are interested in.
[DeprecatedMethodMoved("StockController", "Add", "1.1.0.0")]
public bool AddStock(DateTime arrival, int quantity) {
return stockController.Add(this, arrival, quantity);
}
Let's say the current calling code looks something like:
stockController.DoSomething();
selectedProduct.AddStock(DateTime.Now, input.Value);
However with a little ingenuity the IDE could examine the new method and map existing parameters based on name and type. If it still doesn't have enough information consider local variables and properties of the objects it does have to present choices. This works especially well if your parameters are not primitives. Our code becomes:
stockController.DoSomething();
stockController.Add(selectedProduct, DateTime.Now, input.Value);
Keeping it clean
We don't want our classes being cluttered with deprecated code indefinitely so the solution should contain two extra revision numbers, one detailing the oldest revision of attributes to keep in the source, the other for the oldest revision to compile into the binary. All the [Deprecated] marked methods and properties can slip into another file, perhaps Product.deprecated.cs so they stay out of sight until needed.
For .NET it would need somebody at Microsoft to take this on board and move us forward from ObsoleteAttribute as the facility should be cross-tool and so adding it solely to SharpDevelop would be of limited gain.
[)amien
The next version of my Envy Code R font especially designed for programming (monospaced, easily distinguishable characters) is nearing completion and represents a very response-driven update to feedback, specifically:
