C# 4 and .NET 4

880 ❘ ChaPTer 31 AdO.net entity frAmewOrk
object Tracking
To allow data read from the store to be modified and saved, the entities must be tracked after they are
loaded. This also requires that the object context be aware if an entity has already been loaded from
the store. If multiple queries are accessing the same records, the object context needs to return already
loaded entities.
The ObjectStateManager is used by the object context to keep track of entities that are loaded
into the context.
The following example demonstrates that indeed if two different queries are done that return the same
record from the database, the state manager is aware of that and does not create a new entity. Instead, the
same entity is returned. The ObjectStateManager instance that is associated with the object context can be
accessed with the ObjectStateManager property. The ObjectStateManager class defines an event named
ObjectStateManagerChanged that is invoked every time a new object is added or removed from the object
context. Here, the method ObjectStateManager_ObjectStateManagerChanged is assigned to the event to
get information about changes.
Two different queries are used to return an entity object. The first query gets the first racer from the country
Austria with the last name Lauda. The second query asks for the racers from Austria, sorts the racers by
the number of races won, and gets the first result. As a matter of fact, that’s the same racer. To verify that the
same entity object is returned, the method Object.ReferenceEquals() is used to verify whether the two
object references indeed reference the same instance:
private static void TrackingDemo()
{
using (var data = new Formula1Entities())
{
data.ObjectStateManager.ObjectStateManagerChanged +=
ObjectStateManager_ObjectStateManagerChanged;
Racer niki1 = data.Racers.Where("it.Country='Austria' && it.Lastname='Lauda'").
First();
Racer niki2 = data.Racers.Where("it.Country='Austria'").
OrderBy("it.Wins DESC").First();
if (Object.ReferenceEquals(niki1, niki2))
{
Console.WriteLine("the same object");
}
}
}
static void ObjectStateManager_ObjectStateManagerChanged(object sender,
CollectionChangeEventArgs e)
{
Console.WriteLine("Object State change — action: {0}", e.Action);
Racer r = e.Element as Racer;
if (r != null)
Console.WriteLine("Racer {0}", r.Lastname);
}
code snippet Formula1Demo/Program.cs
Running the application, you can see that the event of the ObjectStateManagerChanged of the
ObjectStateManager occurs only once, and the references niki1 and niki2 are indeed the same:
Object State change — action: Add
Racer Lauda
The same object
www.it-ebooks.info