Refactoring to make code open for extensions but closed for modifications

Question

For my project purpose I need to send metrics to AWS.

I have main class called SendingMetrics.

private CPUMetric _cpuMetric;
private RAMMetric _ramMetric;
private HDDMetric _hddMetric;
private CloudWatchClient _cloudWatchClient(); //AWS Client which contains method Send() that sends metrics to AWS

public SendingMetrics()
{
    _cpuMetric = new CPUMetric();
    _ramMetric = new RAMMetric();
    _hddMetric = new HDDMetric();
    _cloudwatchClient = new CloudwatchClient();
    InitializeTimer();
}

private void InitializeTimer()
{
   //here I initialize Timer object which will call method SendMetrics() each 60 seconds.
}

private void SendMetrics()
{
    SendCPUMetric();
    SendRAMMetric();
    SendHDDMetric();
}

private void SendCPUMetric()
{
    _cloudwatchClient.Send("CPU_Metric", _cpuMetric.GetValue());
}

private void SendRAMMetric()
{
    _cloudwatchClient.Send("RAM_Metric", _ramMetric.GetValue());
}

private void SendHDDMetric()
{
    _cloudwatchClient.Send("HDD_Metric", _hddMetric.GetValue());
}

Also I have CPUMetric, RAMMetric and HDDMetric classes that looks pretty much similar so I will just show code of one class.

internal sealed class CPUMetric
{
    private int _cpuThreshold;

    public CPUMetric()
    {
        _cpuThreshold = 95;
    }

    public int GetValue()
    {
        var currentCpuLoad = ... //logic for getting machine CPU load
        if(currentCpuLoad > _cpuThreshold)
        {
             return 1;
        }
        else 
        {
             return 0;
        }
    }
}

So the problem I have is that clean coding is not satisfied in my example. I have 3 metrics to send and if I need to introduce new metric I will need to create new class, initialize it in SendingMetrics class and modify that class and that is not what I want. I want to satisfy Open Closed principle, so it is open for extensions but closed for modifications.

What is the right way to do it? I would move those send methods (SendCPUMetric, SendRAMMetric, SendHDDMetric) to corresponding classes (SendCPUMetric method to CPUMetric class, SendRAMMEtric to RAMMetric, etc) but how to modfy SendingMetrics class so it is closed for modifications and if I need to add new metric to not change that class.

Answer 1

Your design is almost correct. You got 3 data retriever and 1 data sender. So it's easy to add more metric (more retriever) (open for extensions) without affecting current metrics (closed for modifications), you just need a bit more refactor to reduce duplicated code.

Instead of have 3 metrics classes look very similar. Only below line is different

var currentCpuLoad = ... //logic for getting machine CPU load

You can create a generic metric like this

internal interface IGetMetric
{
    int GetData();
}

internal sealed class Metric
{
    private int _threshold;
    private IGetMetric _getDataService;

    public Metric(IGetMetric getDataService)
    {
        _cpuThreshold = 95;
        _getDataService = getDataService;
    }

    public int GetValue()
    {
        var currentCpuLoad = _getDataService.GetData();
        if(currentCpuLoad > _cpuThreshold)
        {
             return 1;
        }
        else 
        {
             return 0;
        }
    }
}

Then just create 3 GetMetric classes to implement that interface. This is just 1 way to reduce the code duplication. You can also use inheritance (but I don't like inheritance). Or you can use a Func param.

UPDATED: added class to get CPU metric

internal class CPUMetricService : IGetMetric
{
    public int GetData() { return ....; }
}
internal class RAMMetricService : IGetMetric
{
    public int GetData() { return ....; }
}
public class AllMetrics
{
    private List<Metric> _metrics = new List<Metric>()
    {
         new Metric(new CPUMetricService());
         new Metric(new RAMMetricService());
    }

    public void SendMetrics()
    {
         _metrics.ForEach(m => ....);
    }
}