Refactor handlers to use DbContextFactory

neozhu · neozhu · commit e47b51e9d579 · 2025-07-23T07:41:52.000+08:00
Updated command and query handlers to utilize `IApplicationDbContextFactory` for improved database context management. This change creates a new context instance for each operation, enhancing asynchronous operations and promoting better design practices. The use of `await using var db = await _dbContextFactory.CreateAsync(cancellationToken);` ensures that all database operations are performed with a fresh context, improving testability and reducing context-related issues.
diff --git a/src/Templates/Commands/AddEdit/.cs.txt b/src/Templates/Commands/AddEdit/.cs.txt
@@ -37,36 +37,37 @@ public class AddEdit{itemname}Command: ICacheInvalidatorRequest<Result<int>>
 public class AddEdit{itemname}CommandHandler : IRequestHandler<AddEdit{itemname}Command, Result<int>>
 {
     private readonly IMapper _mapper;
-    private readonly IApplicationDbContext _context;
+    private readonly IApplicationDbContextFactory _dbContextFactory;
     public AddEdit{itemname}CommandHandler(
         IMapper mapper,
-        IApplicationDbContext context)
+        IApplicationDbContextFactory dbContextFactory)
     {
         _mapper = mapper;
-        _context = context;
+        _dbContextFactory = dbContextFactory;
     }
     public async Task<Result<int>> Handle(AddEdit{itemname}Command request, CancellationToken cancellationToken)
     {
+        await using var db = await _dbContextFactory.CreateAsync(cancellationToken);
         if (request.Id > 0)
         {
-            var item = await _context.{nameofPlural}.FindAsync(request.Id, cancellationToken);
+            var item = await db.{nameofPlural}.FindAsync(request.Id, cancellationToken);
             if (item == null)
             {
                 return await Result<int>.FailureAsync($"{itemname} with id: [{request.Id}] not found.");
             }
             item = _mapper.Map(request, item);
 			// raise a update domain event
 			item.AddDomainEvent(new {itemname}UpdatedEvent(item));
-            await _context.SaveChangesAsync(cancellationToken);
+            await db.SaveChangesAsync(cancellationToken);
             return await Result<int>.SuccessAsync(item.Id);
         }
         else
         {
             var item = _mapper.Map<{itemname}>(request);
             // raise a create domain event
 			item.AddDomainEvent(new {itemname}CreatedEvent(item));
-            _context.{nameofPlural}.Add(item);
-            await _context.SaveChangesAsync(cancellationToken);
+            db.{nameofPlural}.Add(item);
+            await db.SaveChangesAsync(cancellationToken);
             return await Result<int>.SuccessAsync(item.Id);
         }
        
diff --git a/src/Templates/Commands/Create/.cs.txt b/src/Templates/Commands/Create/.cs.txt
@@ -34,21 +34,22 @@ public class Create{itemname}Command: ICacheInvalidatorRequest<Result<int>>
     public class Create{itemname}CommandHandler : IRequestHandler<Create{itemname}Command, Result<int>>
     {
         private readonly IMapper _mapper;
-        private readonly IApplicationDbContext _context;
+        private readonly IApplicationDbContextFactory _dbContextFactory;
         public Create{itemname}CommandHandler(
             IMapper mapper,
-            IApplicationDbContext context)
+            IApplicationDbContextFactory dbContextFactory)
         {
             _mapper = mapper;
-            _context = context;
+            _dbContextFactory = dbContextFactory;
         }
         public async Task<Result<int>> Handle(Create{itemname}Command request, CancellationToken cancellationToken)
         {
+           await using var db = await _dbContextFactory.CreateAsync(cancellationToken);
            var item = _mapper.Map<{itemname}>(request);
            // raise a create domain event
 	       item.AddDomainEvent(new {itemname}CreatedEvent(item));
-           _context.{nameofPlural}.Add(item);
-           await _context.SaveChangesAsync(cancellationToken);
+           db.{nameofPlural}.Add(item);
+           await db.SaveChangesAsync(cancellationToken);
            return  await Result<int>.SuccessAsync(item.Id);
         }
     }
