Overriding Methods vs Assigning Method Delegates / Events in OOP

Question

This is a bit of an odd oop question. I want to create a set of objects (known at design time) that each have certain functions associated with them. I can either do this by giving my objects properties that can contain 'delegates':

public class StateTransition {
    Func<bool> Condition { get; set; }
    Action ActionToTake { get; set; }
    Func<bool> VerifyActionWorked { get; set; }
}

StateTransition foo = new StateTransition {
    Condition = () => {//...}
    // etc
};

Alternatively I can use an abstract class and implement this for each object I want to create:

public abstract class StateTransition {
    public abstract bool Condition();
    public abstract void ActionToTake();
    public abstract bool VerifyActionWorked();
}

class Foo : StateTransition {
    public override bool Condition() {//...}
    // etc
}

Foo f = new Foo();

I realise the practical consequences (creating at design time vs run time) of these two methods are quite different.

How can I choose which method is appropriate for my application?

Answer 1

How can I choose which method is appropriate for my application?

Does your application requires to define new transition objects that have additional different properties, or additional different methods ? Then making new subclasses, overrding methods, ("Polymorphism") is better.

Or.

Does your application requires to define transition objects that only change method behaviour ? Then Method Delegates or Methods Events are better.

Summary

Overriding Methods ("Polymorphism") is better when your application requires to add different features, like properties or methods, for different subclasses, not just changing the implementation of methods.