System.InvalidOperationException: Service für Typ

Question

kann nicht aufgelöst werden Ich arbeite an einer Web-API mit ASP.NET Core. Wenn ich meine API mit einer Postanforderung ausführe, wird eine Ausnahme vor meinem Unterbrechungspunkt in der Post-Methode von UnitController ausgelöst.

Exception

Request starting HTTP/1.1 POST http://localhost:5000/api/unit application/json 31 fail: Microsoft.AspNetCore.Server.Kestrel[13] Connection id "0HKVTL9A1LTD4": An unhandled exception was thrown by the application. System.InvalidOperationException: Unable to resolve service for type 'Project.DataAccess.Repository.UnitRepository' while attempting to activate 'Project.Service.UnitService'.

Kontext

namespace Project.DataAccess.Library.Interface { 
public interface IBaseRepository<M> where M : class, IEntity 
{ 
    IEnumerable<M> SelectAll(); 

    M SelectByID(int id); 

    void Insert(M obj); 

    void Update(M obj); 

    void Delete(int id); 

    void Save(); 
} 
} 

namespace Project.DataAccess.Library { 
public abstract class BaseRepository<M> : IBaseRepository<M> where M : class, IEntity 
{ 
    protected ProjectContext Db { get; } 
    private DbSet<M> table = null; 

    protected DbSet<M> Table 
    { 
     get 
     { 
      return this.table; 
     } 
    } 

    public BaseRepository(ProjectContext dbContext) 
    { 
     Db = dbContext; 
     this.table = Db.Set<M>(); 
    } 

    public void Delete(int id) 
    { 
     M existing = this.SelectByID(id); 
     if (existing != null) 
      this.table.Remove(existing); 
    } 

    // others methods 
} 
} 

namespace Project.DataAccess.Repository 
{ 
    public class UnitRepository : BaseRepository<Unit>, IUnitRepository 
    { 
     public UnitRepository(Projectcontext) : base(context) { } 
    } 
} 

namespace Project.Service 
{ 
    public class UnitService : BaseService<Unit>, IUnitService 
    { 
     public UnitService(UnitRepository unitRepository) : base(unitRepository) { } 
    } 
} 


namespace AssoManager.Service.Library 
{ 
    public abstract class BaseService<M> : IBaseService<M> where M : class, IEntity 
    { 
     private IBaseRepository<M> _repository; 

     public BaseService(IBaseRepository<M> repository) 
     { 
      _repository = repository; 
     } 

     public IEnumerable<M> GetAll() 
     { 
      return this._repository.SelectAll(); 
     } 
    } 
} 


namespace Project 
{ 
    public class Startup 
    { 
     public Startup(IHostingEnvironment env) 
     { 
      var builder = new ConfigurationBuilder() 
       .SetBasePath(env.ContentRootPath) 
       .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true) 
       .AddJsonFile($"appsettings.{env.EnvironmentName}.json", optional: true) 
       .AddEnvironmentVariables(); 
      Configuration = builder.Build(); 
     } 

     public IConfigurationRoot Configuration { get; } 

     // This method gets called by the runtime. Use this method to add services to the container. 
     public void ConfigureServices(IServiceCollection services) 
     { 
      // Add framework services. 
      services.AddMvc(); 

      this.DataAccessMySqlConfiguration(services); 
      this.ConfigureRepository(services); 
      this.ConfigureServicesUnit(services); 
      this.ConfigureServicesUser(services); 
     } 

     // This method gets called by the runtime. Use this method to configure the HTTP request pipeline. 
     public void Configure(IApplicationBuilder app, IHostingEnvironment env, ILoggerFactory loggerFactory) 
     { 
      loggerFactory.AddConsole(Configuration.GetSection("Logging")); 
      loggerFactory.AddDebug(); 

      app.UseMvc(); 
     } 

     #region Database configuration 

     public void DataAccessMySqlConfiguration(IServiceCollection services) 
     { 
      services.AddDbContext<ProjectContext>(options => options.UseMySQL(Configuration.GetConnectionString("MsSQLConnection"))); 
     } 

     #endregion 

     #region DataAccess configuration 

