Why do we use virtual and override?

Question

Why do we use override and virtual if it gives the same effect when we dont use override and virtual?

example 1:

class BaseClass
{
    public virtual         


        

Answer 1

Best example I can think of where this is useful is when you create your own object(class) and you have to add a list of that object to a combobox.

When you add your object to the combobox you want to be able to control what text is displayed for each item. Object.toString is a virtual method. http://msdn.microsoft.com/en-us/library/system.object.tostring.aspx and because of this you can override that method and set .toString to display the correct information about your object by overriding it.

public MyClass()
{
     private int ID;
     public override string ToString()
     {
         return "My Item:" + ID;
     }
}

Answer 2

Virtual and override are a base mechanism of inheritance in object oriented programming. This is perhaps the most important thing to understand when you use classes in a language like C# or Java.

http://en.wikipedia.org/wiki/Inheritance_(object-oriented_programming)

Inheritance allow you to reuse code adding new fields, properties and methods or replacing methods and properties of previously defined classes.

Virtual and Override allow you to replace the content of a method, and when i say replace, i say replace.

I would propose you a nice example.

public class MyClassEnglish
{
    public virtual string SomethingToSay()
    {
        return "Hello!";
    }

    public void WriteToConsole()
    {
        Console.WriteLine(this.SomethingToSay());
    }
}

public class MyClassItalian :
    MyClassEnglish
{
    public override string SomethingToSay()
    {
        return "Ciao!";
    }
}

int main()
{
    MyClassItalian it = new MyClassItalian();

    it.WriteToConsole();
}

If you omit virtual and override, MyClassItalian will print out "Hello!" and not "Ciao!".

In your example you show a Shadowing technique, but the compiler should give you a warning. You shoul add the "new" keyword if you want to hide a method in a base class. Hiding a method is not overriding! Is just hiding.

One possible use that comes into my mind is that it can be used when you need some kind of optimization for example.

public abstract class MySpecialListBase
{
    public int Count()
    {
        return this.GetCount();
    }

    protected abstract int GetCount();
}

public sealed class MySpecialArrayList : MySpecialListBase
{
    int count;

    public new int Count()
    {
        return this.count;
    }

    protected override int GetCount()
    {
        return this.count;
    }
}

Now... You can use MySpecialListBase in all your code, and when you call the Count() it will call the virtual method GetCount(). But if you use just MySpecialArrayList it will call the optimized Count() that is not virtual and that just return a field, increasing performances.

// This works with all kind of lists, but since it is a more general purpose method it will call the virtual method.    
public void MyMethod(MySpecialListBase list)
{
    Console.WriteLine(list.Count());
}

// This works only with MySpecialArrayList, and will use the optimized method.
public void MyMethod(MySpecialArrayList list)
{
    Console.WriteLine(list.Count());
}

Answer 3

(note, I'm quietly ignoring the compile errors)

Now do:

BaseClass obj = new DerivedClass();
Console.WriteLine(obj.call());

Without virtual, this will print A, when actually a DerivedClass should be writing B. This is because it has simply called the BaseClass implementation (since obj is typed as BaseClass, and no polymorphism is defined).

Answer 4

Method Overriding:

Where you define or implement a virtual method in a parent class and then replace it in a descendant class.

When you decide to declare a method as virtual, you are giving permission to derived classes to extend and override the method with their own implementation. You can have the extended method call the parent method's code too.

In most OO languages you can also choose to hide a parent method. When you introduce a new implementation of the same named method with the same signature without overriding, you are hiding the parent method.

C# Overriding In C#, you specify a virtual method with the virtual keyword in a parent class and extend (or replace) it in a descendant class using the override keyword.

Use the base keyword in the descendant method to execute the code in the parent method, i.e. base.SomeMethod().

Syntax Example:

class Robot
{
  public virtual void Speak()
  {
  }
}

class Cyborg:Robot
{
   public override void Speak()
   {
   }
}

Override Details You cannot override a regular non-virtual method, nor a static method. The first version of the parent method must be virtual or abstract. You can override any parent method marked virtual, abstract, or override (already overridden). The methods must have the same signature. The methods must have the same visibility (the same access level). Use the base keyword to refer to the parent class as in base.SomeMethod(). C# Override Example The following code snippet demonstrates using virtual and override to override a parent method in a descendant class.

using System;

class Dog
{
   public virtual void Bark()
   {
       Console.WriteLine("RUFF!");
   }
}

class GermanShepard:Dog
{
    public override void Bark()
    {
       Console.WriteLine("Rrrrooouuff!!");
    }
}

class Chiuaua:Dog
{
    public override void Bark()
    {
         Console.WriteLine("ruff");
    }
}
class InclusionExample
{
     public static void Main()
     {
        Dog MyDog=new Dog();    
        MyDog=new GermanShepard();
        MyDog.Bark(); // prints Rrrrooouuff!!

        MyDog=new Chiuaua();
        MyDog.Bark(); // prints ruff;
    }
}

Hiding a Method with New Use the new keyword to introduce a new implementation of a parent method (this hides the parent method). You can hide a method without using new but you will get a compiler warning. Using new will suppress the warning.

The new and override modifiers have different meanings. The new modifier creates a new member with the same name, signature, and visibility and hides the original member. The override modifier extends the implementation for an inherited member and allows you to implement inheritance-based polymorphism.

Avoid Introducing New Members: Sometimes there are clear reasons to introduce a new method with the same name, signature, and visibility of a parent method. In those clear cases, introducing a new member is a powerful feature. However, if you do not have a clear reason, then avoid introducing a new version of a method by naming the new method something unique and appropriate.

class Robot : System.Object
{
  public void Speak()
  {
    MessageBox.Show("Robot says hi");
  }
}

class Cyborg : Robot
{
  new public void Speak()
  {
    MessageBox.Show("hi");
  }
}

Calling the Base Class Version A common task In OO is to extend a method by first executing the parent method code and then adding code. Use the base keyword to refer to the parent class as in base.SomeMethod().

class Robot : System.Object
{
    public virtual void Speak()
    {
       MessageBox.Show("Robot says hi");
    }
}
class Cyborg : Robot
{
  public override void Speak()
  {
      base.Speak(); 
      MessageBox.Show("hi");
  }
}