如何将 <T> 转换为其泛型方法的基本类型？

Question

我有一个通用的 CRUD 类来对我的实体对象执行添加、删除、选择和创建。

其中之一 - Message 有两个派生类 - order_message 和 report_message。

我的问题是，在我的泛型类中，我需要一个对象集来执行 crud ops，但对象集不接受派生类类型，它只接受基类类型。

这是我收到的错误：

没有为指定的实体类型“CustomerWebPortal_Entities.Order_Message”定义实体集。如果“CustomerWebPortal_Entities.Order_Message”是派生类型，请改用基类型。

我尝试使用 typeof(T).BaseType 来替换 T，结果没有用。

我应该如何纠正这个问题？

这是泛型类的概述：

 public abstract class baseCrudDao<T> : ICrudDao<T> where T : class
{
    private System.Data.Objects.ObjectContext _context;

    private System.Data.Objects.ObjectSet<T> _entity; 
    public baseCrudDao()
    {

        _context = new CustomerWebPortalEntities();
        _entity = _context.CreateObjectSet<T>(); <-- error at here, only accept base type

    }

Answer 1

好吧，我终于有机会按照建议编写原型。我认为这样的事情会起作用，但我还没有测试过。现在可以针对 IObjectSet<> 成员定义所有的 crud 方法。

public class Crud<EntityType> where EntityType : class
{
    private readonly ObjectContext Context;
    private readonly IObjectSet<EntityType> Entities;

    public Crud(ObjectContext context)
    {
        Context = context;

        Type BaseType = GetBaseEntityType();

        if (BaseType == typeof(EntityType))
        {
            Entities = Context.CreateObjectSet<EntityType>();
        }
        else
        {
            Entities = (IObjectSet<EntityType>)Activator.CreateInstance(typeof(ObjectSetProxy<,>).MakeGenericType(typeof(EntityType), BaseType), Context);
        }
    }

    private static Type GetBaseEntityType()
    {
        //naive implementation that assumes the first class in the hierarchy derived from object is the "base" type used by EF
        Type t = typeof(EntityType);

        while (t.BaseType != typeof(Object))
        {
            t = t.BaseType;
        }

        return t;
    }
}

internal class ObjectSetProxy<EntityType, BaseEntityType> : IObjectSet<EntityType>
    where EntityType : BaseEntityType
    where BaseEntityType : class
{
    private readonly IObjectSet<BaseEntityType> Entities;

    public ObjectSetProxy(ObjectContext context)
    {
        Entities = context.CreateObjectSet<BaseEntityType>();
    }

    public void AddObject(EntityType entity)
    {
        Entities.AddObject(entity);
    }

    //TODO: implement remaining proxy methods

    public IEnumerator<EntityType> GetEnumerator()
    {
        return Entities.OfType<EntityType>().GetEnumerator();
    }

    System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
    {
        return GetEnumerator();
    }

    public Type ElementType
    {
        get { return typeof(EntityType); }
    }

    public Expression Expression
    {
        get { return Entities.OfType<EntityType>().Expression; }
    }

    public IQueryProvider Provider
    {
        get { return Entities.Provider; }
    }
}

Answer 2

一种解决方法是使用两个泛型类型参数（在基类上），例如

public abstract class baseCrudDao<T, U> : ICrudDao<T> where U : class, T: U
{
    ...
    public baseCrudDao()
    {
        _context = new CustomerWebPortalEntities();
        _entity = _context.CreateObjectSet<U>(); <-- error at here, only accept base type
    }
    ...
}

使用 Message 代替 U。如果您有许多类型并且并非所有类型都具有继承关系，那么约束 T:U 将不起作用，您可能需要使用 T:class 约束。我还建议您创建另一个骨架基类以用于其他类型，例如

public abstract class base2CrudDao<T> : baseCrudDao<T, T>

这样你就不必为没有继承关系的类指定U参数。