À l'aide de l'Unité, comment vous inscrire à ce type de mappages pour les génériques?

Je suis en train de mettre en œuvre un solution d'archivage pour Entity Framework mais j'ai du mal à enregistrer les types incluent les génériques à l'aide de l'Unité.

Donné:

    //IRepository interface
    public interface IRepository<TEntity>
    {
        //omitted for brevity
    }

    //Repository implementation
    public class Repository<TEntity, TContext> : IRepository<TEntity>, IDisposable 
            where TEntity : class
            where TContext : DbContext
    {
        //omitted for brevity
    }

    //service layer constructor
    public MyServiceConstructor(IRepository<Account> repository)
    {
        _repository = repository;
    }

J'ai besoin d'enregistrer le type de mappage pour IRepository de Référentiel. mais j'ai de la difficulté avec l'Unité de la syntaxe de ce type de cartographie.

J'ai essayé les suivantes avec pas de chance:

container.RegisterType<IRepository<>, typeof(Repository<,>)>();
container.RegisterType<typeof(IRepository<>), Repository<,>>();

MODIFIER

@Steven réponse que j'ai la suite de la mise en œuvre maintenant:

//UnityRepository implementation   
public class UnityRepository<TEntity> : Repository<TEntity, MyDbContextEntities>
        where TEntity : class
{
    public UnityRepository() : base(new MyDbContextEntities()) { }
}

//Unity bootstrapper
container.RegisterType(typeof(IRepository<>), typeof(UnityRepository<>));

OriginalL'auteur Mark Erasmus | 2013-09-18

16

Vous essayez d'effectuer les opérations suivantes:
```
container.RegisterType(typeof(IRepository<>), typeof(Repository<,>));
```
Il devrait normalement travailler, mais ne pas faire l'affaire dans ce cas, puisqu'il n'est IRepository<TEntity> a un argument générique et Repository<TEntity, TContext> a deux, et l'Unité (évidemment) ne peut pas deviner de quel type il doit remplir pour TContext.

Ce que vous avez besoin est cela:
```
container.RegisterType(
    typeof(IRepository<>),
    typeof(Repository<, MyDbContextEntities>));
```
En d'autres termes, vous voulez fournir le Repository<TEntity, TContext> partiel ouvert de type générique (avec un paramètre rempli). Malheureusement, le compilateur C# ne prend pas en charge cette.

Mais même si le C# n'a l'appui de cette, l'Unité ne prend pas en charge partielle ouvrir les types génériques. En fait, la plupart du Cio bibliothèques eworks ne prennent pas en charge cette. Et pour que une bibliothèque qui prend en charge, vous auriez encore à faire ce qui suit (chose désagréable) pour créer l'partielle ouvert de type générique:
```
Type myDbContextEntitiesRepositoryType =
    typeof(Repository<,>).MakeGenericType(
        typeof(Repository<,>).GetGenericParameters().First(),
        typeof(MyDbContextEntities));
```
Il y a un facile ~~truc~~ contourner pour obtenir que cela fonctionne bien: définir une classe dérivée, avec un type générique:
```
//Special implementation inside your Composition Root
public class UnityRepository<TEntity> : Repository<TEntity, MyDbContextEntities>
        where TEntity : class
{
    public UnityRepository([dependencies]) : base([dependencies]) { }
}
```
Maintenant, nous pouvons facilement s'ouvrir ce type générique:
```
container.RegisterType(typeof(IRepository<>), typeof(UnityRepository<>));
```
Merci! Veuillez voir mon montage ci-dessus. Ne vous recommandons de placer les UnityRepository mise en œuvre dans la composition de la racine/de l'unité de programme d'amorçage, ou dans un fichier de classe dans le Dépôt de la couche? J'ai actuellement dans le second. Et quand vous dites publique UnityRepository([dependencies]) : base([dependencies]) { }, je suppose que vous voulez dire public UnityRepository(TEntity entity) : base(new MyDbContextEntities()) { }. J'ai actuellement le programme d'installation comme public UnityRepository(TEntity entity) : base(new MyDbContextEntities()) { } et ça fonctionne.
Étant donné que cette classe est minuscule et juste un détail de l'implémentation de la Composition de la Racine, j'ai l'habitude de les créer privée classes imbriquées à l'intérieur du programme d'amorçage de la classe.
Depuis le UnityRepository est juste une classe d'assistance, vous souhaitez généralement qu'il ont les même arguments du constructeur que de la classe d'origine. De cette façon, vous pouvez toujours laisser le conteneur de faire le câblage pour vous. Donc j'attendrais la UnityRepository à accepter un MyDbContextEntities, ou dans votre cas, probablement pas d'arguments. En passant dans un TEntity est bizarre, depuis que vous ne devriez pas utiliser votre conteneur à créer des entités.
Parfait, fait sens, merci.
Une solution pour la conception de la configuration? XML?

OriginalL'auteur Steven

Vous devez vous connecter pour publier un commentaire.