CODEWITHSUNDEEP
c#polymorphism
Frank Visaggio
Frank Visaggio

Reputation: 3712

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

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?

Upvotes: 27

Views: 11175

Answers (6)

Eran
Eran

Reputation: 22020

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.

Upvotes: 35

Volodymyr Dombrovskyi
Volodymyr Dombrovskyi

Reputation: 269

This behavior is right. If you don't want inherited class to override your virtual method, you can mark it "sealed" like this:

public class Line : DrawingObject
 {
       public sealed override void Draw()
       {
               Console.WriteLine("I'm a Line.");
       }
  }

After that LittleLine class won't be able to override Draw method.

Upvotes: 2

Mr. Graves
Mr. Graves

Reputation: 452

It looks like it worked as intended.

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

You're calling Draw() and in a loop

heres the output Drawing Object I'm a Line. I'm a Little Line

dObj[0].Draw() -> "Drawing Object" dObj[1].Draw() -> "I'm a Line." dObj[2].Draw() -> "I'm a Little Line"

So The draw method in Line looks as though it was Overrriden by LittleLine

Yes, isn't that what you expected? The method was marked as Virtual at the base class and you've overridden it. If you want to 'add to it' you'll need to use some other pattern. A decorator perhaps.

Upvotes: 1

YavgenyP
YavgenyP

Reputation: 2123

I think you simply misunderstood how virtual works. It's not limited to one level of inheritance, as explained here, for example:

For every virtual method declared in or inherited by a class, there exists a most derived implementation of the method with respect to that class. The most derived implementation of a virtual method M with respect to a class R is determined as follows:
•If R contains the introducing virtual declaration of M, then this is the most derived implementation of M.
•Otherwise, if R contains an override of M, then this is the most derived implementation of M.
•Otherwise, the most derived implementation of M with respect to R is the same as the most derived implementation of M with respect to the direct base class of R.

Upvotes: 2

Jon Skeet
Jon Skeet

Reputation: 1500515

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

Indeed. The method stays virtual unless you override it with a method which is also declared to be sealed. (You can only use the sealed modify on a method when you're overriding something.) From section 10.6.5 of the C# 4 spec:

When an instance method declaration includes a sealed modifier, that method is said to be a sealed method. If an instance method declaration includes the sealed modifier, it must also include the override modifier. Use of the sealed modifier prevents a derived class from further overriding the method.

Upvotes: 5

MNGwinn
MNGwinn

Reputation: 2394

virtual means your method is dispatched through a virtual method table. If a method's virtual, any reference to that method on a derived class has to go through the vtable. You can't non-virtualize it just because a derived class overrides it - what would happen if LittleLine was cast to DrawingObject? You still need to find the correct implementation, which wouldn't be DrawingObject's

Upvotes: 1

Related Questions