![Microsoft Argentina y Uruguay [Official Space], profile picture](https://cdn.slidesharecdn.com/profile-photo-comunidadesms-48x48.jpg?cb=1522877393)
Descargado 10 veces
![[Run Reloaded] Entity Framework 4.0 (Daniel Laco)](https://image.slidesharecdn.com/runreloadedentityframework4-0daniellaco-100119122230-phpapp01/75/Run-Reloaded-Entity-Framework-4-0-Daniel-Laco-14-2048.jpg)
[Run Reloaded] Entity Framework 4.0 (Daniel Laco)
Entity Framework 4.0 introduce mejoras como objetos POCO, generación de código T4, carga diferida y entidades de seguimiento propio para admitir capas, así como opciones de desarrollo centrado en el modelo y solo en código con mejoras en el diseñador de entidades. El documento también resume las nuevas características de Entity Framework 4.0 como pluralización, devolución de tipos de procedimientos almacenados, soporte para tipos complejos y métodos para ejecutar consultas SQL.
![[Run Reloaded] Presentando .NET 4.0 (Diego González + Pablo Zaidenvoren)](https://cdn.slidesharecdn.com/ss_thumbnails/runreloadedpresentando-net4-0diegogonzlezpablozaidenvoren-100119122247-phpapp02-thumbnail.jpg?width=640&height=640&fit=bounds)
[Run Reloaded] Entity Framework 4.0 (Daniel Laco)
- 1. Entity Framework 4.0DanielLacoDirector Ejecutivodaniell@vemn.com.ar
- 2. Voto de DesconfianzaEntityFramework in 3.5 SP1 is:Too complex. Too many steps are required.Too many restrictions. I want control over my code.Not in sync with the way I work: TDD, N-Tier, Patterns
- 3. TemarioPersistanceIgnorance (POCO)POCO Change-Tracking(PlainOld CLR Object)T4 Code GenerationLazyLoadingSoporte para N-Capas con Self-Tracking EntitiesModel-FirstDevelopmentCode-OnlyDevelopmentMejoras en el Diseñador de EntidadesPluralizaciónOpciones de Change Tracking
- 4. DemoObjetos POCO (PlainOldCLR Object)
- 5.
- 6.
- 7. DemoDesarrollo solo porCódigo
- 8.
- 9. Que hay denuevo?Plurales / SingularesMejoras en el DiseñadorGeneraciónautomática de tiposretornadospor Stored ProceduresSoporte para Tipos ComplejosForeignKeysMejoras en testing con IObjectSet<T>T-SQL mas performante y simple de leerMétodos para Ejecutar SQL
- 10. Que NOes unORM? La respuesta a la vida del universo y todo eso …La forma absoluta más rápida de hacer todo …No siempre están en sintonía con los avances de las Bases de Datos …
- 11. ResumenPersistanceIgnorance (POCO)POCO Change-Tracking(PlainOld CLR Object)T4 Code GenerationLazyLoadingSoporte para N-Capas con Self-Tracking EntitiesModel-FirstDevelopmentCode-OnlyDevelopmentMejoras en el Diseñador de EntidadesPluralizaciónOpciones de Change Tracking
- 12.
- 13. Muchas graciaspor suparticipaciónDaniel LacoDirector Ejecutivodaniell@vemn.com.ar
Notas del editor
- #2 Accediendo a datos con Entity Framework
- #4 http://msdn.microsoft.com/en-us/library/bb738695.aspx Persistence Ignorance: You can define your own POCO’s (Plain Old CLR Objects) that are decoupled from any specific persistence technology. This allows you to swap out one data access stack for another should the need arise.
- #5 Nuevos metodos en ObjectStatemManagerObjectStateManager.ChangeObjectStateObjectStateManager.ChangeRelationshipStateObjectStateManager.GetObjectStateEntry(entityObject).ApplyCurrentValuesObjectStateManager.GetObjectStateEntry(entityObject). ApplyOriginalValuesObjectContext.LoadProperty
- #9 Better N-Tier SupportOne of the most common reasons for using POCO’s is to conceal details of object persistence behind a data access layer. Similarly, POCO’s are often passed across tiers as Data Transfer Objects (DTO’s) in a service-oriented application. One problem that has vexed distributed application developers is how to pass changes from one tier to another so they can be persisted in a disconnected manner. At first, the Entity Framework team decided to provide a low-level API for applying changes to detached objects, requiring you to roll your own change-tracking mechanism, but much of the feedback they received included requests for a built-in change-tracking mechanism and an end-to-end architecture for building n-tier apps that use the Entity Framework. In response to this feedback, the team delivered a T4 template for Self-Tracking Entities, which allows each entity to keep track of its own change state, so that you can pass it to a remote service where the entire object graph is persisted.Each generated class implements the IObjectWithChangeTracker interface, which has a ChangeTracker property, as well as methods to mark the entity as Unchanged, Modified, Added or Deleted. ObjectChangeTracker not only records the object state but also maintains original values of reference properties as well as objects that have been added to or deleted from collection properties. This means that the client can make changes to an Order by adding or removing OrderDetails, and the state of the Order and OrderDetails can be sent to the service for persistence. Change state is serialized because each entity is marked with a [DataContract] attribute and the ChangeTracker is marked with a [DataMember] attribute.Self-Tracking Entities allow the client to track change state on entities without needing to reference the Entity Framework assembly, System.Data.Entity. The change-tracking code is auto-generated by the T4 template, which produces the ObjectChangeTracker class and a generic FixupChangeTrackingCollection class that does relationship fix-up and implements ICollection to keep track of additions and deletions. Deleted items are cached so they can be removed later when changes are persisted on the service side.Your service would typically expose a method for retrieving an object graph such as Order and OrderDetails, and a method for updating the object graph. In the update method, you would call ApplyChanges<T> on the appropriate entity set. ApplyChanges is an extension method residing in the Microsoft.Data.Entity.CTP assembly, which you bring into scope by adding a using directive for the Microsoft.Data.Entity namespace. This method accepts an object graph as well as a pointer to a method that returns an IEntityChangeTracker, which is responsible for informing the object state manager of these changes. The Self-Tracking Entities T4 template also generates a EntityChangeTrackerAdapter class that implements IEntityChangeTracker by translating the persistence-neutral ObjectStateenum (Added, Deleted, Modified, Unchanged) to the equivalent EF-specific EntityStateenum values. The code in your service-side update method could look something like this:public Order UpdateOrder(Order order){ using (NorthwindEntitiesctx = new NorthwindEntities()) { ctx.Orders.ApplyChanges(order, EntityChangeTrackerAdapter.GetSelfTrackingEntityInfo); ctx.SaveChanges(); return order; }}
- #10 http://code.msdn.microsoft.com/DesignerExtStartKit (ADO.NET Entity Data ModelDesignerExtensionStarter Kit )T-SQL mas performante Se mejoraron los Joins Se sacaron Cast innecesarios Se sacaron algunos IsNull innecesariosContains, StartWidh y EndWith ahora son Like %%
- #12 http://msdn.microsoft.com/en-us/library/bb738695.aspx Persistence Ignorance: You can define your own POCO’s (Plain Old CLR Objects) that are decoupled from any specific persistence technology. This allows you to swap out one data access stack for another should the need arise.
- #14 Accediendo a datos con Entity Framework