enabling lazy loading for only one query but enabling it enables it for full class as it has only one dbcontext i have set lazy loading globallly false iwant it to work for only one query in dotnet 6

Question

#region Dummy Usings

using DummyNamespace1;
using DummyNamespace2;
using DummyNamespace3;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;

#endregion

namespace DummyNamespace4
{
    [UsedImplicitly]
    public class DummyHandler : IRequestHandler<DummyRequest, IEnumerable<DummyModel>>
    {
        private readonly DummyDbContext _dbContext;
        private readonly IMapper _mapper;

        public DummyHandler(
            DummyDbContext dbContext,
            IMapper mapper)
        {
            _dbContext = dbContext;
            _mapper = mapper;
        }

        public async Task<IEnumerable<DummyModel>> Handle(DummyRequest message, CancellationToken cancellationToken)
        { 

// i want to enables for only thi query

            var dummyEntities = await _dbContext.EnableLazyLoading().DummyEntities.AsQueryable()
                                                  .Where(x => x.Status != DummyStatus.Archive)
                                                  .ToArrayAsync(cancellationToken); 


//but lazy loading still works here i know because of same context can you suggest way to enable thisfor  only one query i have removed EnableLazyLoading as well 
            var dummyModels = await _dbContext.DummyEntities.AsQueryable().Where(x => x.Status != DummyStatus.Archive).ToArrayAsync(cancellationToken);

            return _mapper.Map<IEnumerable<DummyModel>>(dummyModels);
        }       
}

my extension class

namespace DummyNamespace
{
    public static class DbContextExtensions
    {
        public static DummyDbContext EnableLazyLoading(this DummyDbContext dbContext)
        {
            dbContext.ChangeTracker.LazyLoadingEnabled = true;
            return dbContext;
        }
    }
}

my dbcontext

using Microsoft.EntityFrameworkCore;

namespace DummyNamespace
{
    public class DummyDbContext : DbContext
    {
        private readonly string _connectionString;
        private readonly int? _commandTimeout;

        public DummyDbContext() { }

        public DummyDbContext(DbContextOptions<DummyDbContext> options) : base(options)
        {
            this.ChangeTracker.LazyLoadingEnabled = false;
        }

        public DummyDbContext(string connectionString)
        {
            _connectionString = connectionString;
            this.ChangeTracker.LazyLoadingEnabled = false;
        }

        public DummyDbContext(string connectionString, int commandTimeout)
        {
            _connectionString = connectionString;
            _commandTimeout = commandTimeout;
            this.ChangeTracker.LazyLoadingEnabled = false;
        }

        protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
        {
            optionsBuilder.UseSqlServer(_connectionString);

            // Assuming AzureDbConfiguration.Configure is a dummy class or method
            AzureDbConfiguration.Configure(optionsBuilder);

            optionsBuilder.UseSqlServer(_connectionString, sqlServerOptions =>
            {
                if (_commandTimeout.HasValue)
                {
                    sqlServerOptions.CommandTimeout(_commandTimeout.Value);
                }
            });

            optionsBuilder.UseLazyLoadingProxies();

            base.OnConfiguring(optionsBuilder);
        }
    }
}