使用实体框架聚合根和性能

Question

I'm trying to implement DDD in my project but I have a performance issue, the model is simple: a calendar (aggregate root) and appointments

public class Calendar
{
    public int Id { get; private set; }

    public IList<Appointment> Appointments { get; private set; }

    public void AddAppointment(Appointment appointment)
    {
        var anyOverlapping = Appointments.Any(a => a.Date.Hour == a.Date.Hour);

        if (anyOverlapping)
        {
            throw new Exception();
        }

        // More validations according to the calendar

        Appointments.Add(appointment);
    }
}

public class Appointment
{
    public int Id { get; private set; }
    public DateTime Date { get; private set; }
    public int CalendarId { get; private set; }
}

The problem is that with the DDD approach I have to load the entire appointments collection in the manager/service method.

public void AddAppointment(int calendarId, Appointment appointment)
{
    var calendar = _context.Calendars
        .Include(c => c.Appointments) // Here load all the records in memory, can be thousands
        .FirstOrDefault(c => c.Id == calendarId);

    calendar.AddAppointment(appointment);
    _context.SaveChanges();
}

But with the no DDD approach the manager/service method is:

public void AddAppointment(int calendarId, Appointment appointment)
{
    var anyOverlaping = _context.Appointments
    .Where(a => a.CalendarId == calendarId)
    .Any(a => a.Date.Hour == appointment.Date.Hour); // Don't load all the records into memory
    
    if (anyOverlapping)
    {
        throw new Exception();
    }
    
    // More validations according to the calendar that belongs
    
    _context.Appointments.Add(appointment)
    _context.SaveChanges();
}

How can I keep using a DDD design and still be performing?

Answer 1

If this is about read performance for querying only use cases you should bypass the domain model classes entirely and read the data the best way that suits you. Eg by using separate read model classes that already only fetch the data needed.

If this is about write performance I suggest you use lazy loading with the proxy package . With that child data of your aggregate will be loaded from the database on demand only. The only thing is that you need to make the corresponding fields virtual in your models but other than the domain model will be free of any dependencies still. I think that's a trade-off one can accept.