1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

实体（Entity）：靠"身份"区分
  有唯一 ID，属性变了还是它
  判等：ID 相同就是同一个
  例：订单 Order（有 OrderId）、用户 Customer
  问："这是哪一个？" → 实体

值对象（Value Object）：靠"值"区分
  没有 ID，所有属性相同就相等
  不可变（改 = 换新对象）
  例：地址 Address、金额 Money、日期范围 DateRange
  问："这是多少/什么样的？" → 值对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

一个判断技巧：
  两个"完全一样"的东西，是两个还是同一个？

  两张一模一样的 100 元 → 是同一个"金额"（值对象 Money）
    （你不在乎是哪张钞票，只在乎面值）
  两个同名同姓的用户 → 是两个不同的用户（实体 Customer）
    （你在乎"是哪一位"）

  在乎"是哪一个" → 实体
  不在乎、只在乎"值是什么" → 值对象

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

经验法则：能用值对象，就别用实体。

  值对象的好处：
    ✓ 不可变 → 天然线程安全、无副作用
    ✓ 按值判等 → 测试和比较简单
    ✓ 无身份管理 → 不用操心 ID 生成、生命周期
    ✓ 自带校验 → 构造时即合法（金额不能负、邮箱要合规）
    ✓ 组合性强 → 小值对象拼出大概念

  实体是"有状态、有生命周期"的东西，是少数。
  现实中大多数概念其实是值对象，只是被误建成了实体。

  典型误建：
    Address 做成有 AddressId 的实体 → 没必要，地址就是值
    Money 做成实体 → 金额就是值
    只有一个数量字段的"积分记录" → 可能是值

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

// record struct 自动提供按值判等；显式构造函数负责建立合法值
public readonly record struct Money
{
    public decimal Amount { get; }
    public string Currency { get; }

    public Money(decimal amount, string currency)
    {
        if (amount < 0) throw new DomainException("金额不能为负");
        if (string.IsNullOrWhiteSpace(currency))
            throw new DomainException("必须指定币种");
        Amount = amount;
        Currency = currency.ToUpperInvariant();
    }

    public Money Add(Money other)
    {
        if (Currency != other.Currency)
            throw new DomainException("币种不同，不能相加");
        return new Money(Amount + other.Amount, Currency);
    }

    public Money Subtract(Money other)
    {
        if (Currency != other.Currency || other.Amount > Amount)
            throw new DomainException("币种不同或余额不足");
        return new Money(Amount - other.Amount, Currency);
    }

    public Money Multiply(int times)
    {
        if (times < 0) throw new DomainException("倍数不能为负");
        return new Money(Amount * times, Currency);
    }
}
// 用法：
//   var price = new Money(99m, "CNY");
//   var total = price.Multiply(3);          // 新对象，price 不变
//   price == new Money(99m, "CNY")          // true（按值判等）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

// 复杂值对象用 record（class），可包含多字段和行为
public sealed record Address(
    string Province, string City, string Detail, string Zip)
{
    public string FullText => $"{Province}{City}{Detail}（{Zip}）";
    public bool IsDomestic => Zip.StartsWith("1") || /* … */;
}

// 日期范围：典型值对象，不可变 + 自带规则
public sealed record DateRange
{
    public DateTime Start { get; }
    public DateTime End { get; }

    public DateRange(DateTime start, DateTime end)
    {
        if (end < start) throw new DomainException("结束不能早于开始");
        Start = start;
        End = end;
    }
    public bool Overlaps(DateRange other) =>
        Start < other.End && other.Start < End;
    public TimeSpan Duration => End - Start;
}

1
2
3
4

值对象实现三要点：
  1. 不可变（record 自动；class 的话所有 setter private/无 setter）
  2. 按值判等（record 自动；class 要重写 Equals/GetHashCode）
  3. 构造即校验（在构造函数/record 的 init 校验上下文里校验）

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

// 实体基类：提供 ID 与按 ID 判等
public abstract class Entity<TId> where TId : notnull
{
    public TId Id { get; protected set; } = default!;
    public override bool Equals(object? obj) =>
        obj is Entity<TId> other && EqualityComparer<TId>.Default.Equals(Id, other.Id);
    public override int GetHashCode() => Id.GetHashCode();
}

// 实体：有身份、有状态流转
public class Customer : Entity<CustomerId>
{
    public CustomerName Name { get; private set; }      // 用值对象装字段
    public Email Email { get; private set; }            // 用值对象
    public CustomerStatus Status { get; private set; }

