private static void DoLoadCollection <T, TProperty>(DbContext context, EntityEntry <T> entry, FilteredIncludeExpression filteredInclude) where T : class where TProperty : class { List <TProperty> collection = filteredInclude.Filter != null ? entry.Collection((Expression <Func <T, IEnumerable <TProperty> > >) filteredInclude.Include) .Query() .Where((Expression <Func <TProperty, bool> >)filteredInclude.Filter).ToList() : entry.Collection((Expression <Func <T, IEnumerable <TProperty> > >)filteredInclude.Include) .Query() .ToList(); if (filteredInclude.FilteredIncludes == null || filteredInclude.FilteredIncludes.Count == 0) { return; } filteredInclude.FilteredIncludes.ToList().ForEach(exp => { context.InvokeMethodForCollection ( collection, exp.Include.Body.GetMemberExpression().GetMemberType(), exp ); }); }
public async Task LoadDetailsAsync(PlaylistDefinition playlistDefinition) { EntityEntry <PlaylistDefinition> entry = DataContext.Entry(playlistDefinition); await entry.Reference(o => o.User).LoadAsync(); await entry.Collection(o => o.PlaylistSources).LoadAsync(); await entry.Collection(o => o.OrderInstructions).LoadAsync(); }
private void LoadRelations(PropertyPath <TEntity> path) { EntityEntry node = entity; foreach (var prop in path.Properties) { var isCollection = typeof(IEnumerable).IsAssignableFrom(prop.PropertyType); if (isCollection && !ReferenceEquals(prop, path.Properties.Last())) { throw new ArgumentException("Invalid path: " + path); } if (isCollection) { node.Collection(prop.Name).Load(); } else { var refEntity = node.Reference(prop.Name); refEntity.Load(); if (refEntity.CurrentValue == null) { return; } node = entity.Context.Entry(refEntity.CurrentValue); } } }
public IQueryable <TCollection> QueryRelation <TCollection>(Expression <Func <TEntity, ICollection <TCollection> > > expr) { var path = PropertyPath <TEntity> .Create(expr); EntityEntry node = entity; foreach (var prop in path.Properties.Take(path.Properties.Count - 1)) { var isCollection = typeof(IEnumerable).IsAssignableFrom(prop.PropertyType); if (isCollection && !ReferenceEquals(prop, path.Properties.Last())) { throw new ArgumentException("Invalid path: " + expr); } var refEntity = node.Reference(prop.Name); refEntity.Load(); if (refEntity.CurrentValue == null) { throw new NullReferenceException(); } node = entity.Context.Entry(refEntity.CurrentValue); } return((IQueryable <TCollection>)node.Collection(path.Properties.Last().Name).Query()); }
public void GetBooksWithExplicitLoading() { var books = _booksContext.Books.TagWith("Explicit").Where(b => b.Publisher.StartsWith("Wrox")); foreach (var book in books) { Console.WriteLine(book.Title); EntityEntry <Book> entry = _booksContext.Entry(book); entry.Collection(b => b.Chapters).Load(); foreach (var chapter in book.Chapters) { Console.WriteLine($"{chapter.Number}. {chapter.Title}"); } entry.Reference(b => b.Author).Load(); Console.WriteLine($"author: {book.Author?.Name}"); entry.Reference(b => b.Reviewer).Load(); Console.WriteLine($"reviewer: {book.Reviewer?.Name}"); entry.Reference(b => b.Editor).Load(); Console.WriteLine($"editor: {book.Editor?.Name}"); } }
private static void MarkDeletedItemsRecursively( EntityEntry entryBeforeUpdate, EntityEntry entryToUpdate, DbContext dbContext) { foreach (var collectionsForEntryToUpdate in entryToUpdate.Collections) { var collectionBeforeUpdate = entryBeforeUpdate.Collection(collectionsForEntryToUpdate.Metadata.Name).CurrentValue.Cast <object>().ToList(); var collectionToUpdate = collectionsForEntryToUpdate.CurrentValue.Cast <object>().ToList(); foreach (var collectionEntityBeforeUpdate in collectionBeforeUpdate) { var collectionEntryBeforeUpdate = dbContext.Entry(collectionEntityBeforeUpdate); var currentEntityToUpdate = collectionToUpdate.FirstOrDefault(f => f.Equals(collectionEntityBeforeUpdate)); if (currentEntityToUpdate == null) { collectionEntryBeforeUpdate.State = EntityState.Deleted; } else { var currentEntityEntryAfterUpdate = dbContext.Entry(currentEntityToUpdate); MarkDeletedItemsRecursively(collectionEntryBeforeUpdate, currentEntityEntryAfterUpdate, dbContext); } } } }
/// <summary> /// Az étterem modell osztály átalakítása részletes adatokat tartalmazó adatátviteli objektummá. /// </summary> /// <param name="restaurant">Étterem típusú entitás.</param> /// <returns>Az étterem részletes adatait tartalmazó adatátviteli objektum.</returns> public static async Task <RestaurantDetailsDto> ToRestaurantDetailsDto(this EntityEntry <Restaurant> restaurant) { await restaurant.Collection(r => r.Reviews).LoadAsync(); await restaurant.Reference(r => r.Owner).LoadAsync(); return(new RestaurantDetailsDto(restaurant.Entity)); }
/// <summary> /// A rendelés modell osztály átalakítása részletes adatokat tartalmazó adatátviteli objektummá. /// </summary> /// <param name="order">Rendelés típusú entitás.</param> /// <returns>A rendelés részletes adatait tartalmazó adatátviteli objektum.</returns> public static async Task <OrderDetailsDto> ToOrderDetailsDto(this EntityEntry <Order> order) { await order.Reference(o => o.Invoice).LoadAsync(); await order.Collection(o => o.OrderFoods).Query() .Include(of => of.Food).LoadAsync(); return(new OrderDetailsDto(order.Entity)); }
public static void LoadCollection <TEntity, TRelationEntity>( this DbContext context, TEntity entity, Expression <Func <TEntity, IEnumerable <TRelationEntity> > > getTmmExpression ) where TEntity : class where TRelationEntity : class { EntityEntry <TEntity> entry = context.Entry(entity); var col = entry.Collection(getTmmExpression); col.Load(); }
public async Task <IActionResult> GetUser() { string id = User.FindFirst("id").Value; User user = await UserManager.FindByIdAsync(id); if (user == null) { return(Unauthorized()); } if (!user.PhoneNumberConfirmed) { return(new OkObjectResult(Mapper.Map <UserLoginViewModel>(user))); } EntityEntry <User> entry = UserDataContext.Entry(user); await entry.Collection(u => u.Photos).LoadAsync(); await entry.Collection(u => u.Activities).LoadAsync(); return(new OkObjectResult(Mapper.Map <UserProfileViewModel>(user))); }
public IEntry <TEntity> LoadRelations <TCollection, TProperty>( Expression <Func <TEntity, ICollection <TCollection> > > collectionExpr, Expression <Func <TCollection, TProperty> > propExpr = null ) where TProperty : class where TCollection : class { var path = PropertyPath <TEntity> .Create(collectionExpr); EntityEntry node = entity; foreach (var prop in path.Properties.Take(path.Properties.Count - 1)) { if (typeof(IEnumerable).IsAssignableFrom(prop.PropertyType)) { throw new ArgumentException("Invalid path: " + collectionExpr); } var refEntity = node.Reference(prop.Name); refEntity.Load(); if (refEntity.CurrentValue == null) { return(this); } node = entity.Context.Entry(refEntity.CurrentValue); } node.Collection(path.Properties.Last().Name).Load(); if (propExpr != null) { var collection = (ICollection <TCollection>)path.Properties.Last().GetValue(node.Entity); foreach (var item in collection) { var entry = new Entry <TCollection>(entity.Context.Entry(item)); entry.LoadRelations(propExpr); } } return(this); }
public async Task PostPersistAction(EntityEntry entry, ISet <EntityMutationInfo> cache) { var actionResult = new ActionResult(); if (!(IsReference || cache.Contains(this))) { cache.Add(this); if (RuleMap != null) { switch (State) { case (EntityState.Added): { await RuleMap.OnAfterCreation(MutationContext.SecurityContext, Entity, entry, this); break; } case (EntityState.Modified): { await RuleMap.OnAfterEdition(MutationContext.SecurityContext, Entity, entry); break; } case (EntityState.Deleted): { await RuleMap.OnAfterDeletion(MutationContext.SecurityContext, Entity, entry); break; } } } foreach (var reference in References.Values.Where(reference => reference.TargetEntityMutationInfo != null)) { var targetEntry = entry.Reference(reference.Navigation.Name).TargetEntry; if (targetEntry != null) { await reference.TargetEntityMutationInfo.PostPersistAction(targetEntry, cache); } } foreach (var collectionMutationInfo in Collections.Values) { var index = 0; var collection = (IEnumerable <object>)collectionMutationInfo.Navigation.GetGetter().GetClrValue(Entity); foreach (var targetEntityMutationInfo in collectionMutationInfo.TargetEntityMutationInfos) { if (targetEntityMutationInfo.State != EntityState.Deleted) { await targetEntityMutationInfo.PostPersistAction(entry.Collection(collectionMutationInfo.Navigation.Name).FindEntry(collection.ElementAt(index)), cache); index++; } } } } }
public async Task PrepareEntry(EntityEntry entry, ISet <EntityMutationInfo> cache) { if (!(IsReference || cache.Contains(this))) { cache.Add(this); var isGeneratedPrimaryKey = PrimaryKey.Properties[0].ValueGenerated.HasFlag(ValueGenerated.OnAdd); var unwantedProperties = Properties.Values.Where(property => { return((property.Property.ValueGenerated.HasFlag(ValueGenerated.OnAdd) && property.Property.IsPrimaryKey()) || (State != EntityState.Added && property.Property.IsPrimaryKey())); }).ToArray(); var touchedProperties = Properties.Values.Where(p => !unwantedProperties.Any(up => up == p) && p.IsTouched).ToArray(); if (State == EntityState.Deleted || State == EntityState.Added) { entry.State = State; } foreach (var property in touchedProperties.Where(p => !p.Property.IsPrimaryKey())) { entry.Property(property.Property.Name).IsModified = property.IsModified; } foreach (var referenceMutationInfo in References.Values.Where(r => r.IsModified)) { var reference = entry.Reference(referenceMutationInfo.Navigation.Name); reference.IsModified = referenceMutationInfo.IsModified; if (reference.TargetEntry != null) { await referenceMutationInfo.TargetEntityMutationInfo.PrepareEntry(reference.TargetEntry, cache); } } foreach (var collectionMutationInfo in Collections.Values.Where(c => c.IsModified)) { var collection = entry.Collection(collectionMutationInfo.Navigation.Name); collection.IsModified = collectionMutationInfo.IsModified; var index = 0; foreach (var item in collectionMutationInfo.TargetEntityMutationInfos) { await item.PrepareEntry(collection.FindEntry(collection.CurrentValue.Cast <object>().ElementAt(index)), cache); index++; } } } }
private NavigationEntry GetNavigationEntry(TResource resource, RelationshipAttribute relationship) { EntityEntry<TResource> entityEntry = _dbContext.Entry(resource); switch (relationship) { case HasOneAttribute hasOneRelationship: { return entityEntry.Reference(hasOneRelationship.Property.Name); } case HasManyAttribute hasManyRelationship: { return entityEntry.Collection(hasManyRelationship.Property.Name); } default: { throw new InvalidOperationException($"Unknown relationship type '{relationship.GetType().Name}'."); } } }
private void TreatList(T entity, T dbEntity, EntityEntry <T> dbEntry, Expression <Func <T, object> > property) { var propertyName = property.GetPropertyAccess().Name; var dbItemsEntry = dbEntry.Collection(propertyName); var accessor = dbItemsEntry.Metadata.GetCollectionAccessor(); dbItemsEntry.Load(); var dbItemsMap = ((IEnumerable <BaseEntity>)dbItemsEntry.CurrentValue) .ToDictionary(e => e.Id); var items = (IEnumerable <BaseEntity>)accessor.GetOrCreate(entity, false); foreach (var item in items) { EntityEntry entityEntryChild = null; if (!dbItemsMap.TryGetValue(item.Id, out var oldItem)) { accessor.Add(dbEntity, item, false); Db.Entry(item).State = EntityState.Added; entityEntryChild = Db.Entry(item); } else { Db.Entry(oldItem).CurrentValues.SetValues(item); Db.Entry(oldItem).State = EntityState.Modified; entityEntryChild = Db.Entry(oldItem); dbItemsMap.Remove(item.Id); } } foreach (var oldItem in dbItemsMap.Values) { accessor.Remove(dbEntity, oldItem); } }
public FindBuilder <TEntity> IncludeCollection <TProperty>(Expression <Func <TEntity, IEnumerable <TProperty> > > propertyExpression) where TProperty : class { _entry.Collection(propertyExpression).Load(); return(this); }