我试图访问我的api项目中的工作单元，但我有一个问题的函数。

这是主要的股票回购储存库

public class StockRepository : GenericRepository<StockItem>, IStockRepository
{ 
    public StockRepository(WarehouseDBContext _context) : base(_context)
    { 
    }
    public IEnumerable<StockItem> GetAllStockItems()
    {
        return context.StockItems.ToList();
    }


    public  bool DoesStockItemExist(string? stockCode)
    {
      return  context.StockItems.Any(e => e.StockCode == stockCode);
    }
    public async Task<StockItem> FindStockItemByIdAsync(int? id)
    {
        return await context.StockItems.FirstOrDefaultAsync(x=>x.Id== id);

    }
    public void Save()
    {
        context.SaveChanges();
    }

    private bool disposed = false;

    protected virtual void Dispose(bool disposing)
    {
        if (!this.disposed)
        {
            if (disposing)
            {
                context.Dispose();
            }
        }
        this.disposed = true;
    }

    public void Dispose()
    {
        Dispose(true);
        GC.SuppressFinalize(this);
    }

    Task<List<StockItem>> GetAll()
    {
        throw new NotImplementedException();
    }
}

这是接口

public interface IStockRepository : IGenericRepository<StockItem>
{ 
    IEnumerable<StockItem> GetAllStockItems();
    Task<StockItem> FindStockItemByIdAsync(int? id);
    bool DoesStockItemExist(string? stockCode);
    Task<List<StockItem>> GetAll();
}

出于某种原因，如果我这样做，这只会勾起引用。

     Task<List<StockItem>> IStockRepository.GetAll()
    {

        return context.StockItems.ToListAsync();
    }

如果我这样做，它会抱怨方法没有实现，这是为什么？

 Task<List<StockItem>> GetAll()
 {

        return context.StockItems.ToListAsync();
 }

这是我的通用接口。

public abstract class GenericRepository<T> : IGenericRepository<T> where T : class
{
    protected readonly WarehouseDBContext context;

    protected GenericRepository(WarehouseDBContext _context)
    {
        context = _context;
    }

    public async Task<T> Get(int? id)
    {
        return await context.Set<T>().FindAsync(id);
    }

    public async Task<IEnumerable<T>> GetAll()
    {
        return await context.Set<T>().ToListAsync();
    }

    public async Task Add(T entity)
    {
        await context.Set<T>().AddAsync(entity);
    }

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

    public void Update(T entity)
    {
        context.Set<T>().Update(entity);
    }

    public IQueryable<T> Where(Expression<Func<T, bool>> predicate)
    {
        return context.Set<T>().Where(predicate);
    }

    public bool Any(Expression<Func<T, bool>> predicate)
    {
        return context.Set<T>().Any(predicate);

    }

}
}