[Best practice] C# 9 Records as DDD Value Objects with EF Core 6

class R1 : IEquatable<R1>
{
    public T1 P1 { get; init; }

    protected virtual Type EqualityContract => typeof(R1);

    public override bool Equals(object? obj) => Equals(obj as R1);

    public virtual bool Equals(R1? other)
    {
        return !(other is null) &&
            EqualityContract == other.EqualityContract &&
            EqualityComparer<T1>.Default.Equals(P1, other.P1);
    }

    public static bool operator==(R1? left, R1? right)
        => (object)left == right || (left?.Equals(right) ?? false);

    public static bool operator!=(R1? left, R1? right)
        => !(left == right);

    public override int GetHashCode()
    {
        return Combine(EqualityComparer<Type>.Default.GetHashCode(EqualityContract),
            EqualityComparer<T1>.Default.GetHashCode(P1));
    }
}

public class Person : Entity<Guid>
{
    public Person(string name, int age) 
        => (Name, Age) = (name, age);

    public string Name { get; }
    public int Age { get; }
    public Address Address { get; private set; }

    public void DefineAddress(Address address)
    {
        if (address is null) throw new BusinessException("Home address must be informed");
        // Benefit of the record Equality Contract
        if(address.Equals(Address)) return;
        Address = address;
    }
}

public record Address : Abstractions.ValueObject
{
    // Empty constructor in this case is required by EF Core,
    // because has a complex type as a parameter in the default constructor.
    private Address() { }

    public Address(Street street, string zipCode)
        => (Street, ZipCode) = (street, zipCode);

    public Street Street { get; private init; }
    public string ZipCode { get; private init; }
}

public class PersonConfiguration : IEntityTypeConfiguration<Person>
{
    public void Configure(EntityTypeBuilder<Person> builder)
    {
        builder.HasKey(user => user.Id);

        ...

        // Configures a relationship where the Address is owned by (or part of) Person.
        builder.OwnsOne(
            person => person.Address,
            addressNavigationBuilder =>
            {
                // Configures a different table that the entity type maps to when targeting a relational database.
                addressNavigationBuilder
                    .ToTable("Addresses");

                // Configures the relationship to the owner, and indicates the Foreign Key.
                addressNavigationBuilder
                    .WithOwner()
                    .HasForeignKey("PersonId"); // Shadow Foreign Key

                // Configure a property of the owned entity type, in this case the to be used as Primary Key
                addressNavigationBuilder
                    .Property<Guid>("Id"); // Shadow property

                // Sets the properties that make up the primary key for this owned entity type.
                addressNavigationBuilder
                    .HasKey("Id"); // Shadow Primary Key

                // Configures a relationship where the Street is owned by (or part of) Addresses.
                // In this case, is not used "ToTable();" to maintain the owned and owner in the same table. 
                addressNavigationBuilder.OwnsOne(
                    address => address.Street,
                    streetNavigationBuilder =>
                    {
                        ...

                        // Configures a relationship where the City is owned by (or part of) Street.
                        // In this case, is not used "ToTable();" to maintain the owned and owner in the same table. 
                        streetNavigationBuilder.OwnsOne(
                            street => street.City,
                            cityNavigationBuilder =>
                            {
                                ...
                            });
                    });
            });
    }
}

CREATE TABLE [Persons]
(
    [Id]   uniqueidentifier NOT NULL,
    [Name] varchar(128)     NOT NULL,
    [Age]  int              NOT NULL,
    CONSTRAINT [PK_Persons] PRIMARY KEY ([Id])
);

CREATE TABLE [Addresses]
(
    [Id]                                 uniqueidentifier NOT NULL,
    [Street_City_Name]                   varchar(128)     NULL,
    [Street_City_State_Country_Initials] varchar(8)       NULL,
    [Street_City_State_Country_Name]     varchar(128)     NULL,
    [Street_City_State_Initials]         varchar(8)       NULL,
    [Street_City_State_Name]             varchar(128)     NULL,
    [Street_Name]                        varchar(128)     NULL,
    [Street_Number]                      int              NULL,
    [ZipCode]                            varchar(32)      NULL,
    [PersonId]                           uniqueidentifier NOT NULL,
    CONSTRAINT [PK_Addresses] PRIMARY KEY ([Id]),
    CONSTRAINT [FK_Addresses_Persons_PersonId] FOREIGN KEY ([PersonId]) REFERENCES [Persons] ([Id]) ON DELETE CASCADE
);

CREATE UNIQUE INDEX [IX_Addresses_PersonId] ON [Addresses] ([PersonId]);