EF Core Circular Relationship Mapping - entity-framework

Question

Given the following entity models:
public class Workshop
{
public Guid Id { get; set; }
public string Name { get; set; }
public ICollection<QuoteRequest> QuoteRequests { get; set; }
}
public class QuoteRequest
{
public Guid Id { get; set; }
public Guid CustomerId { get; set; }
public Guid WorkshopId { get; set; }
public bool Responded { get; set; }
public decimal? Amount { get; set; }
public virtual Customer Customer { get; set; }
public virtual Workshop Workshop { get; set; }
}
and the following 2 view models:
public class WorkshopModel
{
public Guid Id { get; set; }
public string Name { get; set; }
public ICollection<QuoteRequestModel> QuoteRequests { get; set; }
}
public class QuoteRequestModel
{
public Guid Id { get; set; }
public Guid CustomerId { get; set; }
public Guid WorkshopId { get; set; }
public bool Responded { get; set; }
public decimal? Amount { get; set; }
public CustomerModel Customer { get; set; }
public WorkshopModel Workshop { get; set; }
}
Next, given the following query:
public async Task<Workshop> GetWorkshopAsync(Guid id, bool includeQuotes = false)
{
IQueryable<Workshop> query = _context.Workshops;
if (includeQuotes)
{
query = query.Include(w => w.QuoteRequests);
}
return await query.FirstOrDefaultAsync(w => w.Id == id);
}
No matter what I do, I cannot get EF to not give me a circular relationship when querying a Workshop. For instance, I query one Workshop that has 14 QuoteRequests, each of which has a Workshop, each of which has 14 QuoteRequests etc. etc. :
I do have the json serializer reference loophandling setting set to ignore, but that's not giving me the desired result
services.AddControllers()
.AddNewtonsoftJson(x => x.SerializerSettings.ReferenceLoopHandling = Newtonsoft.Json.ReferenceLoopHandling.Ignore);
I want to thus strip out this circle in my mapping profile. I am using automapper. I have managed to break the circular reference with my mapping profile from the QuoteRequest side:
CreateMap<QuoteRequestModel, QuoteRequest>()
.ForMember(dest => dest.Customer, opt => opt.MapFrom(src => src.Customer))
.ForMember(dest => dest.Workshop, opt => opt.MapFrom(src => src.Workshop))
.ForPath(dest => dest.Customer.QuoteRequests, opt => opt.MapFrom(src => new List<QuoteRequest>()))
.ForPath(dest => dest.Workshop.QuoteRequests, opt => opt.MapFrom(src => new List<QuoteRequest>()));
CreateMap<QuoteRequest, QuoteRequestModel>()
.ForMember(dest => dest.Customer, opt => opt.MapFrom(src => src.Customer))
.ForMember(dest => dest.Workshop, opt => opt.MapFrom(src => src.Workshop))
.ForPath(dest => dest.Customer.QuoteRequests, opt => opt.MapFrom(src => new List<QuoteRequestModel>()))
.ForPath(dest => dest.Workshop.QuoteRequests, opt => opt.MapFrom(src => new List<QuoteRequestModel>()));
This might be a bit of a jank solution, but it's working for now when I query an individual QuoteRequest. What I want to figure out is how to do the same in the mapping profile, from the Workshop side:
CreateMap<WorkshopModel, Workshop>()
.ForMember(dest => dest.QuoteRequests, opt => opt.MapFrom(src => src.QuoteRequests));
CreateMap<Workshop, WorkshopModel>()
.ForMember(dest => dest.QuoteRequests, opt => opt.MapFrom(src => src.QuoteRequests));
I can't really target each iteration of the QuoteRequests to set the Workshop a default value.

Answer 1

This is not an issue. What you're seeing is EF's object fix-up. Because it already has these entities in its object cache, it automatically "fixes up" the relationships on each entity, without querying anything again.
The only time this might be an issue is during serialization, as serializing will attempt to recursively drill-down indefinitely. However, depending on the serialization method, there's different ways to prevent such recursive serialization. Additionally, you should really not serialize entities, directly, anyways. Instead, you should map them over into DTO classes, where you would then define a more basic structure that wouldn't suffer from the same recursive issues. Then, you would serialize the DTO, rather than the entity.