通用基类具体实现的c#工厂

Question

我有一个通用的基类。我有一个实现基类的具体类。

我将如何创建工厂类/方法来交付不同类型的具体类？

举个例子:

public class ReceiverBase<T>
    where T : IInterpreter
{ ... }

public class SpecialReceiver : ReceiverBase<OwnInterpreter> { ... }

public class ReceiverFactory<T>
    where T : ReceiverBase<IInterpreter>, new()

    public T Create(string type) {
        switch(type) {
            default:
                return new SpecialReceiver();
        }
    }
}

问题是 ReceiverBase 似乎是不可能的，因为编译器只希望类作为约束，而不是接口(interface)。第二个问题是我无法将 SpecialReceiver 转换为 T。

那么有什么方法可以让它发挥作用吗？

=== 编辑:根据第一个答案添加示例 ===

public interface IInterpreter
{
}

public class OwnInterpreter : IInterpreter
{
    public void Dispose()
    {
        throw new NotImplementedException();
    }

    public void DoSomething() { }
}



public abstract class ReceiverBase<T>
    where T : IInterpreter
{
    public T MyReceiver { get; set; }

    internal abstract void Start();
}

public class SpecialReceiver<T> : ReceiverBase<T>
    where T : IInterpreter, new()
{
    public void CheckSomething()
    {
        MyReceiver.DoSomething();
    }

    internal override void Start()
    {
        MyReceiver = new T();
    }
}

public class ReceiverFactory<T>
    where T : IInterpreter, new()
{
    public static ReceiverBase<T> Create(string type)
    {
        switch (type)
        {
            default:
                return new SpecialReceiver<T>();
        }
    }
}

问题是:MyReceiver.DoSomething();不管用。此外，我必须像这样给工厂打电话:ReceiverFactory<OwnInterpreter>.Create("");我想这样:ReceiverFactory.Create("SpecialReceiver");

Answer 1

你可以在你的工厂中使用泛型方法:

class Program
{
    static void Main(string[] args)
    {
        var own = ReceiverFactory.Create<OwnInterpreter>();
        var other = ReceiverFactory.Create<OtherInterpreter>();
        own.Start();
        other.Start();
        Console.ReadLine();
    }
}
interface IInterpreter
{
    void DoSomething();
}

class OwnInterpreter : IInterpreter
{
    public void DoSomething() { Console.WriteLine("Own"); }
}

class OtherInterpreter : IInterpreter
{
    public void DoSomething() { Console.WriteLine("Other"); }
}

abstract class ReceiverBase<T> where T: IInterpreter, new()
{
    public T Interpreter { get; set; }
    public ReceiverBase()
    {
        Interpreter = new T();  
    }
    public void Start()
    {
        Interpreter.DoSomething();
    }
}

class SpecialReceiver : ReceiverBase<OwnInterpreter> { }
class OtherReceiver : ReceiverBase<OtherInterpreter> { }

static class ReceiverFactory
{
    private static Dictionary<string, object> factories = new Dictionary<string, object>();
    static ReceiverFactory()
    {
        RegisterFactory(() => new SpecialReceiver());
        RegisterFactory(() => new OtherReceiver());
    }
    public static void RegisterFactory<T>(Func<ReceiverBase<T>> factory) where T : IInterpreter, new()
    {
        factories.Add(typeof(T).FullName, factory);
    }
    public static ReceiverBase<T> Create<T>() where T : IInterpreter, new()
    {
        var type = typeof(T);
        return ((Func<ReceiverBase<T>>)factories[type.FullName]).Invoke();
    }
}

事实上，你在这里不需要“new()”约束，因为你使用了工厂。