Explaining virtual methods in C# with words and pictures

In this post I will try to explain virtual methods in C#.  There are similar concepts in other languages, like C++ and Java, but I can’t vouch that all the details I go into here will apply exactly to any other language.  The whole post is quite long, but I want to get to a slightly weird destination in a series of small and hopefully easy to understand steps.

To start with I will go through a very simple example that lays the foundations for the later examples.  It will introduce you to a diagram that I hope will prove useful later, via a gentle reminder of inheritance.  There might be times when you want to compare two examples, e.g. to see how a code change leads to a behaviour change.  I suggest you bring this article up in two different browser windows and have them side-by-side on the screen so you can scroll them to different positions.

The major difference between the article you’re reading now and other articles that I’ve seen is that as well as listings and output, I will try to explain things using diagrams.  This is an area that only properly clicked for me once I’d got out paper and pen to draw a diagram that would explain the behaviour I was seeing.  I have no idea if this is what’s actually happening behind the scenes, but it fits the evidence and also works for me.

1. Simple inheritance

This is almost as simple as it could get but is mostly to introduce the source code that will act as a framework for later examples, and to introduce the diagrams.

Class A is the parent class for B, which in turn is the parent class for C.  A defines a public method X, which is therefore visible to B and C.  (It could also have been protected rather than public.)  All the examples will be like this – one method X, and a set of classes named after the letters of the alphabet that derive from each other in this kind of straight line.

In the calling code there’s an important pair of related things to keep separate in your mind.  One is the type of the variable, and the other is the type of the value held by the variable.  For the first three variables – a, b and c – these are the same.  The variable a has the type A and stores a value that is also of type A and so on.

For each of the next three variables, the type of the variable is different from the type of the value it holds.  In all cases, the value’s type is a child or grand-child type of the variable’s type.

Seeing as we have only one definition of any method, it’s probably not surprising that the output is the same from all variables (apart from the label).  Note that the main method is common to all the examples apart from the last one (which is bigger), and so it will be shown here but not repeated in the examples below.  Its job is just to call the classes in our class hierarchy in a variety of ways.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

using System;

namespace Inheritance
{
    class Program
    {
        static void Main()
        {
            A a = new A();
            B b = new B();
            C c = new C();

            A bInA = new B();

            A cInA = new C();
            B cInB = new C();

            a.X(1, "a");
            b.X(2, "b");
            c.X(3, "c");

            bInA.X(4, "bInA");

            cInA.X(5, "cInA");
            cInB.X(6, "cInB");

            Console.ReadLine();
        }
    }

    public class A
    {
        public void X(int lineNum, string label)
        {
            Console.WriteLine(lineNum.ToString() + ". A:X from " + label);
        }
    }

    public class B : A
    {
    }

    public class C : B
    {
    }
}

It produces the following output. The layout is probably a bit confusing, but I hope it will be worth it later when the examples get more complicated. I’ve rearranged things from the linear order of the code into a grid to show the relationship between types and output.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

    public class A
    {
        public void X(int? lineNum, string label)
        {
            Console.WriteLine((lineNum.HasValue ? lineNum.ToString() + "." : "  ") + " A:X from " + label);
        }
    }

    public class B : A
    {
    }

    public class C : B
    {
        public new void X(int? lineNum, string label)
        {
            Console.WriteLine((lineNum.HasValue ? lineNum.ToString() + "." : "  ") + " C:X from " + label);
            base.X(null, label);
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

   public static class Log
    {
        public static void Write(int? lineNum, string label, string me)
        {
            Console.WriteLine((lineNum.HasValue ? lineNum.ToString() + "." : "  ") + " " + me +" from " + label);
        }
    }

    public class A
    {
        public void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "A:X");
        }
    }

    public class B : A
    {
        public new void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "B:X");
            base.X(null, label);
        }
    }

    public class C : B
    {
        public new void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "C:X");
            base.X(null, label);
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

    public class A
    {
        public virtual void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "A:X");
        }
    }

    public class B : A
    {
        public override void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "B:X");
            base.X(null, label);
        }
    }

    public class C : B
    {
        public override void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "C:X");
            base.X(null, label);
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

    public class A
    {
        public virtual void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "A:X");
        }
    }

    public class B : A
    {
        public override void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "B:X");
            base.X(null, label);
        }
    }

    public class C : B
    {
        public new void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "C:X");
            base.X(null, label);
        }
    }

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

    public class A
    {
        public virtual void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "A:X");
        }
    }

    public class B : A
    {
        public override void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "B:X");
            base.X(null, label);
        }
    }

    public class C : B
    {
        public new virtual void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "C:X");
            base.X(null, label);
        }
    }

    public class D : C
    {
        public override void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "D:X");
            base.X(null, label);
        }
    }

    public class E : D
    {
        public override void X(int? lineNum, string label)
        {
            Log.Write(lineNum, label, "E:X");
            base.X(null, label);
        }
    }