Take advantage of ownership to enable aggregate behaviors in model

This is a grouping of related issues. Feel free to vote (👍) for this issue to indicate that this is an area that you think we should spend time on, but consider also voting for individual issues for things you consider especially important.

---

This an “epic” issue for the theme of automatic aggregate behaviors in the model based on ownership. Specific pieces of work will be tracked by linked issues.

Backlog

• A delete orphans/cascade delete policy an can be applied by convention to owned entities #10179
• For example, we could implement client-only cascade delete for aggregates, which should be fully loaded and hence won’t have issues with some entities needing to be deleted in the store. However, also consider that an aggregate cannot have true cycles, and hence the SQL Server limitation might not be as bad. #12168
• A cascade update could also be applied #10551)
• Smarter logic can be applied to infer the intended state of objects while merging a detached graph into a context: non root objects within the aggregate that are no longer reachable can be marked as deleted, while non root objects that appear for the first time within the aggregate being merged can be marked as added. The same assumptions can’t be made with the same confidence across aggregate boundaries. This could be handled by a new method: ‘Merge()’ (related to #5536)
• Concurrency control could be delegated to the aggregate root when it’s not mapped to the same store object #18529
• Allow related entities to be passed to constructor of aggregate root #12078
• Allow to configure an owned navigation as lazy
• Entity Equality: owned entity support #15936
• Decide how null owned properties are handled by SaveChanges #24581
• Shouldn’t DbContext.Update() result in commands to delete (set all null) an entity’s owned type navigation property if it is null? #26493
• Make EntityEntry methods (GetDatabaseValues, etc) aggregate friendly #13890
• Fluent API - Mapping an index over more than one column across entity types. #11336
• Allow moving the navigation and/or the FK to an owned type for a relationship that involves the principal #26505

Original issue

Define included properties

When you get an entity from the database and you also want to get a “child entity”, you need to pass that “child object” as an expression in order to also get it from the database (when not using lazy loading).

public class Parent
{
    public Child Child { get; set;}
}
public class Child
{   
}

var dataContext = new DataContext();
var parents = dataContext.Parents.Include(p => p.Child).ToList();

Would it be possible to add an new attribute that will be read by the datacontext and add the include statements automatic?

public class Parent
{
   [Include]
    public Child Child { get; set;}
}
public class Child
{   
}

var dataContext = new DataContext();
var parents = dataContext.Parents.ToList();  // Child entity is also read from the database

[HappyNomad]

Just because an entity’s property is an aggregate part of the entity, doesn’t mean you always want to include it. But sometimes you do. Instead of [Include], consider introducing [Part] to indicate a part-whole relationship. After appropriately dispersing [Part] throughout your model, you query like this:

var parents = dataContext.Parents.IncludeParts().ToList();

This recursively loads parts and parts of parts, etc…

Also consider adding a RequiresFilter property to [Part] like this:

public class PartAttribute : Attribute
{
    public bool RequiresFilter { get; set; }
}

Setting this property to true indicates that a filter must be specified for the property as part of a query with IncludeParts, or else an exception is thrown upon loading.

[popcatalin81]

@kennytordeur this is a very dangerous feature. In a large application someone would “think” they always want to load B & C together with A. However in other parts of the code this creates issues due to the fact that it creates overly complex queries (perf) or loads more than necessary (attach/detach scenarios over the wire/web services) or breaks some logic IE: someone checks if B is not loaded (== null) then loads B and B1+B2 etc (an entire graph) after this change application is broken because B is loaded but not B1+B2.

Also there are alternative solutions to this, like: A repository pattern: List<Parent> GetParents(){return datacontext.Parents.Include(p => p.Child);}

Which is also more flexible because it allows you to customize the query with more than just includes.