views:

771

answers:

1

Entity Framework 4, POCO objects and ASP.Net MVC2. I have a many to many relationship, lets say between BlogPost and Tag entities. This means that in my T4 generated POCO BlogPost class I have:

public virtual ICollection<Tag> Tags {
    // getter and setter with the magic FixupCollection
}
private ICollection<Tag> _tags;

I ask for a BlogPost and the related Tags from an instance of the ObjectContext and send it to another layer (View in the MVC application). Later I get back the updated BlogPost with changed properties and changed relationships. For example it had tags "A" "B" and "C", and the new tags are "C" and "D". In my particular example there are no new Tags and the properties of the Tags never change, so the only thing which should be saved is the changed relationships. Now I need to save this in another ObjectContext. (Update: Now I tried to do in the same context instance and also failed.)

The problem: I can't make it save the relationships properly. I tried everything I found:

  • Controller.UpdateModel and Controller.TryUpdateModel don't work.
  • Getting the old BlogPost from the context then modifying the collection doesn't work. (with different methods from the next point)
  • This probably would work, but I hope this is just a workaround, not the solution :(.
  • Tried Attach/Add/ChangeObjectState functions for BlogPost and/or Tags in every possible combinations. Failed.
  • This looks like what I need, but it doesn't work (I tried to fix it, but can't for my problem).
  • Tried ChangeState/Add/Attach/... the relationship objects of the context. Failed.

"Doesn't work" means in most cases that I worked on the given "solution" until it produces no errors and saves at least the properties of BlogPost. What happens with the relationships varies: usually Tags are added again to the Tag table with new PKs and the saved BlogPost references those and not the original ones. Of course the returned Tags have PKs, and before the save/update methods I check the PKs and they are equal to the ones in the database so probably EF thinks that they are new objects and those PKs are the temp ones.

