自动包含实体框架属性

Question

the answer to my question might be trivial, but I can't figure out how to do it.

Suppose, we have the following situation:

A DB first EF-Entity with nested Properties:

public partial class Employee
{
     public int ID { get; set;}
     public virtual ICollection<EmployeeDepartmentHistory> EmployeeDepartmentHistory { get; set;}
     public virtual ICollection<JobCandidate> JobCandidate { get; set;}
}

A Domain Class Employee

(related classes don't matter for this example)

public class Employee
{
     public int ID { get; set;}
     public IEnumerable<Department> Departments { get; set;}
     public IEnumerable<JobCandidate> Candidates { get; set;}
}

A Service Class EmployeeService that applies business rules to the query

public class EmployeeService
    private RepoTestEntities1 _Database;

    public EmployeeService(RepoTestEntities1 database)
    {
        _Database = database;
    }

    public IQueryable<DomainModels.Employee> GetSalariedEmployeesByDepartmentName(string departmentName)
    {
        _Database.Configuration.LazyLoadingEnabled = false;
        return _Database.Employee
            .Include(e => e.EmployeeDepartmentHistory)
            .Include(e => e.JobCandidate)
            .Include(e => e.EmployeeDepartmentHistory.Select(his => his.Department))
            .AsNoTracking()
            .WhereDepartmentName(departmentName)
            .WhereSalariedFlag(true)
            .Select(e => CreateEmployee(e));
    }
    private DomainModels.Employee CreateEmployee(Employee e)
    {
        [...] (transform to domain)
    }

WhereDepartmentName and WhereSalariedFlag are implemented as extension methods to IQueryable<Employee> .

Now to the question

---

Suppose I need further methods, that retrieve Employees from DbContext and I don't want to use Lazy loading.

Repeatedly calling all those includes is redundant, error prone and tedious. Do you know an elegant way of always including the needed properties for all methods of the EmployeeService ?

Might a strategy pattern be a viable approach?

Answer 1

If you REALLY need to Include all the navigation properties you can use this piece of code.
If you need to eagerly load also collections (not always a good idea) you can delete the continue statement in the code.
Context is your context ( this if you insert this code in your context)

    public IQueryable<T> IncludeAllNavigationProperties<T>(IQueryable<T> queryable)
    {
        if (queryable == null)
            throw new ArgumentNullException("queryable");

        ObjectContext objectContext = ((IObjectContextAdapter)Context).ObjectContext;
        var metadataWorkspace = ((EntityConnection)objectContext.Connection).GetMetadataWorkspace();

        EntitySetMapping[] entitySetMappingCollection = metadataWorkspace.GetItems<EntityContainerMapping>(DataSpace.CSSpace).Single().EntitySetMappings.ToArray();

        var entitySetMappings = entitySetMappingCollection.First(o => o.EntityTypeMappings.Select(e => e.EntityType.Name).Contains(typeof(T).Name));

        var entityTypeMapping = entitySetMappings.EntityTypeMappings[0];

        foreach (var navigationProperty in entityTypeMapping.EntityType.NavigationProperties)
        {
            PropertyInfo propertyInfo = typeof(T).GetProperty(navigationProperty.Name);
            if (propertyInfo == null)
                throw new InvalidOperationException("propertyInfo == null");
            if (typeof(System.Collections.IEnumerable).IsAssignableFrom(propertyInfo.PropertyType))
                continue;

            queryable = queryable.Include(navigationProperty.Name);
        }

        return queryable;
    }