Entity Framework - Codice prima - Ignora tutte le proprietà tranne quelle specificate

Question

Sto lavorando con alcune classi di grandi dimensioni che hanno molte proprietà e non voglio dover ignorare tutte le proprietà che non voglio salvare nel Banca dati. Piuttosto, c'è comunque da ignorare tutte le proprietà e specificare solo quelle che voglio?

Così, invece di questo

protected override void OnModelCreating(DbModelBuilder mb) 
{ 
    // code to ignore properties i don't want one at a time, i.e. 
    mb.Entity<Person>().Ignore(i => i.Name); 
    mb.Entity<Person>().Ignore(i => i.Birthday); 
} 

avrei

protected override void OnModelCreating(DbModelBuilder mb) 
{ 
    // code to ignore all properties 
    // code to include only properties I want 
} 

Answer 1

È possibile utilizzare riflessione per chiamare Ignore metodo per tutte le proprietà ad eccezione di quelli di cui avete bisogno. Può essere raggiunto con la creazione di un metodo di estensione in questo modo:

public static class EntityTypeConfigurationExtentions 
{ 
    public static EntityTypeConfiguration<TEntityType> IgnoreAllExcept<TEntityType> 
     (this EntityTypeConfiguration<TEntityType> t, params string[] except) 
     where TEntityType:class 
    { 
     var type = typeof(TEntityType); 
     var properties = type.GetProperties(); 
     var dontIgnore = except ?? new string[0]; 
     //Here you can add more constraints on the class properties 
     var toIgnore = properties.Where(x => !except.Contains(x.Name) && 
              x.SetMethod != null).ToList(); 
     foreach (var name in toIgnore) 
     { 
      var selector = GetIgnoreExpression<TEntityType>(name); 
      MethodInfo genericMethod = GetIgnoreMethod<TEntityType>(name.PropertyType); 
      genericMethod.Invoke(t, new object[] { selector }); 
     } 
     return t; 
    } 
    private static MethodInfo GetIgnoreMethod<TEntityType>(Type propType) 
    { 
     var t = typeof(EntityTypeConfiguration<>); 
     t = t.MakeGenericType(typeof(TEntityType)); 
     MethodInfo method = t.GetMethod("Ignore"); 
     MethodInfo genericMethod = method.MakeGenericMethod(propType); 
     return genericMethod; 
    } 
    //This method creates the 'x=>x.PropertyName' expression for Ignore method 
    private static Expression GetIgnoreExpression<TEntityType>(PropertyInfo prop) 
    { 
     ParameterExpression arg = Expression.Parameter(typeof(TEntityType), "x"); 
     MemberExpression property = Expression.Property(arg, prop.Name); 
     var exp = Expression.Lambda(property, new ParameterExpression[] { arg }); 
     return exp; 
    } 
} 

In primo luogo si estrae tutte le proprietà della classe che ha un setter (se si dispone di più vincoli, è più fornire loro ci) e non appartengono all'elenco delle eccezioni, quindi chiamiamo il metodo Ignore della classe EntityTypeConfiguration<TEntityType> per ogni proprietà, in modo da ignorare tale proprietà.

di richiamare il metodo Ignore, abbiamo bisogno di ottenere il tipo di classe generica, e quindi trovare il metodo della classe Ignore, quindi fornire il tipo generico del metodo Ignore, e, infine, eseguire con l'argomento appropriato.

L'argomento del metodo Ignore viene ottenuto creando un'espressione lambda che seleziona la proprietà desiderata dalla classe TEntityType.

Dopo aver definito questa classe estensione, è possibile chiamare il IgnoreAllExcept in questo modo:

protected override void OnModelCreating(DbModelBuilder modelBuilder) 
{ 
     modelBuilder.Entity<TestClass>().IgnoreAllExcept("Id", "Name"); 
} 

Si può anche migliorare questo metodo, modificando il parametro except alle espressioni che seleziona le proprietà della classe.