Entity Framework – Tipps und Tricks

In diesem Blogbeitrag möchte ich einige Tipps und Tricks rund um Entity Framework mit euch teilen. In allen Beispielen gehen wir vom Code-First Ansatz aus.

 

1. 1-zu-1 Beziehung

Es gibt keine 1-zu-1 Beziehung in Datenbanken. Es gibt lediglich eine 1-zu-0/1 Beziehung. In Entity Framework wird diese Beziehung am besten mit der Fluent-API beschrieben.

public class Employee 
{
    public string Name { get; set; }
    public virtual Address Address { get; set; }    
}
 
public class Address
{
    public string Street { get; set; }
    public string PostCode { get; set; }
    public string City { get; set; }
    public virtual Employee Employee { get; set; }
}

Hier hat jede Datenbank ein Henne-Ei-Problem. Die Objekte können nicht simultan generiert werden und sofort auf das andere Objekt referenzieren.

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Address>()
                .HasOptional(e => e.Address) 
                .WithRequired(a => a.Employee); 
}

In diesem Beispiel kann ein Employee eine Address haben, aber ein Address kann nicht ohne Employee existieren.

Anmerkung: Mit Entity Framework kann eine (echte) 1-zu-1 Beziehung vorgetäuscht werden. Für die Datenbank sind diese Felder jedoch keine Pflichtfelder und somit keine echte 1-zu-1 Beziehung.

2. Mehr als eine 1-zu-n Beziehung zwischen zwei Entitäten

In unserem Beispiel gibt es folgende (vereinfachte) Klassen:

public class User
{
    public int Id { get; set; }
    public string UserName { get; set; }
}

public class Task
{
    public string Title { get; set; }
    public string Body { get; set; }
    public virtual User CreatedBy { get; set; }
}

Daraus resultiert folgende Datenbank:

Datenbank mit einer 1-zu-n Beziehung
Datenbank mit einer 1-zu-n Beziehung

Jetzt möchten wir die Klasse Task noch um einen User erweitern, der diese Aufgabe zugewiesen bekommt. Somit hätten wir zwei 1-zu-n Beziehungen zwischen Task und User. Mit Data Annotations lässt sich diese Beziehung einfach realisieren:

public class User
{
    public int Id { get; set; }
    public string UserName { get; set; }
    [InverseProperty(“AssignedTo”)]
    public virtual ICollection<Task> Tasks { get; set; }
}
public class Task
{
    public int Id { get; set; }
    public string Title { get; set; }
    public string Body { get; set; }
    public virtual User CreatedBy { get; set; }
    public virtual User AssignedTo { get; set; }
}

Daraus resultiert dann folgende Datenbank:

Datenbank mit zwei 1-zu-n Beziehung
Datenbank mit zwei 1-zu-n Beziehung

3. Mit Entity Framework habe ich gar keine Kontrolle über meine Tabellen

Das ist ein hartnäckiges Vorurteil gegenüber Entity Framework, welches aber nicht ganz wahr ist. Wenn eine Zwischentabelle (für eine n-zu-m Beziehung) in Entity Framework erstellt wird, wird die Zwischentabelle mit dem Namen der verbundenen Entitäten erstellt.

public class Employee
{
    public string Firstname { get; set; }
    public string Lastname { get; set; }
    public virtual ICollection<Skill> Skills { get; set; }
}
 
public class Skill
{
    public string Name { get; set; }
    public int Level { get; set; }
    public virtual ICollection<Employee> Employees { get; set; }
}

Daraus kann nun eine EmployeeSkills oder eine SkillEmployees Tabelle entstehen. Die Erstellung dieser Zwischentabelle kann mit der Fluent-API gesteuert werden.

protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
    modelBuilder.Entity<Employee>()
          .HasMany<Skill>(e => e.Skills)
                .WithMany(s => s.Employees)
                .Map(es =>
                {
                    es.MapLeftKey(“EmployeeRefId”);
                    es.MapRightKey(“SkillRefId”);
                    es.ToTable(“EmployeeSkillList”);
                });
}

Die Methoden HasMany() und WithMany() werden zur Konfiguration von n-zu-m Beziehungen verwendet. Danach wird mit der Map() Methode die Tabelle mit dem gewünschten Namen definiert.

Wichtig: Die Entität, aus welcher die HasMany() Methode aufgerufen wird (in unserem Beispiel die Employee Entität), wird mit MapLeftKey() in die „linke Spalte“ geschrieben.

4. SQL + Entity Framework = <3

Eine Kombination aus SQL und Entity Framework ist immer möglich. Die Performance bei komplexen Abfragen mit vielen ungewollten JOINS kann Entity Framework schnell in die Knie zwingen. Eine Kombination aus Entity Framework und einer SQL View kann die Performance enorm anheben. Im nächsten Beispiel haben wir eine sehr simple View, die uns die Namen der Mitarbeiter, deren Skills und deren Skillstufe anzeigt:

