Comment éviter de passer une référence au conteneur ou d'utiliser CommonServiceLocator pour une entité EntityFactory

Question

Ma classe d'entité a une dépendance sur un référentiel.

public class User 
{ 
    private readonly IUserRepository _userRepository; 

    public User(IUserRepository userRepository) 
    { 
     _userRepository = userRepository; 
    } 

    ... 
} 

Et j'ai une classe EntityFactory utilisée par le Repository pour créer des entités.

public class UserRepository : IUserRepository 
{ 
    private readonly EntityFactory _entityFactory; 

    public UserRepository(EntityFactory entityFactory) 
    { 
     _entityFactory = entityFactory; 
    } 

    ... 
} 

// EntityFactory #1 with no references or dependencies to DI frameworks or CommonServiceLocator 
public class EntityFactory 
{ 
    public User InstantiateUser() 
    { 
     return new User(); // Requires IUserRepository parameter 
    } 
} 

// EntityFactory #2 with reference to Ninject 
using Ninject; 

public class EntityFactory 
{ 
    private readonly IKernel _kernel; 

    public EntityFactory(IKernel kernel) 
    { 
     _kernel = kernel; 
    } 

    public User InstantiateUser(IKernel kernel) 
    { 
     return new User(_kernel.Get<IUserRepository>()); 
    } 
} 

// EntityFactory #3 with reference to CommonServiceLocator 
using Microsoft.Practices.ServiceLocation; 

public class EntityFactory 
{ 
    public User InstantiateUser() 
    { 
     return new User(ServiceLocator.Current.GetInstance<IUserRepository>()); 
    } 
} 

Y at-il un moyen d'éviter la EntityFactory ayant une référence au conteneur ou à l'aide du CommonServiceLocator? (Context Agnostic)

Ou suis-je juste en train de concevoir mes classes incorrectes et la classe User ne devrait pas dépendre de n'importe quel dépôt?

Edit: Voici le code en utilisant la méthode de David:

// Ninject binding 
Bind<Func<User>>().ToMethod(cxt =>() => new User(cxt.Kernel.Get<IUserRepository>())); 

// EntityFactory class 
private readonly Func<User> _userFactory; 
public EntityFactory(Func<User> userFactory) 
{ 
    _userFactory = userFactory; 
} 
public User InstantiateUser() 
{ 
    return userFactory.Invoke(); 
} 

Answer 1

Votre cadre de DI devrait vous fournir une méthode de création d'usines:

public class EntityFactory 
{ 
    public EntityFactory(Func<User> userFactory) { /* ... */ } 

    public User InstantiateUser() 
    { 
     return userFactory.Invoke(); 
    } 
} 

Lorsque le EntityFactory est créé, il va recevoir une User bonne usine qui peut ensuite être utilisé pour créer des utilisateurs correctement résolus sans aucune référence à l'IoC.

Answer 2

Quel est le problème avec l'option 2 ou 3? Si vous utilisez IoC ou un localisateur de service, vous aurez besoin d'une référence quelque part.

J'ai une référence globale au conteneur IoC et l'utilise pour résoudre les interfaces partout. Cela ressemble beaucoup au localisateur de service, mais utilise plutôt le conteneur IoC.

Je ne crois pas qu'il existe un moyen de contourner cela.