The NeceMoon | December 2015

My 12 Favorite Entity Framework Tricks

by necemon 12. December 2015 22:45

The Entity Framework is an ORM system, a set of technologies that support the development of data-oriented software applications. It's part of the .NET Framework. I have been playing with it for a couple of years and here are my top tips :


1. Extending the TimeOut value
When loading large amounts of data, the operations happen to fail every time they hit the default time out, so it may be a good idea to extend it to a few hours.
Doing it when initializing the Context object ensures that it's all set before any database call.


2. Second Level Caching
That's a caching of query results. The results of SQL commands are stored in the cache, so that the same SQL commands retrieve their data from the Cache rather than executing the query again against the underlying provider. This can have a performance boost for your application and results in less activity against your database. To enable this feature, you can download and implement this open source project.


3. Dynamic Code First and database migration
EF allows you to program against a model without having to deal with a database directly. With the Code-First approach, you can focus on the domain design and start creating classes. Code-First APIs will create/update the database on the fly based on your entity classes and configuration.
By the way, while we are on the topic on configuration, you can do it all within your C# code. Here are a couple of handy properties:
AutomaticMigrationEnabled : Set it to true to enable the Code-First magic
AutomaticMigrationDataLossAllowed : a value indicating if data loss is acceptable during automatic migration. If set to false an exception will be thrown when data loss may occur as part of an automatic migration.


4. Previewing Code-First change details
There is an easy way to generate the SQL scripts that EF plans to execute, before/without actually commiting those changes. It goes like this:
var configuration = new MigrationConfiguration();
var migrator = new DbMigrator(configuration);
var scriptor = new MigratorScriptingDecorator(migrator);
string script = scriptor.ScriptUpdate(null, null);
It could be useful if you want to make some changes to that script, or if you are debugging an issue or if you are just curious about what's going on :-)


Multiple Active Result Sets (MARS) is a feature that allows the execution of multiple batches on a single connection. To say it in a simple way, you can make a connection to server and then submit multiple requests to server at the same time, and then read results from these requests in whatever way you want. Just include "MultipleActiveResultSets=True" in your web.config file.


6. Setting all the properties constraints in a single place
For example, instead of adding an attribute to each string property, you could set a default string maximum length as follow:
protected override void OnModelCreating(DbModelBuilder modelBuilder)
       modelBuilder.Properties<String>().Configure(p => p.HasMaxLength(360));


7. Inheritance strategy
EF has many ways of dealing with inheritance
-Table per hierarchy : a single table with all based and derived class properties (A discriminator property being used to differenciate between them)
-Table per type : base properties on the base table, and for each derived class, derived properties on a separate table
-Table per concrete type : each derived class  gets its own table with all (based or derived) properties.
Pretty extensive, the only case I am not sure about : is there a way to make EF not deal with inheritance at all ? I mean, assuming A derives from B, is there a way to make EF treats A and B as completely different classes and ignore the fact that that one inherits from the other ?
Not a very common scenario, but just for the sake of avoiding duplication, I could want to use inheritance in the C# code so that I don't copy the properties twice in different classes but I wouldn't want to involve any reaction from EF. TPC comes close to that, but the classes still share the same primary key.


8. EntityFunctions Methods
When using LINQ to Entity Framework, your predicates inside the Where clause get translated to SQL, which doesn't have a translation for some complex constructions like DateTime.AddDays(). That's where EntityFunctions methods come in the picture.


9. LINQKit
LINQKit is a free set of extensions for LINQ to SQL and Entity Framework power users. I mostly use it to dynamically build predicates and insert expression variables in subqueries, but it also allow to :
- Plug expressions into EntitySets and EntityCollections
- Combine expressions (have one expression call another)
- Leverage AsExpandable to add your own extensions.


10. Lazy Loading
One of the most interesting Entity Framework features is the Lazy Load function, which is the process whereby an entity or collection of entities is automatically loaded from the database the first time that a property referring to the entity/entities is accessed.
To put it simply, lazy loading means delaying the loading of related data, until you specifically request for it.
This could be enabled by setting the Configuration.LazyLoadingEnabled property to true.


11. AsNoTracking
Entity Framework exposes a number of performance tuning options to help you optimise the performance of your applications. One of these tuning options is .AsNoTracking(). This optimisation allows you to tell Entity Framework not to track the results of a query. This means that Entity Framework performs no additional processing or storage of the entities which are returned by the query.
There are significant performance gains to be had by using AsNoTracking().


12. Staying away from performance traps and other EF gotchas
The object context manager can lead to situations where EF behaves in surprising ways. It's good to be aware of the patterns that you can follow to avoid these pitfalls.

Tags: , , ,

English | Technical

Mes 12 Astuces Préférées Avec Entity Framework

by necemon 12. December 2015 20:52


Entity Framework est un mappeur objet/relationnel qui permet aux développeurs .NET d'utiliser des données relationnelles à l'aide d'objets spécifiques au domaine. Il rend inutile la plupart du code d'accès aux données que les développeurs doivent généralement écrire. Je joue avec ça depuis deux ou trois ans, et voici mes techniques préférées:


1. Prolongement de la valeur TimeOut
Lors du chargement de grandes quantités de données, il peut arriver que certaines opérations échouent chaque fois qu'elles atteignent le temps mort par défaut, du coup ça pourrait être une bonne idée d'étendre cette durée à quelques heures. C'est bien de le faire pendant l'initialisation de l'objet Contexte, donc avant tout appel de base de données.


2. Cache de deuxième niveau
C'est la mise en cache des résultats de la requête. Les résultats de commandes SQL sont stockés dans le cache, de sorte que les commandes répétées récupérent leurs données à partir du cache au lieu d'exécuter la requête à nouveau contre la base de données. Ceci peut présenter un gain de performances pour l'application et moins d'activités au niveau de la base de données. Pour activer cette fonctionnalité, tu peux télécharger et utiliser ce projet open source.


