Time measurement in an ASP.NET Core application

My team introduces lots of time measurements for various code sections that might take longer than expected in a real-life flow.

These rely on initializing a StopWatch, getting the elapsed time and sometimes ensuring that measurement is done even if an exception is raised.

The following tries to make this as simple as possible.

The factory

/// <summary>
/// allows to measure time in a disposable scope
/// </summary>
public interface IStopwatchHelperFactory
{
    IStopwatchHelper Create();
    IStopwatchHelper Create(Action<TimeSpan>? measurementAction);
}

public class StopwatchHelperFactory : IStopwatchHelperFactory
{
    public IStopwatchHelper Create()
    {
        return new StopwatchHelper();
    }

    /// <summary>
    /// creates a new instance of <see cref="IStopwatchHelper"/> and specifies what happens when the measurement scope is disposed
    /// </summary>
    /// <param name="measurementAction"></param>
    /// <returns></returns>
    public IStopwatchHelper Create(Action<TimeSpan>? measurementAction)
    {
        return new StopwatchHelper(measurementAction);
    }
}

The measurement helper

public interface IStopwatchHelper : IDisposable
{
    void SetMeasurementAction(Action<TimeSpan>? value);
}

public sealed class StopwatchHelper : IStopwatchHelper
{
    private readonly Stopwatch _stopwatch;
    private Action<TimeSpan>? _measurementAction;

    public StopwatchHelper()
    {
        _stopwatch = Stopwatch.StartNew();
    }

    public StopwatchHelper(Action<TimeSpan>? measurementAction) : this()
    {
        _measurementAction = measurementAction;
    }

    public void SetMeasurementAction(Action<TimeSpan>? value)
    {
        _measurementAction = value;
    }

    public void Dispose()
    {
        _measurementAction?.Invoke(Elapsed);
    }

    public TimeSpan Elapsed => _stopwatch.Elapsed;
}

Setup

services.AddSingleton<IStopwatchHelperFactory, StopwatchHelperFactory>();

Usage example

The following shows how to measure time spent in a function from one point until the function returns (or exception is thrown + return).

    // this is constructor injected
    private readonly IStopwatchHelperFactory _stopwatchHelperFactory;

    public async Task DoStuff()
    {
        // init code

        // start measuring time
using var sw = _stopwatchHelperFactory.Create(elapsed => _specificLoggingData.Foo.Duration = (int)elapsed.TotalMilliseconds);

        // other code might come here
    }

The review

I am interested in potential issues with this solution, and possible edge cases I am missing. Coding comments, style, and bad practices are also welcomed.

posted about 2 months ago

CC BY-NC-SA 4.0

Alexei‭

4928 reputation 111 101 679 474