EF-Code Erster Fremdschlüssel ohne Navigationseigenschaft

Angenommen, ich habe die folgenden Entitäten:

public class Parent
{
    public int Id { get; set; }
}
public class Child
{
    public int Id { get; set; }
    public int ParentId { get; set; }
}

Wie lautet die erste fließende API-Syntax des Codes, um zu erzwingen, dass ParentId in der Datenbank mit einer Fremdschlüsseleinschränkung für die Parents-Tabelle erstellt wird, ohne dass eine Navigationseigenschaft erforderlich ist ?

Ich weiß, dass ich Folgendes tun kann, wenn ich eine Navigationseigenschaft Parent to Child hinzufüge:

modelBuilder.Entity<Child>()
    .HasRequired<Parent>(c => c.Parent)
    .WithMany()
    .HasForeignKey(c => c.ParentId);

Aber ich möchte die Navigationseigenschaft in diesem speziellen Fall nicht.

Mit EF Code First Fluent API ist dies nicht möglich. Sie benötigen immer mindestens eine Navigationseigenschaft, um eine Fremdschlüsseleinschränkung in der Datenbank zu erstellen.

Wenn Sie Code First Migrations verwenden, können Sie der Paketmanagerkonsole ( add-migration SomeNewSchemaName) eine neue codebasierte Migration hinzufügen . Wenn Sie etwas an Ihrem Modell geändert oder zugeordnet haben, wird eine neue Migration hinzugefügt. Wenn Sie nichts geändert haben, erzwingen Sie eine neue Migration mit add-migration -IgnoreChanges SomeNewSchemaName. Die Migration enthält in diesem Fall nur leere Upund DownMethoden.

Anschließend können Sie die UpMethode ändern , indem Sie Folgendes hinzufügen:

public override void Up()
{
    // other stuff...

    AddForeignKey("ChildTableName", "ParentId", "ParentTableName", "Id",
        cascadeDelete: true); // or false
    CreateIndex("ChildTableName", "ParentId"); // if you want an index
}

Wenn Sie diese Migration ( update-databaseauf der Paketverwaltungskonsole) ausführen, wird eine ähnliche SQL-Anweisung ausgeführt (für SQL Server):

ALTER TABLE [ChildTableName] ADD CONSTRAINT [FK_SomeName]
FOREIGN KEY ([ParentId]) REFERENCES [ParentTableName] ([Id])

CREATE INDEX [IX_SomeName] ON [ChildTableName] ([ParentId])

Alternativ können Sie ohne Migrationen einfach einen reinen SQL-Befehl mit ausführen

context.Database.ExecuteSqlCommand(sql);

Dabei contexthandelt es sich um eine Instanz Ihrer abgeleiteten Kontextklasse und sqlnur um den obigen SQL-Befehl als Zeichenfolge.

Beachten Sie, dass EF bei alledem keine Ahnung hat, dass ParentIdes sich um einen Fremdschlüssel handelt, der eine Beziehung beschreibt. EF betrachtet es nur als gewöhnliche Skalareigenschaft. Irgendwie ist all das nur komplizierter und langsamer als das Öffnen eines SQL-Verwaltungstools und das manuelle Hinzufügen der Einschränkung.

Obwohl dieser Beitrag Entity Frameworknicht Entity Framework Coredazu gedacht ist, kann er für jemanden nützlich sein, der dasselbe mit Entity Framework Core erreichen möchte (ich verwende V1.1.2).

Ich habe keine Navigationseigenschaften müssen (obwohl sie sind nett) , weil ich DDD übe und ich möchte Parentund Childzwei separate Aggregate Wurzeln zu sein. Ich möchte, dass sie über Fremdschlüssel und nicht über infrastrukturspezifische Entity FrameworkNavigationseigenschaften miteinander kommunizieren können .

Alles, was Sie tun müssen, ist, die Beziehung auf einer Seite mit HasOneund WithManyohne Angabe der Navigationseigenschaften zu konfigurieren (sie sind schließlich nicht vorhanden).

public class AppDbContext : DbContext
{
    public AppDbContext(DbContextOptions<AppDbContext> options) : base(options) {}

    protected override void OnModelCreating(ModelBuilder builder)
    {
        ......

        builder.Entity<Parent>(b => {
            b.HasKey(p => p.Id);
            b.ToTable("Parent");
        });

        builder.Entity<Child>(b => {
            b.HasKey(c => c.Id);
            b.Property(c => c.ParentId).IsRequired();

            // Without referencing navigation properties (they're not there anyway)
            b.HasOne<Parent>()    // <---
                .WithMany()       // <---
                .HasForeignKey(c => c.ParentId);

            // Just for comparison, with navigation properties defined,
            // (let's say you call it Parent in the Child class and Children
            // collection in Parent class), you might have to configure them 
            // like:
            // b.HasOne(c => c.Parent)
            //     .WithMany(p => p.Children)
            //     .HasForeignKey(c => c.ParentId);

            b.ToTable("Child");
        });

        ......
    }
}

