Fluent Api Entity Framework core

问题

A user can have 1 or 0 account

public class User
    {
        public int UserId { get; set; }
        public string Name { get; set; }
        public string Email { get; set; }
        public Account Account { get; set; }
    }

    public class Account
    {
        public int AccountId { get; set; }         
        public DateTime CreatedDateTime { get; set; }
        public User User { get; set; }

    }

This is the fluent api code using Entity Framework 6

public class ClassDbContext: DbContext
{
    protected override void OnModelCreating(DbModelBuilder modelBuilder)
    {

        modelBuilder.Entity<User>()
                  .HasOptional(s => s.Account) 
                  .WithRequired(ad => ad.User);
    }
    public DbSet<User> Users { get; set; }
    public DbSet<Account> Accounts { get; set; }
}

This is the result ResultImage

what is the equivalent fluent api code using Entity Framework Core?

回答1:

@Tseng is close, but not enough. With the proposed configuration you'll get exception with message:

The child/dependent side could not be determined for the one-to-one relationship that was detected between 'Account.User' and 'User.Account'. To identify the child/dependent side of the relationship, configure the foreign key property. See http://go.microsoft.com/fwlink/?LinkId=724062 for more details.

It's basically explained in the documentation from the link.

First, you need to use HasOne and WithOne.

Second, you must use HasForeignKey to specify which one of the two entities is the dependent (it cannot be detected automatically when there is no separate FK property defined in one of the entities).

Third, there is no more required dependent. The IsRequired method can be used to specify if the FK is required or not when the dependent entity uses separate FK (rather than PK as in your case, i.e. with the so called Shared Primary Key Association because PK apparently cannot be null).

With that being said, the correct F Core fluent configuration of the posted model is as follows:

modelBuilder.Entity<User>()
    .HasOne(e => e.Account)
    .WithOne(e => e.User)
    .HasForeignKey<Account>(e => e.AccountId);

and the result is:

migrationBuilder.CreateTable(
    name: "User",
    columns: table => new
    {
        UserId = table.Column<int>(nullable: false)
            .Annotation("SqlServer:ValueGenerationStrategy", SqlServerValueGenerationStrategy.IdentityColumn),
        Email = table.Column<string>(nullable: true),
        Name = table.Column<string>(nullable: true)
    },
    constraints: table =>
    {
        table.PrimaryKey("PK_User", x => x.UserId);
    });

migrationBuilder.CreateTable(
    name: "Account",
    columns: table => new
    {
        AccountId = table.Column<int>(nullable: false),
        CreatedDateTime = table.Column<DateTime>(nullable: false)
    },
    constraints: table =>
    {
        table.PrimaryKey("PK_Account", x => x.AccountId);
        table.ForeignKey(
            name: "FK_Account_User_AccountId",
            column: x => x.AccountId,
            principalTable: "User",
            principalColumn: "UserId",
            onDelete: ReferentialAction.Cascade);
    });

回答2:

Pretty much the same, with other names.

modelBuilder.Entity<User>()
    .HasOne(s => s.Account) 
    .WithOne(ad => ad.User)
    .IsRequired(false);

来源：https://stackoverflow.com/questions/43546825/fluent-api-entity-framework-core