Je sais que c'est un problème simple, mais je ne trouve pas le moyen de gérer cela correctement. Je pense que c'est moche et je suis sûr qu'il existe un meilleur moyen.

    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();
        }
    }

L'objectif est d'inclure des données imbriquées à partir d'indicateurs booléens.

Plus d'informations sur ma classe ci-dessous:

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

    }

    // Here is my method
}
0
BaptX 25 févr. 2021 à 12:58

3 réponses

Meilleure réponse

Qu'en est-il de

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();
    }

Cela devrait fonctionner car l'inclusion de DocumentTypes plusieurs fois n'est pas un problème pour EF et est gérée comme si elle était incluse une seule fois.

1
Nannanas 25 févr. 2021 à 11:55

Que diriez-vous de quelque chose comme ça, où vous construisez la requête en étapes distinctes.

CAVEAT - Ce code n'a pas été testé et peut ne pas fonctionner immédiatement. Le type de query nécessiterait probablement du travail

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 févr. 2021 à 10:17

Vous pouvez effectuer des modifications simples comme ci-dessous

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 févr. 2021 à 11:55