Lets say you have a Class with 300 properties with no backing variables, each of those properties returns a decimal/double.
Example:
public decimal MathValue { get; set; }
Now you decided that each one of those values should be rounded.
I am looking for the simplest way to refactor this without having to rewrite all of those properties.
Something, of this equivalent that actually works :D:
public decimal MathValue { get {return Math.Round(MathValue);} set; }
No. If you need any custom logic in either getter or setter, you cannot use auto-properties.
You could create a new value type that pretends to be a decimal, but returns the rounded value. Something like this:
struct RoundedDecimal
{
public decimal Value { get; private set; }
public RoundedDecimal(decimal value) : this()
{
this.Value = value;
}
public static implicit operator decimal(RoundedDecimal d)
{
return Math.Round(d.Value);
}
}
Each property in your class should be of type RoundedDecimal instead of decimal.
Int96, because that's what it effectively is.Easiest way to refactor the code? Here's what I would do:
Now you'll need to define a set of corresponding private variables that begin with an underscore but otherwise have the same names as the properties. Start with a fresh copy of the properties from your class and perform a similar set of steps as described above.
My assumption is that each line starts with 2 tabs and there are no empty lines between properties.
Rather than having each property call Math.Round, you may want to consider defining your own utility function that they all call so that if you need to change it again, you can just change it in one place.
You could create a derivative of this class that overrides the gets and returns the rounded values. You would then need to modify the base property to be virtual. But that would allow you to define the get without defining the set and using auto properties.
public class Base
{
public virtual decimal MathValue { get; set; }
}
public class Derived : Base
{
public override decimal MathValue
{
get { return Math.Round(base.MathValue); }
}
}
But what happens if the client doesn't want a rounded value? ie, some new client code sets a decimal and expects that "exact" value back?
If some clients really need the output of the property call to be rounded, then the client should handle this and leave your class alone.
One option is to use aspect-oriented programming to intercept the property invocations on return and round the return value before passing control back to the caller.
Visual Studio used to have a built-in "prop" code snippet that would generate something like the following code:
private decimal _MathValue;
public decimal MathValue
{
get { return _MathValue; }
set { _MathValue = value; }
}
That would get you most of the way to a complete solution, but since VS 2008 it now generates the automatic property version:
public decimal MathValue { get; set; }
I haven't tried this yet, but here is a suggestion for creating your own code snippet to get the VS 2005 version of the "prop" code snippet back:
You could do this with PostSharp or some other .NET-based AOP framework. Here is the MethodExecutionEventArgs.ReturnValue property that says it can be used to "modify the return value..."
This will do it:
[Serializable]
public class RoundingAttribute : OnMethodBoundaryAspect
{
public override void OnExit(MethodExecutionEventArgs eventArgs)
{
base.OnExit(eventArgs);
eventArgs.ReturnValue = Math.Round((double)eventArgs.ReturnValue, 2);
}
}
class MyClass
{
public double NotRounded { get; set; }
public double Rounded { [Rounding] get; set; }
}
class Program
{
static void Main(string[] args)
{
var c = new MyClass
{
Rounded = 1.99999,
NotRounded = 1.99999
};
Console.WriteLine("Rounded = {0}", c.Rounded); // Writes 2
Console.WriteLine("Not Rounded = {0}", c.NotRounded); // Writes 1.99999
}
}
