StructureMap Question

Question

Ceci est l'équivalent de ce que je suis en train de créer avec StructureMap:

new ChangePasswordWithNotificationAndLoggingService(
new ChangePasswordService(
     new ActiveDirectoryRepository(new ActiveDirectoryCredentials()), 
     new TokenRepository("")), 
new EmailNotificationService(new PasswordChangedNotification(new UserAccount())), 
new LoggingService()); 

C'est ce que j'ai en ce moment:

ForRequestedType<IChangePasswordService>() 
    .TheDefault.Is.ConstructedBy(() => 
    new ChangePasswordService(DependencyRegistrar.Resolve<IActiveDirectoryRepository>(), 
           DependencyRegistrar.Resolve<ITokenRepository>())) 
    .EnrichWith<IChangePasswordService>(x => 
    new ChangePasswordWithNotificationAndLoggingService(x, 
        DependencyRegistrar.Resolve<INotificationService>(), 
        DependencyRegistrar.Resolve<ILoggingService>())); 

J'ai besoin de passer l'UserAccount à l'INotificationService ... ne peut pas le comprendre.

J'ai essayé ceci: DependencyRegistrar.With (nouveau UserAccount {Nom d'utilisateur = "test"});

Pas de chance ... UserAccount s'avère toujours nul. Je n'ai pas à tout faire avec StructureMap, je suis ouvert à toutes les suggestions.

C'est ce que je travaille actuellement:

public static IChangePasswordService ChangePasswordService(UserAccount userAccount) 
{ 
    return new ChangePasswordWithNotificationService(
     new ChangePasswordService(ActiveDirectoryRepository(), TokenRepository()), 
     new EmailNotificationService(new PasswordChangedNotification(userAccount))); 
} 

Answer 1

Avez-vous essayé juste en utilisant AutoWiring? Ce sont toutes des classes concrètes avec une construction simple afin que StructureMap puisse comprendre ce dont vous avez besoin. En regardant votre construction, je pense que cette configuration simple pourrait bien fonctionner.

Modifier En ce qui concerne les commentaires.

Vous devez utiliser With(T instance) method pour que le conteneur construise votre IChangePasswordService à l'aide de l'userAccount donné.

var userAccount = new UserAccount("derans"); 
var changePasswordService = container.With(userAccount).GetInstance<IChangePasswordService>(); 

Answer 2

Pourquoi ne pas encapsulent la création du changement de service de mot de passe dans une usine - l'usine est alors une mise en œuvre en usine StructureMap qui utilisent un UserAccount passé et le « ObjectFactory » pour créer des instances du IIChangePasswordService au besoin?

Je demo'ed ci-dessous:

namespace SMTest 
{ 
class Program 
{ 
    static void Main(string[] args) 
    { 
     // bootstrapper... 
     ObjectFactory.Configure(x => x.AddRegistry(new TestRegistry())); 

     // create factory for use later (IoC manages this)... 
     var changePasswordServiceFactory = ObjectFactory.GetInstance<IChangePasswordServiceFactory>(); 

     var daveAccount = new UserAccount("Dave Cox"); 
     var steveAccount = new UserAccount("Steve Jones"); 

     var passwordService1 = changePasswordServiceFactory.CreateForUserAccount(daveAccount); 
     var passwordService2 = changePasswordServiceFactory.CreateForUserAccount(steveAccount); 


    } 
} 

public class TestRegistry : Registry 
{ 
    public TestRegistry() 
    { 
     Scan(x => 
       { 
        x.TheCallingAssembly(); 
        x.AssemblyContainingType(typeof(IChangePasswordService)); 
        x.AssemblyContainingType(typeof(IActiveDirectoryRepository)); 
        x.AssemblyContainingType(typeof(IActiveDirectoryCredentials)); 
        x.AssemblyContainingType(typeof(ITokenRepository)); 
        x.AssemblyContainingType(typeof(INotification)); 
        x.AssemblyContainingType(typeof(INotificationService)); 
        x.AssemblyContainingType(typeof(ILoggingService)); 

        ForRequestedType<ILoggingService>().TheDefault.Is.OfConcreteType<MyLogger>(); 

        ForRequestedType<IActiveDirectoryRepository>().TheDefault.Is.OfConcreteType<MyAdRepository>(); 
        ForRequestedType<IActiveDirectoryCredentials>().TheDefault.Is.OfConcreteType<MyAdCredentials>(); 

        ForRequestedType<ITokenRepository>().TheDefault.Is.OfConcreteType<MyTokenRepository>(); 

        ForRequestedType<IChangePasswordService>().TheDefault.Is.OfConcreteType<ChangePasswordService>(); 
        ForRequestedType<IChangePasswordServiceFactory>().CacheBy(InstanceScope.Singleton).TheDefault.Is.OfConcreteType<StructureMapChangePasswordServiceFactory>(); 

        ForRequestedType<INotification>().TheDefault.Is.OfConcreteType<MyPasswordChangedNotification>(); 
        ForRequestedType<INotificationService>().TheDefault.Is.OfConcreteType<MyEmailNotificationService>(); 
       }); 
    } 
} 

public interface ILoggingService 
{ 
} 

public class MyLogger : ILoggingService 
{ 
} 

public class UserAccount 
{ 
    public string Name { get; private set; } 

    public UserAccount(string name) 
    { 
     Name = name; 
    } 
} 

public interface INotification 
{ 
} 

public class MyPasswordChangedNotification : INotification 
{ 
    private readonly UserAccount _account; 
    private readonly ILoggingService _logger; 

    public MyPasswordChangedNotification(UserAccount account, ILoggingService logger) 
    { 
     _account = account; 
     _logger = logger; 
    } 
} 

public interface INotificationService 
{ 
} 

public class MyEmailNotificationService : INotificationService 
{ 
    private readonly INotification _notification; 
    private readonly ILoggingService _logger; 

    public MyEmailNotificationService(INotification notification, ILoggingService logger) 
    { 
     _notification = notification; 
     _logger = logger; 
    } 
} 

public interface ITokenRepository 
{ 
} 

public class MyTokenRepository : ITokenRepository 
{ 
} 

public interface IActiveDirectoryRepository 
{ 
} 

public interface IActiveDirectoryCredentials 
{ 
} 

public class MyAdCredentials : IActiveDirectoryCredentials 
{ 
} 

public class MyAdRepository : IActiveDirectoryRepository 
{ 
    private readonly IActiveDirectoryCredentials _credentials; 

    public MyAdRepository(IActiveDirectoryCredentials credentials) 
    { 
     _credentials = credentials; 
    } 
} 

public interface IChangePasswordService 
{ 
} 

public class ChangePasswordService : IChangePasswordService 
{ 
    private readonly IActiveDirectoryRepository _adRepository; 
    private readonly ITokenRepository _tokenRepository; 
    private readonly INotificationService _notificationService; 

    public ChangePasswordService(IActiveDirectoryRepository adRepository, ITokenRepository tokenRepository, INotificationService notificationService) 
    { 
     _adRepository = adRepository; 
     _tokenRepository = tokenRepository; 
     _notificationService = notificationService; 
    } 
} 

public interface IChangePasswordServiceFactory 
{ 
    IChangePasswordService CreateForUserAccount(UserAccount account); 
} 

public class StructureMapChangePasswordServiceFactory : IChangePasswordServiceFactory 
{ 
    public IChangePasswordService CreateForUserAccount(UserAccount account) 
    { 
     return ObjectFactory.With(account).GetInstance < IChangePasswordService>(); 
    } 
} 
}