c# – Problem with loading related data in ef core using Ardalis Specification: List of objects evaluates to null

I’m new to ef core development and this looked at eShopOnWeb for guidance. I adapted many things and ended up with a somewhat working API, where I just can’t load related data. I have used Ardalis.Specification but ended up not being able to fix the issue. Originally I coded according to Ardalis and then adapted somewhat in Java Spring Patterns having and approach of using Conrtoller > Service > Repository > Entity.

In a structure like this:

.sln

 - Controllers
 - Core
 - Infrastructure

When fetching api/Book/ I get this result:

[{
  "bookId":1,
  "title":"Borja On Fleek uD83DuDD25",
  "description":"De jung Pirat Borja mischt die 7 Weltmeer uf",
  "coverImageUrl":"https://s3.amazonaws.com/[...].png",
  "chapters":null,
  "bookCategories":null,
  "bookTags":null
}]

This is fine as there is one book in the DB. But there are also:

  • 0 Chapters in the DB
  • 1 BookCategory in the DB
  • 2 BookTag in the DB
Entry BookId CategoryId
1 1 2
Entry BookId TagId
1 1 1
1 1 2

The corresponding entries in Tag and Category do exist.

I stuck to Microsofts’ guide to relations in order to create Many-To-Ony (Chapters) and Many-To-Many (Tags, Categories).

The entities:

Book.cs

using Core.Interfaces;

namespace Core.Entities.BookAggregate
{
    public class Book :  IAggregateRoot
    {
        public int BookId { get; set; }
        public string Title { get; set; }
        public string Description { get; set; }
        public string CoverImageUrl { get; set; }
        public ICollection<Chapter> Chapters { get; set; }
        public ICollection<BookCategory> BookCategories { get; set; }
        public ICollection<BookTag> BookTags { get; set; }
    }
}

Category.cs

using Core.Entities.BookAggregate;
using Core.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Core.Entities.Aggregates
{
    public class Category : IAggregateRoot
    {
        public int CategoryId { get; set; }
        public string Name { get; set; }
        public int Order { get; set; }
        public string ImageUrl { get; set; }
        public ICollection<BookCategory> BookCategories { get; set; }
    }
}

BookCategory.cs

using Core.Entities.Aggregates;
using Core.Entities.BookAggregate;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Core.Entities
{
    public class BookCategory
    {
        public int BookId { get; set; }
        public Book Book { get; set; }
        public int CategoryId { get; set; }
        public Category Category { get; set; }
    }
}

As Tag.cs and BookTag.cs are equal they are omitted.

Chapter.cs

using Core.Entities.BookAggregate;
using Core.Interfaces;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Core.Entities
{
    public class Chapter : IAggregateRoot
    {
        public int ChapterId { get; set; }
        public string Title { get; set; }
        public int Ordinal { get; set; }
        public int BookId { get; set; }
        public Book Book { get; set; }
        public ICollection<Page> Pages { get; set; }
    }

}

The Controller is mostly abstracted, so for the BookController we have this code.

BookController.cs

using Core.Entities.BookAggregate;
using Core.Interfaces;
using Microsoft.AspNetCore.Mvc;

// For more information on enabling Web API for empty projects, visit https://go.microsoft.com/fwlink/?LinkID=397860

namespace API.Controllers
{
    [Route("api/[controller]")]
    [ApiController]
    public class BookController : BaseController<Book>
    {
        public BookController(IService<Book> service) : base(service)
        {
        }

        [HttpPut("{id}")]
        public override async Task<IActionResult> Put(int id, [FromBody] Book book)
        {
            Book entity = await _service.GetByIdAsync(id);
            entity.Title = book.Title;
            entity.Chapters = book.Chapters;
            
            await _service.UpdateAsyc(entity);
            return Ok(entity);
        }
    }
}

Which inherits from BaseController.cs

using Core.Interfaces;
using Microsoft.AspNetCore.Mvc;

namespace API.Controllers
{
    public class BaseController<T> : Controller where T : class, IAggregateRoot
    {
        private protected readonly IService<T> _service;

        public BaseController(IService<T> service)
        {
            _service = service;
        }

        [HttpGet]
        public async Task<IEnumerable<T>> Get()
        {
            return await _service.ListAsync();
        }

        [HttpGet("{id}")]
        public async Task<T> Get(int id)
        {
            return await _service.GetByIdAsync(id);
        }

        [HttpPost]
        public async Task<IActionResult> Post([FromBody] T t)
        {
            await _service.AddAsync
            return Ok
        }

        [HttpPut("{id}")]
        public virtual async Task<IActionResult> Put(int id, [FromBody] T t)
        { 
            throw new NotImplementedException();
        }

        [HttpDelete("{id}")]
        public async Task<IActionResult> Delete(int id)
        {
            if (await _service.GetByIdAsync(id) == null)
                return NotFound();

            await _service.DeleteByIdAsync(id);
            return Ok();
        }
    }
}

The GenericService and IService are generics:

IService.cs

namespace Core.Interfaces
{
    public interface IService<T> where T : class, IAggregateRoot
    {
        Task<T> GetByIdAsync(int id);
        Task<IEnumerable<T>> ListAsync();
        Task DeleteByIdAsync(int id);
        Task AddAsync(T t);
        Task UpdateAsyc(T t);
    }
}

GenericService.cs

using Core.Interfaces;

namespace Core.Services
{
    public class GenericService<T> : IService<T> where T : class, IAggregateRoot
    {
        private readonly IRepository<T> _repository;
        private readonly IAppLogger<GenericService<T>> _logger;


