imported>INOUIW: /* growthexperiments-addlink-summary-summary:1|0|0 */

2025-06-07T14:26:19Z

growthexperiments-addlink-summary-summary:1|0|0

Neue Seite

{{Infobox Software
|Name = ADO.NET Entity Framework (bis ca. 2012), Entity Framework
|Logo =
|Screenshot = 
|Beschreibung = 
|Maintainer = [[GitHub]]
|Hersteller = [[Microsoft]] (ursprünglich)
|Erscheinungsjahr = 2008
|AktuelleVersion = 6.4.4
|AktuelleVersionFreigabeDatum = 15. Mai 2020
|AktuelleVorabVersion =
|AktuelleVorabVersionFreigabeDatum =
|Betriebssystem =
|Programmiersprache =
|Kategorie = [[Objektrelationale Abbildung|ORM]]-Framework
|Lizenz = [[Apache-Lizenz|Apache 2.0]]
|Deutsch =
|Sonstiges =
|Website = [https://github.com/dotnet/ef6 EF auf GitHub]
|Dateien =
}}
{{Infobox Software
| Name = Entity Framework Core auch: EF Core
| Logo =
| Screenshot = 
| Beschreibung = 
| Maintainer = [[GitHub]]
| Hersteller =
| Erscheinungsjahr = 2016
| AktuelleVersion = 6.0.8<ref name="currentVersion">[https://github.com/dotnet/efcore/releases Releases], in: [[GitHub]], abgerufen am 30. Aug. 2022</ref>
| AktuelleVersionFreigabeDatum = August 2022
| AktuelleVorabVersion = 7.0 Preview 7<ref name="currentVersion" />
| AktuelleVorabVersionFreigabeDatum = August 2022
| Betriebssystem =
| Programmiersprache =
| Kategorie = [[Objektrelationale Abbildung|ORM]]-Framework
| Lizenz = [[Apache-Lizenz|Apache 2.0]]
| Deutsch =
| Website = [https://github.com/dotnet/efcore EF Core auf GitHub]
| Sonstiges =
}}
'''Entity Framework''', kurz auch '''EF''', ist ein [[Framework]] für [[objektrelationale Abbildung]] (ORM). Es wurde von [[Microsoft]] entwickelt und dient dem ORM auf [[.Net-Framework]]- sowie auf [[.NET (Plattform)|.NET]]-Objektstrukturen. Seine erste finale Version erschien als Teil des .NET Framework 3.5 ([[Service Pack]] 1) im Jahr 2008. Damals trug es den Namen '''ADO.NET Entity Framework'''. Für die folgende Version, die die Nummer 4.0 trägt und 2010 als Teil des .NET Framework 4.0 erschien, wurde das Framework deutlich erweitert. Ab der Version 4.1 wird das Entity Framework unabhängig von der Entwicklung des .NET Frameworks fortgeführt. Etwa seit dem Jahr 2012, in dem die Version 5.0 erschien und Microsoft das Framework [[quelloffen]] verfügbar machte, heißt es ''Entity Framework''. Ab der Version 6.0, die 2013 erschien, gehört das Framework nicht mehr zum .NET Framework.<ref>Holger Schwichtenberg: [https://www.heise.de/newsticker/meldung/Microsoft-stellt-OR-Mapper-von-NET-quelloffen-zur-Verfuegung-1647266.html ''Microsoft stellt OR-Mapper von .NET quelloffen zur Verfügung''], in: [[heise online]] vom 19. Juli 2012, abgerufen am 7. Dez. 2015.</ref><ref>Holger Schwichtenberg: [https://www.heise.de/newsticker/meldung/Asynchrone-Datenbankzugriffe-mit-Microsofts-Entity-Framework-6-0-1981569.html ''Asynchrone Datenbankzugriffe mit Microsofts Entity Framework 6.0''], in: [[heise online]] vom 18. Okt. 2013, abgerufen am 7. Dez. 2015.</ref>

Einhergehend mit [[.NET Core]] gibt es seit 2016 das separate Framework '''Entity Framework Core''', das auch '''EF Core''' genannt wird. Seit der .NET Core Version 3 ist dieses ein Zusatzpaket und nicht mehr automatisch Bestandteil von .NET Core.<ref>{{Internetquelle |url=https://devblogs.microsoft.com/dotnet/announcing-entity-framework-core-3-1-and-entity-framework-6-4/ |titel=Announcing Entity Framework Core 3.1 and Entity Framework 6.4 – .NET Blog |abruf=2019-12-07}}</ref>

== Modellieransätze ==
{| class="wikitable"
|+ Entity Framework Modellieransätze
!   !! Code First !! Model First
|-
! Keine Datenbank vorhanden
| Bestehende [[Klasse (Objektorientierung)|Klassen]] werden mit [[Annotation (Programmierung)|Annotationen]] (<code>Table</code>, <code>Column</code>) ausgezeichnet, welche die Abbildung auf eine Datenbank steuern. Darauf aufbauend werden vom DbContext die Datenbank und die Datenbank-Tabellen modelliert und beim Aufruf der <code>SaveChanges()</code>-Methode erstellt.
| Die Entity-Klassen werden mit einem grafischen Designer modelliert. Das Modell wird einerseits mit Hilfe des ''{{lang|en|Text Template Transformation Toolkit}}'' (T4) und der zugehörigen T4-Skriptsprache in Entity-Klassen umgewandelt. Zudem erlaubt es der Designer, ein SQL-Skript zu erstellen, mit dem die Datenbank erstellt wird.
|-
! Verwendung einer bestehenden Datenbank
| Die Entity-Klassen können entsprechend der vorgegebenen Datenbank manuell erstellt, modelliert und ausgezeichnet werden. Dies ist jedoch sehr arbeitsintensiv.
| Mit Hilfe eines Assistenten wird die Datenbank abgefragt und entsprechend der Datenbankstruktur ein passendes Modell erstellt. Dieses wird mit einem T4-Skript in die entsprechenden Klassen umgewandelt.
|}

== Architektur ==
[[Datei:ADO.NET EF.svg|400px|mini|Prinzipielle Funktionsweise des ADO.NET Entity Framework]]
{| class="wikitable"
|+ Überblick über wichtige ADO.NET Entity Framework Objekte
! DbContext API<ref group="EF4">Während das EF5 standardmäßig die Db-Klassen verwendet, wird im EF4 ein entsprechendes T4-Template (EF4.x DbContext Generator) benötigt.</ref> (EF5) !! EF4 !! Aufgabe
|-
| DbContext || ObjectContext || Stellt eine Verbindung mit der Datenbank dar. Stellt Methoden für Abfragen ({{lang|en|Query}}), Änderungsverfolgung ({{lang|en|Tracking}}) und Speichern ({{lang|en|Save}}) bereit.
|-
| DbQuery || ObjectQuery || Stellt Methoden für das Hinzufügen ({{lang|en|Add}}), Anhängen ({{lang|en|Attach}}) und Entfernen ({{lang|en|Remove}}) von Entitäten bereit.
|-
| DbSet || ObjectSet || Erbt von DbQuery/ObjectQuery und stellt die entsprechenden Methoden für Entity-Typen bereit.
|-
| Change Tracker API || ObjectContext.ObjectStateManager || Bietet Methoden, um Änderungen verfolgen zu können. Hierzu gehört das Abfragen des ursprünglichen und des derzeitigen Zustands von Entitäten.
|-
| Validation API || — || Automatische Validierung der Daten im DataLayer.
|-
| Code First Model Building || — || [[Reflexion (Programmierung)|Reflektiert]] über [[Quelltext|Code]]-basierte Klassen, um für diese passende [[Datenbankobjekt]]e und die zugehörigen Metadaten im [[Arbeitsspeicher]] und der Datenbank zu erstellen.
|-
|colspan="3"|
<references group="EF4" />
|}

== Verwendung ==
=== Erstellen eines Mappings mit CodeFirst ===
<syntaxhighlight lang="csharp">
public class MyDbEntities : DbContext
{
public IDbSet<Person> Persons { get; set; }

// Fluent Configurations
protected override void OnModelCreating(DbModelBuilder modelBuilder)
{
modelBuilder.Entity<Person>().ToTable("People");
modelBuilder.Entity<Person>().Property(p => p.FirstName).IsRequired();
// ...
}
}

[Table("People")]
public class Person
{
[Key]
[Column("PersonId")]
public int Id { get; set; }

[Required]
[MaxLength(255)]
public string FirstName { get; set; }

[Required]
[MaxLength(255)]
public string LastName { get; set; }

// ...
}
</syntaxhighlight>

=== Datenbank-Initialisierung ===
Die Datenbank wird im Entity Framework durch einen Initializer angelegt. Dieser wird ausgeführt, wenn das erste Entity dem Datenbankkontext hinzugefügt wird.<ref>{{Internetquelle |autor=Bipin Joshi |url=http://www.codeguru.com/csharp/article.php/c19999/Understanding-Database-Initializers-in-Entity-Framework-Code-First.htm |titel=Understanding Database Initializers in Entity Framework Code First |datum=2012-02-10 |sprache=en |abruf=2014-06-10}}</ref>

<syntaxhighlight lang="csharp">
// setze Initialisierer
Database.SetInitializer(new DropCreateDatabaseAlways<MyDbEntities>());

using (var context = new MyDbEntities())
{
var person = new Person() {
FirstName = "William",
LastName = "Adama",
DateOfBirth = DateTime.Now
};

context.Persons.Add(person); // Datenbank-Initialisierer wird ausgeführt
context.SaveChanges();
}
</syntaxhighlight>

In ASP.NET MVC Projekten kann das <code>InitializeSimpleMembership</code>-Attribut eingesetzt werden, um eine Initialisierung der Datenbank zu gewährleisten.<ref>{{Internetquelle |autor=Rick Anderson |url=http://blogs.msdn.com/b/rickandy/archive/2012/08/15/initializesimplemembership-attribute-and-simplemembership-exceptions.aspx |titel=InitializeSimpleMembership Attribute and SimpleMembership Exceptions |werk=MSDN Blog |hrsg=Microsoft |datum=2012-08-15 |sprache=en |abruf=2014-06-10}}</ref>

=== Hinzufügen von Entities ===
<syntaxhighlight lang="csharp">
using (var context = new MyDbEntities())
{
// Erstelle zwei Personen-Entities
var person1 = new Person() {
FirstName = "William",
LastName = "Adama",
DateOfBirth = DateTime.Now
};
var person2 = new Person() {
FirstName = "Laura",
LastName = "Roslin",
DateOfBirth = DateTime.Now
};
// Erstelle ein Adressen-Entity
var address = new Address() {
Street = "Market Street 70",
City = "Philadelphia",
State = "PA",
Zip = "12345"
};

// Erste Variante
context.Persons.Add(person1);

// Zweite Variante
// mit dem Kontext verlinken und als hinzugefügt markieren.
context.Entry(person2).State = EntityState.Added;

// Dritte Variante
// Das Entity wird an ein bereits vom Kontext beobachtetes Entity gehängt
person1.Address.Add(address);

// Speichere Änderungen am Kontext in der Datenbank
context.SaveChanges();
}
</syntaxhighlight>

=== Abfrage von Daten ===
Abfragen aller Daten aus einem Datensatz:
<syntaxhighlight lang="csharp">
using (var context = new MyDbEntities())
{
foreach (var person in context.Persons) // entspricht SELECT * FROM [Persons]
{
// führt zusätzliche SQL-Abfragen an die Adresses-Tabelle
// mit einem entsprechenden JOIN aus
foreach (var address in person.Adresses)
{
// ...
}
}
}
</syntaxhighlight>

Um zu verhindern, dass dieselbe Datenbankabfrage mehrfach ausgeführt wird, kann die <code>ToList()</code>-Methode verwendet werden:
<syntaxhighlight lang="csharp">
using (var context = new MyDbEntities())
{
var persons = context.Persons;

// Datenbankabfrage wird ausgeführt und als Liste zurückgegeben
var allPersons = persons.ToList();

// Keine weitere Datenbankabfragen durch Verwendung der Liste
foreach (var person in allPersons) { /* ... */ }
foreach (var person in allPersons) { /* ... */ }
}
</syntaxhighlight>

Sucht ein bestimmtes Objekt in der Datenbank:
<syntaxhighlight lang="csharp">
var person = context.Persons.SingleOrDefault(p => p.PersonId == personId);
</syntaxhighlight>

oder in Comprehension Syntax:
<syntaxhighlight lang="csharp">
var person = (from p in context.Persons
where p.PersonId == personId
select p).SingleOrDefault();
</syntaxhighlight>

{| class="wikitable"
|+ [[LINQ]] Selectors
! Methode !! Ergebnis
|-
| <code>Single()</code> || Gibt das eine Element zurück, welches die Anfrage liefert. Wirft eine Exception, falls keine oder mehrere Ergebnisse zurückgeliefert werden.
|-
| <code>SingleOrDefault()</code> || Gibt das eine Element zurück, welches die Anfrage liefert. Gibt null zurück, falls keine Ergebnisse geliefert werden. Wirft eine Exception, falls mehrere Ergebnisse zurückgeliefert werden.
|-
| <code>First()</code> || Gibt das erste Element zurück, falls die Anfrage ein oder mehrere Ergebnisse liefert. Wirft eine Exception, falls keine Ergebnisse zurückgeliefert werden.
|-
| <code>FirstOrDefault()</code> || Gibt das erste Element zurück, falls die Anfrage ein oder mehrere Ergebnisse liefert. Gibt <code>null</code> zurück, falls keine Ergebnisse zurückgeliefert werden.
|}

Bei Db-Objekten steht zudem die <code>Find()</code>-Methode bereit. Diese sucht das Objekt zuerst im Arbeitsspeicher und macht eine Datenbankabfrage, falls das Objekt nicht im Speicher gefunden wird:
<syntaxhighlight lang="csharp">
var person = context.Persons.Find(personId);
</syntaxhighlight>

==== Lazy, Eager und Explicit Loading ====
Das Entity Framework verwendet im Normalfall ''{{lang|en|lazy loading}}'', bei dem Daten aus der Datenbank erst dann geladen werden, wenn die Daten abgefragt werden:
<syntaxhighlight lang="csharp">
// lazy loading
// nur die Personen werden abgefragt und geladen
var persons = context.Peoples;
</syntaxhighlight>
Falls weitere Daten mitgeladen werden müssen, wird ''{{lang|en|eager loading}}'' verwendet:
<syntaxhighlight lang="csharp">
// eager loading
// Adressen werden bereits bei der Abfrage der Personen geladen
var persons = context.Peoples.Include("Addresses");
</syntaxhighlight>
<syntaxhighlight lang="csharp">
// LINQ-to-Entities Beispiel für eager loading
var persons = context.Peoples.Include("Addresses").Where(p => p.FirstName == fname);
</syntaxhighlight>
oder typsicher ab EF5:
<syntaxhighlight lang="csharp">
// LINQ-to-Entities Beispiel für eager loading
var persons = context.Peoples.Include(p => p.Addresses).Where(p => p.FirstName == fname);
</syntaxhighlight>
Das explizite Laden (''{{lang|en|explicit loading}}'') der Daten ist ähnlich dem {{lang|en|lazy loading}}, erlaubt jedoch das Laden der Navigationseigenschaften (''{{lang|en|navigation properties}}'').
<syntaxhighlight lang="csharp">
// explicit loading
var persons = context.Peoples; // wie lazy loading; Adressen werden nicht mitgeladen
foreach (var person in persons)
{
person.Addresses.Load(); // explicit loading; navigation properties für Adressen werden geladen
foreach (var address in person.Addresses)
{
// ...
}
}
</syntaxhighlight>


=== Delete Entities ===
Löschen eines Entities im Entity Framework 4:
<syntaxhighlight lang="csharp">
using (var context = new MyDbEntities())
{
// Abfrage eines Entities aus der Datenbank
var person = context.Persons.SingleOrDefault(p => p.Id == id);
if (person == null)
return;

context.Persons.DeleteObject(person);
context.SaveChanges();
}
</syntaxhighlight>

Löschen eines Entities im Entity Framework 5:
<syntaxhighlight lang="csharp">
using (var context = new MyDbEntities())
{
// Abfrage eines Entities aus der Datenbank
var person = (for p in context.Persons.SingleOrDefault(p => p.Id == id);

if (person == null)
return;

context.Entry(person).State = EntityState.Deleted; // Entity zur Löschung markieren
context.SaveChanges(); // Entity in der Datenbank löschen
}
</syntaxhighlight>

=== Vorkompilierte Abfragen ===
Datenbankanfragen werden vom Entity Framework in für die Datenbankschnittstelle passende Anfragen kompiliert. Dieser Vorgang kostet jedoch Zeit, weshalb kompilierte Anfragen – sofern diese erneut benötigt werden – nicht verworfen, sondern in einem Objekt gespeichert und später wiederverwendet werden sollten.

Um bei der ersten Verwendung einer Abfrage mit dem Entity Framework 4 Zeit zu sparen, können Abfragen vorkompiliert werden.
<syntaxhighlight lang="csharp">
static Func<MyDbEntities, int, ObjectQuery<Person>> QueryContactById =
CompiledQuery.Compile<MyDbEntities, int, IQueryable<Person>>( (context, personId) => context.Persons.Select(p => p.Id == personId) );
</syntaxhighlight>

Im Entity Framework 5 werden Abfragen automatisch bei der Erstellung vorkompiliert.

=== Transaktionen ===
<syntaxhighlight lang="csharp">
using (var context = new MyDbEntities())
{
using (var scope = new TransactionScope())
{
// Der TransactionScope sucht den neuesten Context auf dem
// Stacktrace und verlinkt sich automatisch mit diesem
try
{
// Bearbeitung von Entities

context.SaveChanges(); // Speichern der Änderungen in der Datenbank
scope.Complete(); // Transaktion wird abgeschlossen
}
catch (InvalidOperationException e)
{
// Transaktion fehlgeschlagen
}
} // scope.Dispose()
} // context.Dispose()
</syntaxhighlight>

=== Code First Migrations ===
''{{lang|en|Code First Migrations}}'' ist eine Reihe von [[Windows PowerShell|Powershell]]-[[Skriptsprache|Skripten]], welche die Datenbankmigration erleichtern.

* Enable-Migrations
*: erstellt ein Migrations-Skript
* Add-Migration
*: Erstelle ein Skript zur Herstellung der aktuellen Datenbankstruktur
* Update-Database
*: Bringt die Datenbankstruktur auf einen bestimmten Zustand. Standardmäßig wird das neueste Migrationsskript verwendet.


== Literatur ==
* {{Literatur
|Autor=Andrew Troelsen
|Titel=Pro C# 5.0 and the .Net 4.5 Framework
|Verlag=Springer
|Datum=2012
|ISBN=978-1-4302-4233-8
|Seiten=1560}}
* {{Literatur
|Autor=Julia Lerman, Rowan Miller
|Titel=Programming Entity Framework: DbContext; Querying, Changing, and Validating Your Data with Entity Framework
|Verlag=[[O’Reilly Verlag|O’Reilly Media]]
|Datum=2012
|ISBN=978-1-4493-1296-1
|Seiten=258}}
* {{Literatur
|Autor=Julia Lerman, Rowan Miller
|Titel=Programming Entity Framework: Code First; Creating and Configuring Data Models from Your Classes
|Verlag=O’Reilly Media
|Datum=2012
|ISBN=978-1-4493-1294-7
|Seiten=194}}

== Weblinks ==
* {{Internetquelle
|url=http://entityframework.codeplex.com/
|titel=Microsoft .NET Entity Framework
|werk=CodePlex
|hrsg=Microsoft
|sprache=en
|kommentar=Projektseite mit [[Quellcode]] des Entity Frameworks
|abruf=2015-03-12}}
* {{Internetquelle
|url=http://www.entityframeworktutorial.net/
|titel=Entity Framework Tutorial
|sprache=en
|abruf=2015-03-12}}
* {{Internetquelle
|url=https://devcouch.de/videos/
|titel=Entity Framework Grundlagen Video
|sprache=de
|abruf=2015-03-15}}
* {{Internetquelle
|url=http://msdn.microsoft.com/en-us/data/hh949853.aspx
|titel=Performance Considerations for Entity Framework 5
|sprache=en
|abruf=2012-11-11}}
* {{Internetquelle
|url=http://msdn.microsoft.com/en-us/data/ee712907
|titel=Get Started with Entity Framework (EF)
|werk=Data Developer Center
|hrsg=[[Microsoft]]
|sprache=en
|abruf=2012-11-12}}
* {{Internetquelle
|url=http://msdn.microsoft.com/en-us/data/jj593170.aspx
|titel=Entity Framework Power Tools
|werk=Data Developer Center
|hrsg=Microsoft
|sprache=en
|abruf=2013-03-30}}

== Einzelnachweise ==
<references />

{{SORTIERUNG:Entity Framework}}
[[Kategorie:.NET]]
[[Kategorie:Datenbankschnittstelle]]

Entity Framework - Versionsgeschichte

imported>INOUIW: /* growthexperiments-addlink-summary-summary:1|0|0 */