在需要时从接口转换为某个具体类是一种好习惯吗？

Question

我正在开发一个小型系统，并且我开发了经典的通用存储库。目前，我的 DAL 具有以下架构。

public interface IRepositorio<T> where T : class
{
    T Get(long id);
    long Insert(T obj);
    bool Update(T obj);
    bool Delete(T obj);
}

public abstract class Repositorio<T> : IRepositorio<T> where T : class
{
    public IDbConnection Connection
    {
        get
        {
            return new SqlConnection(ConfigurationManager.ConnectionStrings["DBFila"].ConnectionString);
        }
    }

    public T Get(long id)
    {
        //...
    }

    public long Insert(T obj)
    {
        //...
    }

    public bool Update(T obj)
    {
        //...
    }

    public bool Delete(T obj)
    {
        //...
    }
}

我的具体存储库如下所示：

public class FilaRepositorio : Repositorio<FilaRepositorio>
{
    public FilaRepositorio() 
    {
    }

    public void SomeCustomMethod()
    {
        // Some custom method
    }
}

我也在使用 Simple Injector 来遵循 IoC 和 DI 模式，因此，当我尝试调用“SomeCustomMethod()”时，我无法访问它（显然）。看：

public class Processador
{
    private IRepositorio<FilaModel> _repoFila;
    public Processador(IRepositorio<FilaModel> repoFila)
    {
        _repoFila = repoFila;
    }

    public void Processar()
    {
        _repoFila.SomeCustomMethod(); // <-- wrong

        ((FilaRepositorio)_repoFila).SomeCustomMethod();// <-- works
    }
}

鉴于此，我有一些问题：

• 制作该演员表 (FilaRepositorio) 是一种好的或可接受的做法吗？
• 如果这不是一个好的做法，如何为这种情况编写好的代码？

Answer 1

有几个选项可用。制作演员表的主要问题是它是一个实现问题。

如果注入的对象不是FilaRepositorio会怎样？

通过进行强制转换，您将类与不能保证是注入依赖项的实现问题紧密耦合。因此，构造函数对于执行其功能所需的内容并不完全真实。

这表明需要练习Explicit Dependencies Principle

显式依赖原则指出：

方法和类应该明确要求（通常通过 方法参数或构造函数参数）任何协作对象 他们需要才能正常工作。

避免这种情况的一种方法是创建一个派生接口，显式公开其依赖项的所需功能。

public interface IFilaRepositorio : IRepositorio<FilaModel> {
    void SomeCustomMethod();
}

public class FilaRepositorio : Repositorio<FilaModel>, IFilaRepositorio {
    public void SomeCustomMethod() {
        //...other code removed for brevity.
    }
}

并让Processador 依赖于更有针对性的抽象。

现在根本不需要演员表，类明确表达了它的需要。

public class Processador {
    private readonly IFilaRepositorio _repoFila;

    public Processador(IFilaRepositorio  repoFila) {
        _repoFila = repoFila;
    }

    public void Processar() {
        _repoFila.SomeCustomMethod(); // <-- works
    }
}

Answer 2

如果您需要从应用程序的任何部分访问特定方法，则该特定方法必须是抽象的一部分，否则无法保证您在更改具体类时可以使用它。

我不相信你使用强制转换是一个好主意，在这种情况下通常做的是创建一个特定的接口来定义你可能需要使用的任何其他方法：

public interface IFilaRepositorio : IRepositorio<Fila>
{
     void SomeCustomMethod();
}

然后在您认为需要使用它的代码的任何部分中使用和声明该特定接口：

public class Processador
{
    private IFilaRepositorio _repoFila;
    public Processador(IFilaRepositorio  repoFila)
    {
        _repoFila = repoFila;
    }

    public void Processar()
    {
        _repoFila.SomeCustomMethod();
    }
}