Optimize your use of Entity Framework by following best practices that enhance performance and maintainability. These guidelines cover everything from efficient querying and data manipulation to leveraging migrations and in-memory providers, ensuring your application runs smoothly and effectively.
Entity Framework allows you to provide a strongly typed object framework (ORM) over your database. This helps abstract the database away allowing it to be replaced with other technologies as needed.
It's expensive retrieving data from a database, as such it's important to only ask for the rows you require when getting data.
When you cast IQueryable to IEnumerable and then query the data from there, Entity Framework must collect the data at the point you do the cast. This can result in very significant extra database load, and extra processing on the client side.
NOTE: Using
.AsEnumerable()achieves the same effect.One of EF Core's best features is the fact it tracks any changes you make to entities after you retrieve them. However this comes with a cost, if the data is only being read and the returned entities will never be modified then you can use the AsNoTracking method to inform EF Core not to bother tracking changes.
This results in fairly significant memory and CPU improvements on the client side.
When retrieving data it's much more efficient to only collect the data you need. It saves computation and IO on the database and also saves memory and CPU on the calling side.
The Update method on an entity in EF Core marks all of its fields as dirty. This will result in all the fields being written back to the database.
Often developers will include all the related entities in a query to help with debugging. Always remember to take these out. They cause excessive database load.
Pagination can be expensive if all the pages are retrieved from the database before grabbing the relevant page. It's much more efficient to get only the page number requested back from the database.
TagWith adds comments to the generated SQL. This makes it easier to identify queries when they run on the database.
To avoid embarrassing failures in Production, it is important to ensure that your development systems are as similar as possible to what's expected in Production.
- Do you know why to use Entity Framework?
- Do you only get the rows you need?
- Do you take care when casting IQueryable to IEnumerable?
- Do you use AsNoTracking for readonly queries?
- Do you only project properties you need?
- Do you avoid using update?
- Do you only explicitly include relationships you need?
- Do you do pagination database side?
- Do you use TagWith?
- Do you ensure your Test environment is representative of Production?
- Do you benchmark?
- Do you know the best benchmarking tools?
- Do you bulk process in chunks?
- Do you know when to use raw sql?
- Do you know to use code migrations?
- Do you use the EF Core In-Memory provider to simplify your tests?
- Do you know how to migrate from EDMX to EF Core