Entity framework .NET核心Web API在数据库上下文中更新模型不起作用

我正在编写一个名为

Cart.API

的小服务，我应该处理我数据库中的所有添加/更新/删除请求（我使用docker，因此我在docker容器中托管一个MSSQL数据库）。现在，我陷入了方法

DeleteCatalogItemAsync

这是CartController.cs的代码：

using System.Collections.Generic;
using System.Linq;
using System.Threading.Tasks;
using Cart.API.Models;
using Cart.API.Services;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;

namespace Cart.API.Controllers
{
    [ApiController]
    [Route("api/[controller]")]
    public class CartController : ControllerBase
    {
        private readonly CartContext _context;
        private readonly ICartService _cartService;
        private readonly ICatalogService _catalogService;

        public CartController(CartContext context, ICartService cartService, ICatalogService catalogService)
        {
            _context = context;
            _cartService = cartService;
            _catalogService = catalogService;
        }

        [HttpGet]
        [Route("cart/{id}")]
        public bool CartExists(int id)
        {
            return _context.UserCarts.Any(cart => cart.Id == id);
        }

        [HttpGet]
        [Route("entries")]
        public async Task<ActionResult<List<CartModel>>> GetAllCartAsync()
        {
            var cartList = await _context.UserCarts.Include(cart => cart.Items).ToListAsync(); //include needed to load Items List
            if (cartList == null)
            {
                return NoContent();
            }

            return cartList;
        }

        [HttpGet]
        [Route("entries/{id}")]
        public async Task<ActionResult<CartModel>> GetCartByIdAsync(int id)
        {
            var cart = await _context.UserCarts.Where(b => b.Id == id).Include(m => m.Items).SingleOrDefaultAsync();

            return cart ?? new CartModel(id);
        }

        [HttpPut]
        [Route("entries")]
        public async Task<ActionResult> AddCartItemAsync([FromBody] AddCartItemRequest requestItem)
        {
            if (requestItem == null || requestItem.Quantity == 0)
            {
                return BadRequest("Invalid payload");
            }

            //Check, if cart already exists or a new one has to be added
            var cartExists = await _cartService.CheckCartExistance(requestItem.CartId);

            //Get or create cart object by the requested Id
            var currentCart = await _cartService.GetCartByIdAsync(requestItem.CartId);

            //Get Catalog Item
            var catalogItem = await _catalogService.GetCatalogItemByIdAsync(requestItem.CatalogItemId);

            currentCart.Items.Add(new CartItem(catalogItem.Id, catalogItem.Name, catalogItem.Price, requestItem.Quantity));

            if (!cartExists)
            {
                _context.UserCarts.Add(currentCart);
            }
            else
            {
                _context.UserCarts.Update(currentCart);
            }

            await _context.SaveChangesAsync();

            return Ok(currentCart);
        }

        [HttpDelete]
        [Route("entries/remove")]
        public async Task<ActionResult> DeleteCatalogItemAsync([FromBody] DeleteCartItemRequest requestItem)
        {
            if (requestItem == null)
            {
                return BadRequest("Cannot perform action");
            }

            //Check if Basket exists
            var basketExists = await _cartService.CheckCartExistance(requestItem.CartId);

            if (basketExists)
            {
                //var currentCart = await _context.UserCarts.Include(model => model.Items).SingleOrDefaultAsync(model => model.Id == requestItem.CartId);

                var currentCart = await _cartService.GetCartByIdAsync(requestItem.CartId);
                if(currentCart != null)
                {
                    var itemToDelete = currentCart.Items.Find(model => model.ProductId == requestItem.CatalogItemId);
                    currentCart.Items.Remove(itemToDelete);
                    //currentCart.RemoveCartItem(requestItem.CatalogItemId);
                    _context.UserCarts.Update(currentCart);
                    await _context.SaveChangesAsync();
                    return Ok();
                }

                return BadRequest("Das Item mit der ID " + requestItem.CatalogItemId + " konnte nicht gelöscht werden.");
            }
            return NotFound("Es existiert kein Warenkorb mit der ID " + requestItem.CartId);
        }

        [HttpGet]
        [Route("test")]
        public async Task<ActionResult> TestCall()
        {
            var test1 = await _catalogService.GetCatalogItemByIdAsync(1);
            return Ok(test1);
        }
    }
}

using System.Collections.Generic;
using System.Net.Http;
using System.Threading.Tasks;
using Cart.API.Models;
using Newtonsoft.Json;

namespace Cart.API.Services
{
    public class CartService : ICartService
    {
        private readonly HttpClient _client;

        public CartService(HttpClient client)
        {
            _client = client;
        }

