Wie implementiert man eine 'eins zu viele'-Beziehung…

In der Datenbank:

Es wird eine Tabelle für "eins" (den Elternteil) und eine Tabelle für "viele" (die Kinder) erstellt.
Es wird ein Fremdschlüssel in der Tabelle "viele" hinzugefügt, der auf den Primärschlüssel der Tabelle "eins" verweist.
Beispiel: Tabellen Companies und Employees. In der Tabelle Employees gibt es eine Spalte CompanyId (Fremdschlüssel), die auf Id (Primärschlüssel) in der Tabelle Companies verweist.

In C#-Code:

Mit Entity Framework Core:

Es werden Modellklassen für den Elternteil und die Kinder definiert.
Die Elternklasse enthält eine Sammlung von Kindobjekten.

Die Kindklasse enthält eine Referenz auf das Elternobjekt und den Fremdschlüssel.

public class Company
{
    public int Id { get; set; }
    public string Name { get; set; }
    public ICollection<Employee> Employees { get; set; } // Navigations-Eigenschaft für "viele"
}

public class Employee
{
    public int Id { get; set; }
    public string Name { get; set; }
    public int CompanyId { get; set; } // Fremdschlüssel
    public Company Company { get; set; } // Navigations-Eigenschaft für "eins"
}

Im Datenbankkontext werden die Beziehungen konfiguriert (manchmal kann Entity Framework Core sie anhand der Konvention erkennen).

public class ApplicationDbContext : DbContext
{
    public DbSet<Company> Companies { get; set; }
    public DbSet<Employee> Employees { get; set; }

    protected override void OnModelCreating(ModelBuilder modelBuilder)
    {
        // Explizite Angabe der Beziehung (nicht immer notwendig)
        modelBuilder.Entity<Company>()
            .HasMany(c => c.Employees) // Das Unternehmen hat viele Mitarbeiter
            .WithOne(e => e.Company) // Der Mitarbeiter hat ein Unternehmen
            .HasForeignKey(e => e.CompanyId); // Fremdschlüssel in der Tabelle Employee
    }
}

Ohne ORM (manuell):

Daten werden aus der Datenbank mit JOIN-Abfragen abgerufen.

// Beispiel SQL-Abfrage
// SELECT c.Name AS CompanyName, e.Name AS EmployeeName
// FROM Companies c
// JOIN Employees e ON c.Id = e.CompanyId;

Entsprechende Klassen werden erstellt und Objekte nach dem Abrufen manuell verbunden.

public class Company
{
    public string Name { get; set; }
    public List<Employee> Employees { get; set; } // Sammlung zum Speichern der verbundenen Objekte
}

public class Employee
{
    public string Name { get; set; }
}

// Beispiel für die Erstellung von Objekten nach dem Abrufen der Daten
// Company company = new Company { Name = "ACME Corp", Employees = new List<Employee>() };
// company.Employees.Add(new Employee { Name = "Alice" });
// company.Employees.Add(new Employee { Name = "Bob" });

Wie implementiert man eine 'eins zu viele'-Beziehung in einer Datenbank oder im C#-Code?