Question

我正在沿实体框架学习ASP.NET Core（v 2.2）。我已经使用CQRS和存储库模式以及MediatR和Auto-Mapper作为实用程序进行开发和应用。

我正在使用Identity来管理我的应用程序用户，因此我创建了一个User类，该类继承了IdentityUser并向身份添加了一些额外的字段，例如名字和姓氏。此外，主要应用程序用户扩展了User并分别添加了几个特定于用户类型的额外字段。

我似乎无法更新用户的任何信息，因为EF似乎已经在跟踪该实体。我仅更新某些字段（例如名字或姓氏）。我还在调试中注意到EF对所有相关实体执行了级联更新。让我们将用户视为Medic。该用户具有诊断程序的链接（MedicDiagnostic链接表，其中包含用于医生和诊断程序的外键）。更新名字也会在所有诊断程序中更新。在存储库中执行SaveChangesAsync时会引发异常。

Exception has occurred: CLR/System.InvalidOperationException Exception thrown: 'System.InvalidOperationException' in System.Private.CoreLib.dll: 'The instance of entity type 'Medic' cannot be tracked because another instance with the same key value for {'Id'} is already being tracked. When attaching existing entities, ensure that only one entity instance with a given key value is attached. Consider using

完整日志here。

我应该如何处理？我曾尝试创建一个通用的UserRepository，但是这失败了，因为我找不到动态加载相关数据的方法，所以我创建了一个Frankenstein，其中既包含用于检索医疗人员的上下文，又包含相关数据，但是仍使用UserRepository。有更好的方法来解决这个问题吗？

完整的存储库可用here

现在，对于某些代码段：

Medic控制器中的GET / POST编辑方法：

    // GET: Medic/Edit/id
    [Authorize (Roles = "Receptionist,Admin,Medic")]
    public async Task<IActionResult> Edit (string id) {
        if (id == null) {
            return NotFound ();
        }

        var medicEditModel = await _mediator.Send (new GetMedicByIdForEditQuery (id));

        if (medicEditModel == null) {
            return NotFound ();
        }

        return View (medicEditModel);
    }

    // POST: Medic/Edit/id
    [HttpPost]
    [ValidateAntiForgeryToken]
    [Authorize (Roles = "Receptionist,Admin,Medic")]
    public async Task<IActionResult> Edit (string id, [Bind ("Medic")] MedicEditModel medicEditModel) {
        if (medicEditModel.ModelState.IsValid) {
            var editSucceeded = await _mediator.Send (new EditMedicCommand (id, medicEditModel.Medic));
            if (editSucceeded) {
                return RedirectToAction ("Details", "Medic", new { id = id });
            }
        }
        return View ();
    }

编辑命令和处理程序：

public class EditMedicCommand : IRequest<bool>
{
    public EditMedicCommand(string medicId, MedicEditDTO medic)
    {
        Medic = medic;
        MedicId = medicId;
    }

    public string MedicId { get; set; }
    public MedicEditDTO Medic { get; set; }
}

public class EditMedicCommandHandler : IRequestHandler<EditMedicCommand, bool>
{
    private readonly IMedicRepository _medicRepository;
    private readonly ILogger<EditMedicCommandHandler> _logger;
    private readonly IMapper _mapper;

    public EditMedicCommandHandler(IMedicRepository medicRepository,
        ILogger<EditMedicCommandHandler> logger,
        IMapper mapper)
    {
        _medicRepository = medicRepository;
        _logger = logger;
        _mapper = mapper;
    }

    public async Task<bool> Handle(EditMedicCommand request, CancellationToken cancellationToken)
    {
        Medic existingMedic = await _medicRepository.GetMedicByID(request.MedicId);

        if (existingMedic == null)
        {
            var errorMessage = $"No medic found for id {request.MedicId}";
            _logger.LogError(errorMessage);
            return false;
        }

        existingMedic.rank = request.Medic.rank;
        existingMedic.firstName = request.Medic.firstName;
        existingMedic.lastName = request.Medic.lastName;
        existingMedic.personalNumericalCode = request.Medic.personalNumericalCode;
        existingMedic.gender = request.Medic.gender;
        existingMedic.Email = request.Medic.Email;
        existingMedic.UserName = request.Medic.Email;
        existingMedic.address = request.Medic.address;


        try
        {
            await _medicRepository.UpdateMedic(existingMedic, request.Medic.Password);
        }
        catch (Exception)
        {
            return false;
        }
        return true;
    }
}

Medic存储库：

public class MedicRepository : IMedicRepository
{
    private readonly IUserRepository<Medic> _userRepository;
    private readonly IDbContext _context;
    private readonly ILogger<MedicRepository> _logger;
    private const string _role = "Medic";

    public MedicRepository(
        IUserRepository<Medic> userRepository,
        ILogger<MedicRepository> logger,
        IDbContext context)
    {
        _userRepository = userRepository;
        _logger = logger;
        _context = context;
    }

