取实现接口的类

Question

我有一个包含一些共享属性的抽象基模型类。 最重要的是，我有许多次要接口，它们定义了模型可用于哪些进程。

下面是基类、接口和派生类的示例：

public abstract class ModelBase
{
    public ModelBase(string name) 
    {
        Name = name;
    }

    public int Id { get; private set; }

    public int Name { get; private set; }
}


public interface ISupportProcessA
{
    public decimal Amount { get; }
}


public class ModelDerived : ModelBase
{
    public ModelDerived(string name) : base(name) { }

    public decimal Amount { get; private set; }
}

为了使用基本模型执行一些工作，我还有一个抽象的基本处理器类，具有一些共享功能和一些派生处理器类，每个进程一个。 它可能看起来像这样：

public abstract class ProcessorBase
{
    private readonly ModelBase model;

    public ProcessorBase(ModelBase model)
    {
        this.model = model;
    }

    // ...some shared methods
 }


 public class ProcessorA : ProcessorBase 
 {
     private readonly ISupportProcessA model;

     public ProcessorA(ISupportProcessA model) : base(model)
     {
         this.model = model;
     }

     // ...some specific methods
 }

现在问题就在这里。 因为ISupportProcessA （编译器的知识）与ModelBase无关，因此不能作为base()输入。 那讲得通。

因此，我试图做的是创建一个接口IModelBase我用，而不是ModelBase 。 但是，一旦我连接到 Entity Framework，这会带来一些问题，它不适用于接口（或者可能只是我？）。

所以这是我的问题：

无论如何要请求一个既从ModelBase派生又实现ISupportProcessA ？

Answer 1

您可以通过泛型获得一些方法：

public class ProcessorA<TModel> : ProcessorBase where TModel : ModelBase, ISupportProcessA
{
    private readonly ISupportProcessA model;

    public ProcessorA(TModel model) : base(model)
    {
        this.model = model;
    }

    // ...some specific methods
}

然而，这有点难看，因为您需要创建一个新的ProcessorA<ModelDerived> ，而不仅仅是一个ProcessorA 。

---

您可以添加更多样板以使事情变得更好：

public abstract class ProcessorBase
{
    protected abstract ModelBase ModelForBase { get; }


    // ...some shared methods
}

public abstract class ProcessorA : ProcessorBase
{
    public static ProcessorA Create<TModel>(TModel model) where TModel : ModelBase, ISupportProcessA
    {
        return new ProcessorA<TModel>(model);
    }

    // Abstract specific methods
    public abstract void SomeSpecificMethod();
}


public class ProcessorA<TModel> : ProcessorA where TModel : ModelBase, ISupportProcessA
{
    protected override ModelBase ModelForBase => model;

    private readonly TModel model;

    public ProcessorA(TModel model)
    {
        this.model = model;
    }

    // Specific method overrides
    public override void SomeSpecificMethod()
    {
    }
}

这意味着您可以执行ProcessorA processor = ProcessorA.Create(new Model()) ，但代价是更多样板。