A presentation for the Calgary .NET User Group on December 14, 2016

1. Data Access: ORMs vs
Micro-ORMs
@Dave_Paquette
Microsoft MVP (ASP.NET/IIS)
contactme@davepaquette.com
http://www.davepaquette.com

2. aspnetmonsters.com
@aspnetmonsters
westerndevs.com
@westerndevs

3. Data Access
How did we get here?
Why is this so hard?
public class Foo
{
//…some properties
}
SQL Server

4. Data Access in .NET
• System.Data
• IDbConnection
• IDbTransaction
• IDbCommand
• IDataReader

5. Sytem.Data - Reading Records
var results = new List<Employee>();
using (SqlConnection connection = new SqlConnection(Settings.ConnectionString))
{
SqlCommand command = new SqlCommand(“SELECT * FROM Employees”, connection);
connection.Open();
IDataReader reader = command.ExecuteReader();
while (reader.Read())
{
results.Add(ReadSingleRow(reader));
}
reader.Close();
}
return results;

6. ORMs
• Hide details of database
• Generate SQL based on object model and configuration
• ChangeTracking
• Complex mapping strategies
• Many-to-many relationships
• Inheritance

7. Popular ORMs
•Entity Framework
•nHibernate?
•Linq 2 Sql?

8. ORM Pain Points
• Black box code generation – What is going on?
• Performance Problems
• Check out MiniProfiler (http://miniprofiler.com/)
• Dealing with disconnected entities (in a web context)
• Eager Loading vs Lazy Loading
• Complex Inheritance Chains

9. Micro-ORMs
• Query --> Objects
• Usually focused on speed
• Light on features

10. Popular Micro-ORMs
• Dapper
• PetaPOCO
• Massive
• Simple.Data

11. F# Data Providers

12. Writing your own Data Access Layer / ORM

13. What should you use?

14. When to use a Micro-ORM
• Speed & Efficiency are extremely important
• You don’t mind (or prefer) writing your own SQL
• Simple object graphs
• Read models / Reports

15. Performance of SELECT mapping over 500
iterations - POCO serialization
Method Duration
Hand coded (using a SqlDataReader) 47ms
Dapper ExecuteMapperQuery 49ms
ServiceStack.OrmLite (QueryById) 50ms
PetaPoco 52ms
BLToolkit 80ms
SubSonic CodingHorror 107ms
NHibernate SQL 104ms
Linq 2 SQL ExecuteQuery 181ms
Entity framework ExecuteStoreQuery 631ms
https://github.com/StackExchange/dapper-dot-net#performance-of-select-mapping-over-500-iterations---dynamic-serialization

16. When to use an ORM
• You like the convenience of change tracking
• Your application logic requires a complex object graph
• You prefer writing queries using LINQ

17. Optimizing your ORM experience
• NoTracking
• SQL Projections
• Avoid Lazy Loading
• Avoid the GodContext
• Write SQL!

18. NoTracking + No Lazy Loading + Projections
return await _context.Tasks.AsNoTracking()
.Include(t => t.Event).ThenInclude(a => a.Campaign)
.Include(t => t.RequiredSkills).ThenInclude(ts => ts.Skill)
.Select(task => new EditViewModel
{
Id = task.Id,
Name = task.Name,
Description = task.Description
//etc…
}).SingleAsync(t => t.Id == taskId);

19. Surprisingly Efficient
SELECT TOP(2) [task].[Id], [task].[Name], [task].[Description]
--, More columns
FROM [AllReadyTask] AS [task]
INNER JOIN [Event] AS [task.Event] ON [task].[EventId] = [task.Event].[Id]
INNER JOIN [Campaign] AS [task.Event.Campaign] ON [task.Event].[CampaignId] =
[task.Event.Campaign].[Id]
WHERE [task].[Id] = @__message_TaskId_0
ExecutionTime: ~35ms

20. More DbContexts / Fewer Navigation Properties
https://msdn.microsoft.com/en-us/magazine/jj883952.aspx

21. Resources
• http://stackexchange.github.io/dapper-dot-net/
• http://www.toptensoftware.com/petapoco/
• https://docs.microsoft.com/en-us/ef/
• https://github.com/dpaquette/OrmComparison

22. Training so big it’s Monstrous
https://training.aspnetmonsters.com/

23. Prizes!

24. www.davepaquette.com
westerndevs.com
aspnetmonsters.com
Blog(s)
Twitter @Dave_Paquette
Email contactme@davepaquette.com
Thanks!