这是抽象工厂模式的正确或可行的实现吗?

灵感来自Mark Seemann的文章：模式识别：抽象工厂还是服务定位器？

我希望像这样写一个抽象工厂：

public interface IAbstractFactory { 
    T Create<T>();
}

然后，使用 Ninject 绑定它，如下所示：

IKernel kernel = new StandardKernel();
kernel.Bind<IAbstractFactory>().ToFactory();

然后，可以按如下方式使用它：

public class CustomerServiceIndicatorsModel {
    public CustomerServiceIndicatorsModel(IAbstractFactory factory) {
        this.emailIndicatorA = factory.Create<EmailIndicatorA>();
        this.emailIndicatorB = factory.Create<EmailIndicatorB>();
        this.emailIndicatorC = factory.Create<EmailIndicatorC>();
    }
}

同样，我没有在任何地方引用 Ninject 的内核，这很有效。内核仅在绑定的Global.asax.cs文件中引用。

是否可以将其视为抽象工厂模式的可接受实现？

我很难理解这种模式。我清楚地将Factory模式理解为创建给定类型实例的委托类。

public interface IEmailIndicatorAFactory {
    EmailIndicatorA Create();
}

然后，当我使用 Ninject ToFactory()绑定它时，它将创建EmailIndicatorA实例。

如何使用 Ninject 绑定IAbstractFactory<T>，因为每种类型：

IAbstractFactory<EmailIndicatorA>
IAbstractFactory<EmailIndicatorB>
IAbstractFactory<EmailIndicatorC>

被认为是完全具体的类型。而且我找不到使用 Ninject 绑定它的方法.

而且我认为编写这样的接口没有任何好处，如果作为回报，我必须编写：

public interface EmailIndicatorAFactory : IAbstractFactory<EmailIndicatorA> { }
public interface EmailIndicatorBFactory : IAbstractFactory<EmailIndicatorB> { }
public interface EmailIndicatorCFactory : IAbstractFactory<EmailIndicatorC> { }

在 @PrestonGuillot 发表评论后，我落入了后者实现 ServiceLocator 而不是 AbstractFactory，因为我使用的是通用Create<T>()方法，而Abstract Factory使用非泛型Create()方法。

感谢您指出，@PrestonGuillot！ =(

也许我在这里把事情复杂化了...这是我的模型：

电子邮件指示器

public abstract EmailIndicator { 
    int EmailCount { get; set; }
    DateTime OldestDateTimeReceived { get; set; }
}

电子邮件指示器A

public class EmailIndicatorA : EmailIndicator { }

电子邮件指示器B

public class EmailIndicatorB : EmailIndicator { }

电子邮件指示器C

public class EmailIndicatorC : EmailIndicator { }

IEmailIndicatorRepository

public interface IEmailIndicatorRepository<T> where T : EmailIndicator {
    T GetIndicator();
}
public class EmailIndicatorARepository : IEmailIndicatorRepository<EmailIndicatorA> {
    public EmailIndicatorARepository(IExchangeService service
        , IExchangeConfiguration configuration
        , INetworkCredentialFactory credentialFactory) {
        exchangeService = service;
        exchangeService.Url = configuration.ExchangeUri;
        exchangeService = credentialFactory.Create(configuration.Login, configuration.Password);       
    }
    EmailIndicatorA GetIndicator() {
        // Code to query Exchange through its Web services here...
    }
}

还有另外两个类似的存储库，因为我必须在我的应用程序中查询三个不同的 Exchange 服务器。

我相信有使用Abstract Factory的空间，而且因为我仍在学习模式，所以我还不知道如何在我的情况下实现它。

如果不是因为指标本身，也许我终于可以通过我的回购掌握Abstract Factory。

就我的理解而言，以下是我将尝试作为解决方案的第一步：

工业工厂

public interface IRepositoryFactory<T> where T : class, new() {
    T Create();
}

IEmailIndicatorARepositoryFactory

public interface IEmailIndicatorARepositoryFactory 
    : IRepositoryFactory<EmailIndicatorARepository> {
    EmailIndicatorARepository CreateEmailIndicatorARepository();
}

IEmailIndicatorB实体工厂

public interface IEmailIndicatorBRepositoryFactory 
    : IRepositoryFactory<EmailIndicatorBRepository> {
    EmailIndicatorBRepository CreateEmailIndicatorBRepository();
}

抽象工厂呢？

public abstract IEmailIndicatorRepositoryFactory 
    : IEmailIndicatorARepositoryFactory
    , IEmailIndicatorBRepositoryFactory
    , IEmailIndicatorCRepositoryFactory {
    EmailIndicatorARepository CreateEmailIndicatorARepository() { // create instance here... }
    EmailIndicatorBRepository CreateEmailIndicatorBRepository() { // create instance here... }
    EmailIndicatorCRepository CreateEmailIndicatorCRepository() { // create instance here... }
}

这是更好的方法吗？

我在这里有点迷茫和困惑。

public interface IEmailIndicatorFactory
{
    IEmailIndicator Create();
}

internal class EmailIndicatorA : IEmailIndicator
{
    private readonly IServiceA serviceA;
    public EmailIndicatorA(IServiceA serviceA)
    {
        this.serviceA = serviceA;
    }
    (...)
}

internal class EmailIndicatorAFactory : IEmailIndicatorFactory
{
    private readonly IServiceA serviceA;
    public EmailIndicatorAFactory(IServiceA serviceA)
    {
        this.serviceA = serviceA;
    }
    public IEmailIndicator Create()
    {
        return new EmailIndicatorA(this.serviceA);
    }
}