Does getting entities with AsNoTracking() disable the automatic call to DetectChanges()?

Question

I've come to know this concept of AsNoTracking(), DetectChanges(), and AutoDetectChangesEnabled very recently. I understand that when fetching records from the database via Entity Framework with AsNoTracking() used, then Entity Framework does not track any changes on those records and updating any property of the fetched record will fail in that case.

My question is if records are fetched in that manner, will it also cause disabling the automatic call to DetectChanges() or does that have to be done explicitly by setting:

Context.Configuration.AutoDetectChangesEnabled = false;

Also kindly let me know what impact (in terms of performance) does it have if both of the actions are performed while fetching the data strictly for read only purposes:

Context.Configuration.AutoDetectChangesEnabled = false;
Context.Set<T>().AsNoTracking();

Answer 1

will it also cause disabling the automatic call to DetectChanges()

No it won't. But you must realize that AsNoTracking and DetectChanges have nothing to do with each other (apart from being part of EF). Objects fetched with AsNoTracking will never be change detected anyway, whether AutoDetectChanges is enabled or not. Besides, AsNoTracking works on a DbSet level, AutoDetectChangesEnabled on the context level. It would be bad to have a DbSet method affect the whole context.

or that [setting AutoDetectChangesEnabled] has to be done explicitly

Well, you probably just shouldn't disable AutoDetectChanges. If you do it you must know what you do.

what impact(in terms of performance) does it have if both of the action is performed

As said, they are not related. They can both improve performance in their own way.

• AsNoTracking is great if you want to fetch read-only data. It has no side effects (as in: its effect is clear)

• Setting AutoDetectChangesEnabled = false stops automatic calls of DetectChanges (which can be numerous), but it has side effects you need to be aware of. From Lerman & Miller's book DbContext:

  Working out when DetectChanges needs to be called isn’t as trivial as it may appear. The Entity Framework team strongly recommends that you only swap to manually calling DetectChanges if you are experiencing performance issues. It’s also recommended to only opt out of automatic DetectChanges for poorly performing sections of code and to reenable it once the section in question has finished executing.