Question

我正在使用类表继承实现类型层次结构。但是，我遇到了返回基类型而不是子类型的静态方法的问题。我已经找到了解决这个问题的方法，但它并不太漂亮。参加以下课程

public class Entity : ActiveRecordBase<Entity> { }
public class Person : Entity {}

致电

Person.FindAll();

实际上返回一个Entity []而不是Person []。我可以通过在所有派生类中实现FindAll来解决这个问题，但是谁想要这样做呢？我还能够创建一个所有类派生并实现

的基类

public R[] FindAll<R>() {}

但我只是不喜欢

的样子

Person.FindAll<Person>()

有没有办法能够从派生类中调用FindAll（）并实际获取派生类而不是基类？

Answer 1

这就是.net的工作原理：静态方法没有多态性。您已经找到了几个解决方法，另一个是不依赖于从ActiveRecordBase<T>继承的这些静态方法，而是直接使用ActiveRecordMediator<T>。

Answer 2

也许你可以这样做：

public class Entity<T> : ActiveRecordBase<T> { }
public class Person : Entity<Person> {}

这样FindAll()会返回Person[]

Answer 3

即使是 Castle.ActiveRecord 的文档也会使用您找到的解决方法。

请参阅此处以获取完整示例和其他一些解决方案：http://docs.castleproject.org/Default.aspx?Page=Type%20hierarchy&NS=Active%20Record

我复制了代码以防网站消失。

基类＆＃34;实体＆＃34;

using Castle.ActiveRecord;

[ActiveRecord("entity"), JoinedBase]
public class Entity : ActiveRecordBase
{
    private int id;
    private string name;
    private string type;

    public Entity()
    {
    }

    [PrimaryKey]
    private int Id
    {
        get { return id; }
        set { id = value; }
    }

    [Property]
    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    [Property]
    public string Type
    {
        get { return type; }
        set { type = value; }
    }

    public static void DeleteAll()
    {
        DeleteAll(typeof(Entity));
    }

    public static Entity[] FindAll()
    {
        return (Entity[]) FindAll(typeof(Entity));
    }

    public static Entity Find(int id)
    {
        return (Entity) FindByPrimaryKey(typeof(Entity), id);
    }
}

派生类＆＃34;人物＆＃34;和＆＃34;公司＆＃34;

using Castle.ActiveRecord;

[ActiveRecord("entitycompany")]
public class CompanyEntity : Entity
{
    private byte company_type;
    private int comp_id;

    [JoinedKey("comp_id")]
    public int CompId
    {
        get { return comp_id; }
        set { comp_id = value; }
    }

    [Property("company_type")]
    public byte CompanyType
    {
        get { return company_type; }
        set { company_type = value; }
    }

    public new static void DeleteAll()
    {
        DeleteAll(typeof(CompanyEntity));
    }

    public new static CompanyEntity[] FindAll()
    {
        return (CompanyEntity[]) FindAll(typeof(CompanyEntity));
    }

    public new static CompanyEntity Find(int id)
    {
        return (CompanyEntity) FindByPrimaryKey(typeof(CompanyEntity), id);
    }
}

[ActiveRecord("entityperson")]
public class PersonEntity : Entity
{
    private int person_id;

    [JoinedKey]
    public int Person_Id
    {
        get { return person_id; }
        set { person_id = value; }
    }

    public new static void DeleteAll()
    {
        DeleteAll(typeof(PersonEntity));
    }

    public new static PersonEntity[] FindAll()
    {
        return (PersonEntity[]) FindAll(typeof(PersonEntity));
    }

    public new static PersonEntity Find(int id)
    {
        return (PersonEntity) FindByPrimaryKey(typeof(PersonEntity), id);
    }
}

使用Castle ActiveRecord类表继承在派生类上调用FindAll

3 个答案: