Page 2 of 2
This is a very silly problem. It all comes down to a careful interpretation of what the Add method actually does. The programmer who had made the mistake had in his head:
"The Add method adds 12 hours to the date stored in t1"
And it clearly does because the test
In fact what he should have had in his head was:
"The Add method adds 12 hours to the date stored in t1 and then returns a brand new TimeDate object"
Now it all makes sense.
When you do
it is the temporary object that is created by the Add method that is used to compare with EndDate and so it all works. However when you do:
t1.Add(new TimeSpan(12, 0, 0));
Do something as the task nearly over
the new object created by Add is just thrown away and t1 doesn't change.
You can easily see that this is the case by writing:
t1.Add(new TimeSpan(12, 0, 0));
and noticing that t1 hasn't changed.
It becomes even more obvious when you consider the operation written in terms of the overloaded "+" operator. For example, you would never write:
TimeSpan d1=new TimeSpan(12, 0, 0);
t1 + d1;
as it is obvious that the + operator doesn't modify t1 and you are clearly throwing away the result of an expression - something that C# doesn't allow so you will also see an error message.
The solution to the problem is obvious - just be aware that the Add method doesn't modify the object it is a member of.
It is all to easy too write this problem off as trivial. In fact it reveals a lot about the way we think of things in procedural programming and in object-oriented programming. For example, when you first start writing code you quickly learn:
and understand the idea of assignment in action. Notice that a mathematical interpretation of the above results in a deduction: i.e. if x=x+1 then 0=1 which is of course nonsense and here you have the distinction between math and programming.
So far so good but then, if you move on to the right programming language, you learn:
both of which can be interpreted as telling data to add one to itself.
Moving on to object-oriented programming you then start to think about methods that do things to objects. For example you might invent a Sort method for an array that sorts it into order. For simple efficiency reasons it might never occur to you that the Sort method should return a new copy of the array and leave the original untouched.That is the Sort method actually sorts the original array - this is generally called an "In place Sort" or an in place method.
In-place methods may seem natural when you first start programming but the "always generate a new object" approach is becoming the norm today - partly because we believe that immutability is a good idea and partly to fit in with the operator semantics i.e. methods should be usable as operators.
As already pointed out just as methods can adopt operator semantics by creating a new object as a result so too can operators take on in-place semantics, i.e. ++data and data++
Whatever the reason we do have two conventions - in-place methods and operator methods and it important that you always know which is which.
|Sharpen Your Coding Skills|
Three Warehouses Puzzle
Talking through a problem is often a good way to see what is required for its solution. Reducing it in scale is another good strategy. But as programmers at the end of the day we need to code an algor [ ... ]