依赖注入的可能循环依赖

Question

I'm using this template as my base project. I would like to set a custom time zone that is user defined hence it is stored in the database.

The following is my failed attempt. Well, I tried many different approaches in vein. I hope that someone will be able to give me a right direction here.

namespace MyApp.Infrastructure.Services;

public class DateTimeService : IDateTime
{
    private readonly IAppDefaultServices _appDefaultServices;
    public DateTimeService(IAppDefaultServices appDefaultServices)
    {
        _appDefaultServices = appDefaultServices;
    }
    public DateTime Now()
    {
        DateTime utcTime = DateTime.UtcNow;
        TimeZoneInfo defaultZone = TimeZoneInfo.FindSystemTimeZoneById(_appDefaultServices.DefaultTimeZone);
        DateTime appDateTime = TimeZoneInfo.ConvertTimeFromUtc(utcTime, defaultZone);
        return appDateTime;
    }
}

namespace MyApp.Application.Common.Interfaces;

public interface IDateTime
{
    DateTime Now();
}


namespace MyApp.Infrastructure.Services;

public class AppDefaultServices : IAppDefaultServices
{
    private readonly IApplicationDbContext _context;
    public AppDefaultServices(IApplicationDbContext context)
    {
        _context = context;
    }
    private AppDefault _appDefault => _context.AppDefaults.First();

    public string DefaultTimeZone => _appDefault.TimeZoneId == null ? "Some Standard Time" : _appDefault.TimeZoneId;

}

namespace MyApp.Application.Common.Interfaces;
public interface IAppDefaultServices
{
    public string DefaultTimeZone { get; }
}

namespace Microsoft.Extensions.DependencyInjection;

public static class ConfigureServices
{
    public static IServiceCollection AddInfrastructureServices(this IServiceCollection services, IConfiguration configuration)
    {
        services.AddTransient<IAppDefaultServices, AppDefaultServices>();
        services.AddTransient<IDateTime, DateTimeService>();
    }
}

When I tried to run the application in Visual Studio, I get no errors but I can see the following message in thread window.

The maximum number of stack frames supported by Visual Studio has been exceeded.

Please note that DateTimeService is being used in MyApp.Infrastructure.Persistence.Interceptors.AuditableEntitySaveChangesInterceptor which is part of ApplicationDbContext

I really appreciate it if anyone could please shed a light here.

Based on Steve's comment below, I'm posting a minimal code to reproduce the issue.

namespace MyApp.Infrastructure.Persistence;

public class ApplicationDbContext : ApiAuthorizationDbContext<ApplicationUser>, IApplicationDbContext
{
    private readonly AuditableEntitySaveChangesInterceptor _auditableEntitySaveChangesInterceptor;

    public ApplicationDbContext(
        DbContextOptions<ApplicationDbContext> options,
        IOptions<OperationalStoreOptions> operationalStoreOptions,
        AuditableEntitySaveChangesInterceptor auditableEntitySaveChangesInterceptor) 
        : base(options, operationalStoreOptions)
    {
        _auditableEntitySaveChangesInterceptor = auditableEntitySaveChangesInterceptor;
    }

    protected override void OnModelCreating(ModelBuilder builder)
    {
        builder.ApplyConfigurationsFromAssembly(Assembly.GetExecutingAssembly());

        base.OnModelCreating(builder);
    }

    protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    {
        optionsBuilder.AddInterceptors(_auditableEntitySaveChangesInterceptor);
    }

    public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
    {
        return await base.SaveChangesAsync(cancellationToken);
    }
}

Interceptor code below...

namespace MyApp.Infrastructure.Persistence.Interceptors;
    
public class AuditableEntitySaveChangesInterceptor : SaveChangesInterceptor
{
    private readonly IDateTime _dateTime;

    public AuditableEntitySaveChangesInterceptor(
        IDateTime dateTime)
    {
        _dateTime = dateTime;
    }

    public override InterceptionResult<int> SavingChanges(DbContextEventData eventData, InterceptionResult<int> result)
    {
        UpdateEntities(eventData.Context);

        return base.SavingChanges(eventData, result);
    }

    public override ValueTask<InterceptionResult<int>> SavingChangesAsync(DbContextEventData eventData, InterceptionResult<int> result, CancellationToken cancellationToken = default)
    {
        UpdateEntities(eventData.Context);

        return base.SavingChangesAsync(eventData, result, cancellationToken);
    }

    public void UpdateEntities(DbContext? context)
    {
        if (context == null) return;

        foreach (var entry in context.ChangeTracker.Entries<BaseAuditableEntity>())
        {
            if (entry.State == EntityState.Added)
            {
                entry.Entity.Created = _dateTime.Now();
            } 

            if (entry.State == EntityState.Added || entry.State == EntityState.Modified)
            {
                entry.Entity.LastModified = _dateTime.Now();
            }
        }
    }
}

Answer 1

Consider the following solutions to refactor your way out of this cyclic dependency:

• Change DateTimeService to always return UtcNow . This prevents it needing to load the time zone and depend on IAppDefaultServices
• Consider loading the default time zone once at startup. This allows the DateTimeService to be injected with that pre-loaded time zone and prevent it from depending on IAppDefaultServices .
• Consider changing AppDefaultServices such that it doesn't depend on IApplicationDbContext , but instead depends on a second DbContext that solely allows accessing the AppDefaults in a read-only fashion. This new read-only DbContext will not need the interceptor, as it only adds behavior when mutating data.
• If, after applying the previous option, AppDefaultServices still requires the IApplicationDbContext dependency, consider splitting the AppDefaultServices into multiple classes with multiple interfaces, such that the new interface only contains the DefaultTimeZone property. This allows its implementation to solely contain a dependency on the 'AppDefaultsDbContext'.