public static void TagEntitiesAsDeleted <T>(this PetShopDBContext dbContext, IList <T> collection) where T : class { if (collection == null || collection.Count <= 0) { var reason = collection == null ? "null" : "equal or less than zero"; var message = string.Format("Tagging entities as deleted could " + "not be executed because to the internal " + "list being {0}", reason); throw new PetsEntityException(message); } foreach (var item in collection) { dbContext.Entry <T>(item).State = EntityState.Deleted; /* Our design pattern for this application was to * have a sepration were all transactions create * a temporary db-context to communicate with the * database. * Because of the sepertaion, we work in a disconneted * way, which means that we have to manually set * the entity-state of the entity before we save * the object to the database. * * If we do not specify an enity-state, then the * entity framework will throw an error. * */ } }
private void TagEntitiesAsDeleted(PetShopDBContext dbContext) { foreach (var item in _coursesToDelete) { dbContext.Entry(item).State = EntityState.Deleted; } }
private void AddNewMessages(PetShopDBContext dbContext) { var newMessages = _currentCustomer.Messages .Where(m => m.ID == 0).ToList(); foreach (var item in newMessages) { dbContext.Entry(item).State = EntityState.Added; } }
public void SaveUpdate() { using (PetShopDBContext _dbcontext = new PetShopDBContext()) { if (_currentStock == null) { return; } _dbcontext.Entry(_currentStock).State = EntityState.Modified; _dbcontext.SaveChanges(); } }
private void UpdateCourses(PetShopDBContext dbContext) { var detatchedCollection = this.GetDetatchedCollection <JoinCustomerCourse>(dbContext, _currentCustomer.Courses, c => c.Courses, true); foreach (var item in detatchedCollection) { var existingData = dbContext.JoinCustomerCourses .FirstOrDefault(x => x.CUSTOMER_ID == item.CUSTOMER_ID && x.COURSE_ID == item.COURSE_ID); dbContext.Entry(item).State = existingData != null ? EntityState.Modified : EntityState.Added; } _currentCustomer.Courses = detatchedCollection; }
private List <TEntity> GetDetatchedCollection <TEntity>(PetShopDBContext dbcontext, ICollection <TEntity> collection, Expression <Func <Customer, ICollection <TEntity> > > loadFunction, bool loadPrevious) where TEntity : class { if (!loadPrevious) { return(collection.ToList()); } var detatchedCollection = collection.ToList(); dbcontext.Entry(_currentCustomer) .Collection(loadFunction) .Load(); collection.Clear(); return(detatchedCollection); }
/*public static void LoadAndMarkEnityCollection<S, T>(this IEntityDaBase entityObject, PetShopDBContext dbcontext, * Func<S, ICollection<T>> loadFunction) where S: class where T : class * { * dbcontext.Entry(entityObject).Collection(loadFunction.ToString()).Load(); * }*/ public static void AddNewItems <TEntity>(this PetShopDBContext dbContext, ICollection <TEntity> collection, Expression <Func <TEntity, bool> > lamdaQuery) where TEntity : class { var newItems = collection.AsQueryable().Where(lamdaQuery) .ToList(); if (newItems != null) { foreach (var item in newItems) { var castedItem = item as IEntityDaBase; if (castedItem != null) { dbContext.Entry(castedItem).State = EntityState.Added; } } } }
public void SaveUpdate() { try { if (_currentAccount == null) { return; } using (PetShopDBContext _dbcontext = new PetShopDBContext()) { _dbcontext.Entry(_currentAccount).State = EntityState.Modified; _dbcontext.SaveChanges(); } } catch (Exception exception) { MessageBox.Show(""); } }
public void SaveUpdate() { if (_currentAnimal == null) { var message = "Animal could not be updated because it is null"; throw new PetsEntityException(message); } try { using (PetShopDBContext _context = new PetShopDBContext()) { _context.Entry(_currentAnimal).State = EntityState.Modified; _context.SaveChanges(); } } catch (Exception exception) { throw; } }
private void UpdateMessages(PetShopDBContext dbContext) { var detatchedCollection = this.GetDetatchedCollection <Message>(dbContext, _currentCustomer.Messages, c => c.Messages, false); // dbcontext.Entry(_currentCustomer).State = EntityState.Modified; /* When tagging child entities in a collection as Entitystate.Modified, * make sure you tag the parent entity as Modified, or else it will throw * am error. * */ var existingMessages = detatchedCollection.Where(m => m.ID > 0) .ToList(); foreach (var item in existingMessages) { dbContext.Entry(item).State = EntityState.Modified; } _currentCustomer.Messages = detatchedCollection; }
public void SaveUpdate() { try { using (PetShopDBContext _dbcontext = new PetShopDBContext()) { if (_currentCustomer == null) { return; } this.AddNewChildEntities(_dbcontext); _dbcontext.Entry(_currentCustomer).State = EntityState.Modified; this.UpdateExistingChildEntities(_dbcontext); /* Before a parent entity is tagged as medified, make sure all new * child entity objects in its collection are tagged as Entitysate.Added, * if the relationship is a one-to-many. * Because if not, it will throw an error, either saying foreign * key property does not match or something like duplicate id. * * The reason why it throws an error is because, the child entities * at that point in time are tagged as Entitysate.Unchanged. * So when we mark the parent entities as Modified, entity looks * through its collection and will find new entity objects whose * foreign key id has not be assigned. * Or, if the foreign key property is assigned, it will think that * the parent entity is new, which in this case will throw an error * because entity knows there is an enitity object with the same id. * */ _dbcontext.SaveChanges(); } } catch (Exception exception) { System.Windows.Forms.MessageBox.Show("Problem encountered during updating customers." + "Message" + exception.Message); } }