ASP.NET Core WebApi无法更新数据库。 （CQRS命令）

Question

因此，我正在研究一种CQRS方法ASP.NET Core WebApi。 我正在尝试更新Azure数据库表中的项目数量（单位）。 每当我使用Commands中的UpdateSubscriptionCommand时，它都不会成功执行，并从以下TransactionBehavior.cs中返回catch异常，最后在SwaggerUI中返回400 BadRequest。 如果有人可以看一下并指导我进行操作，并希望告诉我我做错了什么：

PS：我正在使用VS Code。

public class TransactionBehaviour<TRequest, TResponse> : IPipelineBehavior<TRequest, TResponse>
{
    private readonly ILogger<TransactionBehaviour<TRequest, TResponse>> _logger;
    private readonly SubscriptionContext _dbContext;
    //private readonly IProductSubscriptionIntegrationEventService _productSubscriptionIntegrationEventService;

    public TransactionBehaviour(SubscriptionContext dbContext,
        //IProductSubscriptionIntegrationEventService productSubscriptionIntegrationEventService,
        ILogger<TransactionBehaviour<TRequest, TResponse>> logger)
    {
        _dbContext = dbContext ?? throw new ArgumentException(nameof(SubscriptionContext));
        //_productSubscriptionIntegrationEventService = productSubscriptionIntegrationEventService ?? throw new ArgumentException(nameof(productSubscriptionIntegrationEventService));
        _logger = logger ?? throw new ArgumentException(nameof(ILogger));
    }

    public async Task<TResponse> Handle(TRequest request, CancellationToken cancellationToken, RequestHandlerDelegate<TResponse> next)
    {
        var response = default(TResponse);
        var typeName = request.GetGenericTypeName();

        try
        {
            if (_dbContext.HasActiveTransaction)
            {
                return await next();
            }

            var strategy = _dbContext.Database.CreateExecutionStrategy();

            await strategy.ExecuteAsync(async () =>
            {
                Guid transactionId;

                using (var transaction = await _dbContext.BeginTransactionAsync())
                using (LogContext.PushProperty("TransactionContext", transaction.TransactionId))
                {
                    _logger.LogInformation("----- Begin transaction {TransactionId} for {CommandName} ({@Command})", transaction.TransactionId, typeName, request);

                    response = await next();

                    _logger.LogInformation("----- Commit transaction {TransactionId} for {CommandName}", transaction.TransactionId, typeName);

                    await _dbContext.CommitTransactionAsync(transaction);

                    transactionId = transaction.TransactionId;
                }

                //await _productSubscriptionIntegrationEventService.PublishEventsThroughEventBusAsync(transactionId);
            });

            return response;
        }
        catch (Exception ex)
        {
            _logger.LogError(ex, "ERROR Handling transaction for {CommandName} ({@Command})", typeName, request);

            throw;
        }
    }
} 

我的控制器：

[Route("update")]
    [HttpPut]
    [ProducesResponseType((int)HttpStatusCode.OK)]
    [ProducesResponseType((int)HttpStatusCode.BadRequest)]
    public async Task<IActionResult> UpdateSubscriptionAsync([FromBody] UpdateSubscriptionCommand command)
    {
        bool commandResult = false;

        var requestUpdateSubscription = new IdentifiedCommand<UpdateSubscriptionCommand, bool>(command, new Guid());

        _logger.LogInformation(
            "----- Sending command: {CommandName} - {IdProperty}: {CommandId} ({@Command})",
            requestUpdateSubscription.GetGenericTypeName(),
            nameof(requestUpdateSubscription.Command.ProductId),
            requestUpdateSubscription.Command.ProductId,
            requestUpdateSubscription.Command.ItemQuantity,
            requestUpdateSubscription);

        commandResult = await _mediator.Send(requestUpdateSubscription);

        if (!commandResult)
        {
            return BadRequest();
        }

        return Ok();
    }

我的UpdateSubscriptionCommand.cs

public class UpdateSubscriptionCommand : IRequest<bool>
{
    [DataMember]
    public int ProductId { get; set; }

    [DataMember]
    public int ItemQuantity { get; set; }

    public UpdateSubscriptionCommand(int productId, int itemQuantity)
    {
        ProductId = productId;
        ItemQuantity = itemQuantity;
    }
}

UpdateSubscriptionCommandHandler.cs

public class UpdateSubscriptionCommandHandler : IRequestHandler<UpdateSubscriptionCommand, bool>
{
    private readonly ISubscriptionRepository _subscriptionRepository;

    public UpdateSubscriptionCommandHandler(ISubscriptionRepository subscriptionRepository)
    {
        _subscriptionRepository = subscriptionRepository;
    }
    public async Task<bool> Handle(UpdateSubscriptionCommand command, CancellationToken cancellationToken)
    {
        SubscriptionItem subscriptionItemToUpdate = null;
        var subscriptionToUpdate = await _subscriptionRepository.GetAsync(command.ProductId);


        foreach(var item in subscriptionToUpdate.SubscriptionItems)
        {
            if (item.ProductId == command.ProductId)
                subscriptionItemToUpdate = item;
        }

        if (subscriptionToUpdate == null || subscriptionItemToUpdate == null)
        {
            return false;
        }

        subscriptionToUpdate.UpdateSubscriptionItemQuantity(subscriptionItemToUpdate.ProductId, command.ItemQuantity);
        return await _subscriptionRepository.UnitOfWork.SaveEntitiesAsync(cancellationToken);
    }
}


// Use for Idempotency in Command process
public class UpdateSubscriptionIdentifiedCommandHandler : IdentifiedCommandHandler<UpdateSubscriptionCommand, bool>
{
    public UpdateSubscriptionIdentifiedCommandHandler(
        IMediator mediator,
        IRequestManager requestManager,
        ILogger<IdentifiedCommandHandler<UpdateSubscriptionCommand, bool>> logger)
        : base(mediator, requestManager, logger)
    {
    }

    protected override bool CreateResultForDuplicateRequest()
    {
        return true;                // Ignore duplicate requests for processing subscription.
    }
}

来自Subscription.cs的相关信息（模型）：

private readonly List<SubscriptionItem> _subscriptionItems;

protected Subscription() {
        _subscriptionItems = new List<SubscriptionItem>();
        _isDraft = false;
    }

public void UpdateSubscriptionItemQuantity(int productId, int quantity)
    {
        _subscriptionItems.Find(s => s.ProductId == productId).UpdateUnits(quantity);
    }

以及SubscriptionItem.cs中的相关信息（模型）：

public int ProductId { get; private set; }

    protected SubscriptionItem() { }

    public SubscriptionItem(int productId, string productName, decimal unitPrice, int units = 1)
    {
        if (units <= 0)
        {
            throw new SubscriptionDomainException("Invalid number of units");
        }

        ProductId = productId;

        _productName = productName;
        _unitPrice = unitPrice;
        _units = units;
    }

public void UpdateUnits(int units)
    {
        if (units < 0)
        {
            throw new SubscriptionDomainException("Invalid units");
        }

        _units = units;
    }