Comment généraliser l'accès à l'DbSet<TEntity> les membres d'une DbContext?

La généralisation est possible en utilisant

var dbSet = _dbContext.Set<T>

et de mettre la plupart de votre méthode dans une méthode avec un des génériques du type de paramètre.

Cependant, il devrait y avoir un interrupteur quelque part à décider quel type doit être spécifié, et le type à créer, parce que je pense que le type est fourni comme une propriété du modèle (est-il?). Donc, il ne sera probablement pas vraiment look élégant, mais probablement beaucoup plus courtes, avec SÈCHE-er code.

OriginalL'auteur Gert Arnold

J'ai été à la recherche d'une réponse à cette question et j'ai trouvé que c'est facile à faire en utilisant le Managed Extensibility Framework. Il y a un moyen plus rapide au bas de ce post, cependant MEF permet pour une approche évolutive.

MEF permet de construire des dynamiques d'accès plugins à partir de différents Assemblages; toutefois, il peut être utilisé pour remplir Collections au sein d'une assemblée unique de l'application.En essence, nous allons l'utiliser comme un moyen sûr de la réflexion de notre assemblée de retour dans la classe. Afin de faire de ce bien fonctionnel, je vais également mettre en œuvre la Stratégie de Modèle pour le Modèle d'Entity Framework.

Ajouter une référence à votre projet, pointant vers System.ComponentModel.Composition. Cela vous donnera accès à la MEF de la bibliothèque.

Maintenant, nous avons besoin de mettre en œuvre le Modèle de Stratégie. Si vous n'avez pas un dossier Interfaces, créer une, et ajouter IEntity.cs, comme ci-dessous.

IEntity.cs

namespace Your.Project.Interfaces
{
    ///<summary>
    ///    Represents an entity used with Entity Framework Code First.
    ///</summary>
    public interface IEntity
    {
        ///<summary>
        ///    Gets or sets the identifier.
        ///</summary>
        ///<value>  
        ///    The identifier.
        ///</value>
        int Id { get; set; }
    }
}

Maintenant, chacun de vous des entités concrètes doivent implémenter cette Interface:

public class MyEntity : IEntity
{
    #region Implementation of IEntity

    ///<summary>
    ///    Gets or sets the identifier.
    ///</summary>
    ///<value>
    ///    The identifier.
    ///</value>
    public int Id { get; set; }

    #endregion

    //Other POCO properties...
}

Je trouve qu'il est de bonne pratique, de ne pas créer des interfaces individuelles pour chaque entité, sauf si vous travaillez dans une grande environnement de test. De façon pragmatique, l'interface doit être utilisé uniquement lorsque le niveau d'abstraction est nécessaire; surtout lorsque plus d'un béton de classe héritera, ou lorsque vous travaillez avec un enthousiaste Inversion de Contrôle moteur. Si vous avez des interfaces pour tout dans votre modèle de production, votre architecture plus que probablement, a de nombreux défauts. Bref, assez de la randonnée.

Maintenant que nous avons toutes nos entités "réfléchi et faire l'objet", nous pouvons utiliser la MEF pour les recueillir et de les peupler une collection au sein de votre contexte.

Au sein de votre contexte, ajoutez une nouvelle propriété:

///<summary>
///    Gets a dynamically populated list of DbSets within the context.
///</summary>
///<value>
///    A dynamically populated list of DbSets within the context.
///</value>
[ImportMany(typeof(DbSet<IEntity>))]
public IEnumerable<DbSet<IEntity>> Sets { get; private set; }

La [ImportMany(typeof(DbSet<IEntity>))] ici, permet MEF pour remplir la collection.

Ensuite, ajoutez le correspondant Export attribut à chaque DbSet dans le contexte:

[Export(typeof(DbSet<IEntity>))]
public DbSet<MyEntity> MyEntities { get; set; }

Chacun des Imported et Exported propriétés est connu comme une "partie". La dernière pièce du puzzle est de composer les parties. Ajoutez les lignes suivantes à votre contexte constructeur:

//Instantiate the Sets list.
Sets = new List<DbSet<IEntity>>();

//Create a new Types catalogue, to hold the exported parts.
var catalogue = new TypeCatalog(typeof (DbSet<IEntity>));

