Configuración global para AsNoTracking()?

Question

principio yo creía que

context.Configuration.AutoDetectChangesEnabled = false; 

hará imposible el seguimiento de cambios. Pero no. Actualmente necesito usar AsNoTracking() en todas mis consultas LINQ (para mi capa de solo lectura). ¿Hay una configuración global para deshabilitar el seguimiento en DbContext?

Answer 1

Dado que esta pregunta no está etiquetada con una versión EF específica, quería mencionar que en EF Core el comportamiento puede ser configured at the context level.

También puede cambiar el comportamiento predeterminado de seguimiento a nivel instancia de contexto:

using (var context = new BloggingContext()) 
{ 
    context.ChangeTracker.QueryTrackingBehavior = QueryTrackingBehavior.NoTracking; 

    var blogs = context.Blogs.ToList(); 
} 

Answer 2

¿Qué pasa con la simple exposición método como este en su contexto derivados y utilizarla para consultas:

public IQueryable<T> GetQuery<T>() where T : class { 
    return this.Set<T>().AsNoTracking(); 
} 

Configuración AsNoTracking a nivel mundial no es posible. Debe configurarlo para cada consulta o por cada ObjectSet (no DbSet). El último enfoque requiere el uso de ObjectContext API.

var objectContext = ((IObjectContextAdapter)dbContext).ObjectContext; 
var set = objectContext.CreateObjectSet<T>(); 
set.MergeOption = MergeOption.NoTracking; 
// And use set for queries 

Answer 3

Se podría hacer algo como esto en su DbContext:

public void ObjectContext_OnObjectMaterialized(Object objSender, ObjectMaterializedEventArgs e) 
{ 
    Entry(e.Entity).State = EntityState.Detached; 
} 

Cada vez que un objeto se materializa por su contexto, será separada y ya no siguió.

Answer 4

Actualización: Esto realmente no funcionó. ¡Ver comentarios!

Odio cuando busco en StackOverflow y la respuesta es: "¡No se puede!" o "Podrías, pero solo si cambias por completo cada llamada que hayas hecho".

Reflexión anyone? Esperaba que fuera una configuración de DbContext. Pero como no lo es, hice uno usando la reflexión.

Este pequeño y útil método configurará AsNoTracking en todas las propiedades del tipo DbSet.

private void GloballySetAsNoTracking() 
    { 
     var dbSetProperties = GetType().GetProperties(); 
     foreach (PropertyInfo pi in dbSetProperties) 
     { 
      var obj = pi.GetValue(this, null); 
      if (obj.GetType().IsGenericType && obj.GetType().GetGenericTypeDefinition() == typeof(DbSet<>)) 
      { 
       var mi = obj.GetType().GetMethod("AsNoTracking"); 
       mi.Invoke(obj, null); 
      } 
     } 
    } 

Agréguela a un constructor de DbContext sobrecargado.

public ActivationDbContext(bool proxyCreationEnabled, bool lazyLoadingEnabled = true, bool asNoTracking = true) 
    { 
     Configuration.ProxyCreationEnabled = proxyCreationEnabled; 
     Configuration.LazyLoadingEnabled = lazyLoadingEnabled; 
     if (asNoTracking) 
      GloballySetAsNoTracking(); 
    } 

Utiliza la reflexión, lo que significa que alguien comentará rápidamente que se trata de un golpe de rendimiento. Pero, ¿realmente es un gran éxito? Depende de tu caso de uso.

Answer 5

En mi caso ya que necesitaba todo el contexto a ser de sólo lectura en lugar de lectura/escritura.

Así que hice un cambio en el archivo tt, y cambié todas las propiedades DbContext para devolver DbQuery en lugar de DbSet, eliminé los conjuntos de todas las propiedades y, para los get, devolví el Modelo.AsNoTracking()

Por ejemplo:

public virtual DbQuery<Campaign> Campaigns { get{ return Set<Campaign>().AsNoTracking();} }

La forma en que hice esto en la plantilla tt es:

public string DbQuery(EntitySet entitySet) 
 
    { 
 
     return string.Format(
 
      CultureInfo.InvariantCulture, 
 
      "{0} virtual DbQuery<{1}> {2} {{ get{{ return Set<{1}>().AsNoTracking();}} }}", 
 
      Accessibility.ForReadOnlyProperty(entitySet), 
 
      _typeMapper.GetTypeName(entitySet.ElementType), 
 
      _code.Escape(entitySet)); 
 
    }