Kann ich diese Erweiterungsmethode konvertieren, um IDbSet <> anstelle von DbContext zu verwenden?

Question

Derzeit verwende ich die folgende Methode wie folgt: db.GetProjectsAllowed(profileId, profOrgList, projectList). Ich möchte dies umwandeln, um IDbSet<Project> zu verwenden, aber ich bin nicht sicher, wie man die zweite LINQ-Abfrage erhält.

public static IQueryable<Project> GetProjectsAllowed 
(
    this IMkpContext db, 
    Guid profileId, 
    List<Guid> profOrgIds = null, 
    List<Guid> projectIds = null 
) 
{ 
    var projects = 
     (
      from p in db.Project 
       .Include(p => p.Proposals) 
       .Include(p => p.RoleAssignments) 
       .Include("RoleAssignments.AssigneeSnapshot") 
      where p.IsActive 
      select p); 

    if (profOrgIds != null && profOrgIds.Any()) 
    { 
     var profileIds = db.ProfileOrganization 
      .Where(po => po.IsActive && profOrgIds.Contains(po.OrganizationId)) 
      .Select(po => po.ProfileId); 
     projects = projects.Where(p => profileIds.Contains(p.CreatedById)); 
    } 

    if (projectIds != null && projectIds.Any()) 
     projects = projects.Where(proj => projectIds.Contains(proj.ProjectId)); 

    return projects;//.ToList(); 
} 

Kann ich wandeln diese IDbSet<Project> zu verwenden oder nicht?

Answer 1

Warum teilen Sie dies nicht in zwei Erweiterungsmethoden auf? Dies macht Ihre GetProjectsAllowed Erweiterungsmethode mehr cohesive und single responsible.

Erste:

public static IEnumerable<Guid> GetProfileIds(
    this IDbSet<ProfileOrganization> profileOrganizations, 
    IEnumerable<Guid> profOrgIds = null) 
{ 
    return profOrgIds == null ? null : 
     from po in profileOrganizations 
     where po.IsActive 
     where profOrgIds.Contains(po.OrganizationId) 
     select po.OrganizationId; 
} 

Und zweite:

public static IQueryable<Project> GetProjectsAllowed(
    this IDbSet<Project> projects, 
    IEnumerable<Guid> profileIds, 
    IEnumerable<Guid> projectIds = null) 
{ 
    var activeProjects = 
     from project in projects 
     //.Include(.. 
     where project.IsActive 
     select project; 

    if (profileIds != null && profileIds.Any()) 
    { 
     activeProjects = activeProjects.Where(p => profileIds.Contains(p.CreatedById)); 
    } 

    if (projectIds != null && projectIds.Any()) 
    { 
     activeProjects = activeProjects.Where(proj => projectIds.Contains(proj.ProjectId)); 
    } 

    return activeProjects;//.ToList(); 
} 

Und dann der Verbraucher es so nennen kann:

var profileIds = db.ProfileOrganization.GetProfileIds(profOrgIds); 
var projectsAllowed = db.Projects.GetProjectsAllowed(profileIds, projectIds);