Compiled Models, Startup Cost, Large Model Optimization, and NativeAOT Considerations

Learning outcomes

1. A compiled model optimizes first-use model initialization

The first meaningful operation on a DbContext type causes EF to build and initialize its runtime model. For a small model the cost is usually insignificant. Microsoft describes compiled models as an optimization for large models—often hundreds to thousands of entity types and relationships—where cold-start becomes measurable.

Do not confuse three separate artifacts: a compiled model is generated C# for EF model initialization; an explicit compiled query is a delegate for one LINQ shape; precompiled queries are generated interceptors used by EF’s experimental NativeAOT/query-precompilation pipeline.

2. Measure ServiceHub before generating anything

// Run each candidate in a fresh process for meaningful cold-start evidence.var sw = Stopwatch.StartNew();await using var db = factory.CreateDbContext();var first = await db.WorkOrders    .AsNoTracking()    .OrderBy(w => w.Id)    .Select(w => w.Id)    .FirstOrDefaultAsync(cancellationToken);sw.Stop();Console.WriteLine($"first-operation-ms={sw.Elapsed.TotalMilliseconds:F3}; id={first}");

A loop in one process measures warm reuse after the model is already initialized. For a cold-start comparison, launch a fresh Release build repeatedly and disclose filesystem/database cache state. The current ServiceHub model is intentionally much smaller than the extreme models for which compiled models are designed, so “no meaningful benefit” is a valid result.

3. Generate the compiled model with the pinned EF tool

dotnet tool run dotnet-ef dbcontext optimize   --context ServiceHubContext   --output-dir CompiledModels   --namespace ServiceHub.EfLab.CompiledModels# Inspect and commit generated code only if the measured optimization is adopted.git diff -- CompiledModels

The command prints the generated model type to wire into options. For this context the typical name is ServiceHubContextModel.Instance; use the name emitted by your actual command rather than copying it blindly.

services.AddDbContextFactory<ServiceHubContext>(options =>{    options.UseSqlite(connectionString);    options.UseModel(ServiceHub.EfLab.CompiledModels.ServiceHubContextModel.Instance);});

4. Generated model code is a build artifact with a synchronization contract

Any change to entity configuration, converters, owned/complex mapping, query filters, relationships, or provider metadata can make a compiled model stale. The fix is not to hand-edit generated runtime-model code; regenerate it. Add CI that runs dbcontext optimize into a clean directory and fails when the checked-in generated output differs.

rm -rf CompiledModels.generateddotnet tool run dotnet-ef dbcontext optimize   --context ServiceHubContext   --output-dir CompiledModels.generated   --namespace ServiceHub.EfLab.CompiledModelsdiff -ru CompiledModels CompiledModels.generated

5. Check documented feature limits before adoption

These are not theoretical footnotes. If a required feature conflicts with compiled models, choose correctness/model clarity over a startup optimization.

6. Failure case: change the model but keep stale generated code

Suppose a developer adds an index or remaps a column and forgets to run dbcontext optimize. The application can build against generated model code representing an older shape. The safe repair is a generation step tied to model changes and a smoke test that compares expected metadata.

await using var db = await factory.CreateDbContextAsync(ct);var entity = db.Model.FindEntityType(typeof(WorkOrder))    ?? throw new InvalidOperationException("WorkOrder missing from model.");var number = entity.FindProperty(nameof(WorkOrder.WorkOrderNumber))    ?? throw new InvalidOperationException("WorkOrderNumber missing.");Console.WriteLine($"column={number.GetColumnName()}; max={number.GetMaxLength()}");

7. Precompiled queries and NativeAOT: current EF Core 10 status

As of this chapter’s August 2026 review, Microsoft still labels EF NativeAOT support, precompiled queries, and the related MSBuild integration as experimental and not suited for production. The mechanism statically finds queries and generates interceptors; dynamic queries and other patterns have limitations, and provider support must be checked.

# Experimental EF Core 10 learning path; not the mandatory production lab.dotnet tool run dotnet-ef dbcontext optimize   --context ServiceHubContext   --precompile-queries# NativeAOT adds additional generated code and provider requirements:dotnet tool run dotnet-ef dbcontext optimize   --context ServiceHubContext   --precompile-queries   --nativeaot

8. Lab: make the adoption decision from cold-start evidence

1. Run the non-compiled model executable in Release mode in a fresh process at least 20 times and save raw first-operation times.
2. Generate and wire the compiled model, rebuild, and repeat under the same conditions.
3. Record generated code size and build-time change.
4. Change one harmless mapping in a throwaway branch, demonstrate the regeneration requirement, then revert.
5. Check the course model for features on the documented unsupported list.
6. Write an adoption decision: keep, reject, or defer. “Reject because the model is small and the gain is noise” is an acceptable outcome.

9. Production judgment

Compiled models trade generated-code/build complexity for first-use model initialization speed. They do not make SQL plans faster, reduce row counts, or fix network latency. Use them when cold-start is an actual service-level problem and the model is large enough to justify the complexity. The next lesson tackles another often-confused optimization family: context pooling versus driver connection pooling.

Authoritative references

Performance behavior is workload-, provider-, and version-sensitive. Re-check these primary sources before carrying a result into production.

• Advanced Performance Topics - compiled models — compiled-model command, use and limitations
• NativeAOT Support and Precompiled Queries — experimental status and limitations
• EF Core MSBuild tasks — experimental build/publish integration for compiled models/precompiled queries
• EF Core .NET CLI tools — dbcontext optimize options
• What’s New in EF Core 10 — stable EF Core 10 LTS baseline