        public GenericService(IRepository<T> repository, IAppLogger<GenericService<T>> logger)
        {
            _repository = repository;
            _logger = logger;
        }

        public async Task<T> GetByIdAsync(int id)
        {
            return await _repository.GetByIdAsync(id);
        }

        public async Task<IEnumerable<T>> ListAsync()
        {
            return await _repository.ListAsync();
        }

        public async Task DeleteByIdAsync(int id)
        {
            var t = await _repository.GetByIdAsync(id);

            if (t == null)
            {
                _logger.Error($"Element with id: {id} can not be found!");
                throw new ArgumentException($"Element with id: {id} can not be found!");
            }

            await _repository.DeleteAsync
        }

        public async Task AddAsync(T t)
        {
            await _repository.AddAsync
        }

        public async Task UpdateAsyc(T t)
        {
            await _repository.UpdateAsync
        }
    }
}

IRepository.cs

using Ardalis.Specification;

namespace Core.Interfaces
{
    public interface IRepository<T> : IRepositoryBase<T> where T : class, IAggregateRoot
    {
    }
}

Everything is strapped-in Program.cs.

using Core.Interfaces;
using Infrastructure.Data;
using Infrastructure.Logging;
using Microsoft.EntityFrameworkCore;
using Core.Services;
using Core.Entities.BookAggregate;
using Core.Entities;
using Core.Entities.Cells;
using Core.Entities.Aggregates;
using Microsoft.OpenApi.Models;

var builder = WebApplication.CreateBuilder(args);

builder.Logging.AddConsole();

Infrastructure.Dependencies.ConfigureServices(builder.Configuration, builder.Services);


builder.Services.AddScoped(typeof(IRepository<>), typeof(EfRepository<>));
builder.Services.AddScoped(typeof(IReadRepository<>), typeof(EfRepository<>));
builder.Services.AddScoped<IService<Book>, GenericService<Book>>();
builder.Services.AddScoped<IService<Chapter>, GenericService<Chapter>>();
builder.Services.AddScoped<IService<Page>, GenericService<Page>>();
builder.Services.AddScoped<IService<Cell>, GenericService<Cell>>();
builder.Services.AddScoped<IService<Category>, GenericService<Category>>();
builder.Services.AddScoped<IService<Tag>, GenericService<Tag>>();
builder.Services.AddScoped(typeof(IAppLogger<>), typeof(LoggerAdapter<>));

builder.Services.AddMemoryCache();

builder.Services.AddControllers();

builder.Services.AddEndpointsApiExplorer();
builder.Services.AddSwaggerGen(c =>
{
    c.SwaggerDoc("v1", new OpenApiInfo { Title = "My API", Version = "v1" });
});

var app = builder.Build();

app.Logger.LogInformation("PublicApi App created...");

app.Logger.LogInformation("Seeding Database...");

using (var scope = app.Services.CreateScope())
{
    var scopedProvider = scope.ServiceProvider;
    try
    {
        var bookDesinerContext = scopedProvider.GetRequiredService<BookDesinerContext>();
        if (bookDesinerContext.Database.IsSqlServer())
        {
            bookDesinerContext.Database.EnsureCreated();
            bookDesinerContext.Database.Migrate();
        }
    }
    catch (Exception ex)
    {
        app.Logger.LogError(ex, "An error occurred seeding the DB.");
    }
}

if (app.Environment.IsDevelopment())
{
    app.UseDeveloperExceptionPage();
}

app.UseHttpsRedirection();

app.UseRouting();

// Enable middleware to serve generated Swagger as a JSON endpoint.
app.UseSwagger();

// Enable middleware to serve swagger-ui (HTML, JS, CSS, etc.), 
// specifying the Swagger JSON endpoint.
app.UseSwaggerUI(c =>
{
    c.SwaggerEndpoint("/swagger/v1/swagger.json", "My API V1");
});

app.UseEndpoints(endpoints =>
{
    endpoints.MapControllers();
});

app.Logger.LogInformation("LAUNCHING PublicApi");
app.Run();

I tried adding a Specification but don’t understand how it works and where to bootstrap it.
BookSpecification.cs

using Ardalis.Specification;
using Core.Entities.BookAggregate;

namespace Core.Specifications
{
    public class BookSpecification : Specification<Book>
    {
        public BookSpecification(int tagId) 
        {
            Query
                .Where(b => b.BookId == tagId)
                .Include(b => b.BookTags);
        }

        /** Can't do that because this type of constructor already exists
        public BookSpecification(int categoryId)
        {
            Query
                .Where(b => b.BookId == categoryId)
                .Include(b => b.BookCategories);
        }

        public BookSpecification(int tagId)
        {
            Query
                .Where(b => b.BookId == tagId)
                .Include(b => b.BookTags);
        }
        **/
    }
}

From the official Microsoft documentation I know that I should be able to use Include() or ThenInclude()but it doesn’t seem to work.

Where would I have to place the Include() or what is the correct way to use Specification or what else can I do to fix this? I know I made myself enough problems by mixing these two architectual styles, but I exhausted all possible error sources I could think of.

Update 1

According to GitHub FAQ for Specification Tried a new approach that didn’t work:

using Ardalis.Specification;
using Core.Entities.BookAggregate;

namespace Core.Specifications
{
    public class BookSpecification : Specification<Book>
    {
        public BookSpecification() 
        {
            Query.Include(b => b.BookTags);
            Query.Include(b => b.BookCategories);
            Query.Include(b => b.Chapters);
        }
    }
}

Leave a Comment