C＃方法，可以选择通过子类实现，而无需基本方法

Question

I have Code OCD, so bear with me.

We have a base class with:

virtual protected void OnHierarchyInitialized()
{
}

Now when someone overrides this method, they almost are to be expected to call the base method:

protected override void OnHierarchyInitialized()
{
    base.OnHierarchyInitialized();
}

But.. nothing is happening in the base method. Nor will in the future. I just don't want people that subclass need to 'worry' when and if they need to call the base method. Plus: this is ugly fat in the implementing code, that distracts from the rest of the code that looks like a C# version of the Mona Lisa itself.

Of course I could make it an abstract method, but here is the big disadvantage that it needs to be implemented. Also screws up my work of art.

Question

Is there something in between a virtual and abstract method, that tells the message:

override me optionally, but there is no base method to call ?

Thanks in advance!

Answer 1

Pretty sure the only thing you can do is use the built in XML documentation to notify the callers. For example, this is how it would show up to the person overriding your method:

Answer 2

There is no keyword in c# to do that. virtual is the best there is for this approach.

Just don't worry about if there is an base class implementation or not. The one implementing the derived class shouldn't worry about it.

There is just one question: Does the current implementation totally replace the base class's implementation?

If it does, don't call the base class. If it doesn't: call it.

Answer 3

If your code looks like this:

public void Foo()
{
    // do something

    OnHierarchyInitialized();

    // do something else

}

You may want to consider events instead of inheritance:

public event EventHandler HierarchyInitialized = delegate { };

OnHierarchyInitialized();

public void Foo()
{
    // do something

    OnHierarchyInitialized(new EventArgs());

    // do something else

}

private void OnHierarchyInitialized(EventArgs e)
{
    EventHandler handler = HierarchyInitialized;
    handler(this, e);
}

Where consumers can then subscribe to the HierarchyInitialized event when they're interested in it.

Answer 4

If you're absolutely sure that the base method will never actually do anything, then an abstract method is exactly the right approach. I know you say this will screw up your work of art, but think about it like this: you want a way to explicitly tell the user that the base method does nothing. An abstract method will accomplish this, whilst reminding them that the method is there, even if they choose not to use it.

Think about how interfaces work - they are a collection of abstract methods that do nothing but have to be overridden. This is the correct approach, and compliments your work of art by enforcing the inclusion of the method. The empty method shows the user that they can hook into the OnHierarchyInitialized method to achieve something.