CREATE VIEW SkillOverview AS
SELECT E.Firstname as Firstname, E.Lastname as Name, S.Level as Level, S.Name as Skill FROM Employees E
JOIN EmployeeSkillList ESL ON ESL.EmployeeRefId = E.Id
JOIN Skills S ON S.Id = ESL.SkillRefId

Als nächstes erstellen wir ein Datenmodell:

public class SkillOverviewModel
{
    public string Firstname { get; set; }
    public string Name { get; set; }
    public int Level { get; set; }
    public string Skill { get; set; }
}

Nun erstellen wir eine Methode, die uns das Datenmodell anhand der View befüllt:

public ICollection<SkillOverviewModel> GetSkillOverview()
{
    string query = “SELECT * FROM [dbo].[SkillOverview]”;           
    List<SkillOverviewModel> result = this.context.Database.SqlQuery<SkillOverviewModel>
   (query).ToList();
    return result;
}

Mit demselben Prinzip können auch SQL-Functions und Stored Procedures angesprochen werden. Die Parameter werden als SqlParameter Array übergeben. Wenn wir also nur die Mitarbeiter mit einem bestimmten Skill-Level sehen wollen entwickeln wir eine neue Methode:

public ICollection<SkillOverviewModel> GetSkillOverview(int skillLevel)
{
    string query = “SELECT * FROM [dbo].[SkillOverview] WHERE [Level] = @skillLevel”;
    List<object> parameters = new List<object>();
    SqlParameter skillLevelParameter = new SqlParameter(“@skillLevel”, skillLevel);
    parameters.Add(skillLevelParameter);
    List<SkillOverviewModel> result = this.context.Database.SqlQuery<SkillOverviewModel>
          (query, parameters.ToArray()).ToList();
   return result;
}

5. Darf es noch ein wenig mehr sein?

Durch den Code First-Ansatz spiegeln unsere Entitäts-Objekte eine ganze Zeile einer Tabelle ab. In einigen Anwendungen können Entitäten viele Eigenschaften haben, die gar nicht immer benötigt werden.

public class Employee
{
    public int Id { get; set; }
    public string Firstname { get; set; }
    public string Lastname { get; set; }
    public virtual ICollection<Skill> Skills { get; set; }
}

class Program
{
static void Main(string[] args)
{
AppContext context = new AppContext();
List<Employee> employees = context.Employee.ToList();
Console.ReadKey();
}
}​

Diese Abfrage liefert uns nun alle Einträge in der Employee Tabelle. Dadurch wird Id, Firstname und Lastname von jeder Entität geladen. Aber was ist mit den Skills eines Mitarbeiters? Lazy Loading ist standardmäßig aktiviert bei Entity Framework. Dadurch werden die Skills erst dann geladen, wenn diese gebraucht werden.

static void Main(string[] args)
{
    AppContext context = new AppContext();
    List<Employee> employees = context.Employee.ToList();
    foreach(Employee employee in employees)
    {
        Console.WriteLine($”{employee.Firstname} {employee.Lastname}”);
        foreach(Skill employeeSkill in employee.Skills)
        {
            Console.WriteLine($”{employeeSkill.Name}: {employeeSkill.Level}”);
        }
    }
    Console.ReadKey();
}

Alle Employees sind bereits geladen, aber deren Skills leider nicht. Dadurch wird in der inneren foreach-Anweisung jedes Mal ein Request zur Datenbank geschickt und lädt den Skill nach. Besser wäre es, wenn die Skills direkt mit den Employees geladen werden. Mit der Include() Methode lässt sich das einfach realisieren:

List<Employee> employees = context.Employee.Include(e => e.Skills).ToList();

6. Das habe ich doch gar nicht gebraucht!

Wie wir sehen, verwenden wir nur FirstName und LastName von Employee sowie Name und Level von Skill. Mitgeladen wird aber auch jeweils die Id. Unser Beispiel ist etwas “klein”, aber stellen Sie sich vor, Sie haben zwei Entitäten mit verschiedenen Datentypen wie Datum, Integer, Float und davon auch noch viele. Diese werden nicht benötigt, aber auch geladen. In SQL würden wir auch nicht

SELECT * FROM [TABLE] 

ausführen, um dann nur die Daten aus der Menge zu nehmen, die wir brauchen. Wieso sollten wir das dann bei Entity Framework tun?

Unser Ergebnis von der Query kommt wieder in ein Model:

