Sharing code between diverse classes of my inheritance tree

Question

Let's say I have the following inheritance tree:

        ______ Object______
       /                   \
     Food              Material
   /     \            /        \
Egg       Carrot   Box          Axe

Expressed like this in C#

class Object { ... }

class Food : Object { ... }
class OfficeMaterial : Object{ ... }    

class Box : OfficeMaterial { ... }
class Spoon : OfficeMaterial { ... }
class Egg : Food { ... }
class Carrot : Food { ... }

And now I want to share the functionality only between the class Box and Egg, for instance:

bool opened = true;

public void Open() { open = true; }
public void Close() { open = false; }
public bool IsOpen() { return opened; }

This is a short example, but it could be something much longer.

What would be the proper way to do it? If I use inheritance, other classes like Carrot and Axe will get it, which is something I do not wish.

UPDATE Many people mention Composition. Could someone show me how that would work in the example I presented?

Answer 1

You have a few options:

1. Use interfaces

Ex:

public interface IOpenable
{
    void Open();
    void Close();
    bool IsOpen();
}

Then any class that needs the openable/closable behavior can implement the interface accordingly.

2. Favor composition over inheritance and compose your objects out of other objects that implement the desired behavior.

Answer 2

Why not use an interface? IOpenable?

interface IOpenable {
    void Open();
    void Close();
    bool IsOpen();
}

Answer 3

When I think about the similarities between Egg and Box that are not properties shared by Carrot and Axe I think first about the fact that they contain something.

1. Egg and Box have Contents which can be exposed, hidden, added, removed, etc.

Notice the language here - Egg and Box have Contents. The word have (or has) is an indicator that an object representing the Contents of another object should be used as a composition element.

An Egg is a type of Food. An Egg has Contents which are a Yolk and an EggWhite.

A Box is a type of OfficeMaterial. A Box has Contents which are OfficeSupplies.

I could write something like this:

public class Food : Object 
{
    public void Eat() { }
}

public class OfficeMaterial : Object { }

public class Contents : Object 
{
    bool _visible = false;

    List<Object> _things = new List<Object>();

    public int Count { get { return _things.Count; } }

    public bool IsOpen { get { return _visible; } }

    public void Expose()
    {
        _visible = true;
    }

    public void Hide()
    {
        _visible = false;
    }

    public void Add(object thing)
    {
        _things.Add(thing);
    }

    public bool Remove(object thing)
    {
        return _things.Remove(thing);
    }
}

public class Box : OfficeMaterial 
{
    public Contents BoxContents = new Contents();
}

public class Egg : Food 
{
    public Contents EggContents = new Contents();
}

Which would further allow me to:

void PlaceEggsInBox(int numEggs, Box box)
{
    box.BoxContents.Expose();

    if (box.BoxContents.AreVisible)
    {
        int eggsInBox = box.BoxContents.Things.Count(thing => thing is Egg);

        for (int i = 0; i < numEggs - eggsInBox; i++)
        {
            box.BoxContents.Add(new Egg());
        }
    }
}

And then I might like to

void EatAllEggsInBox(Box box)
{
    box.BoxContents.Expose();

    foreach (Egg egg in box.BoxContents.Things.Where(thing => thing is Egg))
    {
        box.BoxContents.Remove(egg);

        egg.EggContents.Expose();

        if (egg.EggContents.AreVisible) egg.Eat();
    }
}

The Eat() method is a method of the Food class. The Expose() method is a method of the Contents class, not the Food class or the OfficeMaterials class, nor of the Egg nor Box classes.

Answer 4

That's effectively multiple inheritance, which C# doesn't support other than through interfaces.

An option is to create an interface without the Open method (otherwise you'll have to implement it, so this is only for typing purposes) then implement a static extension methods in a static class alongside your interface.

public Interface IOpenable { }

public static class IOpenableExtensions {
  public static Open(this IOpenable obj){
      // work on any concrete implementation of IOpenable
  }
}

Usage:

var box = new Box; // Box implements IOpenable
var egg = new Egg; // Egg implements IOpenable
box.Open();
egg.Open();

This pattern may work well when the actual inheritance reflect a core structure or organization while the interfaces provide common "behaviors" shared by certain objects. A class may implement one or more of such interfaces.

C# 8 default interface implementation might make this pattern more common.

In practice, you often end up needing to cast your objects to the interface when working with functions that deal with your base classes.

public IEnumerable<Food> GetFoods(){ ... }

public void HandleFood() {
    for(var food in GetFoods()) {
        if(food is IOpenable openableFood){ 
             openableFood.Open();
        }
    }
}

Finally, note that this is not true multiple inheritance as you cannot inherit/override the extension methods themselves through a hierarchy of interfaces. If you have IOpenableFood inherit IOpenable with both an Open() extension method, you can't call base() in the derived one, and you'll have to choose which extension method to use explicitly. Best to avoid this altogether.

var egg = new Egg(); // Egg inherits both IOpenable and IOpenableFood
egg.Open(); // Error: Ambiguous method
IOpenableFoodExtensions.Open(egg); // OK, call that method
IOpenableExtensions.Open(egg); // OK, call other method