Ich gebe auch Beispiele zum Konfigurieren von Entitätseigenschaften, aber das wichtigste hier ist HasOne<>, WithMany()und HasForeignKey().

Ich hoffe es hilft.

Kleiner Hinweis für diejenigen, die DataAnotations verwenden und die Navigationseigenschaft nicht verfügbar machen möchten - verwenden protected

public class Parent
{
    public int Id { get; set; }
}
public class Child
{
    public int Id { get; set; }
    public int ParentId { get; set; }

    protected virtual Parent Parent { get; set; }
}

Das war's - der Fremdschlüssel mit cascade:trueAfter Add-Migrationwird erstellt.

Im Fall von EF Core müssen Sie nicht unbedingt eine Navigationseigenschaft angeben. Sie können einfach einen Fremdschlüssel auf einer Seite der Beziehung angeben. Ein einfaches Beispiel mit Fluent API:

using Microsoft.EntityFrameworkCore;
using System.Collections.Generic;

namespace EFModeling.Configuring.FluentAPI.Samples.Relationships.NoNavigation
{
    class MyContext : DbContext
    {
        public DbSet<Blog> Blogs { get; set; }
        public DbSet<Post> Posts { get; set; }

        protected override void OnModelCreating(ModelBuilder modelBuilder)
        {
             modelBuilder.Entity<Post>()
                .HasOne<Blog>()
                .WithMany()
                .HasForeignKey(p => p.BlogId);
        }
    }

    public class Blog
    {
         public int BlogId { get; set; }
         public string Url { get; set; }
    }

    public class Post
    {
         public int PostId { get; set; }
         public string Title { get; set; }
         public string Content { get; set; }

        public int BlogId { get; set; }
    }
}

Ich verwende .Net Core 3.1, EntityFramework 3.1.3. Ich habe mich umgesehen und die Lösung, die ich gefunden habe, war die Verwendung der generischen Version von HasForeginKey<DependantEntityType>(e => e.ForeginKeyProperty). Sie können eine Eins-zu-Eins-Beziehung wie folgt erstellen:

builder.entity<Parent>()
.HasOne<Child>()
.WithOne<>()
.HasForeginKey<Child>(c => c.ParentId);

builder.entity<Child>()
    .Property(c => c.ParentId).IsRequired();

Ich hoffe, dies hilft oder liefert zumindest einige andere Ideen zur Verwendung der HasForeginKeyMethode.

Mein Grund dafür nicht Navigationseigenschaften verwende, sind Klassenabhängigkeiten. Ich habe meine Modelle in wenige Baugruppen unterteilt, die in verschiedenen Kombinationen in verschiedenen Projekten verwendet werden können oder nicht. Wenn ich also eine Entität habe, die über eine Nagivationseigenschaft verfügt, die von einer anderen Assembly klassifiziert werden soll, muss ich auf diese Assembly verweisen, die ich vermeiden möchte (oder jedes Projekt, das einen Teil dieses vollständigen Datenmodells verwendet, enthält alles).

Und ich habe eine separate Migrations-App, die für Migrationen (ich verwende Automigrationen) und die anfängliche DB-Erstellung verwendet wird. Dieses Projekt bezieht sich aus offensichtlichen Gründen auf alles.

Lösung ist C-Stil:

• Datei mit Zielklasse über Link in Migrationsprojekt "kopieren" (Drag & Drop mit altSchlüssel in VS)
• Deaktivieren Sie die Nagivationseigenschaft (und das FK-Attribut) über #if _MIGRATION
• Legen Sie diese Präprozessordefinition in der Migrations-App fest und legen Sie sie nicht im Modellprojekt fest, damit sie auf nichts verweist ( Contactim Beispiel nicht auf Assembly mit Klasse verweisen ).

Stichprobe:

    public int? ContactId { get; set; }

#if _MIGRATION
    [ForeignKey(nameof(ContactId))]
    public Contact Contact { get; set; }
#endif

Natürlich sollten Sie die usingDirektive auf die gleiche Weise deaktivieren und den Namespace ändern.

Danach können alle Konsumenten diese Eigenschaft wie gewohnt als DB-Feld verwenden (und nicht auf zusätzliche Assemblys verweisen, wenn sie nicht benötigt werden), aber der DB-Server weiß, dass es sich um FK handelt, und kann Kaskadierung verwenden. Sehr schmutzige Lösung. Funktioniert aber.