Trying to delete from database using HTTPDELETE does nothing

I am learning to code in c# and I am developing an API application. My GET method works but I have issues with my DELETE, it returns a success code(200) but it does not delete from my database which is connected to my application. I am using the unit of work and repository patterns and my code is as follows:

Controller code:

        private readonly IOrderService _orderService;

        public OrdersController(IOrderService orderService)
        {
            _orderService = orderService;         
        }

[HttpDelete("{id}")]
        public async Task<ActionResult> RemoveOrder(int id)
        {
            try
            {
                await _orderService.Delete(id);
                return StatusCode(200);
            }
            catch (Exception ex)
            {
                return StatusCode(500);
            }

        }

Service Interface

public interface IOrderService
    {
        Task<Order> Get(int id);
        Task Add(Order order);
        Task Delete(int id);
        Task Update(int id, Order order);

        Task<IEnumerable<Order>> GetAllOrdersAsync();
        Task<IEnumerable<OrderDTO>> GetOrdersToCityAsync(string cityName);

        Task<OrderDTO> GetEmployeeOrdersToCountryAsync
    (
    string countryName, string employeeLastName
    );
    }

Service class:

 public class OrderService : IOrderService
    {
        private readonly IUnitOfWork _unitOfWork;
        public OrderService(IUnitOfWork unitOfWork)
        {
            _unitOfWork = unitOfWork;
        }
        public async Task Delete(int id)
        {
            try
            {
                var order = await _unitOfWork.OrderRepository.Get(id);
                _unitOfWork.OrderRepository.Delete(order);
                await _unitOfWork.CommitAsync();
            }
            catch (Exception e)
            {
                await _unitOfWork.RollbackAsync();
                throw;
            }
            
        }
}

Unit of work class:

public class UnitOfWork : IUnitOfWork
    {
        private readonly NorthwindContext _db;
        private List<object> _customRepositories = new List<object>();
        private IProductRepository _productRepository;
        private IOrderRepository _orderRepository;
        public UnitOfWork(
            NorthwindContext db, 
            IProductRepository ProductRepository,
            IOrderRepository orderRepository
            )
        { 
            _db = db;
            _productRepository = ProductRepository;
            _orderRepository = orderRepository;
        }

uow interface:

    public interface IUnitOfWork
    {
        IProductRepository ProductRepository { get; }

        IOrderRepository OrderRepository { get; }
        Task CommitAsync();
        Task RollbackAsync();
    }

Order repository interface which extends my genericRepository:

    public interface IOrderRepository : IGenericRepository<Order>
    {
        Task<IEnumerable<OrderDTO>> GetOrdersToCityAsync(string cityName);

        Task<OrderDTO> GetEmployeeOrdersToCountryAsync
            (
            string countryName, string employeeLastName
            );
    }

Order repository:

   public class OrderRepository : GenericRepository<Order>, IOrderRepository
    {
        private readonly NorthwindContext _northwindContext;
        public OrderRepository(NorthwindContext db) : base(db)
        {
            _northwindContext = db;
        }

generic repository:

    public class GenericRepository<T> : IGenericRepository<T> where T : class
    {
        protected readonly NorthwindContext _db;

        public GenericRepository(NorthwindContext db)
        {
            _db = db;
        }


        public void Delete(T entity)
        {
            _db.Set<T>().Remove(entity);
        }

Please ignore if the curly braces are not closed properly, in my application they are.