diff --git a/src/Templates/Commands/Delete/.cs.txt b/src/Templates/Commands/Delete/.cs.txt
@@ -30,22 +30,23 @@ public class Delete{itemname}CommandHandler :
              IRequestHandler<Delete{itemname}Command, Result>
 
 {
-    private readonly IApplicationDbContext _context;
+    private readonly IApplicationDbContextFactory _dbContextFactory;
     public Delete{itemname}CommandHandler(
-        IApplicationDbContext context)
+        IApplicationDbContextFactory dbContextFactory)
     {
-        _context = context;
+        _dbContextFactory = dbContextFactory;
     }
     public async Task<Result> Handle(Delete{itemname}Command request, CancellationToken cancellationToken)
     {
-        var items = await _context.{nameofPlural}.Where(x=>request.Id.Contains(x.Id)).ToListAsync(cancellationToken);
+        await using var db = await _dbContextFactory.CreateAsync(cancellationToken);
+        var items = await db.{nameofPlural}.Where(x=>request.Id.Contains(x.Id)).ToListAsync(cancellationToken);
         foreach (var item in items)
         {
 		    // raise a delete domain event
 			item.AddDomainEvent(new {itemname}DeletedEvent(item));
-            _context.{nameofPlural}.Remove(item);
+            db.{nameofPlural}.Remove(item);
         }
-        await _context.SaveChangesAsync(cancellationToken);
+        await db.SaveChangesAsync(cancellationToken);
         return await Result.SuccessAsync();
     }
 
diff --git a/src/Templates/Commands/Import/.cs.txt b/src/Templates/Commands/Import/.cs.txt
@@ -37,26 +37,26 @@ namespace {namespace};
                  IRequestHandler<Create{nameofPlural}TemplateCommand, Result<byte[]>>,
                  IRequestHandler<Import{nameofPlural}Command, Result<int>>
     {
-        private readonly IApplicationDbContext _context;
+        private readonly IApplicationDbContextFactory _dbContextFactory;
         private readonly IStringLocalizer<Import{nameofPlural}CommandHandler> _localizer;
         private readonly IExcelService _excelService;
         private readonly {itemname}Dto _dto = new();
         private readonly IMapper _mapper;
         public Import{nameofPlural}CommandHandler(
-            IApplicationDbContext context,
+            IApplicationDbContextFactory dbContextFactory,
             IMapper mapper,
             IExcelService excelService,
             IStringLocalizer<Import{nameofPlural}CommandHandler> localizer)
         {
-            _context = context;
+            _dbContextFactory = dbContextFactory;
             _localizer = localizer;
             _excelService = excelService;
             _mapper = mapper;
         }
         #nullable disable warnings
         public async Task<Result<int>> Handle(Import{nameofPlural}Command request, CancellationToken cancellationToken)
         {
-
+           await using var db = await _dbContextFactory.CreateAsync(cancellationToken);
            var result = await _excelService.ImportAsync(request.Data, mappers: new Dictionary<string, Func<DataRow, {itemname}Dto, object?>>
             {
                 {importFuncExpression}
@@ -71,10 +71,10 @@ namespace {namespace};
                         var item = _mapper.Map<{itemname}>(dto);
                         // add create domain events if this entity implement the IHasDomainEvent interface
 				        // item.AddDomainEvent(new {itemname}CreatedEvent(item));
-                        await _context.{nameofPlural}.AddAsync(item, cancellationToken);
+                        await db.{nameofPlural}.AddAsync(item, cancellationToken);
                     }
                  }
-                 await _context.SaveChangesAsync(cancellationToken);
+                 await db.SaveChangesAsync(cancellationToken);
                  return await Result<int>.SuccessAsync(result.Data.Count());
            }
            else
diff --git a/src/Templates/Commands/Update/.cs.txt b/src/Templates/Commands/Update/.cs.txt
@@ -36,27 +36,27 @@ public class Update{itemname}Command: ICacheInvalidatorRequest<Result<int>>
 
 public class Update{itemname}CommandHandler : IRequestHandler<Update{itemname}Command, Result<int>>
 {
-    private readonly IApplicationDbContext _context;
+    private readonly IApplicationDbContextFactory _dbContextFactory;
     private readonly IMapper _mapper;
     public Update{itemname}CommandHandler(
         IMapper mapper,
-        IApplicationDbContext context)
+        IApplicationDbContextFactory dbContextFactory)
     {
-        _context = context;
+        _dbContextFactory = dbContextFactory;
         _mapper = mapper;
     }
     public async Task<Result<int>> Handle(Update{itemname}Command request, CancellationToken cancellationToken)
     {
-
-       var item = await _context.{nameofPlural}.FindAsync(request.Id, cancellationToken);
+       await using var db = await _dbContextFactory.CreateAsync(cancellationToken);
+       var item = await db.{nameofPlural}.FindAsync(request.Id, cancellationToken);
        if (item == null)
        {
            return await Result<int>.FailureAsync($"{itemname} with id: [{request.Id}] not found.");
        }
        item = _mapper.Map(request, item);
 	    // raise a update domain event
 	   item.AddDomainEvent(new {itemname}UpdatedEvent(item));
-       await _context.SaveChangesAsync(cancellationToken);
+       await db.SaveChangesAsync(cancellationToken);
        return await Result<int>.SuccessAsync(item.Id);
     }
 }
