Question

我有Factory Pattern的实现

public interface IFactory<T>
{
    T GetObject();
}

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

但我希望比GetObject返回泛型类Repository<Customer>（Repository implement IRepository）的实例，并且工厂有一个参数（ISession类型）

结果应为：

IRepository<ICustomer> myRepo = new Factory<ICustomer>(session);

我该怎么做？

谢谢，

Answer 1

考虑使用无参数构造函数，以及一些采用参数的初始化函数。除了无法通过工厂传递参数之外，请考虑您希望反序列化对象的情况。应该构建它们，然后在此之后逐个填充参数。

Answer 2

它必须如此通用吗？为什么不喜欢这个？

public interface IFactory<T>
{
    IRepository<T> Create(ISession session);
}

public class RepositoryFactory<T> : IFactory<T> where T : new()
{
    public IRepository<T> Create(ISession session)
    {
        return new IRepository<T>();
    }
}

Answer 3

我不确定你是否真的需要那种级别的泛型，但你可以使用通用的流利工厂方法，而不是来自构造函数的初始化函数。

  var CustomerGeneric = GenericFluentFactory<Customer, WebSession>
                        .Init(new Customer(), new WebSession())
                        .Create();


public static class GenericFluentFactory<T, U>
{
    public static IGenericFactory<T, U> Init(T entity, U session)
    {
        return new GenericFactory<T, U>(entity, session);
    }        
}

public class GenericFactory<T, U> : IGenericFactory<T, U>
{
    T entity;
    U session;

    public GenericFactory(T entity, U session)
    {
        this.entity = entity;
        this.session = session;
    }

    public T Create()
    {
        return this.entity;
    }
}

工厂模式，返回一个泛型类并有一个参数

3 个答案: