Entity Framework - Code First - Ignoriere alle Eigenschaften außer den angegebenen

Question

Ich arbeite mit einigen großen Klassen, die viele Eigenschaften haben, und ich möchte nicht alle Eigenschaften ignorieren müssen, die ich nicht speichern möchte Datenbank. Gibt es denn sowieso alle Eigenschaften zu ignorieren und nur diejenigen zu spezifizieren, die ich möchte?

Statt dieser

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); 
} 

hätte ich

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

Answer 1

Sie Reflexion verwenden können, um Ignore Methode für alle Eigenschaften mit Ausnahme derjenigen zu nennen, die Sie benötigen. Es kann durch die Schaffung eines Erweiterungsmethode wie dies erreicht werden:

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; 
    } 
} 

Zuerst extrahieren wir alle Eigenschaften der Klasse, die einen Setter hat (, wenn Sie weitere Einschränkungen haben, können Sie sie am meisten bieten dort) und nicht gehören zu der Ausnahmeliste, dann rufen wir Ignore Methode der EntityTypeConfiguration<TEntityType> Klasse für jede Eigenschaft, um diese Eigenschaft zu ignorieren.

die Ignore Methode aufzurufen, müssen wir die generische Klasse-Typ, und dann finden die Ignore Methode der Klasse erhalten, geben Sie dann die Gattung des Ignore Methode, und es schließlich durch das entsprechende Argument aufrufen. Das Argument der Ignore-Methode wird durch Erstellen eines Lambda-Ausdrucks erhalten, der die gewünschte Eigenschaft aus der Klasse TEntityType auswählt.

Nach dieser Erweiterung Klasse definieren, können Sie die IgnoreAllExcept wie folgt aufrufen:

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

Sie können auch dieses Verfahren verbessern, indem die except Parameter Ausdrücke zu ändern, die die Eigenschaften der Klasse auswählt.