Sé que es un problema simple, pero no encuentro la manera de gestionarlo correctamente. Creo que es feo y estoy seguro de que existe una forma mejor.

    public async Task<List<DocumentCategory>> GetAll(bool includeDocumentTypes = false, bool includeDocumentDescriptions = false)
    {
        if (!includeDocumentTypes && !includeDocumentDescriptions)
        {
            return await _context.DocumentCategories.ToListAsync();
        }
        else if (includeDocumentTypes && !includeDocumentDescriptions)
        {
            return await _context.DocumentCategories.Include(dc => dc.DocumentTypes).ToListAsync();
        }
        else
        {
            return await _context.DocumentCategories.Include(dc => dc.DocumentTypes).ThenInclude(dt => dt.DocumentDescriptions).ToListAsync();
        }
    }

El objetivo es incluir datos anidados de banderas booleanas.

Más información sobre mi clase a continuación:

public class DocumentCategoriesRepository : GenericRepository<DocumentCategory>, IDocumentCategoriesRepository
{
    public DocumentCategoriesRepository(myDbContext context) : base(context)
    {

    }

    // Here is my method
}
0
BaptX 25 feb. 2021 a las 12:58

3 respuestas

La mejor respuesta

Qué pasa

public async Task<List<DocumentCategory>> GetAll(bool includeDocumentTypes = false, bool includeDocumentDescriptions = false)
    {
        var categories =  _context.DocumentCategories.AsQueryable();

        if (includeDocumentTypes)
        {
            categories = categories.Include(dc => dc.DocumentTypes);
        }

        if (includeDocumentDescriptions)
        {
            categories = categories
                              .Include(dc => dc.DocumentTypes)
                              .ThenInclude(dt => dt.DocumentDescriptions);
        }

        return await categories.ToListAsync();
    }

Esto debería funcionar, ya que incluir DocumentTypes varias veces no es un problema para EF y se maneja como si se hubiera incluido solo una vez.

1
Nannanas 25 feb. 2021 a las 11:55

¿Qué tal algo como esto, donde construye la consulta en distintos pasos?

AVISO: este código no se ha probado y es posible que no funcione de inmediato. Es probable que el tipo de query necesite algo de trabajo

public async Task<List<DocumentCategory>> GetAll(bool includeDocumentTypes = false, bool includeDocumentDescriptions = false)
{
    var query = _context.DocumentCategories;

    if (includeDocumentTypes)
    {
        query = query.Include(dc => dc.DocumentTypes);

        if (includeDocumentDescriptions)
        {
            query = query.ThenInclude(dt => dt.DocumentDescriptions);
        }
    }

    return await query.ToListAsync()
}
0
phuzi 25 feb. 2021 a las 10:17

Puede realizar ediciones simples como a continuación

public async Task<List<DocumentCategory>> GetAll(bool includeDocumentTypes = false, bool includeDocumentDescriptions = false)
        {
            var lstCategoires = _context.DocumentCategories;

            if (includeDocumentTypes)
            {
                 lstCategoires = includeDocumentDescriptions ? lstCategoires.Include(dc => dc.DocumentTypes).ThenInclude(dt => dt.DocumentDescriptions) :
                                                               lstCategoires = lstCategoires.Include(dc => dc.DocumentTypes);
            }

            return await lstCategoires.ToListAsync();
        }
0
Mohamed Adel 25 feb. 2021 a las 11:55