A problem I know about and might make it impossible to find an automated simple solution: When a POCO object's collection is changed, that should happen by the above mentioned virtual collection property, because then the FixupCollection trick will update the reverse references on the other end of the many-to-many relationship. However when a View "returns" an updated BlogPost object, that didn't happen. This means that maybe there is no simple solution to my problem, but that would make me very sad and I would hate the EF4-POCO-MVC triumph :(. Also that would mean that EF can't do this in the MVC environment whichever EF4 object types are used :(. I think the snapshot based change tracking should find out that the changed BlogPost has relationships to Tags with existing PKs.

Btw: I think the same problem happens with one-to-many relations (google and my colleague say so). I will give it a try at home, but even if that works that doesn't help me in my six many-to-many relationships in my app :(.

+2  A: 

Let's try it this way:

  • Attach BlogPost to context. After attaching object to context the state of the object, all related objects and all relations is set to Unchanged.
  • Use context.ObjectStateManager.ChangeObjectState to set your BlogPost to Modified
  • Iterate through Tag collection
  • Use context.ObjectStateManager.ChangeRelationshipState to set state for relation between current Tag and BlogPost.
  • SaveChanges

Edit:

I guess one of my comments gave you false hope that EF will do the merge for you. I played a lot with this problem and my conclusion says EF will not do this for you. I think you have also found my question on MSDN. In reality there is plenty of such questions on the Internet. The problem is that it is not clearly stated how to deal with this scenario. So lets have a look on the problem:

Problem background

EF needs to track changes on entities so that persistance knows which records have to be updated, inserted or deleted. The problem is that it is ObjectContext responsibility to track changes. ObjectContext is able to track changes only for attached entities. Entities which are created outside the ObjectContext are not tracked at all.

Problem description

Based on above description we can clearly state that EF is more suitable for connected scenarios where entity is always attached to context - typical for WinForm application. Web applications requires disconnected scenario where context is closed after request processing and entity content is passed as HTTP response to the client. Next HTTP request provides modified content of the entity which has to be recreated, attached to new context and persisted. Recreation usually happends outside of the context scope (layered architecture with persistance ignorace).

Solution

So how to deal with such disconnected scenario? When using POCO classes we have 3 ways to deal with change tracking:

  • Snapshot - requires same context = useless for disconnected scenario
  • Dynamic tracking proxies - requires same context = useless for disconnected scenario
  • Manual synchronization.

Manual synchronization on single entity is easy task. You just need to attach entity and call AddObject for inserting, DeleteObject for deleting or set state in ObjectStateManager to Modified for updating. The real pain comes when you have to deal with object graph instead of single entity. This pain is even worse when you have to deal with independent associations (those that don't use Foreign Key property) and many to many relations. In that case you have to manually synchronize each entity in object graph but also each relation in object graph.

Manual synchronization is proposed as solution by MSDN documentation: Attaching and Detaching objects says:

Objects are attached to the object context in an Unchanged state. If you need to change the state of an object or the relationship because you know that your object was modified in detached state, use one of the following methods.

Mentioned methods are ChangeObjectState and ChangeRelationshipState of ObjectStateManager = manual change tracking. Similar proposal is in other MSDN documentation article: Defining and Managing Relationships says:

If you are working with disconnected objects you must manually manage the synchronization.

Moreover there is blog post related to EF v1 which criticise exactly this behavior of EF.

Reason for solution

EF has many "helpful" operations and settings like Refresh, Load, ApplyCurrentValues, ApplyOriginalValues, MergeOption etc. But by my investigation all these features work only for single entity and affects only scalar preperties (= not navigation properties and relations). I rather not test this methods with complex types nested in entity.

Other proposed solution

Instead of real Merge functionality EF team provides something called Self Tracking Entities (STE) which don't solve the problem. First of all STE works only if same instance is used for whole processing. In web application it is not the case unless you store instance in view state or session. Due to that I'm very unhappy from using EF and I'm going to check features of NHibernate. First observation says that NHibernate perhaps has such functionality.

Conclusion

I will end up this assumptions with single link to another related question on MSDN forum. Check Zeeshan Hirani's answer. He is author of Entity Framework 4.0 Recipes. If he says that automatic merge of object graphs is not supported, I believe him.

But still there is possibility that I'm completely wrong and some automatic merge functionality exists in EF.

Edit 2:

As you can see this was already added to MS Connect as suggestion in 2007. MS has closed it as something to be done in next version but actually nothing had been done to improve this gap except STE.

Ladislav Mrnka
This won't add the Tags, that's good. It adds the new relationships, that's also good. It doesn't remove the existing relationships. That's bad :(.using (var context = new Entities.Blog()){ context.BlogPosts.Attach(BlogPost); context.ObjectStateManager.ChangeObjectState(BlogPost, System.Data.EntityState.Modified); foreach (Tag t in BlogPost.Tags) { context.ObjectStateManager.ChangeRelationshipState(BlogPost, t, c => c.Tags, System.Data.EntityState.Added); } context.DetectChanges(); context.SaveChanges();}
foldip
It also fails when user edits the same BlogPost again and tried to save. It says:"An object with the same key already exists in the ObjectStateManager. The ObjectStateManager cannot track multiple objects with the same key."On the line:context.BlogPosts.Attach(BlogPost);
foldip
But that are elementary principles when working with ORM. You have to say context what was deleted. It didn't delete record which is not known.
Ladislav Mrnka
You have to track changes. Context doesn't know about them unitl you show it what was changed. If you want to go easier way you can explicitly load the whole object graph again and merge loaded and attached object with data from View.
Ladislav Mrnka
"If you want to go easier way you can explicitly load the whole object graph again and merge loaded and attached object with data from View"This is what I want. Snapshot based change tracking done by EF and not me. Loading the graph is ok, since in the controller I would need to go to the database anyway if I want to find out the changes.Could you please give me some hints? I tried this already. I got the original graph and then tried to apply the changes in different ways, but it never worked :(.
foldip
"But that are elementary principles when working with ORM. You have to say context what was deleted. It didn't delete record which is not known."This sounds reasonable, except that I expect a feature, which is:"Here is my BlogPost object in its new state including all the relationships. Please update the database accordingly."
foldip
I have added some description because you have misconceived me. Easier solution with reloading object graph will not do the merge for you. It will only allow you easily find which relationships are new and wich are deleted. You will still have to set their state.
Ladislav Mrnka
I see. My conclusion was similar. And I also decided to have a look at NHibernate hoping that it can do this very basic thing for me. Thank you for the answer.
foldip