C# Updating model using HttpPost

Question

I started learning C# and I want to update my model using the [HttpPost] annotation. I tried removing the [FromBody]Item itm parameter and the fields on the repository but it's not working either. Below is my code.

Controller:

       [HttpPost("{id}")]
        public ActionResult<Item> UpdateItem([FromBody]Item itm, int id)
        {
            var getItem = _repository.GetItemById(id);
            if (getItem == null)
            {
                return NotFound();
            }

            _repository.UpdateItem(itm);
            _repository.SaveChanges();

            return Ok(getItem);
        }

Repository:

        public void UpdateItem(Item itm)
        {
            if (itm == null)
            {
                throw new ArgumentNullException(nameof(itm));
            }
            var itemToUpdate = this.GetItemById(itm.Id);

            if (itm.Name != null)
            {
                itemToUpdate.Name = itm.Name;
            }
            itemToUpdate.Price = itm.Price;
            itemToUpdate.Condition = itm.Condition;
            itemToUpdate.Size = itm.Size;
            itemToUpdate.DateSold = itm.DateSold;
            itemToUpdate.SellMethod = itm.SellMethod;
            
            _context.Items.Update(itemToUpdate);
        }

Interface:

void UpdateItem(Item itm);

Model:

        public int Id { get; set; }
        [Required]
        public string Name { get; set; }
        public int Price { get; set; }
        public string Condition { get; set; }
        public string Size { get; set; }
        public string DateSold { get; set; }
        public string SellMethod { get; set; }

Answer 1

First of all verify that you're sending that item correctly:

• Is the form correct and pointing to that method of your controller?
• Are you sending that item via the form (have you used the provided methods for this) ?

After that, if you're sending the item in the body of your post request, then verify the item in the method's parameter is available.

EDIT:

Well, as already discussed with Panagiotis you should rather directly use the DbContext itself as it already provides everything you need.

[HttpPost("{id}")]
public ActionResult<Item> UpdateItem(int id, [FromBody]Item itemData)
{
    var foundItem = _dbContext.Items.SingleOrDefault(x => x.Id == id);
    if (foundItem == null)
    {
        return NotFound();
    }

    foundItem.Name = itemData.Name;
    foundItem.Size = itemData.Size;
    // and so on

    _dbContext.SaveChanges();

    return Ok(foundItem);
}

Another way to keep your current structure, but it's not recommended, would be the following:

[HttpPost("{id}")]
public ActionResult<Item> UpdateItem(int id, [FromBody]Item itemData)
{
    var updatedItem = _repository.UpdateItem(id, itemData);
    
    if (updatedItem == null)
    {
        return NotFound();
    }    

    return Ok(updatedItem);
}

public void UpdateItem(int id, Item itemData)
{
    // you can validate parameters and throw errors if e.g. itemData == null

    var originalItem = GetItemById(id); // this should internally get the item e.g. _dbContext.Items.Where(x => x.id == itemData.Id);

    if(originalItem == null)
    {
        return null;
    }

    originalItem.Name = itemData.Name;    
    originalItem.Price = itemData.Price;
    originalItem.Condition = itemData.Condition;
    originalItem.Size = itemData.Size;
    originalItem.DateSold = itemData.DateSold;
    originalItem.SellMethod = itemData.SellMethod;

    SaveChanges(); // guess this will be _dbContext.SaveChanges() instead

    return originalItem;
}

Well, you could also change it to first load the item and then pass the originalItem and the itemData into the UpdateItem method inside your repository. But as you see the better way to directly use the DbContext is more clearer and shorter.