如何指定类型参数，以便泛型基类将使用其调用的DAL方法所使用的相同模型类？

Question

I am trying to create a generic base controller that would provide a single point of maintenance of the basic CRUD for a number of similar data base tables in my MVC EF application. My design:

There is a base model class:

public class ModelBaseClass {}

Each database table has a model class. All model classes inherit ModelBaseClass:

public class ModelSomeDatabaseTable : ModelBaseClass {}

Each database table is associated with a data access (DAL) class. The class includes CRUD methods. The DAL class uses the corresponding model class to pass data to the business layer:

public abstract class DalBaseClass
{
    public abstract List<ModelBaseClass> ToList();
}

There is a generic base controller with two type parameters: The first one is for the DAL class associated with the database table. The second one is for the database table's model class:

 public class ControllerBaseClass<T1Dal, T2Model> : Controller
    where T1Dal : DalBaseClass, new()
    where T2Model : ModelBaseClass
{
    T1Dal _dal = new T1Dal();

    public ControllerBaseClass() { }

    //----------------------------------------------------------------------------------------
    // GET: List all entries in the table
    //----------------------------------------------------------------------------------------
    public ActionResult Index()
    {
        List<T2Model> _List = new List<T2Model>();
        _List = _dal.ToList(); //Compiler error: "Cannot implicitly convert type ‘…<...ModelBaseClass>' to '…<...T2Model>'"
        return View(_List);
    }
}

I have read what seemed to be relevant in the MSDN, as well as quite a number of blogs and responses to questions related to the use of type parameters. In particular, I read several blogs describing the construction of generic base classes that provide a single point of maintenance for the basic CRUD logic. Yet none of them seems to pass both type parameters, one for the DAL class of a certain table, and the other for the model class of the same table.

My problem is related to the second type parameter, the model class. The controller and the DAL class must use the same model when data is transferred between the two. Of course, the identity of the model type will be revealed only at run time. Still, the compiler needs the assurance that the same types are used by the controller and by the DAL, otherwise it raises a “ Cannot implicitly convert type '…<...ModelBaseClass>' to '…<...T2Model>' ”

BTW, when I replace the type parameter (T2Model) with the explicit name of the model base class (ModelBaseClass), then the compiler is happy.

In the generic base controller (ControllerBaseClass) below, T1Dal is constrained by the DalBaseClass. The DalBaseClass, in turn, has an abstract method, thus the compiler is happy when the generic base controller calls that method. Not only that, but also the generic base controller is aware of the inherited model's type, ModelBaseClass, as declared in the DalBaseClass. Here is the problem: T1Dal is constrained by the models' base class. Therefore, I naively expected that here, again through inheritance, the compiler will appreciate the same model type. However, the compiler does not use this information in the assignment statement

_List = _dal.ToList();

therefore, it raises the said cast error.

How should I fix my code so that the generic base controller will recognize that the type parameter representing the model is the same type as the one used by the DAL?

Answer 1

This is an extremely poor design and very inflexible. The chief problem is that you're assuming each controller will only ever work with one entity type. That's actually not a real-world design and is pretty rare that you'd only need to work with just one thing in every controller. It's like you're trying to create a repository, but it's not quite a repository. First, you should simply design your "DAL" class to be generic. EF actually has a generic DbSet accessor that you can utilize, which will make your work much easier. For example:

public class MyDalClass
{
    protected readonly DbContext context;

    public MyDalClass(DbContext context)
    {
        this.context = context;
    }

    public List<TEntity> GetAll<TEntity>()
    {
        return context.Set<TEntity>().ToList();
    }
}

Then, throw away your generic controller and inject your DAL:

public class MyController : Controller
{
    protected readonly MyDalClass dal;

    public MyController(MyDalClass dal)
    {
        this.dal = dal;
    }

    ...
}

Then, in your actions, you can simply do something like:

var foos = dal.GetAll<Foo>();

To inject into your controller, you'll need to utilize a dependency injection container. There's many choices out there. My personal choice is Ninject, as I find it blends power and ease of use pretty well. For example, with Ninject, you'd set this up like:

kernel.Bind<DbContext>().To<ApplicationDbContext>().InRequestScope();
kernel.Bind<MyDalClass>().ToSelf().InRequestScope();

Obviously, with the scope of Stack Overflow, this is an extremely basic example. You probably utilize interfaces and create a much more robust DAL. If you're interested, I have as eries of articles that present more advanced scenarios with a similar approach.