aggiorna entità in DDD con EFCore 3

ho senario per l'uso dello stato attivo modifica stato. IsActive .

ho un problema con l'entità aggiornamento in asp core e DomainDriven Desogn.

quando cambio IsActive su True o False , crea un nuovo record inctance un aggiornamento che è stato ripetuto.

ho inserito qui il mio codice:

Primo passo :

questo è il mio controller, in questo controller chiamo il comando:

        public async Task<ApiReturn> ChangeUserActiveStatus(long id)
    {
        var result = await dispatchers.SendAsync(new UserActiveStateCommand { id = id });
        if(result.Success)
        {
            return Ok();
        }
        return BadRequest(result.Exception);
    }

passo due: invio una richiesta al database e fornisco il record desiderato:

    public class UserActiveStateCommandHandler : ICommandHandler<UserActiveStateCommand, OperationResult<string>>, IScopedDepency
{
    private readonly IDomainUnitOfWork unitOfWork;
    private readonly IDispatchers dispatchers;

    public UserActiveStateCommandHandler(IDomainUnitOfWork unitOfWork, IDispatchers dispatchers)
    {
        this.unitOfWork = unitOfWork;
        this.dispatchers = dispatchers;
    }
    public async Task<OperationResult<string>> HandlerAsync(UserActiveStateCommand command)
    {
        var user = await dispatchers.QueryAsync(new GetUserByIdQuery { id = command.id });
        if (user != null)
        {
            var u = new User();
            var value = u.SetUser(user.Result.Id, user.Result.Email, user.Result.LastName, user.Result.Photo, user.Result.FirstName, user.Result.UserName, user.Result.PhoneNumber, !user.Result.IsActive);
            await dispatchers.CallEvent(new UserActiveStateEvent { User = value });
            return OperationResult<string>.BuildSuccessResult("success");
        }
        else
        {
            return OperationResult<string>.BuildFailure("fail");
        }
    }
}

}

questo è quello reco ed è corretto:

    "email": "kiadr9372@gmail.com",
    "photo": null,
    "lastName": "Dortaj",
    "firstName": "Kianoush",
    "userName": "kia9372",
    "phoneNumber": "09159810616",
    "securityStamp": "e7cd82a5-71f3-41a1-b239-4d705b6d5d35",
    "isActive": false,
    "phoneConfirm": false,
    "emailConfirm": false,
    "isLockOut": false,
    "lockOutEnd": null,
    "isFailurAccount": 0,
    "userRoles": null,
    "id": 1

passo lì:

chiamo Event for Update Record nel database:

 public class UserActiveStatusEventHandler : IEventHandler<UserActiveStateEvent> , IScopedDepency
{
    private readonly IDomainUnitOfWork unitOfWork;

    public UserActiveStatusEventHandler(IDomainUnitOfWork unitOfWork)
    {
        this.unitOfWork = unitOfWork;
    }
    public async Task HandelEventAsync(UserActiveStateEvent @event)
    {
        var state = await unitOfWork.UserRepository.UpdateUser(@event.User);
        if (state.Success)
        {
            unitOfWork.Commit();
        }
    }
}

questo è il codice di aggiornamento nel repository:

 public async Task<OperationResult<bool>> UpdateUser(User user)
    {
        if (user != null)
        {
            try
            {
                context.Update(user);
                return OperationResult<bool>.BuildSuccessResult(true);
            }
            catch (Exception ex)
            {
                return OperationResult<bool>.BuildFailure(ex);
            }
        }
        return OperationResult<bool>.BuildFailure("user Cannot be null");
    }

e questo è il codice di commit:

public void Commit()
    {
        context.SaveChanges();
    }

questo è User Aggregate:

    public class User : AggregrateRoot, IAggregate
{
    #region Backing Field
    private string _email;
    private string _photo;
    private string _userName;
    private string _phoneNumber;
    private string _firstName;
    private string _lastName;
    private Guid _securityStamp;
    private bool _isActive;
    private bool _phoneConfirm;
    private bool _emailConfirm;
    private bool _isLockOut;
    private DateTimeOffset? _lockOutEnd;
    private int _isFailurAccount;
    #endregion

    #region Properies
    public string Email
    {
        get
        {
            return _email;
        }
        private set
        {
            _email = value;
            SetNotification();
        }
    }
    public string Photo
    {
        get
        {
            return _photo;
        }
        set
        {
            _photo = value;
            SetNotification();
        }
    }
    public string LastName
    {
        get
        {
            return _lastName;
        }
        private set
        {
            _lastName = value;
            SetNotification();
        }
    }
    public string FirstName
    {
        get
        {
            return _firstName;
        }
        private set
        {
            _firstName = value;
            SetNotification();
        }
    }
    public string UserName
    {
        get
        {
            return _userName;
        }
        private set
        {
            _userName = value;
            SetNotification();
        }
    }
    public string PhoneNumber
    {
        get
        {
            return _phoneNumber;
        }
        private set
        {
            _phoneNumber = value;
            SetNotification();
        }
    }
    public Guid SecurityStamp
    {
        get
        {
            return _securityStamp;
        }
        private set
        {
            _securityStamp = value;
            SetNotification();
        }

    }
    public bool IsActive
    {
        get
        {
            return _isActive;
        }
        private set
        {
            _isActive = value;
            SetNotification();
        }
    }
    public bool PhoneConfirm
    {
        get
        {
            return _phoneConfirm;
        }
        private set
        {
            _phoneConfirm = value;
            SetNotification();
        }
    }
    public bool EmailConfirm
    {
        get
        {
            return _emailConfirm;
        }
        private set
        {
            _emailConfirm = value;
            SetNotification();
        }
    }
    public bool IsLockOut
    {
        get
        {
            return _isLockOut;
        }
        private set
        {
            _isLockOut = value;
            SetNotification();
        }
    }
    public DateTimeOffset? LockOutEnd
    {
        get
        {
            return _lockOutEnd;
        }
        private set
        {
            _lockOutEnd = value;
            SetNotification();
        }

    }
    public int IsFailurAccount
    {
        get
        {
            return _isFailurAccount;
        }
        private set
        {
            _isFailurAccount = value;
            SetNotification();
        }
    }

    public ICollection<UserRole> UserRoles { get; set; }
    #endregion

    public User()
    {

    }

    #region Private Constructor
    private User(long id,string Email, string LastName, string photo, string FirstName, string UserName, string PhoneNumber, bool isActive)
    {
        this.Email = Email;
        this.Photo = photo;
        this.LastName = LastName;
        this.FirstName = FirstName;
        this.UserName = UserName;
        this.PhoneNumber = PhoneNumber;
        this.SecurityStamp = Guid.NewGuid();
        this.IsActive = isActive;
        this.PhoneConfirm = false;
        this.EmailConfirm = false;
        this.IsLockOut = false;
        this.LockOutEnd = null;
        this.IsFailurAccount = 0;
    }
    #endregion

    #region Methonds
    public User SetUser(string email, string lastName, string photo, string firstName, string userName, string phoneNumber, bool isActive = false)
    {
        var user = new User(email, lastName, firstName, photo, userName, phoneNumber, isActive);

        return user;
    }


    public UserRole AddUserRole(long userId, long roleId)
    {
        return new UserRole().AddUserRole(userId, roleId);
    }
    #endregion
}

ma il problema è qui: creo un nuovo recoed in datebase ma ho bisogno di aggiornarlo. Come posso risolvere questo problema ???