Lars-Erik's blog

[Edit: this post is not really on track, see my comment further down..] 

There's been quite a few blog posts about this, but I think we've come to a more or less working solution.

An object without associations, and all properties with "Update Check" set to never, can be attached using context.Attach(object, true). As soon as you attach some associations, you might start to get the annoying "An attempt has been made to Attach or Add an entity that is not new, perhaps having been loaded from another DataContext. This is not supported.." exception.

But if the datacontext had had its ObjectTrackingEnabled property to false when the object was read, the Attach(object, true) method will run fine.

Have a look at the following example to get a feeling of it. The Manufacturer object has its Update Check properties set to false, but it has two one to many associations on it.

[TestMethod]
public void MultipleContexts()
{
	using (TransactionScope scope = new TransactionScope())
	{
		Guid id = Guid.NewGuid();

		Manufacturer manu = new Manufacturer();
		manu.ManufacturerId = id;
		manu.Name = "Test";

		DataContext ctx = new DataContext();
		ctx.Manufacturers.InsertOnSubmit(manu);

		ctx.SubmitChanges();

		ctx.Dispose();
		manu = null;

		ctx = DataContext();
		// Comment out the following line to provoke the exception
		ctx.ObjectTrackingEnabled = false;
		manu = ctx.Manufacturers.Where(m => m.ManufacturerId == id).FirstOrDefault();

		ctx.Dispose();

		ctx = new DataContext();
		manu.Name = "Test 2";
		ctx.Manufacturers.Attach(manu, true);

		ctx.SubmitChanges();

		ctx.Dispose();
	}
}

In a 2 tier scenario where the objects are not serialized, it seems it's a good idea to have one context for reading where object tracking is always turned on, You can create a new context for update batches and attach all objects read as necessary with Attach(object, true). Even if the "Update Check" properties are set to false, the objects are still updated if read from the context you use for updating. (No attach necessary).

In an n-tier scenario where the objects are serialized, you won't need to set the ObjectTrackingEnabled property of the DataContext to false, since the objects don't remember being in another context when they're deserialized. Don't however attempt to load the same object from the context before you're gonna attach the deserialized one. ;)

Seems like LINQ can be tweaked to work well in an n-tier scenario, you just have to keep your tongue 90 degrees left and be very aware of any performance killers you introduce. :)