I want to redefine the ToString() function in one of my classes.
I wrote
public string ToString()
... and it's working fine. But ReSharper is telling me to change this to either
public new string ToString()
or
public override string ToString()
What's the difference? Why does C# requires something like this?
If you use public string ToString()
it is unclear what you intended to do. If you mean to change the behaviour of ToString
via polymorphism, then override
. You could add a new ToString()
, but that would be silly. Don't do that!
The difference is what happens when you do:
MyType t = new MyType();
object o = t;
Console.WriteLine(t.ToString());
Console.WriteLine(o.ToString());
If you override
, both will output your new version. If you new
, only the first will use your new version; the second will use the original implementation.
I don't think I've ever seen anybody use method hiding (aka new
) on ToString()
.
The problem is that ToString is a virtual method. In order to override a virtual method in C# you need to specify the override keyword.
You almost certainly do not want the "new" version. .
The new modifier will hide or "shadow" the member with the same signature in the base class where as overriding provides a new implementation of a member inherited from a base class. Here is a good article on the differences between shadowing and overriding.
You want to override. There's really no advantage to hiding in your case (using "new").
Here's an article on the differences between overriding and hiding.
C# doesn't require it; Resharper does. It requires it because the two keywords represent significantly different behavior, and if you don't specify, someone reading your code might not be entirely clear on which the default behavior is (it's new
.)
In this case you clearly want to override.
ToString is a virtual method in base class. To make the current member override that implementation, add the override keyword. Otherwise add the new keyword.
What you do all depends on the behaviour you want. This article explains how the behaviour of ToString works depending on how you defined the method and what level in a class hierarchy you call ToString on.
A personal recommendation from me would be to not use hiding; it causes many ambiguities and solves few.
ToString() method is available for every type in .NET, as this method is defined as a virtual method in the base System.Object class, and all types directly or indirectly inherit from System.Object. If the default implementation of ToString() method doesn't server your purpose, you may wish to override (use override keyword) or hide (use new keyword) it.
I have come across the following 2 excellent articles explaining the reasons to override ToString() method, and the difference between method hiding and method overriding. There is also a youtube video on the same concepts
Reason to override ToString()
Difference between method hiding and method overriding