Depend on the behavior you need

First, build a mental model

An interface names a capability. Composition gives an object a collaborator that provides that capability. Inheritance is appropriate when a subtype can honor the base contract, not merely because two classes share a few lines.

1. A C# class explicitly implements an interface and supplies its required members.
2. A caller accepting the interface can work with different conforming implementations.
3. Constructor parameters can make a dependency visible and replaceable in tests.
4. A base class shares implementation and a subtype relationship; an interface expresses a contract. Composition can avoid a fragile hierarchy of unrelated variants.

IDamageRule rule = new FlatShield();
Console.WriteLine(rule.Apply(7));
Console.WriteLine(rule.Apply(1));

interface IDamageRule
{
    int Apply(int incoming);
}
sealed class FlatShield : IDamageRule
{
    public int Apply(int incoming) => Math.Max(0, incoming - 2);
}
sealed class NoShield : IDamageRule
{
    public int Apply(int incoming) => Math.Max(0, incoming);
}

1. Contract

   The caller relies on Apply(int), not a particular shield's private details.

2. Implementation

   FlatShield removes two damage while keeping the result nonnegative.

3. Substitution

   NoShield can be supplied through the same IDamageRule contract.