Programming Entity Framework - Cdn.oreilly.com

More documents

Recommendations

Info

Example 13-6. The Contact.AddAddress method to fix up a two-way relationship public void AddAddress(Address address) { //instantiate Addresses if necessary if (Addresses == null) { Addresses=new List(); } //add the address if it is not already in the list if (!Addresses.Contains(address)) { Addresses.Add(address); } //set the contact property, but protect from circular reference if (address.Contact != this) { address.Contact = this; } } Next, you can modify the Address class so that it will also provide two-way relationship fix-ups. The current Contact property of the Address class uses an auto-implementer. Replace that with the code in Example 13-7. Example 13-7. The modified Address.Contact property to fix up the two-way relationship private Contact _contact; public Contact Contact { get { return _contact;} set { _contact = value; //explicit relationship fixup _contact.AddAddress(this); } } Notice that the property provides the alternate relationship by calling the AddAddress method of the contact. This is why the AddAddress method checks the value of the Address.Contact prior to setting the value; otherwise, you will trigger an infinite loop. Now, back in the Main method, comment out the call to DetectChanges that you added earlier, and run the application again. You’ll see that the newAddressContact does get populated. Finally, you can check the other direction of the relationship. Replace the line of code that reads firstContact.Addresses.Add(newAddress); again, this time with newAddress.Contact=firstContact;. Now you are only setting the contact property of addresses. The address class will provide the fix-up for the other direction. You should find that this has caused the firstContact.Addresses.Count() to increase.
Using Proxies to Enable Change Notification, Lazy Loading, and Relationship Fix-Up As you read earlier, DetectChanges also forces the context to update the ObjectStateEntry objects that it uses for change tracking. When you call DetectChanges, the context takes a snapshot of the current state of the entities. It is possible to force the entities to notify the context of changes so that you don’t have to wait until you (or the SaveChanges method) call DetectChanges. You can do this by using a special feature of Entity Framework that enables classes to be wrapped by a special proxy class at runtime. To use this, you must mark every property in the class as virtual. In VB, this is Overridable. At runtime, Entity Framework uses reflection to discover that you have marked the properties as virtual and it will create a DynamicProxy class on the fly, then force it to inherit from your entity. This proxy will add functionality to the runtime POCO class that has many of the same features as an EntityObject. But as you’ll see further on, it is not an EntityObject. It is something completely different. Using proxies will automatically provide your classes with automatic relationship fix-up. At the same time, you also gain (or regain, as it were) many of the same behaviors provided by EntityObject, such as change notification and lazy loading. Change Notification by Proxy As you learned previously, the EntityObject notifies the ObjectContext when a scalar property has changed, enabling the context to keep track of the entity’s state. When you’ve make properties virtual, anytime you inspect the ObjectStateEntry objects that the context is maintaining they will be current and there will be no need to call DetectChanges. Every scalar and navigation property in the class must be marked as virtual for this to work. Example 13-8 shows a few of the scalar properties with the virtual/Overridable keyword. VB C# Example 13-8. Enabling POCO classes to use a proxy for change tracking Public Overridable Property FirstName As String Public Overridable Property LastName As String public virtual string FirstName {get; set;} public virtual string LastName {get;set;} Lazy Loading by Proxy Entity Framework’s ObjectContext can perform lazy loading on any navigation properties that are virtual. If you have marked all of the properties as virtual in order to get change tracking, you will also get lazy-loading behavior. However, you can get lazy
Page 1 and 2: Free Sampler
Page 3 and 4: Programming Entity Framework by Jul
Page 5 and 6: The EDM Within the Entity Framework
Page 7 and 8: Retrieving a Single Entity with Get
Page 9 and 10: Breaking Apart the ObjectQuery 222
Page 11 and 12: Using a New EntityDataSource to Add
Page 13 and 14: Insert, Update, and Delete Function
Page 15 and 16: Digging Through ObjectStateEntry 53
Page 17 and 18: 19. Using Your Own Custom Classes .
Page 19 and 20: Designing the Service Interface 725
Page 21 and 22: In addition to POCO support, the te
Page 23 and 24: using System.Text; namespace Chapte
Page 25 and 26: } } public ObjectSet Addresses { ge
Page 27: } If you run the code now, you will
Page 31 and 32: Figure 13-2. A high-level view of t
Page 33 and 34: Rule 2: To enable lazy loading on a
Page 35 and 36: using System.Collections.ObjectMode
Page 37 and 38: Modifying the POCO Template Althoug
Page 39 and 40: The next step is to modify the temp
Page 41 and 42: get; set; } public string Street1 {
Page 43: Want to read more? You can find thi

Programming Entity Framework - Cdn.oreilly.com

Create successful ePaper yourself

Delete template?

Save as template?