Inheritance question

Question

I'm a newbie to C#. I tried C++ and but found it too convoluted.

Here's my question. If I use inheritance, and later realize that a subclass needs a method or field that is not applicable to the other parts, should I declare that in the base class and not have it implemented in the child classes, or should I declare that method or property in the subclass?

If I choose to declare the method in the subclass, then I can no longer treat everything polymorphically. On the other hand, if I choose to put it in the base class then I end up with a lot of classes not implementing the property or method. I have seen examples in the .net framework where the 'not implemented' approach is chosen. What is the best way to go?

Answer 1

is it a specialized method at only one subbclass needs? then implement in the sub class. Otherwise implement as a virtual in the base class that throws a NotImplementedException. Then in any class that needs it add as override.

Answer 2

If only one subclass has method X, of course you can't call X polymorphically, by definition. Is it reasonable for X to exist in the superclass (and therefore everywhere) but be a no-op in most cases? Sometimes it is, sometimes you just have to rethink your whole class hierarchy, i.e., why do you want to call X polymorphically, even where it might not exist (or at best be a no-op)? It's impossible to respond without knowing much, much more about your specific use case!

Answer 3

If it will only be used in the subclass and doesn't need to be called polymorphically, then implement it only in the subclass. However, if you need to use it polymorphically then think about what that function would mean for other subclasses of the super class.

If there is no good meaning for that function, then you may need to rethink your class hierarchy. However, you can just do No-op or throw a NotImplementedException for subclasses where the function has no valid meaning. I'm not really a fan of either, but sometimes there isn't a way around using those.

Answer 4

I've always preferred to use NotImplemented style exceptions for code that isn't finished yet. I would never personally use it just so I could push more methods into a base class.

Answer 5

For this one you need to answer some questions about the intent of your API.

1. How is your API to be used: If your API consumers are to almost always refer to your base class, then it may make sense to put it into the base class.
2. If the method your trying to implement is applicable to almost all derived classes that could choose to implement the functionality, then put it in the base class.

Consider System.IO.Stream, this is an abstract class with abstract methods for seek operations, it makes sense to not have to derive from something like System.IO.SeekableStrem just to get seek functionality, users of the API should only refer to Stream.