实体框架SaveChanges（）错误？

Question

我有一个CRUD应用程序，处理两个对象，卡和日志。 用户创建，编辑或删除卡时，将在数据库的日志表中创建一个新的日志记录。 用户创建卡时，日志记录的NewCard值为JSON数据，而OldCard值为null。 当用户删除卡时，日志记录的OldCard值为JSON数据，而NewCard为空。

但是，无论何时删除卡，Entity Framework都会创建此额外的记录，并用红色圆圈圈出：

记录2101是IActionResult Create CreateNewLog(card, null)之后的结果。 记录2102和2103是IActionResult Delete CreateNewLog(null, oldCard)之后的结果。 记录2103是问题。 如何停止创建此记录？

CardController.cs

    private ICardData _cardData;
    private ILogData _logData;

    public CardController(ICardData cardData, ILogData logData)
    {
        _cardData = cardData;
        _logData = logData;
    }

    // POST api/card
    [HttpPost]
    public IActionResult Create([FromBody] Card card)
    {
        try
        {
            if (ModelState.IsValid)
            {
                _cardData.Add(card);
                CreateNewLog(card, null);

                Response.StatusCode = (int)HttpStatusCode.Created;
                return Json(new { Data = card });
            }
        }
        catch (Exception ex)
        {
            Response.StatusCode = (int)HttpStatusCode.BadRequest;
            return Json(new { Message = ex.Message });
        }

        return Json("Failed");
    }

    // DELETE api/card/1
    [HttpDelete("{id}")]
    public void Delete(int id)
    {
        Card oldCard = _cardData.Get(id).ShallowCopy();
        CreateNewLog(null, oldCard);

        _cardData.Delete(id);
    }

    public void CreateNewLog(Card newCard, Card oldCard)
    {
        Log newLog = new Log()
        {
            DateChanged = DateTime.Now,

            CardId = newCard == null ? oldCard.CardId : newCard.CardId,
            OldCard = JsonConvert.SerializeObject(oldCard),
            NewCard = JsonConvert.SerializeObject(newCard),
            User = "John Smith"
        };

        _logData.Add(newLog);
    }

LogData.cs

public class SqlLogData : ILogData
{
    private LitmusDbContext _context;

    public SqlLogData(LitmusDbContext context)
    {
        _context = context;
    }

    public IEnumerable<Log> GetAll()
    {
        return _context.Logs.ToList();
    }

    public Log Get(int id)
    {
        return _context.Logs.FirstOrDefault(c => c.Id == id);
    }

    public void Add(Log newLog)
    {
        _context.Add(newLog);
        _context.SaveChanges();
    }

}

CardData.cs

public class SqlCardData : ICardData
    {
        private LitmusDbContext _context;

        public SqlCardData(LitmusDbContext context)
        {
            _context = context;
        }

        public IEnumerable<Card> GetAll()
        {
            return _context.Cards.ToList();
        }

        public Card Get(int id)
        {
            Card card = _context.Cards.FirstOrDefault(c => c.Id == id);

            return card;
        }

        public void Add(Card newCard)
        {
            _context.Add(newCard);
            _context.SaveChanges();
        }

        public int Commit()
        {
            _context.SaveChanges();
            return 0;
        }

        public void Update(Card newCard)
        {
            var oldCard = Get(newCard.Id);

            if (oldCard != null)
            {
                oldCard.CardId = newCard.CardId;
                oldCard.State = newCard.State;
                _context.SaveChanges();
            }
        }

        public void Delete(int id)
        {
            var cardToDelete = Get(id);

            _context.Remove(cardToDelete);
            _context.SaveChanges();
        }
    }

Answer 1

根据所提供的代码，我看不出这怎么可能。 新卡和旧卡都不会同时提供给CreateNewLog函数，但是有些东西正在将序列化卡保存到旧/新列中。

您可以在CreateNewLog函数中放置一个断点并找出提供两个参数的时间，然后查看调用堆栈吗？