    private readonly List<Address> _addresses = new();  // 值对象集合
    public IReadOnlyCollection<Address> Addresses => _addresses.AsReadOnly();

    public Customer(CustomerId id, CustomerName name, Email email) : base()
    {
        Id = id;
        Name = name ?? throw new DomainException("姓名必填");
        Email = email ?? throw new DomainException("邮箱必填");
        Status = CustomerStatus.Active;
    }

    public void ChangeEmail(Email newEmail)
    {
        if (Status == CustomerStatus.Closed)
            throw new DomainException("已注销客户不能改邮箱");
        Email = newEmail;
    }
}

1
2
3
4
5

实体要点：
  - 继承 Entity<TId>，按 ID 判等（不是按所有字段）
  - 状态流转通过方法（ChangeEmail），不暴露 setter
  - 字段尽量用值对象包装（CustomerName / Email），而非裸 string
    → 裸 string "abc" 不是合法邮箱；Email 值对象构造即校验

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

痛点：
  public void Transfer(Guid fromAccountId, Guid toAccountId, decimal amount)
  → fromAccountId 和 toAccountId 都是 Guid，传反了编译器不报错！

强类型 ID：给每个 ID 套一层类型
  public readonly record struct AccountId(Guid Value);
  public readonly record struct CustomerId(Guid Value);

  void Transfer(AccountId from, AccountId to, Money amount)
  → AccountId 不会被误传成 CustomerId；但 from/to 是同一类型，彼此传反仍需靠命名、封装和测试防范。
  → 顺手解决了"裸 Guid 满天飞、容易传错"的经典 bug。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

public readonly record struct AccountId(Guid Value)
{
    public static AccountId New() => new(Guid.NewGuid());
    public override string ToString() => Value.ToString();
}

public class Account : Entity<AccountId>, IAggregateRoot
{
    public Money Balance { get; private set; }
    public void Withdraw(Money amount)
    {
        if (amount.Amount > Balance.Amount)
            throw new DomainException("余额不足");
        Balance = Balance.Subtract(amount);
    }
}
// 调用：Transfer(new AccountId(...), new AccountId(...), money)
//       —— 强类型能阻止其他 ID 类型混入，但不能识别两个 AccountId 的语义顺序

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// 实体 → 表
modelBuilder.Entity<Order>(b =>
{
    b.HasKey(o => o.Id);
    b.Property(o => o.Status).HasConversion<string>();

    // 聚合内的子实体（订单项）：同一个聚合，一起存取
    b.OwnsMany(o => o.Items, item =>
    {
        item.WithOwner().HasForeignKey("OrderId");
        item.HasKey("Id");
        item.Property(i => i.Price).HasConversion(
            m => m.Amount, v => new Money(v, "CNY"));
    });
});

// 值对象 → Owned Entity（值对象没有自己的表身份，归属宿主）
modelBuilder.Entity<Customer>(b =>
{
    b.OwnsOne(c => c.Name);          // CustomerName 作为宿主的一列/几列
    b.OwnsOne(c => c.Email);
    b.OwnsMany(c => c.Addresses);    // 值对象集合 → 关联表
});

// 强类型 ID → 转换为底层类型存储
modelBuilder.Entity<Account>(b =>
{
    b.Property(a => a.Id).HasConversion(
        id => id.Value, v => new AccountId(v));
});

1
2
3
4
5
6
7

EF Core 映射心智模型：
  实体（聚合根、子实体）→ 有主键 → 表/行
  值对象 → 无独立身份 → OwnsOne（单值）/ OwnsMany（集合）→ 宿主的列或子表

  关键：值对象不该有自己的 DbSet（它不独立），
       子实体的仓储也归聚合根（OrderItem 不单独存取）。
  这与第二篇"按聚合根整体存取"一致。

1
2
3
4
5
6
7
8
9

场景                              用实体还是值对象
──────────────────────────────────────────────────────
订单、用户、账户（有生命周期）       实体
收货地址、金额、坐标                 值对象
邮箱、手机号、用户名                 值对象（自带格式校验）
日期范围、时间段                     值对象
订单项（依附订单存在）               子实体（在聚合内，不独立）
订单项里的"单价"                    值对象（Money）
两个"完全相同"是否算同一个           是→值对象；否→实体