     public void ConfigureRepository(IServiceCollection services) 
     { 
      services.AddScoped<IUnitRepository, UnitRepository>(); 
      services.AddScoped<IUserRepository, UserRepository>(); 
     } 

     #endregion 

     #region Services configuration 

     /// <summary> 
     /// Is used to add unit services to the container 
     /// </summary> 
     public void ConfigureServicesUnit(IServiceCollection services) 
     { 
      services.AddTransient<IUnitService, UnitService>(); 
      services.AddTransient<IMeetingService, MeetingService>(); 
     } 

     /// <summary> 
     /// Is used to add user services to the container 
     /// </summary> 
     public void ConfigureServicesUser(IServiceCollection services) 
     { 
      services.AddTransient<IUserService, UserService>(); 
     } 

     #endregion Services configuration 
    } 
} 


namespace Project.Controllers 
{ 
    [Route("api/[controller]")] 
    public class UnitController : Controller 
    { 
     private IUnitService UnitService; 

     public UnitController(IUnitService unitService) 
     { 
      UnitService = unitService; 
     } 

     // GET api/units 
     [HttpGet] 
     public IEnumerable<Unit> Get() 
     { 
      return UnitService.GetAll(); 
     } 

     // GET api/unit/5 
     [HttpGet("{id}")] 
     public IActionResult Get(int id) 
     { 
      Unit unit; 
      //->Check 
      if (id < 1) 
       return BadRequest(); 
      //->Processing 
      unit = UnitService.GetByID(id); 
      if (unit == null) 
       return NotFound(); 
      return new ObjectResult(unit); 
     } 

     // POST api/unit 
     [HttpPost] 
     public IActionResult Post([FromBody]Unit unit) 
     { 
      //->Check 
      if (unit == null) 
       return BadRequest(); 
      //->Processing 
      UnitService.Create(unit); 
      return CreatedAtRoute("Get", new { id = unit.Id }, unit); 
     } 

     // PUT api/unit/5 
     [HttpPut("{id}")] 
     public void Put(int id, [FromBody]string value) 
     { 
     } 

     // DELETE api/unit/5 
     [HttpDelete("{id}")] 
     public void Delete(int id) 
     { 
     } 
    } 
} 

Version

"dependencies": { 
    "Microsoft.NETCore.App": { 
     "version": "1.0.0", 
     "type": "platform" 
    }, 
    "Microsoft.AspNetCore.Mvc": "1.0.0", 
    "Microsoft.AspNetCore.Server.Kestrel": "1.0.0", 
    "Microsoft.Extensions.Configuration.EnvironmentVariables": "1.0.0", 
    "Microsoft.Extensions.Configuration.FileExtensions": "1.0.0", 
    "Microsoft.Extensions.Configuration.Json": "1.0.0", 
    "Microsoft.Extensions.Logging": "1.0.0", 
    "Microsoft.Extensions.Logging.Console": "1.0.0", 
    "Microsoft.Extensions.Logging.Debug": "1.0.0", 
    "Microsoft.Extensions.Options.ConfigurationExtensions": "1.0.0", 
    "Microsoft.EntityFrameworkCore": "1.0.0", 
    "MySql.Data.Core": "7.0.4-IR-191", 
    "MySql.Data.EntityFrameworkCore": "7.0.4-IR-191", 
    "IdentityServer4": "1.0.0-rc2", 
    "AssoManager.Domain": "1.0.0-*", 
    "AssoManager.Service": "1.0.0-*", 
    "AssoManager.DataAccess": "1.0.0-*" 
    }, 

Frage

Ich denke, das Problem ist vielleicht mit der Vererbung zwischen BaseRepository und IBaseRepository. Aber ich verstehe nicht, wo mein Fehler liegen könnte. Wie kann ich diesen Fehler beheben? Danke

für Ihre hilft :),

Answer 1

Sie UnitRepository als IUnitRepository Registrierung, aber anfordernden Ihre IoC UnitRepository lösen. Es hat keine Registrierung dafür, also scheitert es.

Versuchen Sie, dass UnitService ein IUnitRepository statt eines UnitRepository nimmt, das Dinge auflösen sollte (verzeihen Sie das Wortspiel).