//Create a new Composition Container, to match all the importable and imported parts.
var container = new CompositionContainer(catalogue);

//Compose the exported and imported parts for this class.
container.ComposeParts(this); 

Maintenant, avec un peu de chance, vous devriez avoir un rempli dynamiquement la liste des DbSets, à l'intérieur de votre cadre.

J'ai utilisé cette méthode pour faciliter la troncature de toutes les tables via une méthode d'extension.

///<summary>
///    Provides extension methods for DbSet objects.
///</summary>
public static class DbSetEx
{
    ///<summary>
    ///    Truncates the specified set.
    ///</summary>
    ///<typeparam name="TEntity">The type of the entity.</typeparam>
    ///<param name="set">The set.</param>
    ///<returns>The truncated set.</returns>
    public static DbSet<TEntity> Truncate<TEntity>(this DbSet<TEntity> set)
        where TEntity : class, IEntity
    {
        set.ToList().ForEach(p => set.Remove(p));
        return set;
    }
}

J'ai ajouté une méthode pour le contexte de tronquer l'ensemble de la base de données.

///<summary>
///    Truncates the database.
///</summary>
public void TruncateDatabase()
{
    Sets.ToList().ForEach(s => s.Truncate());
    SaveChanges();
}

ÉDITION (Révision):

La solution ci-dessus a été amortis. Certains tweeking que devait être fait pour obtenir que cela fonctionne maintenant. Pour faire ce travail, vous devez importer le DbSets en une temporaire de la collection de DbSet de type "objet", puis lancer cette collection de DbSet de votre type d'interface. De base, le IEntity interface suffira.

    #region Dynamic Table List

    ///<summary>
    ///    Gets a dynamically populated list of DbSets within the context.
    ///</summary>
    ///<value>
    ///    A dynamically populated list of DbSets within the context.
    ///</value>
    public List<DbSet<IEntity>> Tables { get; private set; }

    ///<summary>
    ///    Gets a dynamically populated list of DbSets within the context.
    ///</summary>
    ///<value>
    ///    A dynamically populated list of DbSets within the context.
    ///</value>
    [ImportMany("Sets", typeof (DbSet<object>), AllowRecomposition = true)]
    private List<object> TableObjects { get; set; }

    ///<summary>
    ///    Composes the sets list.
    ///</summary>
    ///<remarks>
    ///    To make this work, you need to import the DbSets into a temporary collection of
    ///    DbSet of type "object", then cast this collection to DbSet of your required
    ///    interface type. For basic purposes, the IEntity interface will suffice.
    ///</remarks>
    private void ComposeSetsList()
    {
        //Instantiate the list of tables.
        Tables = new List<DbSet<IEntity>>();

        //Instantiate the MEF Import collection.
        TableObjects = new List<object>();

        //Create a new Types catalogue, to hold the exported parts.
        var catalogue = new TypeCatalog(typeof (DbSet<object>));

        //Create a new Composition Container, to match all the importable and imported parts.
        var container = new CompositionContainer(catalogue);

        //Compose the exported and imported parts for this class.
        container.ComposeParts(this);

        //Safe cast each DbSet<object> to the public list as DbSet<IEntity>.
        TableObjects.ForEach(p => Tables.Add(p as DbSet<IEntity>));
    }

    #endregion

Ensuite, exécutez le CompileSetsList() façade du constructeur (avec les meilleures pratiques pour le Web):

    public MvcApplicationContext()
    {
        //Enable verification of transactions for ExecuteSQL functions.
        Configuration.EnsureTransactionsForFunctionsAndCommands = true;

        //Disable lazy loading.
        Configuration.LazyLoadingEnabled = false;

        //Enable tracing of SQL queries.
        Database.Log = msg => Trace.WriteLine(msg);

        //Use MEF to compile a list of all sets within the context.
        ComposeSetsList();
    }

Ensuite, il suffit de décorer votre DbSet<>s comme ceci:

    ///<summary>
    ///Gets or sets the job levels.
    ///</summary>
    ///<value>
    ///The job levels.
    ///</value>
    [Export("Sets", typeof(DbSet<object>))]
    public DbSet<JobLevel> JobLevels { get; set; }

Maintenant il ne fonctionne plus correctement.

OriginalL'auteur Apache