覆盖泛型基类型的方法

Question

我目前的结构是这样的：

public class CustomerRepository
{
    // ..

    public virtual Customer LoadCustomer()
    {
        // ...
    }
}

public class OracleCustomerRepository : CustomerRepository
{
    private OracleConnection oracleConnection;

    public OracleCustomerRepository()
    : base(){
        if(this.EnsureIsConnected()){
             // ...
        }
    }

    private bool EnsureIsConnected(){
        // ..
    }

    public override Customer LoadCustomer(){
        // ..
    }
}

效果很好，除了 - 对于每个 OracleRepository - 我必须再次编写方法 EnsureIsConnected，我必须再次声明归档的 OracleConnection 等等。

我想抽象一下。我的第一个想法是使用Interface，但这并不能解决重复代码的问题。我的第二个想法是使用基类CustomerRepository 作为另一个新基类OracleRepository<T> 的泛型类型，然后定义通用例程。

问题是：据我所知，override 无法使用泛型类型的 virtual 方法，例如 CustomerRepository。

这就是我认为它会起作用的方式。

public class OracleRepository<T> where T : class{

    public OracleRepository(){
        this.EnsureIsConnected());
    }

    protected OracleConnection oracleConnection;

    protected EnsureIsConnected(){
        // ...
    }
}

public class OracleCustomerRepository : OracleRepository<CustomerRepository>{

    // ..

    // this is not possible, defined in CustomerRepository
    public override Customer LostCustomer(){

    }
}

注意：CustomerRepository 不是我拥有的唯一存储库。这主要是我试图找到更好的解决方案的原因。

关于如何解决这个问题的任何建议？

Answer 1

你能做到吗？或者这不是您想要的？

public abstract class CustomerRepository<T>
{
    protected OracleConnection oracleConnection;

    protected CustomerRepository() : base(){
        if(EnsureIsConnected()){
            // ...
        }
    }

    protected bool EnsureIsConnected()
    {
        return true;
    }

    public abstract T Load();
}

public class OracleCustomerRepository : CustomerRepository<Customer>
{
    public override Customer Load(){
        return new Customer();
    }
}

Answer 2

我的第一个想法是您的抽象似乎有点泄漏。 我通常做的是创建与数据库引擎交互的接口，方法如下：

public interface IPersistence
{
    void ExecuteOperation(string prodecureName, Dictionary<string, object> parameters);
    T ExecuteSingle(string procedureName, Dictionary<string, object> parameters, Func<IDataReader, T> rowReader);
    List<T> ExecuteMultirow(string procedureName, Dictionary<string, object> parameters, 
Func<IDataReader, T> rowReader);
}

然后在存储库中，我将其作为依赖项，并从 IoC 容器中决定使用哪个实现。 所以在你的代码中你会有：

public class CustomerRepository
{
    private readonly IPersistence persistence;

    public CustomerRepository(IPersistence persistence)
    {
        this.persistence = persistence;
    }

    public virtual Customer LoadCustomer()
    {
        // preparation code
        return this.persistence.ExecuteSingle("some procedure", parameters, r => new Customer((int)r["Id"], (string)r["DisplayName"]));
    }
}