Api 在.net core NLayer体系结构中处理请求时发生未处理的异常

我正在尝试在.NETCore中开发一个具有NLayer体系结构和通用存储库的api

当我尝试获取数据时，我看到一个错误

我的错误 处理请求时发生未处理的异常。 InvalidOperationException:在尝试激活“Fenerbace.API.Controllers.PlayerController”时，无法解析类型“Fenerbace.Business.Abstract.IPlayerManager”的服务。

IPlayerManager：

public interface IPlayerManager
{
        Task<IEnumerable<Player>> GetAllPlayers();
        Task<Player> GetPlayerById(int id);
        Task<Player> CreatePlayer(Player player);
        Task UpdatePlayer(Player playerToBeUpdated,Player player);
        Task DeletePlayer(Player player);
}

公共接口IPlayerManager
{
任务getAllPlayer（）；
任务GetPlayerById（int-id）；
任务CreatePlayer（Player-Player）；
任务更新层（Player-Player-tobeupdated，Player-Player）；
任务删除玩家（Player-Player）；
}

游戏管理员

私人只读i工作单元(unitof工作单元);

public PlayerManager(IUnitOfWork unitOfWork)
{
    this._unitOfWork = unitOfWork;
}
public async Task<Player> CreatePlayer(Player player)
{
    await _unitOfWork.Players.AddAsync(player);
    await _unitOfWork.CommitAsync();
    return player;
}

public async Task DeletePlayer(Player player)
{
    _unitOfWork.Players.Remove(player);
    await _unitOfWork.CommitAsync();
}

public async Task<IEnumerable<Player>> GetAllPlayers()
{
    return await _unitOfWork.Players.GetAllAsync();
}

public async Task<Player> GetPlayerById(int id)
{
    return await _unitOfWork.Players.GetByIdAsync(id);
}

public async Task UpdatePlayer(Player playerToBeUpdated, Player player)
{
    
    playerToBeUpdated.updatedAt = DateTime.Now;

    await _unitOfWork.CommitAsync();
}

public PlayerManager（IUnitOfWork unitOfWork）
{
这个。_unitOfWork=unitOfWork；
}
公共异步任务CreatePlayer（播放器）
{
wait_unitOfWork.Players.AddAsync（播放器）；
wait_unitOfWork.CommitAsync（）；
返回球员；
}
公共异步任务DeletePlayer（播放器）
{
_单位工作。玩家。移除（玩家）；
wait_unitOfWork.CommitAsync（）；
}
公共异步任务GetAllPlayer（）
{
return wait_unitOfWork.Players.GetAllAsync（）；
}
公共异步任务GetPlayerById（int-id）
{
return wait_unitOfWork.Players.GetByIdAsync（id）；
}
公共异步任务更新层（Player-playerToBeUpdated，Player-Player）
{
playerToBeUpdated.updatedAt=DateTime.Now；
wait_unitOfWork.CommitAsync（）；
}

}

工夫

  public interface IUnitOfWork : IDisposable
    {
        IBranchDal Branchs { get; }
        ICoachDal Coachs { get; }
        IPlayerDal Players {get;}
        ITeamDal Teams {get;}
        Task<int> CommitAsync();
    }

公共接口IUnitOfWork:IDisposable
{
伊布兰奇达尔分支{get；}
ICoachDal引导{get；}
IPlayerDal玩家{get；}
ITeamDal团队{get；}
任务提交同步（）；
}

EfUnitOfWork.cs

public class EfUnitOfWork : IUnitOfWork
{
    private readonly FBDbContext _context;
    private EfBranchDal _branchDal;
    private EfCoachDal _coachDal;
    private EfPlayerDal _playerDal;
    private EfTeamDal _teamDal;
   

    public EfUnitOfWork(FBDbContext context)
    {
        this._context = context;
    }

    public IBranchDal Branchs => _branchDal = _branchDal ?? new EfBranchDal(_context);

    public ICoachDal Coachs => _coachDal = _coachDal ?? new EfCoachDal(_context);

    public IPlayerDal Players => _playerDal = _playerDal ?? new EfPlayerDal(_context);

    public ITeamDal Teams => _teamDal = _teamDal ?? new EfTeamDal(_context);

    public async Task<int> CommitAsync()
    {
        return await _context.SaveChangesAsync();
    }

     public void Dispose()
    {
        _context.Dispose();
    }
}

公共类EfUnitOfWork:IUnitOfWork
{
私有只读FBDbContext\u上下文；
私人银行；
私人Efcocachdalu coachDal；
私人Efplayerdalu playerDal；
私人Efteamdalu teamDal；
公共EfUnitOfWork（FBDbContext上下文）
{
这._context=context；
}
公共IBranchDal Branchs=>_branchDal=_branchDal？？新的EfBranchDal（_上下文）；
公共ICoachDal Coachs=>\u coachDal=\u coachDal？？新的EfCoachDal（\u上下文）；
公共IPlayerDal玩家=>\u玩家玩家=\u玩家？？新的EfPlayerDal（\u上下文）；
公共ITeamDal团队=>\u teamDal=\u teamDal？？新的EfTeamDal（\u上下文）；
公共异步任务CommitAsync（）
{
return wait_context.saveChangesSync（）；
}
公共空间处置（）
{
_context.Dispose（）；
}
}

PlayerController.cs

  public class PlayerController:ControllerBase
    {

        private readonly IPlayerManager _playerManager;
        private readonly IMapper _mapper; 
    
        public PlayerController(IPlayerManager playerManager, IMapper mapper)
        {
            this._playerManager = playerManager;
            this._mapper = mapper;
       
        }

        [HttpGet] 
        public async Task<ActionResult<IEnumerable<PlayerDTO>>> ListAllPlayers()
        {
            var players = await _playerManager.GetAllPlayers();

            var playerResources = _mapper.Map<IEnumerable<Player>,
            IEnumerable<PlayerDTO>>(players);
            return Ok(playerResources);

        }
    }

公共类PlayerController:ControllerBase
{
专用只读IPlayerManager _playerManager；
专用只读IMapper\u映射器；
公共播放器控制器（IPlayerManager播放器管理器、IMapper映射器）
{
这是._playermanger=playermanger；
这个._mapper=mapper；
}
[HttpGet]
公共异步任务ListAllPlayer（）
{
var players=await_playerManager.GetAllPlayers（）；
var playerResources=_mapper.Map（玩家）；
返回Ok（播放资源）；
}
}

---

感谢您的帮助。

显然，依赖项注入容器丢失了。你可以使用unity/ninject/autofac来实现这一点，你可以从谷歌学习如何使用

---

此外，她的ZAMAN HER YERDE..

它告诉您确切的问题是什么

无法解析类型“Fenerbace.Business.Abstract.IPlayerManager”的服务，同时尝试激活“Fenerbace.API.Controllers.PlayerController”

-您需要一个实现注册到依赖项注入框架的接口的类型。是的，我在服务和工作中添加了瞬态。。正如你所说的那样，在贝尤肯·费内巴切，贝图恩·布阿莱姆德。。