    public async Task AddMedic(Medic medic, string Password)
    {
        await _userRepository.Add(medic, Password, _role);
    }

    public async Task UpdateMedic(Medic medic, string NewPassword)
    {
        if (!String.IsNullOrEmpty(NewPassword))
        {
            medic.PasswordHash = _userRepository.UpdatePassword(medic, NewPassword);

        }
        await _userRepository.Update(medic);
    }

    public async Task<Medic> GetMedicByID(string id)
    {
        return await _context.Medics
        .Include(medic => medic.Diagnostics).ThenInclude(diagnostic => diagnostic.Diagnostic)
            .ThenInclude(medication => medication.Medications)
            .ThenInclude(medication => medication.Medication)
            .ThenInclude(medicine => medicine.Medicines)
        .Include(medic => medic.Departments).ThenInclude(department => department.Department)
        .FirstOrDefaultAsync(medic => medic.Id == id);
    }

    public async Task<IEnumerable<Medic>> GetAllMedics()
    {
        return await _userRepository.GetAll(_role);
    }

    public async Task<bool> AnyMedic(Func<Medic, bool> predicate)
    {
        return await _userRepository.Any(predicate, _role);
    }

    public async Task RemoveMedic(Medic medic)
    {
        await _userRepository.Remove(medic);
    }
}

UserRepository：

public class UserRepository<TEntity> : IUserRepository<TEntity> where TEntity : User {
    private readonly UserManager<TEntity> _userManager;
    private readonly ILogger<UserRepository<TEntity>> _logger;

    public UserRepository (
        ApplicationDbContext context,
        IServiceProvider serviceProvider,
        ILogger<UserRepository<TEntity>> logger
    ) {
        _userManager = serviceProvider.GetRequiredService<UserManager<TEntity>> ();
        _logger = logger;
    }

    public async Task Add (TEntity user, string password, string role) {
        if (user != null) {
            var userCreation = await _userManager.CreateAsync (user, password);

            if (userCreation.Succeeded) {
                await _userManager.AddToRoleAsync (user, role);
            } else {
                var errorMessage = $"Failed to create user {user.ToString()}.Aborting creation!";
                _logger.LogError (errorMessage);
                throw new TaskFailedException (errorMessage);
            }
        } else {
            var errorMessage = "Null user! Aborting creation!";
            _logger.LogError (errorMessage);
            throw new InvalidArgumentException (errorMessage);
        }
    }

    public async Task Remove (TEntity user) {
        if (user != null) {
            var userDeleteion = await _userManager.DeleteAsync (user);
            if (!userDeleteion.Succeeded) {
                var errorMessage = $"Failed to remove user {user.ToString()}.Aborting removal!";
                _logger.LogError (errorMessage);
                throw new TaskFailedException (errorMessage);
            }
        } else {
            var errorMessage = "Null user! Aborting creation!";
            _logger.LogError (errorMessage);
            throw new InvalidArgumentException (errorMessage);
        }
    }

    public async Task Update (TEntity user) {
        if (user != null) {
            var userUpdate = await _userManager.UpdateAsync (user);
            if (!userUpdate.Succeeded) {
                var errorMessage = $"Failed to update user {user.ToString()}.Aborting update!";
                _logger.LogError (errorMessage);
                throw new TaskFailedException (errorMessage);
            }
        } else {
            var errorMessage = "Null user! Aborting creation!";
            _logger.LogError (errorMessage);
            throw new InvalidArgumentException (errorMessage);
        }
    }

    public async Task<IEnumerable<TEntity>> GetAll (string role) {
        return await _userManager.GetUsersInRoleAsync (role);
    }

    public async Task<TEntity> GetByEmail (string email) {
        return await getUserByEmail (email).ToAsyncEnumerable ().FirstOrDefault ();
    }

    public async Task<bool> Any (Func<TEntity, bool> predicate, string role) {
        IEnumerable<TEntity> usersWithRole = await GetAll (role);
        return usersWithRole.Any (predicate);
    }

    private async Task<TEntity> getUserByEmail (string email) {
        TEntity user = null;
        if (email != null) {
            user = await _userManager.FindByEmailAsync (email);
        } else {
            var errorMessage = "Null email address provided! Aborting search by email!";
            _logger.LogError (errorMessage);
            throw new InvalidArgumentException (errorMessage);
        }
        return user;
    }

    public async Task<TEntity> GetById (string id) {
        TEntity user = null;
        if (id != null) {
            user = await _userManager.FindByIdAsync (id);
        } else {
            var errorMessage = "Null id provided! Aborting search by id!";
            _logger.LogError (errorMessage);
            throw new InvalidArgumentException (errorMessage);
        }
        return user;
    }

    public string UpdatePassword (TEntity user, string password) {
        return _userManager.PasswordHasher.HashPassword (user, password);
    }
}

谢谢！

尝试更新具有导航属性的实体会引发DbConcurrencyException

0 个答案: