一对多 (EF Core) 的建议

Question

I'm trying to figure out the best way to define a one to many relationship table as it pertains to Customers and Addresses. Each Customer can have multiple address (Mailing, Billing, Delivery, etc). The Type of address is stored in a separate table (AddressType).

Here's what I have:

public class Company
    {
        public int Id { get; set; }
        public string Name { get; set; }
        public List<Address> Addresses { get; set; }
    }

  public class Address
    {
        public int Id { get; set; }
        public int AddressTypeId { get; set; }
        public AddressType AddressType { get; set; }
        public string Street1 { get; set; }
        public string Street2 { get; set; }
        public string City { get; set; }
        public int StateId { get; set; }
        public State State { get; set; }
        public string PostalCode { get; set; }
        public int CountryId { get; set; }
        public Country Country { get; set; }
        public bool Active { get; set; }
        public int CompanyId { get; set; }
    }

    public class AddressType
    {
        public int Id { get; set; }
        public string Display { get; set; }
        public bool Active { get; set; }
    }

Couple of questions...

1. Would what I have above be considered good practice? If not, how would you define it?
2. Assuming that the AddressType table contains Mailing, Billing and Delivery, how would I issue a Linq query where I only want to pull the Mailing Address?

Thanks a bunch.

--- Val

Answer 1

I'd suggest a 'base' address class. Mailing, Billing, Delivery etc. would inherit from this base class.

public class Address
{
    public string Street { get; set; }

    public int HouseNumber { get; set; }

    public string HouseNumberAddition { get; set; }

    public string City { get; set; }

    public string Country { get; set; }
}

In case of delivery, you might want to print a delivery note with the address label for the delivery driver. But is does not make sense to include a DeliveryNote in the base address class, because when would a billing address need a delivery note?

So you inherit from your base Address class to create specific address types.

For example:

public class DeliveryAddress : Address
{
    public string DeliveryNote { get; set; } = "Please don't ring the bell after 10pm."
}

Assuming you use EF Code First, Entity framework creates an Address table, with a discriminator column. When you save a new address, the discriminator column defines the type of address.

var googleCompany = new Company
{
    DeliveryAddress = new DeliveryAddress
    {
        Street = "Google Street",
        HouseNumber = 1,
        DeliveryNote = "Watch out for the dog."
    },
    CompanyAddress = new CompanyAddress()
};

var microsoftCompany = new Company
{
    DeliveryAddress = new DeliveryAddress
    {
        Street = "Microsoft Street",
        HouseNumber = 2,
        DeliveryNote = "Don't bring an Apple device on the premise."
    },
    CompanyAddress = new CompanyAddress()
};


_context.Companies.Add(googleCompany);
_context.Companies.Add(microsoftCompany);
_context.SaveChanges();

Now to query the companies and specify the type of address you need, you just need to make a call to include and let EF Core include the address.

var companiesWithBothDeliveryAddress = 
    _context.Companies.Include(x => x.CompanyAddress)
                      .Include(x => x.DeliveryAddress).ToList();

var companiesWithOnlyDeliveryAddress =
    _context.Companies.Include(x => x.DeliveryAddress).ToList();

The EF Fluent API configuration should be something like this:

        protected override void OnModelCreating(ModelBuilder builder)
        {
            // Company to CompanyAddress, without inverse property on CompanyAddress.
            builder.Entity<Company>()
                .HasOne(x => x.CompanyAddress)
                .WithOne()
                .HasForeignKey<Company>(x => x.CompanyAddressId)
                .IsRequired(false)
                .OnDelete(DeleteBehavior.NoAction);

            // Company to DeliveryAddress, without inverse property on DeliveryAddress.
            builder.Entity<Company>()
                .HasOne(x => x.DeliveryAddress)
                .WithOne()
                .HasForeignKey<Company>(x => x.DeliveryAddressId)
                .IsRequired(false)
                .OnDelete(DeleteBehavior.NoAction);

            // We let all the Address types share the 'CompanyId' column, 
            // otherwise, EF would create a seperate CompanyId column for all of them.
            builder.Entity<Address>()
                .Property(x => x.CompanyId)
                .HasColumnName(nameof(Address.CompanyId));

            builder.Entity<CompanyAddress>()
                .Property(x => x.CompanyId)
                .HasColumnName(nameof(Address.CompanyId));            
            
            builder.Entity<DeliveryAddress>()
                .Property(x => x.CompanyId)
                .HasColumnName(nameof(Address.CompanyId));

            base.OnModelCreating(builder);
        }

        public DbSet<Address> Addresses { get; set; }

        public DbSet<DeliveryAddress> DeliveryAddresses { get; set; }

        public DbSet<CompanyAddress> CompanyAddresses { get; set; }
        

The result would look like this:

Address Table (I left out some columns for conciseness)

Companies Table (I left out some columns for conciseness)