diff --git a/Choreography/Choreography.OrderService.API/Consumers/PaymentCompletedEventConsumer.cs b/Choreography/Choreography.OrderService.API/Consumers/PaymentCompletedEventConsumer.cs
index 70c3b72..b320e94 100644
--- a/Choreography/Choreography.OrderService.API/Consumers/PaymentCompletedEventConsumer.cs
+++ b/Choreography/Choreography.OrderService.API/Consumers/PaymentCompletedEventConsumer.cs
@@ -2,24 +2,24 @@
 {
     public class PaymentCompletedEventConsumer : IConsumer<PaymentCompletedEvent>
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly ILogger<PaymentCompletedEventConsumer> _logger;
 
         public PaymentCompletedEventConsumer(
-            AppDbContext context,
+            AppDbContext dbContext,
             ILogger<PaymentCompletedEventConsumer> logger)
         {
-            _context = context;
+            _dbContext = dbContext;
             _logger = logger;
         }
 
         public async Task Consume(ConsumeContext<PaymentCompletedEvent> context)
         {
-            var order = await _context.Orders.FindAsync(context.Message.OrderId);
+            var order = await _dbContext.Orders.FindAsync(context.Message.OrderId);
             if (order is not null)
             {
                 order.Status = OrderStatus.Completed;
-                await _context.SaveChangesAsync();
+                await _dbContext.SaveChangesAsync();
 
                 _logger.LogInformation("Order (Id={@orderId}) status changed : {@orderStatus}", context.Message.OrderId, order.Status);
             }
diff --git a/Choreography/Choreography.OrderService.API/Consumers/PaymentFailedEventConsumer.cs b/Choreography/Choreography.OrderService.API/Consumers/PaymentFailedEventConsumer.cs
index 32c5f9a..3757ce2 100644
--- a/Choreography/Choreography.OrderService.API/Consumers/PaymentFailedEventConsumer.cs
+++ b/Choreography/Choreography.OrderService.API/Consumers/PaymentFailedEventConsumer.cs
@@ -2,25 +2,25 @@
 {
     public class PaymentFailedEventConsumer : IConsumer<PaymentFailedEvent>
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly ILogger<PaymentCompletedEventConsumer> _logger;
 
         public PaymentFailedEventConsumer(
-            AppDbContext context,
+            AppDbContext dbContext,
             ILogger<PaymentCompletedEventConsumer> logger)
         {
-            _context = context;
+            _dbContext = dbContext;
             _logger = logger;
         }
 
         public async Task Consume(ConsumeContext<PaymentFailedEvent> context)
         {
-            var order = await _context.Orders.FindAsync(context.Message.OrderId);
+            var order = await _dbContext.Orders.FindAsync(context.Message.OrderId);
             if (order is not null)
             {
                 order.Status = OrderStatus.Fail;
                 order.FailMessage = context.Message.Message;
-                await _context.SaveChangesAsync();
+                await _dbContext.SaveChangesAsync();
 
                 _logger.LogInformation("Order (Id={@orderId}) status changed : {@orderStatus}", context.Message.OrderId, order.Status);
             }
diff --git a/Choreography/Choreography.OrderService.API/Consumers/StockNotReservedEventConsumer.cs b/Choreography/Choreography.OrderService.API/Consumers/StockNotReservedEventConsumer.cs
index 3cb4495..1cb8230 100644
--- a/Choreography/Choreography.OrderService.API/Consumers/StockNotReservedEventConsumer.cs
+++ b/Choreography/Choreography.OrderService.API/Consumers/StockNotReservedEventConsumer.cs
@@ -2,25 +2,25 @@
 {
     public class StockNotReservedEventConsumer : IConsumer<StockNotReservedEvent>
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly ILogger<PaymentCompletedEventConsumer> _logger;
 
         public StockNotReservedEventConsumer(
-            AppDbContext context,
+            AppDbContext dbContext,
             ILogger<PaymentCompletedEventConsumer> logger)
         {
-            _context = context;
+            _dbContext = dbContext;
             _logger = logger;
         }
 
         public async Task Consume(ConsumeContext<StockNotReservedEvent> context)
         {
-            var order = await _context.Orders.FindAsync(context.Message.OrderId);
+            var order = await _dbContext.Orders.FindAsync(context.Message.OrderId);
             if (order is not null)
             {
                 order.Status = OrderStatus.Fail;
                 order.FailMessage = context.Message.Message;
-                await _context.SaveChangesAsync();
+                await _dbContext.SaveChangesAsync();
 
                 _logger.LogInformation("Order (Id={@orderId}) status changed : {@orderStatus}", context.Message.OrderId, order.Status);
             }
diff --git a/Choreography/Choreography.OrderService.API/Controllers/OrdersController.cs b/Choreography/Choreography.OrderService.API/Controllers/OrdersController.cs
index 5e3b646..d28a919 100644
--- a/Choreography/Choreography.OrderService.API/Controllers/OrdersController.cs
+++ b/Choreography/Choreography.OrderService.API/Controllers/OrdersController.cs
@@ -4,14 +4,14 @@
     [ApiController]
     public class OrdersController : ControllerBase
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly IPublishEndpoint _publishEndpoint;
 
         public OrdersController(
-            AppDbContext context,
+            AppDbContext dbContext,
             IPublishEndpoint publishEndpoint)
         {
-            _context = context;
+            _dbContext = dbContext;
             _publishEndpoint = publishEndpoint;
         }
 
@@ -73,8 +73,8 @@ private async Task<Order> AddOrderAsync(OrderCreateRequest request)
                 });
             });
 
-            await _context.AddAsync(order);
-            await _context.SaveChangesAsync();
+            await _dbContext.AddAsync(order);
+            await _dbContext.SaveChangesAsync();
 
             return order;
         }
diff --git a/Choreography/Choreography.StockService.API/Consumers/OrderCreatedEventConsumer.cs b/Choreography/Choreography.StockService.API/Consumers/OrderCreatedEventConsumer.cs
index f680796..c3f003f 100644
--- a/Choreography/Choreography.StockService.API/Consumers/OrderCreatedEventConsumer.cs
+++ b/Choreography/Choreography.StockService.API/Consumers/OrderCreatedEventConsumer.cs
@@ -2,18 +2,18 @@
 {
     public class OrderCreatedEventConsumer : IConsumer<OrderCreatedEvent>
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly ILogger<OrderCreatedEventConsumer> _logger;
         private readonly ISendEndpointProvider _sendEndpointProvider;
         private readonly IPublishEndpoint _publishEndpoint;
 
         public OrderCreatedEventConsumer
-            (AppDbContext context,
+            (AppDbContext dbContext,
             ILogger<OrderCreatedEventConsumer> logger,
             ISendEndpointProvider sendEndpointProvider,
             IPublishEndpoint publishEndpoint)
         {
-            _context = context;
+            _dbContext = dbContext;
             _logger = logger;
             _sendEndpointProvider = sendEndpointProvider;
             _publishEndpoint = publishEndpoint;
@@ -39,11 +39,11 @@ public async Task Consume(ConsumeContext<OrderCreatedEvent> context)
 
             foreach (var orderItem in context.Message.OrderItems)
             {
-                var stock = await _context.Stocks.FirstOrDefaultAsync(x => x.ProductId == orderItem.ProductId);
+                var stock = await _dbContext.Stocks.FirstOrDefaultAsync(x => x.ProductId == orderItem.ProductId);
 
                 stock.Count -= orderItem.Count;
 
-                await _context.SaveChangesAsync();
+                await _dbContext.SaveChangesAsync();
             }
 
             _logger.LogInformation("Stock was reserved for buyer Id :{@buyerId}", context.Message.BuyerId);
@@ -69,7 +69,7 @@ private async Task<bool> CheckStockOfAllProductsAsync(ConsumeContext<OrderCreate
         {
             foreach (var orderItem in context.Message.OrderItems)
             {
-                bool isHasStock = await _context.Stocks.AnyAsync(x => x.ProductId == orderItem.ProductId && x.Count > orderItem.Count);
+                bool isHasStock = await _dbContext.Stocks.AnyAsync(x => x.ProductId == orderItem.ProductId && x.Count > orderItem.Count);
                 if (!isHasStock)
                 {
                     return isHasStock; //herhangi bir üründe stok yoksa işlemi bitir.
diff --git a/Choreography/Choreography.StockService.API/Consumers/PaymentFailedEventConsumer.cs b/Choreography/Choreography.StockService.API/Consumers/PaymentFailedEventConsumer.cs
index 7afa0bf..55e68b4 100644
--- a/Choreography/Choreography.StockService.API/Consumers/PaymentFailedEventConsumer.cs
+++ b/Choreography/Choreography.StockService.API/Consumers/PaymentFailedEventConsumer.cs
@@ -2,14 +2,14 @@
 {
     public class PaymentFailedEventConsumer : IConsumer<PaymentFailedEvent>
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly ILogger<PaymentFailedEventConsumer> _logger;
 
         public PaymentFailedEventConsumer(
-            AppDbContext context,
+            AppDbContext dbContext,
             ILogger<PaymentFailedEventConsumer> logger)
         {
-            _context = context;
+            _dbContext = dbContext;
             _logger = logger;
         }
 
@@ -17,11 +17,11 @@ public async Task Consume(ConsumeContext<PaymentFailedEvent> context)
         {
             foreach (var item in context.Message.OrderItems)
             {
-                var stock = await _context.Stocks.FirstOrDefaultAsync(x => x.ProductId == item.ProductId);
+                var stock = await _dbContext.Stocks.FirstOrDefaultAsync(x => x.ProductId == item.ProductId);
                 if (stock is not null)
                 {
                     stock.Count += item.Count;
-                    await _context.SaveChangesAsync();
+                    await _dbContext.SaveChangesAsync();
                 }
             }
 
diff --git a/Choreography/Choreography.StockService.API/Controllers/StocksController.cs b/Choreography/Choreography.StockService.API/Controllers/StocksController.cs
index d2cb6ac..2edf493 100644
--- a/Choreography/Choreography.StockService.API/Controllers/StocksController.cs
+++ b/Choreography/Choreography.StockService.API/Controllers/StocksController.cs
@@ -4,17 +4,17 @@
     [ApiController]
     public class StocksController : ControllerBase
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
 
-        public StocksController(AppDbContext context)
+        public StocksController(AppDbContext dbContext)
         {
-            _context = context;
+            _dbContext = dbContext;
         }
 
         [HttpGet]
         public async Task<IActionResult> All(CancellationToken cancellationToken)
         {
-            var stocks = await _context.Stocks.ToListAsync(cancellationToken);
+            var stocks = await _dbContext.Stocks.ToListAsync(cancellationToken);
             if (!stocks.Any())
             {
                 return NotFound();
diff --git a/EventSourcing/EventSourcing.API/Queries/GetProductsByUserIdQueryHandler.cs b/EventSourcing/EventSourcing.API/Queries/GetProductsByUserIdQueryHandler.cs
index 9b26034..39fff4d 100644
--- a/EventSourcing/EventSourcing.API/Queries/GetProductsByUserIdQueryHandler.cs
+++ b/EventSourcing/EventSourcing.API/Queries/GetProductsByUserIdQueryHandler.cs
@@ -2,16 +2,16 @@
 {
     public class GetProductsByUserIdQueryHandler : IRequestHandler<GetProductsByUserIdQuery, List<ProductDto>>
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
 
-        public GetProductsByUserIdQueryHandler(AppDbContext context)
+        public GetProductsByUserIdQueryHandler(AppDbContext dbContext)
         {
-            _context = context;
+            _dbContext = dbContext;
         }
 
         public async Task<List<ProductDto>> Handle(GetProductsByUserIdQuery request, CancellationToken cancellationToken)
         {   
-            var products = await _context.Products
+            var products = await _dbContext.Products
                 .Where(product => product.UserId == request.UserId)
                 .Select(product => new ProductDto
                 {
diff --git a/Orchestration/Orchestration.OrderService.API/Consumers/OrderRequestCompletedEventConsumer.cs b/Orchestration/Orchestration.OrderService.API/Consumers/OrderRequestCompletedEventConsumer.cs
index 6eba04e..ed73a7f 100644
--- a/Orchestration/Orchestration.OrderService.API/Consumers/OrderRequestCompletedEventConsumer.cs
+++ b/Orchestration/Orchestration.OrderService.API/Consumers/OrderRequestCompletedEventConsumer.cs
@@ -2,22 +2,22 @@
 {
     public class OrderRequestCompletedEventConsumer : IConsumer<IOrchestrationOrderRequestCompletedEvent>
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly ILogger<OrderRequestCompletedEventConsumer> _logger;
 
-        public OrderRequestCompletedEventConsumer(AppDbContext context, ILogger<OrderRequestCompletedEventConsumer> logger)
+        public OrderRequestCompletedEventConsumer(AppDbContext dbContext, ILogger<OrderRequestCompletedEventConsumer> logger)
         {
-            _context = context;
+            _dbContext = dbContext;
             _logger = logger;
         }
 
         public async Task Consume(ConsumeContext<IOrchestrationOrderRequestCompletedEvent> context)
         {
-            var order = await _context.Orders.FindAsync(context.Message.OrderId);
+            var order = await _dbContext.Orders.FindAsync(context.Message.OrderId);
             if (order is not null)
             {
                 order.Status = OrderStatus.Completed;
-                await _context.SaveChangesAsync();
+                await _dbContext.SaveChangesAsync();
 
                 _logger.LogInformation($"Order (Id={context.Message.OrderId}) status changed : {order.Status}");
             }
diff --git a/Orchestration/Orchestration.OrderService.API/Consumers/OrderRequestFailedEventConsumer.cs b/Orchestration/Orchestration.OrderService.API/Consumers/OrderRequestFailedEventConsumer.cs
index d8bdb3f..dfceb6d 100644
--- a/Orchestration/Orchestration.OrderService.API/Consumers/OrderRequestFailedEventConsumer.cs
+++ b/Orchestration/Orchestration.OrderService.API/Consumers/OrderRequestFailedEventConsumer.cs
@@ -2,24 +2,24 @@
 {
     public class OrderRequestFailedEventConsumer : IConsumer<IOrchestrationOrderRequestFailedEvent>
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly ILogger<OrderRequestFailedEventConsumer> _logger;
 
-        public OrderRequestFailedEventConsumer(AppDbContext context, ILogger<OrderRequestFailedEventConsumer> logger)
+        public OrderRequestFailedEventConsumer(AppDbContext dbContext, ILogger<OrderRequestFailedEventConsumer> logger)
         {
-            _context = context;
+            _dbContext = dbContext;
             _logger = logger;
         }
 
         public async Task Consume(ConsumeContext<IOrchestrationOrderRequestFailedEvent> context)
         {
-            var order = await _context.Orders.FindAsync(context.Message.OrderId);
+            var order = await _dbContext.Orders.FindAsync(context.Message.OrderId);
 
             if (order != null)
             {
                 order.Status = OrderStatus.Fail;
                 order.FailMessage = context.Message.Reason;
-                await _context.SaveChangesAsync();
+                await _dbContext.SaveChangesAsync();
 
                 _logger.LogInformation($"Order (Id={context.Message.OrderId}) status changed : {order.Status}");
             }
diff --git a/Orchestration/Orchestration.OrderService.API/Controllers/OrdersController.cs b/Orchestration/Orchestration.OrderService.API/Controllers/OrdersController.cs
index ab47b06..438ce8e 100644
--- a/Orchestration/Orchestration.OrderService.API/Controllers/OrdersController.cs
+++ b/Orchestration/Orchestration.OrderService.API/Controllers/OrdersController.cs
@@ -6,14 +6,14 @@ namespace Orchestration.OrderService.API.Controllers
     [ApiController]
     public class OrdersController : ControllerBase
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly ISendEndpointProvider _sendEndpointProvider;
 
         public OrdersController(
-            AppDbContext context,
+            AppDbContext dbContext,
             ISendEndpointProvider sendEndpointProvider)
         {
-            _context = context;
+            _dbContext = dbContext;
             _sendEndpointProvider = sendEndpointProvider;
         }
 
@@ -76,8 +76,8 @@ private async Task<Order> AddOrderAsync(OrderCreateRequest request)
                 });
             });
 
-            await _context.AddAsync(order);
-            await _context.SaveChangesAsync();
+            await _dbContext.AddAsync(order);
+            await _dbContext.SaveChangesAsync();
 
             return order;
         }
diff --git a/Orchestration/Orchestration.StockService.API/Consumers/OrderCreatedEventConsumer.cs b/Orchestration/Orchestration.StockService.API/Consumers/OrderCreatedEventConsumer.cs
index 4085e62..3e35ef3 100644
--- a/Orchestration/Orchestration.StockService.API/Consumers/OrderCreatedEventConsumer.cs
+++ b/Orchestration/Orchestration.StockService.API/Consumers/OrderCreatedEventConsumer.cs
@@ -2,16 +2,16 @@
 {
     public class OrderCreatedEventConsumer : IConsumer<IOrchestrationOrderCreatedEvent>
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly ILogger<OrderCreatedEventConsumer> _logger;
         private readonly IPublishEndpoint _publishEndpoint;
 
         public OrderCreatedEventConsumer
-            (AppDbContext context,
+            (AppDbContext dbContext,
             ILogger<OrderCreatedEventConsumer> logger,
             IPublishEndpoint publishEndpoint)
         {
-            _context = context;
+            _dbContext = dbContext;
             _logger = logger;
             _publishEndpoint = publishEndpoint;
         }
@@ -33,11 +33,11 @@ await _publishEndpoint.Publish<IOrchestrationStockNotReservedEvent>(new Orchestr
 
             foreach (var orderItem in context.Message.OrderItems)
             {
-                var stock = await _context.Stocks.FirstOrDefaultAsync(x => x.ProductId == orderItem.ProductId);
+                var stock = await _dbContext.Stocks.FirstOrDefaultAsync(x => x.ProductId == orderItem.ProductId);
 
                 stock.Count -= orderItem.Count;
 
-                await _context.SaveChangesAsync();
+                await _dbContext.SaveChangesAsync();
             }
 
             _logger.LogInformation("Stock was reserved for CorrelationId Id :{@correlationId}", context.Message.CorrelationId);
@@ -58,7 +58,7 @@ private async Task<bool> CheckStockOfAllProductsAsync(ConsumeContext<IOrchestrat
         {
             foreach (var orderItem in context.Message.OrderItems)
             {
-                bool isHasStock = await _context.Stocks.AnyAsync(x => x.ProductId == orderItem.ProductId && x.Count > orderItem.Count);
+                bool isHasStock = await _dbContext.Stocks.AnyAsync(x => x.ProductId == orderItem.ProductId && x.Count > orderItem.Count);
                 if (!isHasStock)
                 {
                     return isHasStock; //herhangi bir üründe stok yoksa işlemi bitir.
diff --git a/Orchestration/Orchestration.StockService.API/Consumers/StockRollBackMessageConsumer.cs b/Orchestration/Orchestration.StockService.API/Consumers/StockRollBackMessageConsumer.cs
index 1c83d94..f650567 100644
--- a/Orchestration/Orchestration.StockService.API/Consumers/StockRollBackMessageConsumer.cs
+++ b/Orchestration/Orchestration.StockService.API/Consumers/StockRollBackMessageConsumer.cs
@@ -2,12 +2,12 @@
 {
     public class StockRollBackMessageConsumer : IConsumer<IOrchestrationStockRollBackMessage>
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
         private readonly ILogger<StockRollBackMessageConsumer> _logger;
 
-        public StockRollBackMessageConsumer(AppDbContext context, ILogger<StockRollBackMessageConsumer> logger)
+        public StockRollBackMessageConsumer(AppDbContext dbContext, ILogger<StockRollBackMessageConsumer> logger)
         {
-            _context = context;
+            _dbContext = dbContext;
             _logger = logger;
         }
 
@@ -15,12 +15,12 @@ public async Task Consume(ConsumeContext<IOrchestrationStockRollBackMessage> con
         {
             foreach (var item in context.Message.OrderItems)
             {
-                var stock = await _context.Stocks.FirstOrDefaultAsync(x => x.ProductId == item.ProductId);
+                var stock = await _dbContext.Stocks.FirstOrDefaultAsync(x => x.ProductId == item.ProductId);
 
                 if (stock != null)
                 {
                     stock.Count += item.Count;
-                    await _context.SaveChangesAsync();
+                    await _dbContext.SaveChangesAsync();
                 }
             }
 
diff --git a/Orchestration/Orchestration.StockService.API/Controllers/StocksController.cs b/Orchestration/Orchestration.StockService.API/Controllers/StocksController.cs
index f1e8887..02deb14 100644
--- a/Orchestration/Orchestration.StockService.API/Controllers/StocksController.cs
+++ b/Orchestration/Orchestration.StockService.API/Controllers/StocksController.cs
@@ -4,17 +4,17 @@
     [ApiController]
     public class StocksController : ControllerBase
     {
-        private readonly AppDbContext _context;
+        private readonly AppDbContext _dbContext;
 
-        public StocksController(AppDbContext context)
+        public StocksController(AppDbContext dbContext)
         {
-            _context = context;
+            _dbContext = dbContext;
         }
 
         [HttpGet]
         public async Task<IActionResult> All(CancellationToken cancellationToken)
         {
-            var stocks = await _context.Stocks.ToListAsync(cancellationToken);
+            var stocks = await _dbContext.Stocks.ToListAsync(cancellationToken);
             if (!stocks.Any())
             {
                 return NotFound();