overriding ToString() method

Valerie Meunier

I wonder whether there are advantages of overriding ToString() method. If yes, which ones?.

This code produces 3 times the same output, so why overriding the ToString() method?

Thanks

using System;
class Program
{
static void Main(string[] args)
{
Employee emp = new Employee() { Name = "Luke", Age= 40 };
Console.WriteLine(emp.ToString());
Console.WriteLine(emp.Name + " " + emp.Age);
emp.MyMethod();
}
}

public class Employee
{
public string Name;
public int Age;

public override string ToString()
{
return Name + " " + Age;
}

public void MyMethod()
{
Console.WriteLine(Name + " " + Age);
}
}

3 Replies

Know the answer? Post it — somebody with the same question will find it here.

Sachin Singh5y ago
Accepted answer
ToString(), simply means the string representation of a Type.
As you know, every type in c# inherits the Object Type, so we get The ToString() as a default method with all .Net Types.
For example the string representation of int i=10 (i.ToString()) will give you 10.
But, with Custom type, especially with Complex type the ToString() lost all its power because we can not represent a Complex type to its equivalent String format, This is the reason , Microsoft has given us the ability to override the ToString() by defining it as virtual.
When you override the ToString() then you actually provide the String equivalent of that type, to the client. Here client means any class that calls it.

For example, In your case, if anyone calls, Employee.ToString(), then it doesn't make sense and will give the namespace name, but when you override it then anyone can get the string form of Employee Type.
public class Employee
{
    public string Name;
    public int Age;



    public void MyMethod()

}

// Employee emp= new Employee();
emp.ToString() // doesn't make sense.

public class Employee
{
    public string Name;
    public int Age;

    public override string ToString()
    {
        return Name + " " + Age;
    }

    public void MyMethod()
    {
        Console.WriteLine(Name + " " + Age);
    }
}

// Employee emp= new Employee(){Name="sachin",Age=25};
// emp.ToString(); Sachin 25// now make sense.
+1
Valerie Meunier5y ago
Thanks
+1
Anant Vernekar5y ago
Hi. It is always best practices to use override the implementation of ToString() instead of adding a specific implementation or normal method. Here OOPS will give a feature of polymorphism to override the implementation as we need it. Incase I inherit this class to another new class,there I can have a override implementation of ToString() as I needed. This will be a very clean and open for extension and close for modification. This will again follow to Open-closed principal of SOLID principals.
+1