public class FullNameModel
{
    public string FullName { get; }
    public FullNameModel(Employee employee)
    {
        this.FullName = $”{employee.Firstname} {employee.Lastname}”;
    }
}
public ICollection<FullNameModel> GetAllFullNames()
{
    List<FullNameModel> result = this.context.Employee
                                        .Select(x => new FullNameModel
                                        {
                                            FullName = $”{x.Firstname} {x.Lastname}”
                                        }).ToList();
    return result;                                                                                                                                                                                                     }

Übersetzt lautet dieser Code: SELECT Firstname, Lastname FROM [Employees] also genau das, was wir brauchen. Ein Entity Framework Select-Statement mit einem angepasstem Data Transfer Object(DTO) kann genauso schnell sein wie ein direktes SQL Statement.

Wichtig: Im Select-Statement kann nur ein parameterloser Konstruktor verwendet werden.

Fazit

Entity Framework oder SQL? Wieso nicht beides? Entity Framework kann die Arbeit erleichtern, aber nicht alles ist standardmäßig genau so eingestellt, wie der Entwickler es gerade braucht. Durch eine gute Kombination aus Entity Framework und SQL können Schwächen kompensiert und Entwicklungszeit verkürzt werden. Dank Codefirst wird die Datenbankgenerierung in der Codeverwaltung gespeichert und ein Wechsel der Datenbankengine ist einfacher zu realisieren. Der Einsatz von Entity Framework ersetzt nicht das Grundwissen von relationaler Datenmodellierung, sondern sollte diese ergänzen.

Erfahren Sie mehr

Ich bin im Flow! – Eine Übersicht zu Microsoft Flow
Blog
Blog

Ich bin im Flow! – Eine Übersicht zu Microsoft Flow

Die Power Platform wird aktuell von Microsoft sehr stark gepusht. Zeit, sich mit dem Potenzial der einzelnen Komponenten zu beschäftigen. Heute: Flow.

DevOps und Container
Blog
Blog

DevOps und Container

DevOps an sich ist nicht an eine Technologie gebunden, jedoch haben sich Container-Technologien und DevOps als Verwandte im Geiste gefunden.

PowerApps – Neuigkeiten, Übersicht, Tipps & Tricks
Blog
Blog

PowerApps – Neuigkeiten, Übersicht, Tipps & Tricks

Neues aus der Welt von PowerApps

May
04
novaCapta auf der dotnet Cologne
Event
Event

novaCapta auf der dotnet Cologne

In nächster Nachbarschaft zu unserem Kölner Büro findet am 04. und 05. Mai die dotnet Cologne im KOMED statt. Wir von der novaCapta sind auch dabei.

Office 365 Groups als Evolution von SharePoint?
Blog
Blog

Office 365 Groups als Evolution von SharePoint?

Zusätzlich zu SharePoint erlauben die Office 365 Groups es mir als Anwender, schnell und einfach neue Gruppen anzulegen und selbständig Benutzer hinzuzufügen.

Das neuste Mitglied der Office 365 Familie: Delve
Blog
Blog

Das neuste Mitglied der Office 365 Familie: Delve

Microsoft legt nach: Mit Delve startet eine neue Form des Suchens und des Auffinden von Dokumenten und Informationen.

Azure Functions: Der Webservice ohne Webserver
Blog
Blog

Azure Functions: Der Webservice ohne Webserver

Azure Functions als Authentifizierungs-Helfer für clientseitige Lösungen mit 3rd Party APIs

DevOps und „The Phoenix Project“
Blog
Blog

DevOps und „The Phoenix Project“

Buchvorstellung "Projekt Phoenix: Der Roman über IT und DevOps - Neue Erfolgsstrategien für Ihre Firma" von Gene Kim.

Paket Dependency Manager für .NET
Blog
Blog

Paket Dependency Manager für .NET

Paket ist ein Dependency Manager für .NET, welcher es sich zum Ziel gesetzt hat einige Probleme von NuGet zu beheben.

Sprechen Sie LUIS? – Der intelligente Chat-Bot im Praxistest
Blog
Blog

Sprechen Sie LUIS? – Der intelligente Chat-Bot im Praxistest

Mit LUIS, der Sprach- und Texterkennungssoftware von Microsoft, und dem Bot Framework von Azure haben wir eine Lösung für den IT-Support entwickelt.

Jan
25
Webcast mit Microsoft: Fit für die digitale Arbeitswelt
Webinar
Webinar

Webcast mit Microsoft: Fit für die digitale Arbeitswelt

Die digitale Transformation und die Veränderung der Arbeitswelt ist längst in vielen Unternehmen und in den öffentlichen Einrichtungen angekommen. Dennoch stell...

Theobald Software neuer Partner von novaCapta
News
News

Theobald Software neuer Partner von novaCapta

Komplexe SAP-Prozesse direkt in SharePoint durchführen – dabei unterstützt uns unser neuer Partner Theobald Software.