计算出的只读属性

Question

I am trying to implement properties on objects which values are derived from values of properties from other objects. For example, a property named TotalPoints in a class named Student has the following code in get{},

foreach(var subject in Subjects)
{
  _totalPoints += subject.Points;
}

return _totalPoints;

This works for simple case. However, when there are more levels involved, eg, Subject.Points is actually refers to something else. The calculation will be slower. What I am trying to figure out is the following:

• If there is any way to detect if there is any changes in value in Points, if not, I do not want to recalculate _totalPoints;

• Is there any alternative way to implement this? What I am thinking is also if it is possible to "inform" TotalPoints that one of the Subject.Points' value has changed, so TotalPoints needs to be re-calculated.

Appreciate if anyone has any idea. Thanks.

Answer 1

What you describe is an event driven system (see dot net events ). Here's a simple example:

public class PointsProvider
{
    public event Action<int> OnPointsChanged;
    private int points;
    public int Points
    {
        get => points;
        set
        {
            if (points == value)
                return;
            int oldValue = points;
            points = value;
            OnPointsChanged?.Invoke(points - oldValue);
        }
    }
}

public class TotalPointsProvider
{
    private PointsProvider providerA, providerB;

    private int totalPoints;
    public int TotalPoints => totalPoints;

    public TotalPointsProvider()
    {
        providerA = new PointsProvider();
        providerA.OnPointsChanged += UpdateTotalPoints;
        providerB = new PointsProvider();
        providerB.OnPointsChanged += UpdateTotalPoints;

        totalPoints = providerA.Points + providerB.Points;
    }

    private void UpdateTotalPoints(int delta)
    {
        totalPoints += delta;
    }
}

TotalPointsProvider gets notified, once one of it's PointsProvider s changes and updates it's own value.

If you have lot's of changes in your sub system ( PointsProvider ) but request the result unfrequently you might want to build a lazy system:

public class PointsProvider
{
    public event Action OnPointsChanged;
    private int points;
    public int Points
    {
        get => points;
        set
        {
            if (points == value)
                return;
            points = value;
            OnPointsChanged?.Invoke();
        }
    }
}

public class TotalPointsProvider
{
    private PointsProvider providerA, providerB;

    private bool dirty = true;

    private int totalPoints;
    public int TotalPoints
    {
        get
        {
            if (dirty)
            {
                totalPoints = providerA.Points + providerB.Points;
                dirty = false;
            }
            return totalPoints;
        }
    }

    public TotalPointsProvider()
    {
        providerA = new PointsProvider();
        providerA.OnPointsChanged += RecalculationNecessary;
        providerB = new PointsProvider();
        providerB.OnPointsChanged += RecalculationNecessary;
    }

    private void RecalculationNecessary()
    {
        dirty = true;
    }
}

Answer 2

get
    {
        return _totalPoints;
    }
set
    {
        foreach(var subject in Subjects)
         {
        _totalPoints += subject.Points;
         }
    }