        public async Task<IEnumerable<CartModel>> GetAllCartsAsync()
        {
            var stringContent = await _client.GetStringAsync("http://cart.api/api/cart/entries");
            return JsonConvert.DeserializeObject<List<CartModel>>(stringContent);
        }

        public async Task<CartModel> GetCartByIdAsync(int id)
        {
            var stringContent = await _client.GetStringAsync("http://cart.api/api/cart/entries/" + id);
            var cart = !string.IsNullOrEmpty(stringContent) ? JsonConvert.DeserializeObject<CartModel>(stringContent) : null;
            return cart;
        }

        public async Task<bool> CheckCartExistance(int cartId)
        {
            var stringContent = await _client.GetStringAsync("http://cart.api/api/cart/cart/" + cartId);
            return JsonConvert.DeserializeObject<bool>(stringContent);
        }
    }
}

CartModel.cs

using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;
using Microsoft.EntityFrameworkCore;

namespace Cart.API.Models
{
    public class CartModel
    {
        [DatabaseGenerated(DatabaseGeneratedOption.None)]
        public int Id { get; set; }
        public List<CartItem> Items { get; set; }

        public CartModel(int id)
        {
            Id = id;
            Items = new List<CartItem>();
        }

        public bool RemoveCartItem(int id)
        {
            var itemToDelete = Items.Find(m => m.ProductId == id);
            return Items.Remove(itemToDelete);
        }

    }
}

using System.ComponentModel.DataAnnotations;
using System.ComponentModel.DataAnnotations.Schema;

namespace Cart.API.Models
{
    public class CartItem
    {
        [Key]
        [DatabaseGenerated(DatabaseGeneratedOption.Identity)]
        public long Id { get; set; }
        public long ProductId { get; set; }
        public string ProductName { get; set; }
        public double ProductPrice { get; set; }
        public int ProductQuantity { get; set; }
        public CartItem(long productId, string productName, double productPrice, int productQuantity)
        {
            ProductId = productId;
            ProductName = productName;
            ProductPrice = productPrice;
            ProductQuantity = productQuantity;
        }
    }
}

因此，在

CartController.cs

的方法

DeleteCatalogItemAsync

中，我试图提供能够删除现有CatalogItem的功能。因此，在我将CatalogItem从购物车列表中删除之前，我调用cartService来检索应该从中删除项目的购物篮。我的问题是，使用上面提供的代码，CatalogItem不会从数据库中删除，因为对currentCart对象的更改不会保存到数据库中。据我所知，currentCart对象未被跟踪，因此在将该对象保存到数据库之前，我将调用.Update方法开始跟踪该项目并将所有属性标记为已修改

var itemToDelete = currentCart.Items.Find(model => model.ProductId == requestItem.CatalogItemId);
currentCart.Items.Remove(itemToDelete);
_context.UserCarts.Update(currentCart);
await _context.SaveChangesAsync();

我按照上面的代码顺序进行了处理，并以某种方式将更改后的对象保存到dababase中，使用以下代码顺序：

var itemToDelete = currentCart.Items.Find(model => model.ProductId == requestItem.CatalogItemId);
_context.UserCarts.Update(currentCart);
currentCart.Items.Remove(itemToDelete);
await _context.SaveChangesAsync();

---

为什么此解决方案有效，但不是第一个？

下面这行代码将实体的

currentCart

实例附加到DBContext，开始跟踪实体，并将实体状态设置为“已修改”

_context.UserCarts.Update(currentCart);

codet的下一行

currentCart.Items.Remove（itemToDelete）

将导致

itemToDelete

实体状态被删除

如果你打电话

currentCart.Items.Remove（itemToDelete）context.UserCarts.Update（currentCart）之前的代码>由于DbContext未跟踪
currentCart
对象，因此
itemToDelete
实体将不会标记为已删除

因此，EntityFramework无法知道在调用
Save
方法时需要删除此实体

希望能有所帮助
首先，感谢您的回复。读过之后，它实际上是有道理的，但是。。。如果查看AddCartItemAsync方法，也会出现同样的情况。我有一个名为currentCart的未跟踪对象，在实际调用.Update之前，我在其中添加CatalogItems。这个订单运作良好。。怎么样？我的意思是，在调用
\u context.SaveChangesAsync（）时，在
AddCartItemAsync
方法中添加项，而不是删除，情况也是一样的
currentCart
及其所有包含购物车项目的状态根据购物车的存在进行修改或添加。在这种情况下，EF框架可以确定如何处理Cart和CartItem实体。要删除实体，必须首先对其进行跟踪，然后将其状态更改为“已删除”