Question

这相当于我尝试使用StructureMap创建的内容：

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

这就是我现在所拥有的：

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>()));

我需要将UserAccount传递给INotificationService ......无法弄明白。

我试过这个： DependencyRegistrar.With（new UserAccount {Username =“test”}）;

没有运气...... UserAccount总是为空。我不需要使用StructureMap来完成所有工作，我对任何建议持开放态度。

这就是我目前的工作方式：

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

Answer 1

您是否尝试过使用AutoWiring？这些都是具有简单结构的具体类，因此StructureMap可以找出你需要的东西。

For<IChangePasswordService>().Use<ChangePasswordService>();

看看你的结构，我认为这个简单的配置可能会起作用。

修改关于评论。

您应该使用With(T instance) method让容器使用给定的userAccount构建您的IChangePasswordService。

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

Answer 2

为什么不将更改密码服务的创建封装到工厂中 - 然后将工厂实现为StructureMap工厂，该工厂使用传入的UserAccount和'ObjectFactory'来根据需要创建IIChangePasswordService的实例？

我在下面演示了它：

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>();
    }
}
}

StructureMap问题

2 个答案: