What happens when calling Object.ToString when the actual type is String

Question

Lets say we have the folowing code.

var foo = "I am a string";
Object obj = foo;
var bar = obj.ToString();

What is actually happening?

Cast the obj to a string and then calls the ToString Method?
Calls the ToString method on obj which is the override of string without casting?
Something else?

Witch one is better to do?

var bar = obj.ToString();
var bar = (string)obj;

`ToString` is overridden by `string` so to your first question, it's the 3rd option, no casting happens but `string.ToString` is called. — DavidG, Jun 23 '15 at 08:37

Steven Lemmens · Answer 1 · 2015-06-23T09:23:54.153

3

ToString is a method defined in the Object class, which is then inherited in every class in the entire framework.

The ToString method in the String class has been overwritten with an implementation that simply returns itself. So there is no overhead in calling ToString() on a String-object.

So, I don't think there's anything to worry about.

Also, I would go with the first option. It's more readable, and you should always get a result, no matter what type "obj" is.

edited Jun 23 '15 at 09:23

answered Jun 23 '15 at 08:30

Steven Lemmens

620
5
18

4

You don't need to bet when the [source](http://referencesource.microsoft.com/#mscorlib/system/string.cs,2758) is available. Also, your ALWAYS may be a bit too strong - you *might* get a `NullReferenceException` instead of a result. – Damien_The_Unbeliever Jun 23 '15 at 08:33
You are right. I updated my answer. – Steven Lemmens Jun 23 '15 at 08:47
Just lookin in decompile there oyu can see one line of code in the string implementation: return this; – Boas Enkler Jun 23 '15 at 08:49
True. I looked up the source as well, as Damien_The_Unbeliever suggested. I updated my answer once more. – Steven Lemmens Jun 23 '15 at 09:24

bright · Accepted Answer · 2015-06-23T08:57:00.550

1) From the open-source dotnet sources at https://github.com/dotnet/coreclr/blob/master/src/mscorlib/src/System/String.cs:

// Returns this string.
public override String ToString() {
    Contract.Ensures(Contract.Result<String>() != null);
    Contract.EndContractBlock();
    return this;
}

The override just returns this.

2) I would just use var bar = foo; instead of the cast or the .ToString(). If you only have an object, then yes .ToString() is preferred.

score 0 · Answer 3 · edited May 23 '17 at 12:14

What is actually happening?

Your code can actually be something like this

var foo = new String("I am a string".ToCharArray());
Object obj = foo;
var bar = obj.ToString();

C# string keyword is an alias to String class. The ToString method that you called simply uses polymorphism mechanism to call proper ToString implementation. As you may know string is a reference type and a child class of Object

Witch one is better to do?

From this answer.

The two are intended for different purposes. The ToString method of any object is supposed to return a string representation of that object. Casting is quite different, and the 'as' key word performs a conditional cast, as has been said. The 'as' key word basically says "get me a reference of this type to that object if that object is this type" while ToString says "get me a string representation of that object". The result may be the same in some cases but the two should never be considered interchangeable because, as I said, they exist for different purposes. If your intention is to cast then you should always use a cast, NOT ToString.

What happens when calling Object.ToString when the actual type is String

3 Answers3