diff --git a/src/Templates/Queries/Export/.cs.txt b/src/Templates/Queries/Export/.cs.txt
@@ -37,26 +37,27 @@ public class Export{nameofPlural}QueryHandler :
          IRequestHandler<Export{nameofPlural}Query, Result<byte[]>>
 {
         private readonly IMapper _mapper;
-        private readonly IApplicationDbContext _context;
+        private readonly IApplicationDbContextFactory _dbContextFactory;
         private readonly IExcelService _excelService;
         private readonly IStringLocalizer<Export{nameofPlural}QueryHandler> _localizer;
         private readonly {itemname}Dto _dto = new();
         public Export{nameofPlural}QueryHandler(
             IMapper mapper,
-            IApplicationDbContext context,
+            IApplicationDbContextFactory dbContextFactory,
             IExcelService excelService,
             IStringLocalizer<Export{nameofPlural}QueryHandler> localizer
             )
         {
             _mapper = mapper;
-            _context = context;
+            _dbContextFactory = dbContextFactory;
             _excelService = excelService;
             _localizer = localizer;
         }
         #nullable disable warnings
         public async Task<Result<byte[]>> Handle(Export{nameofPlural}Query request, CancellationToken cancellationToken)
         {
-            var data = await _context.{nameofPlural}.ApplySpecification(request.Specification)
+            await using var db = await _dbContextFactory.CreateAsync(cancellationToken);
+            var data = await db.{nameofPlural}.ApplySpecification(request.Specification)
                        .OrderBy($"{request.OrderBy} {request.SortDirection}")
                        .ProjectTo<{itemname}Dto>(_mapper.ConfigurationProvider)
                        .AsNoTracking()
diff --git a/src/Templates/Queries/GetAll/.cs.txt b/src/Templates/Queries/GetAll/.cs.txt
@@ -30,19 +30,20 @@ public class GetAll{nameofPlural}Query : ICacheableRequest<IEnumerable<{itemname
 public class GetAll{nameofPlural}QueryHandler :
      IRequestHandler<GetAll{nameofPlural}Query, IEnumerable<{itemname}Dto>>
 {
-    private readonly IApplicationDbContext _context;
+    private readonly IApplicationDbContextFactory _dbContextFactory;
     private readonly IMapper _mapper;
     public GetAll{nameofPlural}QueryHandler(
         IMapper mapper,
-        IApplicationDbContext context)
+        IApplicationDbContextFactory dbContextFactory)
     {
         _mapper = mapper;
-        _context = context;
+        _dbContextFactory = dbContextFactory;
     }
 
     public async Task<IEnumerable<{itemname}Dto>> Handle(GetAll{nameofPlural}Query request, CancellationToken cancellationToken)
     {
-        var data = await _context.{nameofPlural}.ProjectTo<{itemname}Dto>(_mapper.ConfigurationProvider)
+        await using var db = await _dbContextFactory.CreateAsync(cancellationToken);
+        var data = await db.{nameofPlural}.ProjectTo<{itemname}Dto>(_mapper.ConfigurationProvider)
                                                 .AsNoTracking()
                                                 .ToListAsync(cancellationToken);
         return data;
diff --git a/src/Templates/Queries/GetById/.cs.txt b/src/Templates/Queries/GetById/.cs.txt
@@ -31,19 +31,20 @@ public class Get{itemname}ByIdQuery : ICacheableRequest<Result<{itemname}Dto>>
 public class Get{itemname}ByIdQueryHandler :
      IRequestHandler<Get{itemname}ByIdQuery, Result<{itemname}Dto>>
 {
-    private readonly IApplicationDbContext _context;
+    private readonly IApplicationDbContextFactory _dbContextFactory;
     private readonly IMapper _mapper;
     public Get{itemname}ByIdQueryHandler(
         IMapper mapper,
-        IApplicationDbContext context)
+        IApplicationDbContextFactory dbContextFactory)
     {
         _mapper = mapper;
-        _context = context;
+        _dbContextFactory = dbContextFactory;
     }
 
     public async Task<Result<{itemname}Dto>> Handle(Get{itemname}ByIdQuery request, CancellationToken cancellationToken)
     {
-        var data = await _context.{nameofPlural}.ApplySpecification(new {itemname}ByIdSpecification(request.Id))
+        await using var db = await _dbContextFactory.CreateAsync(cancellationToken);
+        var data = await db.{nameofPlural}.ApplySpecification(new {itemname}ByIdSpecification(request.Id))
                                                 .ProjectTo<{itemname}Dto>(_mapper.ConfigurationProvider)
                                                 .FirstAsync(cancellationToken) ?? throw new NotFoundException($"{itemname} with id: [{request.Id}] not found.");
         return await Result<{itemname}Dto>.SuccessAsync(data);
diff --git a/src/Templates/Queries/Pagination/.cs.txt b/src/Templates/Queries/Pagination/.cs.txt
@@ -35,19 +35,20 @@ public class {nameofPlural}WithPaginationQuery : {itemname}AdvancedFilter, ICach
 public class {nameofPlural}WithPaginationQueryHandler :
          IRequestHandler<{nameofPlural}WithPaginationQuery, PaginatedData<{itemname}Dto>>
 {
-        private readonly IApplicationDbContext _context;
+        private readonly IApplicationDbContextFactory _dbContextFactory;
         private readonly IMapper _mapper;
         public {nameofPlural}WithPaginationQueryHandler(
             IMapper mapper,
-            IApplicationDbContext context)
+            IApplicationDbContextFactory dbContextFactory)
         {
             _mapper = mapper;
-            _context = context;
+            _dbContextFactory = dbContextFactory;
         }
 
         public async Task<PaginatedData<{itemname}Dto>> Handle({nameofPlural}WithPaginationQuery request, CancellationToken cancellationToken)
         {
-           var data = await _context.{nameofPlural}.OrderBy($"{request.OrderBy} {request.SortDirection}")
+           await using var db = await _dbContextFactory.CreateAsync(cancellationToken);
+           var data = await db.{nameofPlural}.OrderBy($"{request.OrderBy} {request.SortDirection}")
                                                    .ProjectToPaginatedDataAsync<{itemname}, {itemname}Dto>(request.Specification,
                                                     request.PageNumber,
                                                     request.PageSize,

Original file line number	Diff line number	Diff line change
`@@ -37,36 +37,37 @@ public class AddEdit{itemname}Command: ICacheInvalidatorRequest<Result<int>>`
`37`	`37`	`public class AddEdit{itemname}CommandHandler : IRequestHandler<AddEdit{itemname}Command, Result<int>>`
`38`	`38`	`{`
`39`	`39`	`private readonly IMapper _mapper;`
`40`		`- private readonly IApplicationDbContext _context;`
	`40`	`+ private readonly IApplicationDbContextFactory _dbContextFactory;`
`41`	`41`	`public AddEdit{itemname}CommandHandler(`
`42`	`42`	`IMapper mapper,`
`43`		`- IApplicationDbContext context)`
	`43`	`+ IApplicationDbContextFactory dbContextFactory)`
`44`	`44`	`{`
`45`	`45`	`_mapper = mapper;`
`46`		`- _context = context;`
	`46`	`+ _dbContextFactory = dbContextFactory;`
`47`	`47`	`}`
`48`	`48`	`public async Task<Result<int>> Handle(AddEdit{itemname}Command request, CancellationToken cancellationToken)`
`49`	`49`	`{`
	`50`	`+ await using var db = await _dbContextFactory.CreateAsync(cancellationToken);`
`50`	`51`	`if (request.Id > 0)`
`51`	`52`	`{`
`52`		`- var item = await _context.{nameofPlural}.FindAsync(request.Id, cancellationToken);`
	`53`	`+ var item = await db.{nameofPlural}.FindAsync(request.Id, cancellationToken);`
`53`	`54`	`if (item == null)`
`54`	`55`	`{`
`55`	`56`	`return await Result<int>.FailureAsync($"{itemname} with id: [{request.Id}] not found.");`
`56`	`57`	`}`
`57`	`58`	`item = _mapper.Map(request, item);`
`58`	`59`	`// raise a update domain event`
`59`	`60`	`item.AddDomainEvent(new {itemname}UpdatedEvent(item));`
`60`		`- await _context.SaveChangesAsync(cancellationToken);`
	`61`	`+ await db.SaveChangesAsync(cancellationToken);`
`61`	`62`	`return await Result<int>.SuccessAsync(item.Id);`
`62`	`63`	`}`
`63`	`64`	`else`
`64`	`65`	`{`
`65`	`66`	`var item = _mapper.Map<{itemname}>(request);`
`66`	`67`	`// raise a create domain event`
`67`	`68`	`item.AddDomainEvent(new {itemname}CreatedEvent(item));`
`68`		`- _context.{nameofPlural}.Add(item);`
`69`		`- await _context.SaveChangesAsync(cancellationToken);`
	`69`	`+ db.{nameofPlural}.Add(item);`
	`70`	`+ await db.SaveChangesAsync(cancellationToken);`
`70`	`71`	`return await Result<int>.SuccessAsync(item.Id);`
`71`	`72`	`}`
`72`	`73`
Original file line number	Diff line number	Diff line change
`@@ -34,21 +34,22 @@ public class Create{itemname}Command: ICacheInvalidatorRequest<Result<int>>`
`34`	`34`	`public class Create{itemname}CommandHandler : IRequestHandler<Create{itemname}Command, Result<int>>`
`35`	`35`	`{`
`36`	`36`	`private readonly IMapper _mapper;`
`37`		`- private readonly IApplicationDbContext _context;`
	`37`	`+ private readonly IApplicationDbContextFactory _dbContextFactory;`
`38`	`38`	`public Create{itemname}CommandHandler(`
`39`	`39`	`IMapper mapper,`
`40`		`- IApplicationDbContext context)`
	`40`	`+ IApplicationDbContextFactory dbContextFactory)`
`41`	`41`	`{`
`42`	`42`	`_mapper = mapper;`
`43`		`- _context = context;`
	`43`	`+ _dbContextFactory = dbContextFactory;`
`44`	`44`	`}`
`45`	`45`	`public async Task<Result<int>> Handle(Create{itemname}Command request, CancellationToken cancellationToken)`
`46`	`46`	`{`
	`47`	`+ await using var db = await _dbContextFactory.CreateAsync(cancellationToken);`
`47`	`48`	`var item = _mapper.Map<{itemname}>(request);`
`48`	`49`	`// raise a create domain event`
`49`	`50`	`item.AddDomainEvent(new {itemname}CreatedEvent(item));`
`50`		`- _context.{nameofPlural}.Add(item);`
`51`		`- await _context.SaveChangesAsync(cancellationToken);`
	`51`	`+ db.{nameofPlural}.Add(item);`
	`52`	`+ await db.SaveChangesAsync(cancellationToken);`
`52`	`53`	`return await Result<int>.SuccessAsync(item.Id);`
`53`	`54`	`}`
`54`	`55`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,22 +30,23 @@ public class Delete{itemname}CommandHandler :`
`30`	`30`	`IRequestHandler<Delete{itemname}Command, Result>`
`31`	`31`
`32`	`32`	`{`
`33`		`- private readonly IApplicationDbContext _context;`
	`33`	`+ private readonly IApplicationDbContextFactory _dbContextFactory;`
`34`	`34`	`public Delete{itemname}CommandHandler(`
`35`		`- IApplicationDbContext context)`
	`35`	`+ IApplicationDbContextFactory dbContextFactory)`
`36`	`36`	`{`
`37`		`- _context = context;`
	`37`	`+ _dbContextFactory = dbContextFactory;`
`38`	`38`	`}`
`39`	`39`	`public async Task<Result> Handle(Delete{itemname}Command request, CancellationToken cancellationToken)`
`40`	`40`	`{`
`41`		`- var items = await _context.{nameofPlural}.Where(x=>request.Id.Contains(x.Id)).ToListAsync(cancellationToken);`
	`41`	`+ await using var db = await _dbContextFactory.CreateAsync(cancellationToken);`
	`42`	`+ var items = await db.{nameofPlural}.Where(x=>request.Id.Contains(x.Id)).ToListAsync(cancellationToken);`
`42`	`43`	`foreach (var item in items)`
`43`	`44`	`{`
`44`	`45`	`// raise a delete domain event`
`45`	`46`	`item.AddDomainEvent(new {itemname}DeletedEvent(item));`
`46`		`- _context.{nameofPlural}.Remove(item);`
	`47`	`+ db.{nameofPlural}.Remove(item);`
`47`	`48`	`}`
`48`		`- await _context.SaveChangesAsync(cancellationToken);`
	`49`	`+ await db.SaveChangesAsync(cancellationToken);`
`49`	`50`	`return await Result.SuccessAsync();`
`50`	`51`	`}`
`51`	`52`
Original file line number	Diff line number	Diff line change
`@@ -37,26 +37,26 @@ namespace {namespace};`
`37`	`37`	`IRequestHandler<Create{nameofPlural}TemplateCommand, Result<byte[]>>,`
`38`	`38`	`IRequestHandler<Import{nameofPlural}Command, Result<int>>`
`39`	`39`	`{`
`40`		`- private readonly IApplicationDbContext _context;`
	`40`	`+ private readonly IApplicationDbContextFactory _dbContextFactory;`
`41`	`41`	`private readonly IStringLocalizer<Import{nameofPlural}CommandHandler> _localizer;`
`42`	`42`	`private readonly IExcelService _excelService;`
`43`	`43`	`private readonly {itemname}Dto _dto = new();`
`44`	`44`	`private readonly IMapper _mapper;`
`45`	`45`	`public Import{nameofPlural}CommandHandler(`
`46`		`- IApplicationDbContext context,`
	`46`	`+ IApplicationDbContextFactory dbContextFactory,`
`47`	`47`	`IMapper mapper,`
`48`	`48`	`IExcelService excelService,`
`49`	`49`	`IStringLocalizer<Import{nameofPlural}CommandHandler> localizer)`
`50`	`50`	`{`
`51`		`- _context = context;`
	`51`	`+ _dbContextFactory = dbContextFactory;`
`52`	`52`	`_localizer = localizer;`
`53`	`53`	`_excelService = excelService;`
`54`	`54`	`_mapper = mapper;`
`55`	`55`	`}`
`56`	`56`	`#nullable disable warnings`
`57`	`57`	`public async Task<Result<int>> Handle(Import{nameofPlural}Command request, CancellationToken cancellationToken)`
`58`	`58`	`{`
`59`		`-`
	`59`	`+ await using var db = await _dbContextFactory.CreateAsync(cancellationToken);`
`60`	`60`	`var result = await _excelService.ImportAsync(request.Data, mappers: new Dictionary<string, Func<DataRow, {itemname}Dto, object?>>`
`61`	`61`	`{`
`62`	`62`	`{importFuncExpression}`
`@@ -71,10 +71,10 @@ namespace {namespace};`
`71`	`71`	`var item = _mapper.Map<{itemname}>(dto);`
`72`	`72`	`// add create domain events if this entity implement the IHasDomainEvent interface`
`73`	`73`	`// item.AddDomainEvent(new {itemname}CreatedEvent(item));`
`74`		`- await _context.{nameofPlural}.AddAsync(item, cancellationToken);`
	`74`	`+ await db.{nameofPlural}.AddAsync(item, cancellationToken);`
`75`	`75`	`}`
`76`	`76`	`}`
`77`		`- await _context.SaveChangesAsync(cancellationToken);`
	`77`	`+ await db.SaveChangesAsync(cancellationToken);`
`78`	`78`	`return await Result<int>.SuccessAsync(result.Data.Count());`
`79`	`79`	`}`
`80`	`80`	`else`
Original file line number	Diff line number	Diff line change
`@@ -36,27 +36,27 @@ public class Update{itemname}Command: ICacheInvalidatorRequest<Result<int>>`
`36`	`36`
`37`	`37`	`public class Update{itemname}CommandHandler : IRequestHandler<Update{itemname}Command, Result<int>>`
`38`	`38`	`{`
`39`		`- private readonly IApplicationDbContext _context;`
	`39`	`+ private readonly IApplicationDbContextFactory _dbContextFactory;`
`40`	`40`	`private readonly IMapper _mapper;`
`41`	`41`	`public Update{itemname}CommandHandler(`
`42`	`42`	`IMapper mapper,`
`43`		`- IApplicationDbContext context)`
	`43`	`+ IApplicationDbContextFactory dbContextFactory)`
`44`	`44`	`{`
`45`		`- _context = context;`
	`45`	`+ _dbContextFactory = dbContextFactory;`
`46`	`46`	`_mapper = mapper;`
`47`	`47`	`}`
`48`	`48`	`public async Task<Result<int>> Handle(Update{itemname}Command request, CancellationToken cancellationToken)`
`49`	`49`	`{`
`50`		`-`
`51`		`- var item = await _context.{nameofPlural}.FindAsync(request.Id, cancellationToken);`
	`50`	`+ await using var db = await _dbContextFactory.CreateAsync(cancellationToken);`
	`51`	`+ var item = await db.{nameofPlural}.FindAsync(request.Id, cancellationToken);`
`52`	`52`	`if (item == null)`
`53`	`53`	`{`
`54`	`54`	`return await Result<int>.FailureAsync($"{itemname} with id: [{request.Id}] not found.");`
`55`	`55`	`}`
`56`	`56`	`item = _mapper.Map(request, item);`
`57`	`57`	`// raise a update domain event`
`58`	`58`	`item.AddDomainEvent(new {itemname}UpdatedEvent(item));`
`59`		`- await _context.SaveChangesAsync(cancellationToken);`
	`59`	`+ await db.SaveChangesAsync(cancellationToken);`
`60`	`60`	`return await Result<int>.SuccessAsync(item.Id);`
`61`	`61`	`}`
`62`	`62`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,19 +30,20 @@ public class GetAll{nameofPlural}Query : ICacheableRequest<IEnumerable<{itemname`
`30`	`30`	`public class GetAll{nameofPlural}QueryHandler :`
`31`	`31`	`IRequestHandler<GetAll{nameofPlural}Query, IEnumerable<{itemname}Dto>>`
`32`	`32`	`{`
`33`		`- private readonly IApplicationDbContext _context;`
	`33`	`+ private readonly IApplicationDbContextFactory _dbContextFactory;`
`34`	`34`	`private readonly IMapper _mapper;`
`35`	`35`	`public GetAll{nameofPlural}QueryHandler(`
`36`	`36`	`IMapper mapper,`
`37`		`- IApplicationDbContext context)`
	`37`	`+ IApplicationDbContextFactory dbContextFactory)`
`38`	`38`	`{`
`39`	`39`	`_mapper = mapper;`
`40`		`- _context = context;`
	`40`	`+ _dbContextFactory = dbContextFactory;`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`public async Task<IEnumerable<{itemname}Dto>> Handle(GetAll{nameofPlural}Query request, CancellationToken cancellationToken)`
`44`	`44`	`{`
`45`		`- var data = await _context.{nameofPlural}.ProjectTo<{itemname}Dto>(_mapper.ConfigurationProvider)`
	`45`	`+ await using var db = await _dbContextFactory.CreateAsync(cancellationToken);`
	`46`	`+ var data = await db.{nameofPlural}.ProjectTo<{itemname}Dto>(_mapper.ConfigurationProvider)`
`46`	`47`	`.AsNoTracking()`
`47`	`48`	`.ToListAsync(cancellationToken);`
`48`	`49`	`return data;`
Original file line number	Diff line number	Diff line change
`@@ -31,19 +31,20 @@ public class Get{itemname}ByIdQuery : ICacheableRequest<Result<{itemname}Dto>>`
`31`	`31`	`public class Get{itemname}ByIdQueryHandler :`
`32`	`32`	`IRequestHandler<Get{itemname}ByIdQuery, Result<{itemname}Dto>>`
`33`	`33`	`{`
`34`		`- private readonly IApplicationDbContext _context;`
	`34`	`+ private readonly IApplicationDbContextFactory _dbContextFactory;`
`35`	`35`	`private readonly IMapper _mapper;`
`36`	`36`	`public Get{itemname}ByIdQueryHandler(`
`37`	`37`	`IMapper mapper,`
`38`		`- IApplicationDbContext context)`
	`38`	`+ IApplicationDbContextFactory dbContextFactory)`
`39`	`39`	`{`
`40`	`40`	`_mapper = mapper;`
`41`		`- _context = context;`
	`41`	`+ _dbContextFactory = dbContextFactory;`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public async Task<Result<{itemname}Dto>> Handle(Get{itemname}ByIdQuery request, CancellationToken cancellationToken)`
`45`	`45`	`{`
`46`		`- var data = await _context.{nameofPlural}.ApplySpecification(new {itemname}ByIdSpecification(request.Id))`
	`46`	`+ await using var db = await _dbContextFactory.CreateAsync(cancellationToken);`
	`47`	`+ var data = await db.{nameofPlural}.ApplySpecification(new {itemname}ByIdSpecification(request.Id))`
`47`	`48`	`.ProjectTo<{itemname}Dto>(_mapper.ConfigurationProvider)`
`48`	`49`	`.FirstAsync(cancellationToken) ?? throw new NotFoundException($"{itemname} with id: [{request.Id}] not found.");`
`49`	`50`	`return await Result<{itemname}Dto>.SuccessAsync(data);`
Original file line number	Diff line number	Diff line change
`@@ -35,19 +35,20 @@ public class {nameofPlural}WithPaginationQuery : {itemname}AdvancedFilter, ICach`
`35`	`35`	`public class {nameofPlural}WithPaginationQueryHandler :`
`36`	`36`	`IRequestHandler<{nameofPlural}WithPaginationQuery, PaginatedData<{itemname}Dto>>`
`37`	`37`	`{`
`38`		`- private readonly IApplicationDbContext _context;`
	`38`	`+ private readonly IApplicationDbContextFactory _dbContextFactory;`
`39`	`39`	`private readonly IMapper _mapper;`
`40`	`40`	`public {nameofPlural}WithPaginationQueryHandler(`
`41`	`41`	`IMapper mapper,`
`42`		`- IApplicationDbContext context)`
	`42`	`+ IApplicationDbContextFactory dbContextFactory)`
`43`	`43`	`{`
`44`	`44`	`_mapper = mapper;`
`45`		`- _context = context;`
	`45`	`+ _dbContextFactory = dbContextFactory;`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`public async Task<PaginatedData<{itemname}Dto>> Handle({nameofPlural}WithPaginationQuery request, CancellationToken cancellationToken)`
`49`	`49`	`{`
`50`		`- var data = await _context.{nameofPlural}.OrderBy($"{request.OrderBy} {request.SortDirection}")`
	`50`	`+ await using var db = await _dbContextFactory.CreateAsync(cancellationToken);`
	`51`	`+ var data = await db.{nameofPlural}.OrderBy($"{request.OrderBy} {request.SortDirection}")`
`51`	`52`	`.ProjectToPaginatedDataAsync<{itemname}, {itemname}Dto>(request.Specification,`
`52`	`53`	`request.PageNumber,`
`53`	`54`	`request.PageSize,`