MSDN Magazine - December 2008 - (Page 76)

Figure 7 Creating an Order Using LINQ to Entities public DTO.Order CreateOrder(DTO.Order order) { using (NorthwindEntities db = new NorthwindEntities (Settings.Default.NorthwindEntityConnection)) { // Create an L2S.Order Order nwOrder = new Order { OrderID = order.OrderID, CustomerID = order.CustomerID, OrderDate = order.OrderDate, Updated = order.Updated }; // Add order details foreach (DTO.OrderDetail od in order.OrderDetails) { Order_Detail detail = new Order_Detail { Order = nwOrder, Product = (from p in db.ProductSet where p.ProductID == od.ProductID select p).First(), Quantity = od.Quantity, UnitPrice = od.UnitPrice, Updated = od.Updated } }; nwOrder.Order_Details.Add(detail); // Add order and order details db.AddToOrderSet(nwOrder); db.SaveChanges(); // Return the updated order return GetOrder(nwOrder.OrderID); } } Figure 8 Updating an Order Using LINQ to SQL public DTO.Order UpdateOrder(DTO.Order order) { using (NorthwindDataContext db = new NorthwindDataContext (Settings.Default.NorthwindSqlConnection)) { // Create an L2S.Order Order nwOrder = new Order { OrderID = order.OrderID, CustomerID = order.CustomerID, OrderDate = order.OrderDate, Updated = order.Updated }; // Attach and save order db.Orders.Attach(nwOrder, true); db.SubmitChanges(); // Return the updated order return GetOrder(order.OrderID); } } Figure 9 Updating an Order Using LINQ to Entities public DTO.Order UpdateOrder(DTO.Order order) { using (NorthwindEntities db = new NorthwindEntities (Settings.Default.NorthwindEntityConnection)) { // Get original order using key from updated order EntityKey key = db.CreateEntityKey("OrderSet", new Order { OrderID = order.OrderID }); Order origOrder = db.GetObjectByKey(key) as Order; // Set Updated to match DTO.Order - (for concurrency) origOrder.Updated = order.Updated; // Commit change to the Updated property db.Detach(origOrder); db.Attach(origOrder); // Create a NW order for updating the original order Order updatedOrder = new Order { OrderID = order.OrderID, OrderDate = order.OrderDate, CustomerID = order.CustomerID, Updated = order.Updated }; // Apply changes to the original order db.ApplyPropertyChanges("OrderSet", updatedOrder); // Persist changes db.SaveChanges(); } // Return the updated order return GetOrder(order.OrderID); } Before looking at deleting or updating entities, I need to discuss how to deal with concurrency issues. LINQ to SQL requires you to attach a disconnected entity prior to calling DeleteOnSubmit. Doing so prompts LINQ to SQL to perform optimistic concurrency checks, causing deletes to fail with a ChangeConflictException if a user tries to delete the item after the another user has changed it. There really isn’t any easy way to turn off this behavior, because LINQ to SQL will throw an InvalidOperationException if you attempt to invoke DeleteOnSubmit without first having called Attach. The Entity Framework, on the other hand, doesn’t force you to handle change conflicts when deleting entities (see the code download accompanying this article). Figure 8 shows the code for updating an order using LINQ to SQL. Notice that the Attach method accepts an asModified parameter of type bool. Setting this parameter to true indicates to LINQ to SQL that you wish to use a timestamp column for concurrency management. Doing so will cause LINQ to SQL to include the current timestamp value in the WHERE clause for the SQL Update statement. If the record was updated by another user, the update will not affect any rows and LINQ to SQL will throw a ChangeConflictException. This strategy relieves the client from needing to preserve original values and submit them along with the update, which would need to be passed to one of the other overloads of the Attach method. It doesn’t matter what you name the column, so long as it has a timestamp data type. When you add a table with a timestamp column to the LINQ to SQL designer in Visual Studio, the UpdateCheck attribute will be set to Never for all entity fields and LINQ to SQL will use the timestamp to check for change conflicts. Updating entities and managing concurrency with the Entity Framework is presently a bit more involved than with LINQ to SQL, because it requires the entity’s original values, even if you are using a timestamp column for concurrency (see Figure 9). (This is likely to improve in the next version of the Entity Framework.) Because the client has not provided the original order, you need to retrieve the order from the database and set its Updated property to the value provided by the client, which is the only “original” value you really care about. Be sure to commit the change to Updated, either by detaching and re-attaching the order to the object conThe Entity Framework 76 msdn magazine

Table of Contents Feed for the Digital Edition of MSDN Magazine - December 2008

MSDN Magazine - December 2008 Contents Toolbox CLR Inside Out Advanced Basics Cutting Edge Patterns In Practice Team System Real-World WF Visual Studio OBA Tools SOA Data Access Geneva Framework Test Run Foundations Windows With C++ Going Places End Bracket

MSDN Magazine - December 2008

For optimal viewing of this digital publication, please enable JavaScript and then refresh the page. If you would like to try to load the digital publication without using Flash Player detection, please click here.