Events or Inheritance?

Question

Hello,

I have a process class, where if the input contains a value it will also do something else.

For example

Person { name; age }

ProcessPerson(person) //takes in a person

in the ProcessPerson if the age is = over 18 (Adult) then send an email.

The ProcessPerson already exists, and the base logic has to be run no matter what (save the person to the DB).

At the moment, there is only 1 condition where this extra logic is run, but it looks like there will be points in the future where there will be more added.

I can think of 2 ways of solving this, and wanted a soundboard session:

1. Inheritance -> create a derived class called ProcessAdult
2. Events -> post saving the person to the DB, raise a processed event. Add a handler which sends the email.

I prefer the latter of the 2. Or perhaps there is another clean and extensible method that I have not thought of?

Answer 1

Your second option is surely a lot better.

Answer 2

I vote for 2nd option.

Answer 3

For the case you describe, I also like #2. Sounds cleaner and more directly addresses your situation.

Answer 4

I might be misunderstanding you but I wouldn't subclass the Process class but rather the Person class and require the children to implement a "PostProcess" method or something. This actually allows you to also require "PreProcess", too, if you think in a couple of years you might ever have a need for it. Then your Process method takes a Person-base, calls PreProcess(), inserts into the DB and then calls PostProcess(). Children must implement the method but obviously don't have to do anything.

But honestly, depending on where this lives and the number of possible scenarios I'd rather just do this from within in the Process() and not deal with Events or Inheritance.

if(person.Age>=18){}else if(person.Pets){}...

Answer 5

Maybe your description is simpler than your actual problem, but what is wrong with:

void ProcessPerson(Person const& p) {
    // do what you always do

    if(p.age>=18) {
        // send mail
    }
    // add other "special" handling here
}

?

You would derive from Person if you had additional data or special methods or both but you don't. You could then implement a specialization of ProcessPerson to handle the derived class.

If all information needed to process a Person object is available locally, do everything necessary in this method.

When you need different pieces of information to process the Person, that have nothing to do with each other, distribute the processing. You could have e.g. different handlers for your database and your mail system and sth like:

Person p;
foreach(handler in handler list) {
    handler.Process(p);
}

and the mail handler would send notifications, the database handler would write to the db etc.

Answer 6

I vote for number 2, but to keep things extensible, be sure to include the processed person in the event signature.

public delegate void PersonProcessedEventHandler(Person p);
public event PersonProcessedEventHandler PersonProcessed;

This keeps your event invocation generalized. Your person processor simply raises the event that a person was processed, and any other handler can do with that person as it pleases.

public void EmailAdult(Person p)
{
    if(p.age >= 18)
    {
        //send email
    }
}

public void SendWaffles(Person p)
{
    if(p.name = "John Skeet")
    {
        //send waffles
    }
 }

thePersonProcessor.PersonProcessed += EmailAdult;
thePersonProcesser.PersonProcessed += SendWaffles;