The aggregate event notifying about the change in properties?

For example, let it be the ship. It consists of compartments. The compartments can be installed with any equipment. The ship has a weight stack of mass of all of the compartments. The mass of each compartment, for example, depends on installed in it or not. And the weight of the equipment itself can also vary, for example, depend on the mass of fuel in the fuel tank. And here about the change in its mass, each component of this chain needs to know.

For clarity, the spherical class hierarchy:
public class Spacecraft
{
 public IEnumerable<hardpoint> Hardpoints { get; private set; }

 public Single Mass => Hardpoints.Select(hp => hp.Mass).Sum();
}

public class Hardpoint
{
 InstalledEquipment public Equipment { get; private set; }

 public Boolean IsEquipmentInstalled => InstalledEquipment != null;

 public Single Mass => IsEquipmentInstalled ? InstalledEquipment.Mass : 0;
}

public abstract class Equipment
{
 public event Action MassChanged;

 public Single Mass
{
 get { return _mass; }
 protected set
{
 _mass = value;
MassChanged?.Invoke();
}
}

 private Single _mass;
}</hardpoint>

(sericinae nowhere)

In other words, there is a tree of properties (in this case Mass), each of which depends on their descendants and property at any level should be able to notify about your change (ie the question of implementation MassChanged Spacecraft at Hardpoint and the least expensive way). Of course, I can just do in Hardpoint event MassChanged and call it on a similar event from installed equipment or when it changes. Also in Spacecraft. A lot of similar code subscriptions/unsubscribing, error-prone.
Another option is to break encapsulation and make invocator events Hardpoint in public, calling him when you call the setter mass together with your event. Also be done with the Spacecraft. Slightly less code, but dirty.

Are there any more advanced practices?
July 2nd 19 at 17:02
3 answers
July 2nd 19 at 17:04
Solution
Thanks for the replies. Not sure that this will greatly help to reduce the amount of code (thinking, came to the conclusion that full automation of the dependencies between the properties and all subscriptions/replies to some of the weak links and these approaches to development will be shooting from a gun on sparrows), but the approaches seem useful, I will study, thank you.
July 2nd 19 at 17:06
The ship is at each moment of time has a certain state.
Something can change it, and someone has to be subscribed to these changes.
Flux -> Redux, you can borrow an implementation.
Implementing Redux in C#

Or the standard INotifyPropertyChanged Interface.
July 2nd 19 at 17:08
Perhaps will suit you reactivex.io

Find more questions by tags C#.NETMono