3. Code First dynamique et migration de bases de donnees
EF permet de programmer contre un modèle sans avoir à toucher la base de données. Avec la technique Code-First, tu peux te concentrer sur la conception des modèles et commencer à créer des classes. Les APIs de Code-First vont créer et/ou mettre à jour la base de données à la volée en fonction de tes classes d'entités et de ta configuration.
D'ailleurs, pendant qu'on parle de configuration, tu peux faire tout ça depuis ton code C#. Voici quelques propriétés pratiques:
AutomaticMigrationEnabled : pour activer la magie de Code-First
AutomaticMigrationDataLossAllowed : Une valeur indiquant si la perte de données est acceptable lors de la migration automatique. Si la valeur est "false", une exception sera levée quand la migration automatique est susceptible de créer une perte de données.


4. Aperçu et anticipation des changements de Code-First
Ceci est un moyen facile de générer les scripts SQL que EF compte exécuter, sans confirmer ou avant de confirmer ses changements. Voici comment ça marche:
var configuration = new MigrationConfiguration();
var migrator = new DbMigrator(configuration);
var scriptor = new MigratorScriptingDecorator(migrator);
string script = scriptor.ScriptUpdate(null, null);
Ça peut être utile si tu veux faire des changements au script qui va être exécuter, ou si tu es en train de déboguer un problème ou simplement si tu es curieux de savoir ce qui se passe :-)


Multiple Active Result Sets (MARS) est une fonctionnalité qui permet l'exécution de plusieurs paquets sur une seule connexion. Pour le dire d'une manière simple, tu peux établir une connexion au serveur, puis soumettre plusieurs commandes au serveur en même temps, puis lire les résultats de ces demandes de la manière que tu veux. Il suffit d'inclure "MultipleActiveResultSets = true" dans ta ConnectionString.


6. Réglage de toutes les propriétés en un seul endroit
Par exemple, au lieu d'ajouter un attribut à chaque propriété String, tu peux définir une longueur maximale par défaut comme suit:
protected override void OnModelCreating(DbModelBuilder modelBuilder)
       modelBuilder.Properties<String>().Configure(p => p.HasMaxLength(360));


7. Stratégie d'héritage
EF a plusieurs façons de gérer l'héritage
-Table par Hiérarchie : une seule table avec toutes les propriétés des classes de base et des classes dérivées (Une propriété discriminatrice étant utilisée pour les différencier)
-Table par Type : les propriétés de base dans la table de base, et pour chaque classe dérivée, les propriétés dérivées dans une table séparée
-Table Par type concret : chaque classe dérivée obtient sa propre table avec toutes les propriétés (base ou dérivées).
C'est assez complet, le seul cas où je ne suis pas sûr: y a-t-il un moyen de faire en sorte que EF évite complètement l'héritage ? Je veux dire, en supposant que A dérive de B, est-il possible de faire en sorte que EF traite A et B comme des classes complètement différentes et ignorer le fait que que l'une hérite de l'autre?
Pas un scénario très commun, mais juste pour éviter la duplication, ce serait alors possible d'utiliser l'héritage dans le code C# sans copier les propriétés deux fois dans des classes différentes, sans réaction de la part EF. TPC se rapproche de cela, mais les classes partagent toujours la même clé primaire.


8. Les Méthodes EntityFunctions
Lorsqu'on utilise LINQ to Entity Framework, tes prédicats dans la proposition Where sont traduits en SQL, mais SQL n'a pas d'équivalent pour certaines constructions complexes telles que DateTime.AddDays(). C'est là que les méthodes EntityFunctions entrent en jeu.


9. LINQKit
LINQKit est un ensemble gratuit d'extensions pour LINQ to SQL et Entity Framework. Je l'utilise surtout pour construire dynamiquement des prédicats et insérer des variables d'expression dans les sous-requêtes, mais il permet aussi de:
- Combiner des expressions (permettre à une expression d'en appeler une autre)
- Insérer des expressions dans les EntitySets et EntityCollections
- Créer tes propres extensions


10. Lazy Loading
L'une des fonctionalités les plus intéressantes de Entity Framework, c'est la fonction Lazy Loading. C'est le processus par lequel une entité ou une collection d'entités sont automatiquement chargés à partir de la base de données la première fois qu'une propriété faisant référence à l'entité ou aux entités est accessible.
Pour le dire plus simplement, Lazy Loading signifie: retarder le chargement des données, jusqu'à ce que tu les appelles explicitement.
Ceci pourrait être activé en activant la propriété Configuration.LazyLoadingEnabled.


11. AsNoTracking
Entity Framework expose un certain nombre d'options d'optimisation des performances pour t'aider à peaufiner tes applications. L'une de ces options de réglage est .AsNoTracking(). Cette optimisation te permet de dire à Entity Framework de pas traquer les résultats d'une requête. Cela signifie que Entity Framework n'effectue aucun traitement supplémentaire ou stockage des entités qui sont retournés par la requête.
Il ya des gains de performance considérables découlant de l'utilisation de AsNoTracking().


12. Rester loin de pièges de performance et autres complications de EF

Le gestionnaire de contexte d'objects peut parfois mener à des situations où EF se comporte de manière étrange. C'est bien d'être informé des méthodes que tu peux suivre pour éviter ces pièges.


Tags: , , ,

Francais | Technical



I am Necemon Yai. I am a .NET developer and a digital artist. Let's keep in touch via Twitter, LinkedIn or Facebook.

Je suis Necemon Yai. Je suis un développeur .NET et un artiste numérique. Restons en contact via Twitter, LinkedIn ou Facebook.