Question

I’ve been getting several errors:

1. cannot add an entity with a key that is already in use

2. An attempt has been made to attach or add an entity that is not new, perhaps having been loaded from another datacontext

In case 1, this stems from trying to set the key for an entity versus the entity. In case 2, I’m not attaching an entity but I am doing this:

MyParent.Child = EntityFromOtherDataContext;

I’ve been using using the pattern of wrap everything with a using datacontext. In my case, I am using this in a web forms scenario, and obviously moving the datacontext object to a class wide member variables solves this.

My questions are thus 2 fold:

1. How can I get rid of these errors and not have to structure my program in an odd way or pass the datacontext around while keeping the local-wrap pattern? I assume I could make another hit to the database but that seems very inefficient.

2. Would most people recommend that moving the datacontext to the class wide scope is desirable for web pages?

Answer 1

1. Linq to SQL is not adapted to disconnected scenarios. You can copy your entity to a DTO having a similar structure as the entity and then pass it around. Then copy the properties back to an entity when it’s time to attach it to a new data context. You can also deserialize/reserialize the entity before attaching to a new data context to have a clean state. The first workaround clearly violates the DRY principle whereas the second is just ugly. If you don’t want to use any of these solution the only option left is to retrieve the entity you’re about to modify by its PK by hitting the DB. That means an extra query before every update. Or use another ORM if that’s an option for you. Entity Framework 4 (included with .NET 4) with self-tracking entities is what I’m using currently on a web forms project and everything is great so far.

2. DataContext is not thread-safe and should only be used with using at the method level, as you already do. You can consider adding a lock to a static data context but that means no concurrent access to the database. Plus you’ll get entities accumulated in memory inside the context that will turn into potential problems.