Does this keyword exist? When an overriding method needs to call the parent

.net, c#, inheritance

Solution

You can't enforce it, but you can do it via a call like `base.Foo(bar)`. `base` allows you to access members of the class you're inheriting from.

You can kind of enforce this behavior by using the template method pattern. For example, imagine you had this code:

abstract class Animal
{
    public virtual void Speak()
    {
        Console.WriteLine("I'm an animal.");
    }
}

class Dog : Animal
{
    public override void Speak()
    {
        base.Speak();
        Console.WriteLine("I'm a dog.");
    }
}

The trouble here is that any class inheriting from `Animal` needs to call `base.Speak();` to ensure the base behavior is executed. You can automatically enforce this by taking the following (slightly different) approach:

abstract class Animal
{
    public void Speak()
    {
        Console.WriteLine("I'm an animal.");
        DoSpeak();
    }

    protected abstract void DoSpeak();
}

class Dog : Animal
{
    protected override void DoSpeak()
    {
        Console.WriteLine("I'm a dog.");
    }
}

In this case, clients still only see the polymorphic `Speak` method, but the `Animal.Speak` behavior is guaranteed to execute. The problem is that if you have further inheritence (e.g. `class Dachsund : Dog`), you have to create yet another abstract method if you want `Dog.Speak` to be guaranteed to execute.

Problem

Often, in C# documentation, you come across a member where the description says something along the lines of "be sure to call the base method if you override this." Is there a way to ensure at compile time that one has actually called the base function? Here's an example: Implementing a Dispose Method From the first lines: A type's Dispose method should release all the resources that it owns. It should also release all resources owned by its base types by calling its parent type's Dispose method. EDIT I was browsing, and I came across this article, which seems rather relevant. It's more of a small than an error, ie. it has valid uses (such as those mentioned): Call Super

Original source