Внешние и основные ключи в отношениях

Все связи "один к одному" и "один ко многим " определяются внешним ключом в зависимом конце, который ссылается на первичный или альтернативный ключ в конце субъекта. Для удобства этот первичный или альтернативный ключ называется "основным ключом" для связи. Связи "многие ко многим " состоят из двух связей "один ко многим", каждая из которых определяется внешним ключом, ссылающимся на ключ субъекта.

Внешние ключи;

Свойство или свойства, составляющие внешний ключ, часто обнаруживаются по соглашению. Свойства также можно настроить явным образом с помощью атрибутов сопоставления или в HasForeignKey API сборки модели. HasForeignKey можно использовать с лямбда-выражением. Например, для внешнего ключа, состоящего из одного свойства:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasForeignKey(e => e.ContainingBlogId);
}

Или для составного внешнего ключа, состоящего из нескольких свойств:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasForeignKey(e => new { e.ContainingBlogId1, e.ContainingBlogId2 });
}

HasForeignKey также можно передать имя свойства внешнего ключа в виде строки. Например, для одного свойства:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasForeignKey("ContainingBlogId");
}

Или для составного внешнего ключа:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasForeignKey("ContainingBlogId1", "ContainingBlogId2");
}

Использование строки полезно в следующих случаях:

• Свойство или свойства являются частными.
• Свойство или свойства не существуют в типе сущности и должны быть созданы в виде теневых свойств.
• Имя свойства вычисляется или строится на основе некоторых входных данных процесса сборки модели.

Столбцы внешнего ключа, не допускающие значения NULL

Как описано в необязательных и обязательных отношениях, значение NULL свойства внешнего ключа определяет, является ли связь необязательной или обязательной. Однако свойство внешнего ключа, допускающее значение NULL, можно использовать для требуемой связи с помощью атрибута [Required]или вызова IsRequired в API сборки модели. Например:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasForeignKey(e => e.BlogId)
        .IsRequired();
}

Или, если внешний ключ обнаруживается по соглашению, IsRequired то его можно использовать без вызова HasForeignKey:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .IsRequired();
}

Конечным результатом этого является то, что столбец внешнего ключа в базе данных не допускает значения NULL, даже если свойство внешнего ключа является пустым. То же самое можно достичь, явно настроив свойство внешнего ключа в соответствии с обязательным требованием. Например:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .Property(e => e.BlogId)
        .IsRequired();
}

Тени внешних ключей

Свойства внешнего ключа можно создать в виде теневых свойств. Теневое свойство существует в модели EF, но не существует в типе .NET. EF отслеживает значение свойства и состояние внутри страны.

Теневые внешние ключи обычно используются, если существует желание скрыть реляционную концепцию внешнего ключа из модели домена, используемой кодом приложения или бизнес-логикой. Затем этот код приложения полностью управляет связью через навигации.

Свойства теневых внешних ключей часто создаются соглашением. Внешний ключ тени также будет создан, если аргумент HasForeignKey не соответствует ни одному свойству .NET. Например:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasForeignKey("MyBlogId");
}

По соглашению теневой внешний ключ получает его тип из основного ключа в связи. Этот тип допускает значение NULL, если связь не обнаружена как или настроена по мере необходимости.

Свойство теневого внешнего ключа также можно создать явно, что полезно для настройки аспектов свойства. Например, чтобы сделать свойство не допускаемым значением NULL:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .Property<string>("MyBlogId")
        .IsRequired();

    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasForeignKey("MyBlogId");
}

Создание теневого свойства, если заданное имя не соответствует ни одному свойству типа сущности, можно отключить с помощью ConfigureWarnings. Например:

protected override void OnConfiguring(DbContextOptionsBuilder optionsBuilder)
    => optionsBuilder.ConfigureWarnings(b => b.Throw(CoreEventId.ShadowPropertyCreated));

Имена ограничений внешнего ключа

По соглашению ограничения внешнего ключа называются FK_<dependent type name>_<principal type name>_<foreign key property name>. Для составных внешних ключей <foreign key property name> становится разделенным списком имен свойств внешнего ключа подчеркивания.

Это можно изменить в API сборки модели с помощью HasConstraintName. Например:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasForeignKey(e => e.BlogId)
        .HasConstraintName("My_BlogId_Constraint");
}

Индексы для внешних ключей

По соглашению EF создает индекс базы данных для свойства или свойств внешнего ключа. Дополнительные сведения о типах индексов, созданных соглашением, см . в соглашениях о сборке моделей.

Ключи субъекта

По соглашению внешние ключи ограничены первичным ключом в конце отношения. Однако вместо этого можно использовать альтернативный ключ. Это достигается с помощью HasPrincipalKey API сборки модели. Например, для одного внешнего ключа свойства:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasPrincipalKey(e => e.AlternateId);
}

Или для составного внешнего ключа с несколькими свойствами:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasPrincipalKey(e => new { e.AlternateId1, e.AlternateId2 });
}

HasPrincipalKey можно также передать имя альтернативного свойства ключа в виде строки. Например, для одного ключа свойства:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasPrincipalKey("AlternateId");
}

Или для составного ключа:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Blog>()
        .HasMany(e => e.Posts)
        .WithOne(e => e.Blog)
        .HasPrincipalKey("AlternateId1", "AlternateId2");
}

Для определения альтернативного ключа основной сущности не требуется HasAlternateKey вызывать вызов. Это делается автоматически при HasPrincipalKey использовании с свойствами, которые не являются свойствами первичного ключа. HasAlternateKey Однако можно использовать для дальнейшей настройки альтернативного ключа, например для задания имени ограничения базы данных. Дополнительные сведения см. в разделе "Ключи ".

Связи с бессерверными сущностями

Каждая связь должна иметь внешний ключ, ссылающийся на основной (первичный или альтернативный) ключ. Это означает, что тип сущности без ключей не может выступать в качестве основного конца связи, так как для ссылок на внешние ключи нет основного ключа.

Однако типы сущностей без ключей по-прежнему могут иметь внешние ключи и, следовательно, могут выступать в качестве зависимого конца связи. Например, рассмотрим эти типы, где Tag нет ключа:

public class Tag
{
    public string Text { get; set; } = null!;
    public int PostId { get; set; }
    public Post Post { get; set; } = null!;
}

public class Post
{
    public int Id { get; set; }
}

Tag можно настроить в зависимом конце связи:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Tag>()
        .HasNoKey();

    modelBuilder.Entity<Post>()
        .HasMany<Tag>()
        .WithOne(e => e.Post);
}

Внешние ключи в отношениях "многие ко многим"

В отношениях "многие ко многим" внешние ключи определяются в типе сущности соединения и сопоставляются с ограничениями внешнего ключа в таблице соединения. Все описанное выше можно также применить к этим внешним ключам сущности соединения. Например, задание имен ограничений базы данных:

protected override void OnModelCreating(ModelBuilder modelBuilder)
{
    modelBuilder.Entity<Post>()
        .HasMany(e => e.Tags)
        .WithMany(e => e.Posts)
        .UsingEntity(
            l => l.HasOne(typeof(Tag)).WithMany().HasConstraintName("TagForeignKey_Constraint"),
            r => r.HasOne(typeof(Post)).WithMany().HasConstraintName("PostForeignKey_Constraint"));
}