polymorphism - Can't use virtual and override on the same method in C#

Question

So apparently you cannot use the virtual modifier with the override modifier.

virtual - a method that can be overridden

override - a method that is overriding a method of the same name in its parent's class

This leads me to believe that if I override a method in a child class, if that child has a child you can't override that method again.

And it is safe to say that if you put override and virtual in a method declaration you will get a compile error in C#.

However I can't understand why the code I made below works the way in which it does

using System;
public class DrawingObject
{
public virtual void Draw()
{
    Console.WriteLine("Drawing Object");
}
}
public class DrawDemo
{
     public static int Main()
     {
          DrawingObject[] dObj = new DrawingObject[3];


          dObj[0] = new DrawingObject();
           dObj[1] = new Line();
           dObj[2] = new LittleLine();

           foreach (DrawingObject drawObj in dObj)
           {
                drawObj.Draw();
           }
            Console.Read();
           return 0;
       }
  }
 public class Line : DrawingObject
 {
       public override void Draw()
       {// the method above me is in fact virtual because LittleLine overid it?
               Console.WriteLine("I'm a Line.");
       }
  }
  public class LittleLine : Line
  {
       public override void Draw()
       {
              Console.WriteLine("I'm a Little Line.");
         }
    }

Here's the output:

Drawing Object

I'm a Line.

I'm a Little Line.

So the draw method in Line looks as though it was overridden by LittleLine. Is this code not actually overriding it, or is the compiler doing some other trick? Or am I not understanding the context of virtual and override?

Answer 1

You can declare a certain method as virtual only once, but you can override it as many times as you want - an override is not final, and it does not limit classes that inherit from the first overriding class. The method that will eventually execute is the last one the overrides the virtual method. So your code does behave as expected.

C# is very verbose with regard to overriding - you have more specifiers than C++ or Java. It is so to let the programmer specify the exact intent:

• You use virtual to specify a method can be overridden by subclasses.
• You use override to specify you are overriding a method that you know is virtual (if it's not, the compiler will report an error).
• You use sealed to prevent further overriding.
• And you use new to hide instead of override.

This can be confusing and sometimes annoying, but it ensures you actually know what you're doing, and it makes your intention self-documented.