Is this ASP.NET Inherited Shared Function practice acceptable?

Question

I have a bunch of different forms that I would like to create a base MustInherit class for. One function I would like them all to contain is a shared function called GetForms(). I know that you can't declare a shared function MustOverride so I did the following in my abstract class:

Public Shared Function GetForms() As List(Of OrderForm)
    'to be overridden in child class'
    Return Nothing
End Function

And this in my child class:

Public Overloads Shared Function GetForms() As List(Of OrderForm)
    'do stuff'
End Function

Will this cause problems down the line, or is this an acceptable workaround? It has a smell to it, but it will enforce that all my forms include a shared GetForms function.

EDIT I realize that if this were possible with interfaces, I would use one, but you can't declare shared functions in interfaces and I would like to make sure that this is a SHARED function.

Any help would be greatly appreciated. Thanks so much!

Answer 1

Yes, that does smell!

Looks like you should be using an interface instead.

Here is a vb.net article: http://www.developer.com/lang/other/article.php/939411

Answer 2

Why wouldn't you simply declare it as:

Public MustOverride Function GetForms() As List(Of OrderForm)?

Answer 3

This has a smell because it creates a false expectation of the behavior of the code.

You mention that your reason for doing this is that 'it will enforce that all my forms include a shared GetForms function'. This is only partly true. Yes, they will all have the GetForms function, but you're not actually forcing the derived classes to implement their own version of it. If you forget to implement the function on one of them, you'll be calling the base version, and you won't get any sort of warning about it from the compiler.

That is the smell: it can't actually enforce the behavior that you want, but it creates an impression, at first glance, that it can. This will lead to headaches 6 months from now when you're adding a new Form type and you've forgotten the convention. You'll get no warning that something's wrong until you start getting bad results during testing.

If you want to enforce behavior, you have to do it using instance members; using MustOverride (abstract) functions or an interface.

Answer 4

Static methods aren't inherited, so the expectation of overriding is not something we want to encourage. In other words, I think you might be barking up the wrong tree here.

Answer 5

You can have static (Shared) methods like that, but you can't enforce the implementation of them.

Each static method is local to it's class, you can't overload it in a child class or make it abstract (MustInherit). You have to use an instance method (non-static) to get the object oriented aspects that you want.