Use DI inside the DbContext

I'm using ef core 6 and I want to get a service from DI inside my db context. This is my DbContext:

public class MyDbContext : DbContext
{
    public MyDbContext (DbContextOptions<MyDbContext> opt) : base(opt)
    {
    }

    public override async Task<int> SaveChangesAsync(CancellationToken cancellationToken = default)
    {
        var myService = this.GetService<IMyService>();
        // Do some stuffs before saving with myService
    
        var result = await base.SaveChangesAsync(cancellationToken);
    
        return result;
    }   

}

The IMyService and MyDbContext already introduced with the DI:

services.AddScoped<IMyService, MyService>(); 
services.AddDbContextPool<MyDbContext>(opt => opt.UseSqlServer(connectionString));

The service doesn't inject, and this line throws an error:

var myService = this.GetService<IMyService>();

Error:
Cannot resolve scoped service 'IMyService' from root provider

What should I do? Do I miss something?

DI works the same way with DbContexts as any other injected service - by adding the dependency as a constructor parameter.

From the comments it seems that what you actually want is to use second-level caching (between sessions/transactions/Units-of-Work) with EF Core. This isn't available out of the box and in general, is a concept that isn't as popular now as it was some years ago. ORMs aren't used to talk to non-relational databases so applications use separate object caching at a higher level instead.

There are some NuGet packages that do add second-level caching to EF Core, for example EFCoreSecondLevelCacheInterceptor. This project uses EF Core DbCommand interceptors to track and cache the data loaded or persisted by EF Core. The landing page examples show how to use either in-memory or Redis caching.

Once you configure caching, adding it to a DbContext is easy :

    public static class MsSqlServiceCollectionExtensions
    {
        public static IServiceCollection AddConfiguredMsSqlDbContext(this IServiceCollection services, string connectionString)
        {
            services.AddDbContextPool<ApplicationDbContext>((serviceProvider, optionsBuilder) =>
                    optionsBuilder
                        .UseSqlServer(
                            connectionString,
                            sqlServerOptionsBuilder =>
                            {
                                sqlServerOptionsBuilder
                                    .CommandTimeout((int)TimeSpan.FromMinutes(3).TotalSeconds)
                                    .EnableRetryOnFailure()
                                    .MigrationsAssembly(typeof(MsSqlServiceCollectionExtensions).Assembly.FullName);
                            })
                        .AddInterceptors(serviceProvider.GetRequiredService<SecondLevelCacheInterceptor>()));
            return services;
        }
    }

The relevant part only adds the DbCommand interceptor SecondLevelCacheInterceptor

.AddInterceptors(serviceProvider.GetRequiredService<SecondLevelCacheInterceptor>()));

The package allows caching the results of specific queries :

var post1 = context.Posts
                   .Where(x => x.Id > 0)
                   .OrderBy(x => x.Id)
                   .Cacheable(CacheExpirationMode.Sliding, TimeSpan.FromMinutes(5))
                   .FirstOrDefault();  

It can also be configured to cache all queries:

        services.AddEFSecondLevelCache(options =>
        {
            options.UseMemoryCacheProvider().DisableLogging(true).UseCacheKeyPrefix("EF_");
            options.CacheAllQueries(CacheExpirationMode.Absolute, TimeSpan.FromMinutes(30));
        });

Specific queries :

        services.AddEFSecondLevelCache(options =>
        {
            options.UseMemoryCacheProvider().DisableLogging(true).UseCacheKeyPrefix("EF_")
                /*.CacheQueriesContainingTypes(
                    CacheExpirationMode.Absolute, TimeSpan.FromMinutes(30), TableTypeComparison.Contains,
                    typeof(Post), typeof(Product), typeof(User)
                    )*/
                .CacheQueriesContainingTableNames(
                    CacheExpirationMode.Absolute, TimeSpan.FromMinutes(30), TableNameComparison.ContainsOnly,
                    "posts", "products", "users"
                    );
        });

Or avoid caching specific queries

        services.AddEFSecondLevelCache(options =>
        {
            options.UseMemoryCacheProvider().DisableLogging(true).UseCacheKeyPrefix("EF_")
                    // How to skip caching specific commands
                   .SkipCachingCommands(commandText =>
                            commandText.Contains("NEWID()", StringComparison.InvariantCultureIgnoreCase));
        });