![\"clip_image002\"](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/32\/2019\/03\/clip_image002_thumb.jpg\")
<\/A><\/P>\nAs you can see, all the client applications (we could be for instance WinForms<\/B>, WPF<\/B>, or even Silverlight<\/B> apps) need to remotely access to the application Server tier using for example WCF Services<\/B>.<\/P>\n
Also, in my opinion. RIA<\/STRONG> (Rich Internet Applications<\/STRONG><\/EM>) is a special subset of N-Tier apps.<\/P>\nA different matter is that we\u2019d probably design our application as an N-Layer<\/I><\/B> application, I mean, with several logic layers where we implement different logic tasks. For example we could have the DAL layer<\/B> (Data Access Layer<\/I>), BLL Layer<\/B> (Business Logic Layer<\/I>), BFLL Layer<\/B> (Busines Fa\u00e7ade Logic Layer), WCF Service Layer<\/B> and several Presentation layers<\/B> depending of the pattern we use, like MVC <\/B>(Model-View-Controller), MVP <\/B>(Model-View-Presenter), etc.. Also, within the N-Layer architecture<\/B>, you can guess that Entity Framework<\/B> fits as the DAL Layer<\/B> (Data Access Classes<\/I>) as well as using EF entities as our disconnected entities to pass thru all the layers, all right?<\/P>\n
![\"image\"](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/32\/2019\/03\/image_thumb_1.png\")
<\/A> <\/P>\nBTW, not all N-Layer apps should be N-Tier apps, but all N-Tier Apps must internally be designed as N-Layer. I mean, there are many cases where the less you physically split your model, the better for performance (more tiers is good for scalability but not for pure performance, due to latencies). Remember, N-Layer is about logic layers.<\/P>\n
OK!, so if we get back to the N-Tier architecture<\/B> (physical tiers<\/B>), like I said, we need remote mechanisms to communicate the client tier with the application server tier (for instance, WCF Services) and therefore when we query the database from the app server tier, to obtain data (like an Order), we keep it as an EF entity, then we disconnect it from the EF context (detach), WCF serializes it and sends that disconnected entity to the presentation tier (client apps & machines). <\/P>\n
So, most enterprise applications use an architectural pattern that needs a stateless facade for its business logic (like N-Tier & N-Layer apps). They have scenarios like WebServices or WCF, ASP.NET applications, Traditional Desktop Application (Windows Forms, WPF) consuming WCF Services, etc. in those cases data access works \u201cdisconnected oriented\u201d, I mean, database data (in the real tables) are not blocked while the user is working in the client tier (btw, this is better for scalability). So, in the client\/presentation tier, the user will be working and maybe, he changes that entity\u2019s data (which is disconnected from the server) and after a while (at any time) the user submits that data to the application server and then the DAL layer (Entity Framework and LINQ to EF, in our case) will update that data into the database. Right?. Well, if we just do that, it will be just a \u201cLast-In-Wins\u201d<\/B> or what I call, a \u201cToo Optimistic Update\u201d<\/B> \ud83d\ude09 . Well, in many apps which are not very exigent or complex regarding updates, this can be enough, but then, we could have other apps where the users need to know if data (regarding the same entity and records he is using at client tier) has changed in the database while he was working and before he tried to update the data. In that case we should use \u201cOptimistic Concurrency Updates\u201d managing \u201cOptimistic Concurrency Exceptions\u201d.<\/P>\n
So, I am using all the following stuff:<\/P>\n
– Entity Framework<\/B> and LINQ to Entities<\/B> as our DAL Layer<\/B><\/P>\n
– WCF<\/B> as our remote communication technology<\/P>\n
– Any .NET UI technology as our client App (WPF, WinForms, OBA or even Silverlight) <\/P>\n
Simple way: Updating data in N-Tier applications and using Entity Framework with detached entities<\/H4>\n
In order to understand what I mean, first of all, I am going to explain how to implement just simple updates in N-Tier applications and using Entity Framework. So this case is the one I called \u201cLast-In-Wins\u201d or a \u201cToo Optimistic Update\u201d ;-). So in this first case I won\u2019t manage any Optimistic Concurrency Exception.<\/P>\n
First of all, we\u2019d have a business class (BLL class) which would be using EF & LINQ to Entities so that class would be querying the database; let\u2019s say to get a Customer data and to return that entity\u2019s data to the client\/presentation tier (thru a WCF Service). The BLL class code could be something like the following code:<\/P>\n
\n\n\n| \n public class CustomerBll<\/P>\n {<\/P>\n private MyDataBaseEntities context;<\/P>\n public CustomerBll()<\/P>\n {<\/P>\n context = new MyDataBaseEntities();<\/P>\n }<\/P>\n public Customer GetCustomer(string customerID)<\/P>\n {<\/P>\n var q = from c in context.Customers \/\/.Include(“Orders”)<\/P>\n where c.CustomerID == numCustomerID<\/P>\n select c;<\/P>\n var customer = q.First();<\/P>\n context.Detach(customer);<\/P>\n return customer;<\/P>\n }<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\n Ok, if you know LINQ to entities, this is a very simple method, right?. The important thing to take into account is the following: \u201cwe are returning a disconnected\/detached entity data object<\/B>\u201d passing it to the upper layers (Service layer\u00e0Presentation Layers). It means that regarding Entity Framework we\u2019ll be working with ObjectContext<\/I> objects in a \u201cshort lived context<\/B>\u201d way. Basically, when we\u2019ll close the loop, we\u2019ll need to re-attach modified EntityObjects, that were updated outside of an ObjectContext (in detached state)<\/U>. This is a very common scenario when we’re using stateless facades (most N-Tier & N-Layer apps).<\/P>\n Coming back to our code, then we could have a WCF Service serializing & returning the disconnected\/detached entity.<\/P>\n Here you could see the Service contract for the method:<\/P>\n \n\n\n| \n \/\/WCF Contract<\/P>\n [OperationContract] <\/P>\n Customer CustomerBll_GetCustomer(string customerID); <\/P>\n …<\/P>\n …<\/P>\n \/\/And now, the method\u2019s implementation in the WCF class library: <\/P>\n public Customer CustomerBll_GetCustomer(string customerID) <\/P>\n { <\/P>\n return new CustomerBll().GetCustomer(customerID); <\/P>\n }<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\n Ok, after that, the client app would be consuming the WCF Service and will display the entity\u2019s data (customer\u2019s data) let\u2019s say in a WPF form. Remember that right now, the client app is working with a disconnected\/detached entity object and there is not an ObjectStateManager tracking changes. We\u2019ll see how it affects later on\u2026<\/P>\n So, once the data is visible within a form, the user can start changing some data in that form until he decides to actually update that data into the application (for me, it means he wants to update that data into the database), pressing, for instance a big button which says \u201cUpdate\u201d. J
Right, in this very moment the client application would be calling another WCF Service method called something like UpdateCustomer(), like you see down below:<\/P>\n \n\n\n| \n public void CustomerBll_UpdateCustomer(Customer customer) <\/P>\n { <\/P>\n new CustomerBll().UpdateCustomer(customer); <\/P>\n }<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\n Then, that WCF method is calling the real business logic method, and this is where I am going to show you how to use Entity Framework to update the detached\/disconnected but modified entity which is coming back from the client tier. This is the code (remember this is the simple case, I am not managing optimistic concurrency exceptions here):<\/P>\n \n\n\n| \n public void UpdateCustomer(Customer customer) <\/P>\n { <\/P>\n \/\/(CDLTLL) Entity must first be reunited with a Context <\/P>\n \/\/Note I do it with my custom extensor method for disconected environments (N-Tier, etc.) <\/P>\n context.AttachUpdated(customer)<\/B>; \/\/Custom extensor method <\/P>\n context.SaveChanges();<\/B> <\/P>\n }<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\n Ok, first, in order for the context to be able to update anything (the entity) into the database using SaveChanges(), it has first to have it attached to the context. So, context.SaveChanges() is an EF regular method we always gotta use to update data (changes). But if we\u2019d just use the method context.Attach(customer) before that, it won\u2019t work because that customer entity is new for the context (it was originally detached, serialized and sent to the client tier) and now the context does not know nothing about it, the context \u201cthinks\u201d it is a new entity object and it would not know any changes to update using the context.SaveChanges().<\/P>\n The following is wrong code:<\/P>\n \n\n\n| \n public void UpdateCustomer(Customer customer) \/\/WRONG CODE <\/P>\n { <\/P>\n \/\/(CDLTLL) Entity must first be reunited with a Context <\/P>\n context.Attach (customer)<\/B>; \/\/Custom extensor method <\/P>\n context.SaveChanges();<\/B>\/\/In this case, nothing happens here\u2026 <\/P>\n }<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\n So in this simpler case, when you\u2019d call SaveChanges() nothing would happen.<\/P>\n That is why I created a custom EF extensor method called \u201ccontext.AttachUpdated()\u201d. To be able to attach updated entities which are disconnected and coming from the client Tier.<\/P>\n It is the following code:<\/P>\n \n\n\n| \n public static void AttachUpdated(this ObjectContext context, EntityObject objectDetached) <\/P>\n { <\/P>\n if (objectDetached.EntityState == EntityState.Detached) <\/P>\n { <\/P>\n object currentEntityInDb = null; <\/P>\n if (context.TryGetObjectByKey<\/B>(objectDetached.EntityKey, out currentEntityInDb)) <\/P>\n { <\/P>\n context.ApplyPropertyChanges<\/B>(objectDetached.EntityKey.EntitySetName, objectDetached); <\/P>\n \/\/(CDLTLL)Apply property changes to all referenced entities in context <\/P>\n context.ApplyReferencePropertyChanges<\/B>((IEntityWithRelationships)objectDetached, <\/P>\n (IEntityWithRelationships)currentEntityInDb); \/\/Custom extensor method <\/P>\n } <\/P>\n else <\/P>\n { <\/P>\n throw new ObjectNotFoundException(); <\/P>\n } <\/P>\n } <\/P>\n }<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\n So, first of all we need to know what is new in this entity, I mean, what are the changes compared with the data we actually have in the database. In order to do that we\u2019d need to query the database and get the actual data using the \u201ccontext.TryGetObjectByKey()\u201d method and attach it as the original data for that entity within the context.<\/P>\n Then, we can call the \u201ccontext.ApplyPropertyChanges()\u201d providing our new updated entity. What EF does is that it compares the original data (actual data in the database) with our new\/updated entity and then it updates within the context all the property changes just regarding our specific entity (Customer, in this case). After that, when we call to \u201ccontext.SaveChanges()<\/B>\u201d in the main method, EF will detect what are actually those changes and it will be able to update it into the real database (SQL Server, for instance).<\/P>\n Notice that after calling to \u201ccontext.ApplyPropertyChanges()\u201d I am calling another method called \u201cApplyReferencePropertyChanges()\u201d. This other method is actually another extensor method which applies all my entity property changes but into all the referenced entities within our EF model (Customer could be related to Company, Order, etc.). This is an important method, otherwise we\u2019ll be taking into account just our isolated entity (Customer). Here you can see my \u201ccontext.ApplyReferencePropertyChanges()<\/B>\u201d custom context extensor method:<\/P>\n\n\n\n| \n public static void ApplyReferencePropertyChanges(this ObjectContext context, <\/P>\n IEntityWithRelationships newEntity, <\/P>\n IEntityWithRelationships oldEntity) <\/P>\n { <\/P>\n foreach (var relatedEnd in oldEntity.RelationshipManager.GetAllRelatedEnds()) <\/P>\n { <\/P>\n var oldRef = relatedEnd as EntityReference; <\/P>\n if (oldRef != null) <\/P>\n { <\/P>\n \/\/ this related end is a reference not a collection <\/P>\n var newRef = newEntity.RelationshipManager.GetRelatedEnd(oldRef.RelationshipName, oldRef.TargetRoleName) as EntityReference; <\/P>\n oldRef.EntityKey = newRef.EntityKey; <\/P>\n } <\/P>\n } <\/P>\n }<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\n So with that, we\u2019re done!, it works ok following the method I said \u201cLast In Wins\u201d or a \u201cToo Optimistic Update\u201d \ud83d\ude09<\/P>\n Btw, another option<\/U> (it works almost the same) would be not to query the database to know the actual data (kind of original data for the context) with \u201ccontext.TryGetObjectByKey()\u201d but to say to the context that all the properties within my entity have actually changed<\/I>, \u201cjust because I say it<\/I>\u201d. After that, when we call \u201ccontext.SaveChanges()<\/B>\u201d it will update all the entity properties just because we said that!. J<\/P>\n Here you can see this other entity extensor method (In this case I coded as an entity extensor method instead as a context extensor method, ok?):<\/P>\n \n\n\n| \n public static void SetAllModified<T>(this T entity, ObjectContext context) where T : IEntityWithKey <\/P>\n { <\/P>\n var stateEntry = context.ObjectStateManager.GetObjectStateEntry(entity.EntityKey); <\/P>\n var propertyNameList = stateEntry.CurrentValues.DataRecordInfo.FieldMetadata.Select(pn => pn.FieldType.Name); <\/P>\n foreach (var propName in propertyNameList) <\/P>\n { <\/P>\n stateEntry.SetModifiedProperty(propName); <\/P>\n } <\/P>\n }<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\n In this other case (using SetAllModified()) our code within “UpdateCustomer()” would be somethin like:<\/P>\n \n\n\n| \n public void UpdateCustomer(Customer customer)
{
context.Attach<\/STRONG>(customer);
customer.SetAllModified<\/STRONG>(context); \/\/ custom extension method
context.SaveChanges<\/STRONG>();
}<\/P><\/TD><\/TR><\/TBODY><\/TABLE>\nCool!, this seems all great, we are happy and we are living in a wonderful world. Sure?. Well, it depends, but like I said at the beginning of this post, this code we have written does not cover scenarios where we want to manage \u201cOptimistic Concurrency Updates & Exceptions\u201d, I mean, let\u2019s say any other guy changed some data, regarding that same data customer, during the timeframe after I performed my Customer query but before I actually updated it to the database. I mean, someone changed data in the database just before I called to context.AttachUpdated(customer)<\/STRONG> and context.SaveChanges(). <\/B>Ok, then, the initial original user won\u2019t be aware that he might be over writing that new data that the other second user updated\u2026 In many cases this can be dangerous depending on the application\u2019s type.<\/P>\nWell, I guess this post is getting too long, I\u2019ll write a second post (very soon) explaining \u201cHow to: Update data in N-Tier applications and using Entity Framework<\/B> with detached entities and managing Optimistic Concurrency Updates and Exceptions<\/B>\u201d.<\/EM><\/P>\n— My second part of this post-article is here:<\/EM><\/P>\nOptimistic Concurrency Updates using Entity Framework in N-Tier and N-Layer Applications (Part 2)<\/U><\/STRONG><\/P>\nhttp:\/\/blogs.msdn.com\/cesardelatorre\/archive\/2008\/09\/05\/optimistic-concurrency-updates-using-entity-framework-in-n-tier-and-n-layer-applications-part-2.aspx<\/A><\/P><\/p>\n","protected":false},"excerpt":{"rendered":"First of all, we are talking about using Entity Framework and how it fits within N-Tier and N-Layer applications, ok?, that\u2019s our initial scenario. An N-Tier application is an application where you have 3 or more physical tiers. I mean with that things like, \u201cPresentation\/Client Tier\u201d, \u201cApplication\/Business Server Tier\u201d and \u201cData Tier\u201d (a database server […]<\/p>\n","protected":false},"author":362,"featured_media":12806,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[4,12,48,101,109],"class_list":["post-1393","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-cesardelatorre","tag-net-3-5","tag-ado-net","tag-entity-framework","tag-visual-studio-2008","tag-wcf"],"acf":[],"blog_post_summary":" First of all, we are talking about using Entity Framework and how it fits within N-Tier and N-Layer applications, ok?, that\u2019s our initial scenario. An N-Tier application is an application where you have 3 or more physical tiers. I mean with that things like, \u201cPresentation\/Client Tier\u201d, \u201cApplication\/Business Server Tier\u201d and \u201cData Tier\u201d (a database server […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/cesardelatorre\/wp-json\/wp\/v2\/posts\/1393","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/cesardelatorre\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/cesardelatorre\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cesardelatorre\/wp-json\/wp\/v2\/users\/362"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cesardelatorre\/wp-json\/wp\/v2\/comments?post=1393"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/cesardelatorre\/wp-json\/wp\/v2\/posts\/1393\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cesardelatorre\/wp-json\/wp\/v2\/media\/12806"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/cesardelatorre\/wp-json\/wp\/v2\/media?parent=1393"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cesardelatorre\/wp-json\/wp\/v2\/categories?post=1393"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/cesardelatorre\/wp-json\/wp\/v2\/tags?post=1393"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}} | | | | | | | | |
![\"clip_image002\"](\"https:\/\/devblogs.microsoft.com\/wp-content\/uploads\/sites\/32\/2019\/03\/clip_image002_2.jpg\")
<\/A><\/P>\n