Comment injecter un paramètre « enregistrer tapé » dans un constructeur

Question

Dans ma quête pour savoir l'unité, je veux enregistrer un type qui, comme un « type enregistré » comme paramètre du constructeur.

Dans mon fichier Bootstrapper.cs J'ai cette configuration:

container.RegisterType<IRepository<User>, UserRepository>(); 
container.RegisterType<BaseService<User>, UserService>(); // <-- Should I inject the parameter here ? 
container.RegisterType<IFactory<BaseService<User>>, Factory<UserService>>(); // <-- or here 

Maintenant, c'est la mise en œuvre de la classe BaseService:

public abstract class BaseService<TModel> 
{ 
    private readonly IRepository<TModel> _repository; 

    // Injected parameter in constructor 
    public BaseService(IRepository<TModel> repository) 
    { 
     _repository = repository; 
    } 
} 

Ma question est de savoir comment injecter dans le constructeur BaseService la paramètre résolu par cette ligne: container.RegisterType, UserRepository>(); ?

J'ai vérifié que j'utiliser le InjectedParameter, mais je ne sais pas comment utiliser correctement dans ce cas.

Merci,

EDIT

ici est l'autre mise en œuvre:

UserService:

public class UserService : BaseService<User> 
{ 
    public UserService(IRepository<User> repository) : base(repository) 
    { 
    } 
} 

usine:

public class Factory<T> : IFactory<T> where T : new() 
{ 
    public T Create() 
    { 
     return new T(); 
    } 
} 

Answer 1

Quel est le problème avec votre code? De mon point de vue, cela devrait fonctionner sans modifications. Si vous laissez Unity créer un objet BaseService<User>, il crée une instance UserService. Je pensais que la définition est:

public class UserService : BaseService<User> 
{ 
    ... 
} 

Parce que vous avez déjà enregistré IRepository<User>, il devrait y avoir aucun problème à résoudre/injecter une instance de UserRepository. Le problème est la contrainte new() dans la classe Factory<T>. Unity (et StructureMap, aussi) sont capables d'utiliser un Func<> pour résoudre les dépendances enregistrées. Ainsi, vous pouvez changer votre Factory<T> classe:

public class Factory<T> : IFactory<T> 
{ 
    private readonly Func<T> _creator; 

    public Factory(Func<T> creator) 
    { 
    if(creator == null) 
     throw new ArgumentNullException("creator"); 

    _creator = creator; 
    } 

    public T Create() 
    { 
    return _creator(); 
    } 
} 

enregistrer cette usine générique une fois:

container.RegisterType(typeof(IFactory<>), typeof(Factory<>));