I have class defined like this:
public class Subject
{
public int Id { get; set; }
[Required]
[StringLength(50)]
public string Name { get; set;
[ForeignKey("LevelId")]
public Level Level { get; set; }
[ForeignKey("ParentId")]
public Subject Parent { get; set; }
public ICollection<Subject> Children { get; set; }
}
And then a method to create:
public int Create(Subject newSubject)
{
var subjectToAdd = _mapper.Map<dataModels.Subject>(newSubject);
_context.Add(subjectToAdd);
SaveChildren(subjectToAdd.Id, newSubject.LevelId, newSubject.Children);
_context.SaveChanges();
return subjectToAdd.Id;
}
My problem is that children are twice saved, once in:
_context.Add(subjectToAdd);
because during mapping, the Children are mapped, and then once again in
SaveChildren();
What I want to achieve is for EF to ignore changes in the Children collection and then I will save the changes manually in SaveChildren().
I tried adding this:
var subjectToAdd = _mapper.Map<dataModels.Subject>(newSubject);
_context.Add(subjectToAdd);
_context.Entry(user).Property(x => x.Children).IsModified = false; // this line
but it did not work. Also tried making it null but it said something about severed error. How do I make EF ignore the Children collection without deleting that property and then I just do my own save logic?
You could just change the entry state of the Children as Unchanged to avoid insert them when SaveChanges has been applied.
You should save Subject before inserting the children manually. newSubject.Id should be generated.
Also, newSubject is being mapped and it is unnecessary. So, I modified the Create method like this;
public int Create(Subject newSubject)
{
// The newSubject entry state has been changed as 'Added'
_context.Subjects.Add(newSubject);
// The children of newSubject entry state has been changed as 'Unchanged' and children will not be inserted
_context.Entry(newSubject.Children).State = EntityState.Unchanged;
//Save the newSubject entity
_context.SaveChanges();
//Save the children
SaveChildren(newSubject.Id, newSubject.LevelId, newSubject.Children);
return newSubject.Id;
}
Related
What I would like to do is duplicate/copy my School object and all of its children/associations in EF Core
I have something like the following:
var item = await _db.School
.AsNoTracking()
.Include(x => x.Students)
.Include(x => x.Teachers)
.Include(x => x.StudentClasses)
.ThenInclude(x => x.Class)
.FirstOrDefaultAsync(x => x.Id == schoolId);
I have been reading up on deep cloning and it seems that I should be able to do just add the entity...so pretty much the next line.
await _db.AddAsync(item);
Then EF should be smart enough to add that entity as a NEW entity. However, right off the bat I get a conflict that says "the id {schoolId} already exists" and will not insert. Even if I reset the Id of the new item I am trying to add, I still get conflicts with the Ids of the associations/children of the school iteam.
Is anyone familiar with this and what I might be doing wrong?
I had the same problem too, but in my case EF core was throwing exception "the id already exists".
Following the answer of #Irikos so I have created method which clones my objects.
Here's example
public class Parent
{
public int Id { get; set; }
public string SomeProperty { get; set; }
public virtual List<Child> Templates { get; set; }
public Parent Clone()
{
var output = new Parent() { SomeProperty = SomeProperty };
CloneTemplates(output);
return output;
}
private void CloneTemplates(Parent parentTo, Child oldTemplate = null, Child newTemplate = null)
{
//find old related Child elements
var templates = Templates.Where(c => c.Template == oldTemplate);
foreach (var template in templates)
{
var newEntity = new Child()
{
SomeChildProperty = template.SomeChildProperty,
Template = newTemplate,
Parent = parentTo
};
//find recursivly all related Child elements
CloneTemplates(parentTo, template, newEntity);
parentTo.Templates.Add(newEntity);
}
}
}
public class Child
{
public int Id { get; set; }
public int ParentId { get; set; }
public virtual Parent Parent { get; set; }
public int? TemplateId { get; set; }
public virtual Child Template { get; set; }
public string SomeChildProperty { get; set; }
}
Then I just call DbContext.Parents.Add(newEntity) and DbContext.SaveChanges()
That worked for me. Maybe this will be useful for someone.
I had the same problem, but in my case, ef core was smart enough save them as new entities even with existing id. However, before realising that, I just made a copy constructor for all the items, created a local task variable containing only the desired properties and returned the copy.
Remove certain properties from object upon query EF Core 2.1
How to configure a EF6 migration with a model class having?
A collection o items
A navigation property to one particular item
public class MyModel
{
[Key]
public int Id { get; set; }
// My collection of elements
public virtual ICollection<MyCollectionElement> MyCollection { get; set; }
// Optional navigation to a particular element from the collection
[ForeignKey("CurrentElement")]
public int? CurrentElementId { get; set; }
public virtual MyCollectionElement CurrentElement { get; set; }
}
public class MyCollectionElement
{
[Key]
public int Id { get; set; }
// Required navigation to MyClass
[ForeignKey("MyModel")]
public int MyModelID { get; set; }
public virtual MyModel Model { get; set; }
}
Configuration
modelBuilder.Entity<MyModel>()
.HasMany(x => x.MyCollection)
.WithRequired(x => x.Model)
.HasForeignKey(x => x.MyModelID)
.WillCascadadeOnDelete(false);
Throws several errors on Update-Database, like
Unable to determine a valid ordering for dependent operations.
I would like a solution which doesn't involve a boolean IsCurrent in MyCollectionElement to make another query later and find which element is the current; instead, I would like to store the current element's id with my model, like exposed.
Also, I don't mind making int CurrentElementId non nullable (required) if it's easier.
Thanks.
This chicken-and-egg problem always looms when there are circular relationships. The error...
Unable to determine a valid ordering for dependent operations.
...is not thrown when the database is created. The database can be created just fine. It occurs when you try to insert a MyModel record and a MyCollectionElement referring to one another in the same unit of work. In the Seed method you probably have something like
var element = new MyCollectionElement();
var model = new MyModel();
model.MyCollection.Add(element);
model.CurrentElement = element;
The statement model.MyCollection.Add(element); requires model to be inserted first, so element can refer to it in its foreign key. But model.CurrentElement = element; requires element to be inserted first.
You can only avoid this situation by calling SaveChanges twice, and wrapping everything in a TransactionScope if you want the assignments to be transactional:
using(var ts = new TransactionScope())
{
using(var db = new MyContext()
{
var element = new MyCollectionElement();
var model = new MyModel();
model.MyCollection.Add(element);
db.MyModels.Add(model);
db.SaveChanges();
model.CurrentElement = element;
db.SaveChanges();
}
ts.Complete();
}
This also means that int CurrentElementId should remain nullable.
I have a trouble with EF (6.1.3)
I have created next classes (with many-to-many relationship):
public class Record
{
[Key]
public int RecordId { get; set; }
[Required]
public string Text { get; set; }
public virtual ICollection<Tag> Tags { get; set; }
}
public class Tag
{
[Key]
public int TagId { get; set; }
[Required]
public string Name { get; set; }
public virtual ICollection<Record> Records{ get; set; }
}
And method:
void AddTags()
{
Record[] records;
Tag[] tags;
using (var context = new AppDbContext())
{
records = context.Records.ToArray();
}//remove line to fix
tags = Enumerable.Range(0, 5).Select(x => new Tag()
{
Name = string.Format("Tag_{0}", x),
Records= records.Skip(x * 5).Take(5).ToArray()
}).ToArray();
using (var context = new AppDbContext()){ //remove line to fix
context.Tags.AddRange(tags);
context.SaveChanges();
}
}
If I use two contexts, the records (which were added to created tags) will be duplicated. If I remove marked rows - problem disappears.
Is there any way to fix this problem without using the same context?
If you can, better reload entities or not detach them at all. Using multiple context instances in application is overall making things much more complicated.
The problem for you comes from the Entity Framework entity change tracker. When you load entitites from your DbContext and dispose that context, entities get detached from entity change tracker, and Entity Framework has no knowledge of any changes made to it.
After you reference detached entity by an attached entity, it (detached entity) immediately gets into entity change tracker, and it has no idea that this entity was loaded before. To give Entity Framework an idea that this detached entity comes from the database, you have to reattach it:
foreach (var record in records) {
dbContext.Entry(record).State = EntityState.Unchanged;
}
This way you will be able to use records to reference in other objects, but if you have any changes made to these records, then all these changes will go away. To make changes apply to database you have to change state to Added:
dbContext.Entry(record).State = EntityState.Modified;
Entity Framework uses your mappings to determine row in database to apply changes to, specifically using your Primary Key settings.
A couple examples:
public class Bird
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
public string Color { get; set; }
}
public class Tree
{
[Key]
public int Id { get; set; }
public string Name { get; set; }
}
public class BirdOnATree
{
[Column(Order = 0), Key, ForeignKey("Bird")]
public int BirdId { get; set; }
public Bird Bird { get; set; }
[Column(Order = 1), Key, ForeignKey("Tree")]
public int TreeId { get; set; }
public Tree Tree { get; set; }
public DateTime SittingSessionStartedAt { get; set; }
}
Here's a small entity structure so that you could see how it works. You can see that Bird and Tree have simple Key - Id. BirdOnATree is a many-to-many table for Bird-Tree pair with additional column SittingSessionStartedAt.
Here's the code for multiple contexts:
Bird bird;
using (var context = new TestDbContext())
{
bird = context.Birds.First();
}
using (var context = new TestDbContext())
{
var tree = context.Trees.First();
var newBirdOnAtree = context.BirdsOnTrees.Create();
newBirdOnAtree.Bird = bird;
newBirdOnAtree.Tree = tree;
newBirdOnAtree.SittingSessionStartedAt = DateTime.UtcNow;
context.BirdsOnTrees.Add(newBirdOnAtree);
context.SaveChanges();
}
In this case, bird was detached from the DB and not attached again. Entity Framework will account this entity as a new entity, which never existed in DB, even though Id property is set to point to existing row to database. To change this you just add this line to second DbContext right in the beginning:
context.Entry(bird).State = EntityState.Unchanged;
If this code is executed, it will not create new Bird entity in DB, but use existing instead.
Second example: instead of getting bird from the database, we create it by ourselves:
bird = new Bird
{
Id = 1,
Name = "Nightingale",
Color = "Gray"
}; // these data are different in DB
When executed, this code will also not create another bird entity, will make a reference to bird with Id = 1 in BirdOnATree table, and will not update bird entity with Id = 1. In fact you can put any data here, just use correct Id.
If we change our code here to make this detached entity update existing row in DB:
context.Entry(bird).State = EntityState.Modified;
This way, correct data will be inserted to table BirdOnATree, but also row with Id = 1 will be updated in table Bird to fit the data you provided in the application.
You can check this article about object state tracking:
https://msdn.microsoft.com/en-US/library/dd456848(v=vs.100).aspx
Overall, if you can avoid this, don't use object state tracking and related code. It might come to unwanted changes that are hard to find source for - fields are updated for entity when you don't expect them to, or are not updated when you expect it.
I had a class called Document, which I split into two entities, in order to separate an expensive binary field:
[Table("Document")]
public class Document
{
[Key]
public int Id { get; set; }
... other fields ...
[Required]
public virtual DocumentBinary DocumentBinary { get; set; }
}
[Table("Document")]
public class DocumentBinary
{
[Key, ForeignKey("Document")]
public int DocumentId { get; set; }
public Document Document { get; set; }
public byte[] DocumentData { get; set; }
}
So, everything works fine, both entities share the same database table and DocumentData is only loaded when it's needed.
However, when it comes to updating the Document entity, I get an error stating that 'DocumentBinary is required'.
When I remove the [Required] attribute from DocumentBinary virtual property, I get the following error:
The entity types 'Document' and 'DocumentBinary' cannot share table 'Documents' because they are not in the same type hierarchy or do not have a valid one to one foreign key relationship with matching primary keys between them.
I can obviously do something like:
var test = document.DocumentBinary;
before updating the document object:
documentRepository.Update(document);
This will then load the binary data on my request and save the changes without any issues, but the whole point is that I shouldn't need to do that.
This can be achieved using the fluent API. If you remove the data annotations and in your OnModelCreating add this, it should work.
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity<Document>().HasRequired(d => d.DocumentBinary).
WithRequiredDependent(db => db.Document);
}
I managed to resolve it by overriding my Update method in DocumentRepository:
public override void Update(Document document)
{
try
{
DataContext.Entry(document.DocumentBinary).State = EntityState.Modified; // added this line
DataContext.Entry(document).State = EntityState.Modified;
}
catch (System.Exception exception)
{
throw new EntityException("Failed to update document");
}
}
I know it probably does the same thing as me evaluating DocumentBinary by assigning it to 'test' variable, but it looks like a much cleaner solution.
I have an object with a self referencing parent child relationship:
[Table("Content")]
public class Content
{
[Key]
[DatabaseGeneratedAttribute(DatabaseGeneratedOption.Identity)]
public int ContentID { get; set; }
public string Text { get; set; }
public int? ParentID { get; set; }
public virtual Content Parent { get; set; }
private ICollection<Content> _contents { get; set; }
public virtual ICollection<Content> Contents
{
get { return _contents ?? (_contents = new HashSet<Content>()); }
set { _contents = value; }
}
}
I am trying to work with the edit function so that if the parent ID changes, the object is correctly removed from the OLD parent's children and added to the new one (or is correctly set to null)
I have tried a number of combinations in order to make the code correctly change the parent ID but I am just not able to crack the correct thing to do here.
[HttpPost]
public ActionResult Edit(Content content)
{
if (ModelState.IsValid)
{
Content oldContent = context.Contents
.Where<Content>(c => c.ContentID == content.ContentID)
.Single<Content>();
// If the parent has changed.
if (content.ParentID != oldContent.ParentID)
{
// if the old parent is not NULL remove from collection
if (oldContent.ParentID != null) {
Content oldParent = context.Contents
.Where<Content>(c => c.ContentID == oldContent.ParentID)
.Single<Content>();
oldParent.Contents.Remove(content);
context.Entry(oldParent).State = EntityState.Modified;
context.SaveChanges();
}
// if the new parent is not NULL add to the new collection
if (content.ParentID != null) {
Content parent = context.Contents
.Where<Content>(c => c.ContentID == content.ParentID)
.Single<Content>();
parent.Contents.Add(content);
context.Entry(parent).State = EntityState.Modified;
context.SaveChanges();
}
}
context.Entry(oldContent).CurrentValues.SetValues(content);
context.SaveChanges();
return RedirectToAction("Index");
}
ViewBag.PossibleParents = context.Contents;
return View(content);
}
The problem is that the data table has two fields related to ParentID - the first ParentID is correctly changing, the second, Parent_ContentID is not. The second one is used for looping through the .Contents property from the parent.
What am I missing? How can I remove the current object from the "related objects" collection of the parent?
oldParent.Contents.Remove(oldContent);
This worked for me. Thanks, #Slauma!