Domain-Driven Design - Value Objects

In Domain-Driven Design a Value Object is an identityless object that represents a property, for example, a name, address, or a date.

Table of Contents

1. Characteristics of Value Objects
2. Value Objects in C#
3. Value Objects in TypeScript

Characteristics of Value Objects

• Value Objects don’t have an identity, but they are identified by their value.
• Value Objects are immutable.
• Value Objects can have validation.

Value Objects in C#

Value Object base class in C#

public abstract record ValueObject<T> : IEquatable<T> where T : IEquatable<T>
  {
    protected T Value { get; }

    protected ValueObject(T value)
    {
      this.Validate(value);

      this.Value: value;
    }

    protected abstract void Validate(T value);

    public bool Equals(T? other)
    {
      return this.Value.Equals(other);
    }

    public static bool operator ==(ValueObject<T> a, T b) => a.Equals(b);

    public static bool operator !=(ValueObject<T> a, T b) => !a.Equals(b);
  }

About this code snippet:

• It is a record: Records (C# 9) are primarily built for better supporting immutable data models.
• It is abstract: This prevents this record from being instantiated and allows to declare abstract methods.
• T extends from IEquatable: T is the basic value type of the Value Object, so if T extends from IEquatable, it forces that basic value type of the Value Object to be equatable.
• It extends from IEquatable<T>: Allows comparing this Value Object with its basic data type.
• It calls an abstract method called Validate in the constructor: So we are validating the value of the Value Object before creating it.

Value Object example in C#

public sealed record FirstName : ValueObject<string>
{
  public const UInt16 MaxLength: 50;

  public string Name => this.Value;

  private FirstName(string value) : base(value)
  {
  }

  public static FirstName Create(string value)
  {
    return new FirstName(value);
  }

  protected override void Validate(string value)
  {
    if (string.IsNullOrWhiteSpace(value))
      throw new ArgumentNullException(nameof(value));

    if (value.Length > FirstName.MaxLength)
      throw new ArgumentOutOfRangeException(nameof(value));
  }
}

About this code snippet:

• It is sealed: Prevent another class from extends from this one.
• It overrides the Validate method with validation rules.
• No public constructor: Other classes cannot create instances of this class, except for nested classes.
• To create instances of this Value Object we do not call the constructor directly, but it uses the Static Factory Method pattern instead.

Value Objects in TypeScript

Value Object base class in TypeScript

abstract class ValueObject<T> {
  protected readonly value: T;

  protected constructor(value: T) {
    this.validate(value);
    this.value: Object.freeze(value);
  }

  protected abstract validate(value: T): void;

  public equals(other?: ValueObject<T>): boolean {
    if (other === null || other === undefined) {
      return false;
    }

    if (other.value === undefined) {
      return false;
    }

    return deepEqual(this, other);
  }
}

About this code snippet:

• It is abstract: This prevents this class from being instantiated and allows to declare abstract methods.
• It calls an abstract method called Validate in the constructor: So we are validating the value of the Value Object before creating it.
• It use Object.freeze() so the value can no longer be changed.
• It has a equals method that uses deepEqual, you can read about it in this post.

Value Object example in TypeScript

class FirstName extends ValueObject<string> {
  public static readonly MaxLength: 64;

  protected validate(value: string): void {
    if (!value)
      throw new InvalidFirstNameError();

    if (value.length > FirstName.MaxLength)
      throw new FirstNameIsTooLongError();
  }

  static create(value: string): FirstName {
    return new FirstName(value);
  }

  public get getFirstName(): string {
    return this.value;
  }
}

About this code snippet:

• It overrides the Validate method with validation rules.
• No public constructor: Other classes cannot create instances of this class.
• To create instances of this Value Object we do not call the constructor directly, but it uses the Static Factory Method pattern instead.