[ActiveRecord] 之六：继承

 ActiveRecord 支持继承体系，我们看看几种不同的实现方式。

1. 无关联继承

public class Person
{
    private int id;

    [PrimaryKey(PrimaryKeyType.Identity)]
    public int Id
    {
        get { return id; }
        set { id = value; }
    }

    private string name;

    [Property(NotNull=true)]
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

[ActiveRecord]
public class Student : Person
{
    private int grade;

    [Property]
    public int Grade
    {
        get { return grade; }
        set { grade = value; }
    }
}

[ActiveRecord]
public class Teacher : Person
{
    private string job;

    [Property]
    public string Job
    {
        get { return job; }
        set { job = value; }
    }
}

调用 ActiveRecordStarter.CreateSchema(); ，你会发现数据库里面分别生成了 Student 和 Teacher 数据表，每个表都拥有基类(Person)的字段，相互没有关联。这种继承方式下，我们无法通过 Find(typeof(Person)) 来返回所有人(Student & Teacher)。严格来说，我们根本无法调用此方法，因为我们不能为 Person 添加 ActiveRecordAttribute。

此方式仅仅是为了代码重用而已，并没有业务上的关联。

== 数据表结构 ==

Student Table
{
    Id
    Name
    Grade
}

Teacher Table
{
    Id
    Name
    Job
}

执行插入对象测试代码

Student s = new Student();
s.Name = "student1";
s.Grade = 2;
ActiveRecordMediator.Create(s);

Teacher t = new Teacher();
t.Name = "teacher1";
t.Job = "班主任";
ActiveRecordMediator.Create(t);

结果

Student Table
{
    Id = 1
    Name = "student1"
    Grade = 2
}

Teacher Table
{
    Id = 1
    Name = "teacher1"
    Job = "班主任"
}

2. 单表关联继承

我们使用 ActiveRecordAttribute 内置属性更改上面的例子，使其成为关联继承。

[ActiveRecord(DiscriminatorColumn = "Type", DiscriminatorType = "String", DiscriminatorValue = "Person")]
public class Person
{
    private int id;

    [PrimaryKey(PrimaryKeyType.Identity)]
    public int Id
    {
        get { return id; }
        set { id = value; }
    }

    private string name;

    [Property(NotNull=true)]
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

[ActiveRecord(DiscriminatorValue = "Student")]
public class Student : Person
{
    private int grade;

    [Property]
    public int Grade
    {
        get { return grade; }
        set { grade = value; }
    }
}

[ActiveRecord(DiscriminatorValue = "Teacher")]
public class Teacher : Person
{
    private string grade;

    [Property]
    public string Job
    {
        get { return grade; }
        set { grade = value; }
    }
}

你会发现数据库里面仅生成了一个Person表。

== 数据表结构 ==

Student Person
{
    Id
    Type // 由 Person[DiscriminatorColumn...] 特性生成！
    Name
    Grade
    Job
}

执行插入对象测试代码
结果

Person Table
{
    // Record 1-----------------
    Id = 1
    Type = "Student"
    Name = "student1"
    Grade = 2
    Job = <NULL>

    // Record 2-----------------
    Id = 2
    Type = "Teacher"
    Name = "teacher1"
    Grade = <NULL>
    Job = "办主任"
}

在基类定义一个 DiscriminatorColumn 特性，子类通过写入不同的 DiscriminatorValue 来达到区分不同子类型的目的。

这种方式解决了多态查询的问题，但当子类新增属性较多，而且多个子类属性差别较大的情况下，数据库空间浪费会比较严重。同时由于对于不属于当前类的数据库字段插入NULL，可能会造成插入时发生错误，触发异常(比如我们将 Teacher.Job 的特性改为 Property(NotNull=true)，那么我们保存Student对象到数据库时就会触发异常)。

我们对基类和子类进行查询测试

foreach Person p in (Person[])ActiveRecordMediator.FindAll(typeof(Person)))
{
    Console.WriteLine("Person {0}:{1}", p.Id, p.Name);
}

foreach (Student p2 in (Student[])ActiveRecordMediator.FindAll(typeof(Student)))
{
    Console.WriteLine("Student {0}:{1}", p2.Id, p2.Name);
}

foreach (Teacher p3 in (Teacher[])ActiveRecordMediator.FindAll(typeof(Teacher)))
{
    Console.WriteLine("Teacher {0}:{1}", p3.Id, p3.Name);
}

输出
Person 1:student1
Person 2:teacher1
Student 1:student1
Teacher 2:teacher1

建议你继续往下看，或许下面的方式更适合你。

3. 多表关联继承

[ActiveRecord, JoinedBase]
public class Person
{
    private int id;

    [PrimaryKey(PrimaryKeyType.Identity)]
    public int Id
    {
        get { return id; }
        set { id = value; }
    }

    private string name;

    [Property(NotNull=true)]
    public string Name
    {
        get { return name; }
        set { name = value; }
    }
}

[ActiveRecord]
public class Student : Person
{
    [JoinedKey("Id")]
    public int StudentId
    {
        get { return base.Id; }
        set { base.Id= value; }
    }
        
    private int grade;

    [Property]
    public int Grade
    {
        get { return grade; }
        set { grade = value; }
    }
}

[ActiveRecord]
public class Teacher : Person
{
    [JoinedKey("Id")]
    public int TeacherId
    {
        get { return base.Id; }
        set { base.Id= value; }
    }
        
    private string grade;

    [Property]
    public string Job
    {
        get { return grade; }
        set { grade = value; }
    }
}

我们注意到为 Person 添加了 ActiveRecordAttribute 和 JoinedBaseAttribute 特性，同时为子类 Student 和 Teacher 添加了一个附加了 JoinedKeyAttribute 的 Id 字段。此继承模式会分别生成 Person、Student 和 Teacher 三个数据表。Person 存储了基类的所有字段，子类表仅包含子类增加的属性和Id映射字段。此继承方式下，我们查找 Person 时，会同时返回 Student 和 Teacher记录。

== 数据表结构 ==

Person Table
{
    Id
    Name
}

Student Table
{
    StudentId
    Grade
}

Teacher Table
{
    TeacherId
    Job
}

执行插入对象测试代码
结果

Person Table
{
    // Record 1---
    Id = 1
    Name = "student1"

    // Record 1---
    Id = 2
    Name = "teacher1"
}

Student Table
{
    Id = 1
    Grade = 2
}

Teacher Table
{
    Id = 2
    Job = "班主任"
}