❔ Simple Api Fails to launch, why?

B

BananaPie•2/14/23, 9:52 PM

did you bind "IRecordRepository"?

B

BananaPie•2/14/23, 9:52 PM

Unable to resolve service for type 'Core.Interfaces.IRecordRepository' while attempting to activate 'Services.Services.RecordService'

A

Angius•2/14/23, 9:53 PM

Yeah,

RecordService

RecordService

RecordService

RecordService has

RecordRepository

RecordRepository

RecordRepository

RecordRepository as a dependency, but the latter is nowhere in the DI

AAngius Yeah, `RecordService` has `RecordRepository` as a dependency, but the latter is ...

A

antimatter8189OP•2/14/23, 9:54 PM

hmm, can u elaborate?

A

Angius•2/14/23, 9:55 PM

Your record service needs a record repository

A

Angius•2/14/23, 9:55 PM

But has nowhere to take it from

A

Angius•2/14/23, 9:55 PM

Everything you want injectable you need to register first

A

antimatter8189OP•2/14/23, 9:55 PM

how would u go about fixing it?

A

Angius•2/14/23, 9:56 PM

Register the repository

AAngius But has nowhere to take it from

A

antimatter8189OP•2/14/23, 9:56 PM

how do i make it take it from somwehre

A

antimatter8189OP•2/14/23, 9:56 PM

builder.Services.AddScoped<IRecordRepository, RecordRepository>();
?

A

Angius•2/14/23, 9:56 PM

Yep

A

Angius•2/14/23, 9:56 PM

For example

A

antimatter8189OP•2/14/23, 9:58 PM

so this:

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(); builder.Services.AddDbContext<ApplicationDbContext>(options => options.UseSqlServer(builder.Configuration.GetConnectionString("defaultConnection")));
builder.Services.AddScoped<IRecordRepository, RecordRepository>();
builder.Services.AddScoped<IRecordService, RecordService>();

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(); builder.Services.AddDbContext<ApplicationDbContext>(options => options.UseSqlServer(builder.Configuration.GetConnectionString("defaultConnection")));
builder.Services.AddScoped<IRecordRepository, RecordRepository>();
builder.Services.AddScoped<IRecordService, RecordService>();

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(); builder.Services.AddDbContext<ApplicationDbContext>(options => options.UseSqlServer(builder.Configuration.GetConnectionString("defaultConnection")));
builder.Services.AddScoped<IRecordRepository, RecordRepository>();
builder.Services.AddScoped<IRecordService, RecordService>();

builder.Services.AddControllers();
// Learn more about configuring Swagger/OpenAPI at https://aka.ms/aspnetcore/swashbuckle
builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(); builder.Services.AddDbContext<ApplicationDbContext>(options => options.UseSqlServer(builder.Configuration.GetConnectionString("defaultConnection")));
builder.Services.AddScoped<IRecordRepository, RecordRepository>();
builder.Services.AddScoped<IRecordService, RecordService>();

gives the same error

A

antimatter8189OP•2/14/23, 9:58 PM

why?

A

antimatter8189OP•2/14/23, 9:58 PM

wth is going on

A

Angius•2/14/23, 9:59 PM

Show your RecordService ig

A

antimatter8189OP•2/14/23, 9:59 PM

public class RecordService : IRecordService
    {
        private readonly IRecordRepository _recordRepository;
        private readonly IUnitOfWork _unitOfWork;

        public RecordService(IRecordRepository recordRepository, IUnitOfWork unitOfWork)
        {
            _recordRepository = recordRepository;
            _unitOfWork = unitOfWork;
        }

        public async Task<Record> AddRecordAsync(Record record)
        {
            try
            {
                await _recordRepository.AddAsync(record);
                await _unitOfWork.SaveAsync();
                return record;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<Record> UpdateRecordAsync(Record record)
        {
            try
            {
                await  _recordRepository.UpdateAsync(record);
                await _unitOfWork.SaveAsync();
                return record;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<bool> DeleteRecordAsync(Guid recordId)
        {
            try
            {
                var record = await _recordRepository.GetByIdAsync(recordId);
                if (record == null)
                {
                    return false;
                }
                await _recordRepository.DeleteAsync(record);
                await _unitOfWork.SaveAsync();
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        public Task<Record> GetRecordByIdAsync(Guid recordId)
        {
            return  _recordRepository.GetByIdAsync(recordId);
        }

        public Task<IEnumerable<Record>> GetAllRecordsAsync()
        {
            return _recordRepository.GetAllAsync();
        }
    }

public class RecordService : IRecordService
    {
        private readonly IRecordRepository _recordRepository;
        private readonly IUnitOfWork _unitOfWork;

        public RecordService(IRecordRepository recordRepository, IUnitOfWork unitOfWork)
        {
            _recordRepository = recordRepository;
            _unitOfWork = unitOfWork;
        }

        public async Task<Record> AddRecordAsync(Record record)
        {
            try
            {
                await _recordRepository.AddAsync(record);
                await _unitOfWork.SaveAsync();
                return record;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<Record> UpdateRecordAsync(Record record)
        {
            try
            {
                await  _recordRepository.UpdateAsync(record);
                await _unitOfWork.SaveAsync();
                return record;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<bool> DeleteRecordAsync(Guid recordId)
        {
            try
            {
                var record = await _recordRepository.GetByIdAsync(recordId);
                if (record == null)
                {
                    return false;
                }
                await _recordRepository.DeleteAsync(record);
                await _unitOfWork.SaveAsync();
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        public Task<Record> GetRecordByIdAsync(Guid recordId)
        {
            return  _recordRepository.GetByIdAsync(recordId);
        }

        public Task<IEnumerable<Record>> GetAllRecordsAsync()
        {
            return _recordRepository.GetAllAsync();
        }
    }

public class RecordService : IRecordService
    {
        private readonly IRecordRepository _recordRepository;
        private readonly IUnitOfWork _unitOfWork;

        public RecordService(IRecordRepository recordRepository, IUnitOfWork unitOfWork)
        {
            _recordRepository = recordRepository;
            _unitOfWork = unitOfWork;
        }

        public async Task<Record> AddRecordAsync(Record record)
        {
            try
            {
                await _recordRepository.AddAsync(record);
                await _unitOfWork.SaveAsync();
                return record;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<Record> UpdateRecordAsync(Record record)
        {
            try
            {
                await  _recordRepository.UpdateAsync(record);
                await _unitOfWork.SaveAsync();
                return record;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<bool> DeleteRecordAsync(Guid recordId)
        {
            try
            {
                var record = await _recordRepository.GetByIdAsync(recordId);
                if (record == null)
                {
                    return false;
                }
                await _recordRepository.DeleteAsync(record);
                await _unitOfWork.SaveAsync();
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        public Task<Record> GetRecordByIdAsync(Guid recordId)
        {
            return  _recordRepository.GetByIdAsync(recordId);
        }

        public Task<IEnumerable<Record>> GetAllRecordsAsync()
        {
            return _recordRepository.GetAllAsync();
        }
    }

public class RecordService : IRecordService
    {
        private readonly IRecordRepository _recordRepository;
        private readonly IUnitOfWork _unitOfWork;

        public RecordService(IRecordRepository recordRepository, IUnitOfWork unitOfWork)
        {
            _recordRepository = recordRepository;
            _unitOfWork = unitOfWork;
        }

        public async Task<Record> AddRecordAsync(Record record)
        {
            try
            {
                await _recordRepository.AddAsync(record);
                await _unitOfWork.SaveAsync();
                return record;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<Record> UpdateRecordAsync(Record record)
        {
            try
            {
                await  _recordRepository.UpdateAsync(record);
                await _unitOfWork.SaveAsync();
                return record;
            }
            catch (Exception)
            {
                throw;
            }
        }

        public async Task<bool> DeleteRecordAsync(Guid recordId)
        {
            try
            {
                var record = await _recordRepository.GetByIdAsync(recordId);
                if (record == null)
                {
                    return false;
                }
                await _recordRepository.DeleteAsync(record);
                await _unitOfWork.SaveAsync();
                return true;
            }
            catch (Exception)
            {
                return false;
            }
        }

        public Task<Record> GetRecordByIdAsync(Guid recordId)
        {
            return  _recordRepository.GetByIdAsync(recordId);
        }

        public Task<IEnumerable<Record>> GetAllRecordsAsync()
        {
            return _recordRepository.GetAllAsync();
        }
    }

A

Angius•2/14/23, 10:00 PM

Huh, the code being very enterprise-y aside, it should work

A

antimatter8189OP•2/14/23, 10:00 PM

However it doesnt

A

antimatter8189OP•2/14/23, 10:04 PM

so,, im dead in the water?

A

Angius•2/14/23, 10:05 PM

Uh, show your RecordRepository too...?

A

antimatter8189OP•2/14/23, 10:05 PM

using Core.Interfaces;
using Core.Models;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace Infrastructure.Repositories
{
    public class RecordRepository : GenericRepository<Record>, IRecordRepository
    {
        public RecordRepository(ApplicationDbContext context) : base(context)
        {
        }
        
    }
}

using Core.Interfaces;
using Core.Models;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace Infrastructure.Repositories
{
    public class RecordRepository : GenericRepository<Record>, IRecordRepository
    {
        public RecordRepository(ApplicationDbContext context) : base(context)
        {
        }
        
    }
}

using Core.Interfaces;
using Core.Models;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace Infrastructure.Repositories
{
    public class RecordRepository : GenericRepository<Record>, IRecordRepository
    {
        public RecordRepository(ApplicationDbContext context) : base(context)
        {
        }
        
    }
}

using Core.Interfaces;
using Core.Models;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;


namespace Infrastructure.Repositories
{
    public class RecordRepository : GenericRepository<Record>, IRecordRepository
    {
        public RecordRepository(ApplicationDbContext context) : base(context)
        {
        }
        
    }
}

A

antimatter8189OP•2/14/23, 10:05 PM

using Core.Interfaces;
using Core.Models;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Infrastructure.Repositories
{
    public class GenericRepository<T> : IRepository<T> where T : class
    {
        private readonly ApplicationDbContext _context;
        private DbSet<T> _entities;

        public GenericRepository(ApplicationDbContext context)     
        {
            _context = context;
            _entities = context.Set<T>();
        }

        public async Task<T> GetByIdAsync(Guid id) => await _entities.FindAsync(id);

        public async Task<T> AddAsync(T entity)
        {
            await _entities.AddAsync(entity);
            await _context.SaveChangesAsync();
            return entity;
        }

        public async Task<IEnumerable<T>> GetAllAsync() 
        {
            var entityType = typeof(T);

            if (entityType.GetProperties().Any(p => p.Name == "IsDeleted"))
            {
                return await _entities.Where(e => !(bool)entityType.GetProperty("IsDeleted")
                .GetValue(e)).ToListAsync();
            }
            else
            {
                return await _entities.ToListAsync();
            }
        }

        public async Task<T> UpdateAsync(T entity)
        {
            _entities.Update(entity);
            await _context.SaveChangesAsync();
            return entity;
        }

        public async Task DeleteAsync(T entity)
        {
            _entities.Remove(entity);
            await _context.SaveChangesAsync();
        }

        public async Task SaveAsync()
        {
            await _context.SaveChangesAsync();
        }
    }
}

using Core.Interfaces;
using Core.Models;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Infrastructure.Repositories
{
    public class GenericRepository<T> : IRepository<T> where T : class
    {
        private readonly ApplicationDbContext _context;
        private DbSet<T> _entities;

        public GenericRepository(ApplicationDbContext context)     
        {
            _context = context;
            _entities = context.Set<T>();
        }

        public async Task<T> GetByIdAsync(Guid id) => await _entities.FindAsync(id);

        public async Task<T> AddAsync(T entity)
        {
            await _entities.AddAsync(entity);
            await _context.SaveChangesAsync();
            return entity;
        }

        public async Task<IEnumerable<T>> GetAllAsync() 
        {
            var entityType = typeof(T);

            if (entityType.GetProperties().Any(p => p.Name == "IsDeleted"))
            {
                return await _entities.Where(e => !(bool)entityType.GetProperty("IsDeleted")
                .GetValue(e)).ToListAsync();
            }
            else
            {
                return await _entities.ToListAsync();
            }
        }

        public async Task<T> UpdateAsync(T entity)
        {
            _entities.Update(entity);
            await _context.SaveChangesAsync();
            return entity;
        }

        public async Task DeleteAsync(T entity)
        {
            _entities.Remove(entity);
            await _context.SaveChangesAsync();
        }

        public async Task SaveAsync()
        {
            await _context.SaveChangesAsync();
        }
    }
}

using Core.Interfaces;
using Core.Models;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Infrastructure.Repositories
{
    public class GenericRepository<T> : IRepository<T> where T : class
    {
        private readonly ApplicationDbContext _context;
        private DbSet<T> _entities;

        public GenericRepository(ApplicationDbContext context)     
        {
            _context = context;
            _entities = context.Set<T>();
        }

        public async Task<T> GetByIdAsync(Guid id) => await _entities.FindAsync(id);

        public async Task<T> AddAsync(T entity)
        {
            await _entities.AddAsync(entity);
            await _context.SaveChangesAsync();
            return entity;
        }

        public async Task<IEnumerable<T>> GetAllAsync() 
        {
            var entityType = typeof(T);

            if (entityType.GetProperties().Any(p => p.Name == "IsDeleted"))
            {
                return await _entities.Where(e => !(bool)entityType.GetProperty("IsDeleted")
                .GetValue(e)).ToListAsync();
            }
            else
            {
                return await _entities.ToListAsync();
            }
        }

        public async Task<T> UpdateAsync(T entity)
        {
            _entities.Update(entity);
            await _context.SaveChangesAsync();
            return entity;
        }

        public async Task DeleteAsync(T entity)
        {
            _entities.Remove(entity);
            await _context.SaveChangesAsync();
        }

        public async Task SaveAsync()
        {
            await _context.SaveChangesAsync();
        }
    }
}

using Core.Interfaces;
using Core.Models;
using Microsoft.EntityFrameworkCore;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Infrastructure.Repositories
{
    public class GenericRepository<T> : IRepository<T> where T : class
    {
        private readonly ApplicationDbContext _context;
        private DbSet<T> _entities;

        public GenericRepository(ApplicationDbContext context)     
        {
            _context = context;
            _entities = context.Set<T>();
        }

        public async Task<T> GetByIdAsync(Guid id) => await _entities.FindAsync(id);

        public async Task<T> AddAsync(T entity)
        {
            await _entities.AddAsync(entity);
            await _context.SaveChangesAsync();
            return entity;
        }

        public async Task<IEnumerable<T>> GetAllAsync() 
        {
            var entityType = typeof(T);

            if (entityType.GetProperties().Any(p => p.Name == "IsDeleted"))
            {
                return await _entities.Where(e => !(bool)entityType.GetProperty("IsDeleted")
                .GetValue(e)).ToListAsync();
            }
            else
            {
                return await _entities.ToListAsync();
            }
        }

        public async Task<T> UpdateAsync(T entity)
        {
            _entities.Update(entity);
            await _context.SaveChangesAsync();
            return entity;
        }

        public async Task DeleteAsync(T entity)
        {
            _entities.Remove(entity);
            await _context.SaveChangesAsync();
        }

        public async Task SaveAsync()
        {
            await _context.SaveChangesAsync();
        }
    }
}

A

Angius•2/14/23, 10:06 PM

Remove the ctor from your non-generic repo?

A

Angius•2/14/23, 10:06 PM

It does nothing anyway

A

antimatter8189OP•2/14/23, 10:06 PM

Yeah It does

A

Angius•2/14/23, 10:07 PM

Not in the code you sent at least

A

antimatter8189OP•2/14/23, 10:07 PM

Cs7036

A

antimatter8189OP•2/14/23, 10:07 PM

it breaks the build

A

antimatter8189OP•2/14/23, 10:07 PM

that piece of code is on all the code examples

A

antimatter8189OP•2/14/23, 10:07 PM

i saw

A

Angius•2/14/23, 10:08 PM

Ah, right, because it creates a default parameterless constructor...

A

antimatter8189OP•2/14/23, 10:08 PM

still the problem lingers

A

Angius•2/14/23, 10:09 PM

The problem is repositories over EF

A

antimatter8189OP•2/14/23, 10:09 PM

System.AggregateException: 'Some services are not able to be constructed (Error while validating the service descriptor 'ServiceType: Services.Interfaces.IRecordService Lifetime: Scoped ImplementationType: Services.Services.RecordService': Unable to resolve service for type 'Core.Interfaces.IUnitOfWork' while attempting to activate 'Services.Services.RecordService'.)'

System.AggregateException: 'Some services are not able to be constructed (Error while validating the service descriptor 'ServiceType: Services.Interfaces.IRecordService Lifetime: Scoped ImplementationType: Services.Services.RecordService': Unable to resolve service for type 'Core.Interfaces.IUnitOfWork' while attempting to activate 'Services.Services.RecordService'.)'

System.AggregateException: 'Some services are not able to be constructed (Error while validating the service descriptor 'ServiceType: Services.Interfaces.IRecordService Lifetime: Scoped ImplementationType: Services.Services.RecordService': Unable to resolve service for type 'Core.Interfaces.IUnitOfWork' while attempting to activate 'Services.Services.RecordService'.)'

System.AggregateException: 'Some services are not able to be constructed (Error while validating the service descriptor 'ServiceType: Services.Interfaces.IRecordService Lifetime: Scoped ImplementationType: Services.Services.RecordService': Unable to resolve service for type 'Core.Interfaces.IUnitOfWork' while attempting to activate 'Services.Services.RecordService'.)'

AAngius The problem is repositories over EF 😛

A

antimatter8189OP•2/14/23, 10:09 PM

nah that aint correct

A

antimatter8189OP•2/14/23, 10:09 PM

https://learn.microsoft.com/en-us/aspnet/mvc/overview/older-versions/getting-started-with-ef-5-using-mvc-4/implementing-the-repository-and-unit-of-work-patterns-in-an-asp-net-mvc-application

Implementing the Repository and Unit of Work Patterns in an ASP.NET...

The Contoso University sample web application demonstrates how users can create ASP.NET MVC 4 applications by using the Entity Framework 5 Code First and Visual Studio.

A

Angius•2/14/23, 10:09 PM

You don't seem to have

IUnitOfWork

IUnitOfWork

IUnitOfWork

IUnitOfWork registered

A

antimatter8189OP•2/14/23, 10:09 PM

ms offican

A

antimatter8189OP•2/14/23, 10:09 PM

l

A

Angius•2/14/23, 10:10 PM

A

Angius•2/14/23, 10:10 PM

A

antimatter8189OP•2/14/23, 10:10 PM

builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();

A

antimatter8189OP•2/14/23, 10:10 PM

CORRECT

A

antimatter8189OP•2/14/23, 10:10 PM

now

A

Angius•2/14/23, 10:10 PM

DbContext

DbContext

DbContext

DbContext is unit of work,

DbSet<T>

DbSet<T>

DbSet<T>

DbSet<T> is a repository

A

antimatter8189OP•2/14/23, 10:11 PM

tell me

A

antimatter8189OP•2/14/23, 10:11 PM

why?

M

MODiX•2/14/23, 10:11 PM

Angius#1586

DbContext

DbContext

DbContext

DbContext is unit of work,

DbSet<T>

DbSet<T>

DbSet<T>

DbSet<T> is a repository

Quoted by

@85903769203642368 from #Simple Api Fails to launch, why? (click here)

React with ❌ to remove this embed.

•

2/14/23, 10:10 PM

❔ Simple Api Fails to launch, why?

Similar Threads

Similar Threads

Similar Threads