Question

This is probably my naivety showing through, but anyway…

I have a generic interface which defines a set of standard methods (implemented differently) across implementations.

I pass the interface into a method as a parameter, this method being responsible for persisting to a database. E.g. I have some implementations called bug, incident, etc, defined from the generic interface (called IEntry). These concerete implementations also make use of IEnumerable

Because a bug is different to an incident, there are different fields. When I pass the interface into a method as a parameter, is there any way to inference the type? So if I pass in the Bug object, I can use its fields, which are not the same fields as in those of Incident. These fields are useful for the persistance to the database. I’m assuming no because there is no way to know what the type to be passed in will be (obviously), but I know people here have more wisdom. In that case, is there a better way of doing things? Because of the similarity, I would like to stick to interfaces.

EDIT: I guess the other way is to make use of some flow control to generate the sql statement on the fly and then pass it in as a parameter.

Thanks

Answer 1

The thing about passing objects and interfaces around is that you really shouldn’t be concerned with the actual type, as long as it inherits from/implements the particular base class/interface you’re interested in.

So building logic into that method to figure out that it’s a bug, and then accessing things that are only present for bugs, that’s basically not the OOP way, although it might be the ‘best’ way in your particular case.

I would, however, advise against it, and instead try to build a proper OOP way with polymorphism to handle the differences, instead of building it into the method as special cases.

You mention persistence, is this method responsible for storing the data somewhere? Perhaps you could separate the part that gathers the information to store from the part that stores the information, that way you could ask the object itself to provide you with all the pertinent information, which could vary from one class to another.