Ein sehr interessantes Interview zum Thema Objektrelationale Mapper
mit Stephan Görgens gibt es in der einhundertachten Episode des
Anwendungsentwickler-Podcasts. TL;DR Am Beispiel von Microsofts
Entity Framework zeige ich dir, wie objektrelationale Mapper
Klassen und Objekte mit Tabellen und Datensätzen verbinden. Mit
Code-first entsteht das Datenbankschema aus deinen Klassen, während
der DbContext den Zugriff auf die Datenbank und das Speichern
übernimmt. SQL gehört weiterhin zu deinem Handwerkszeug, weil große
Datenmengen und zeitkritische Aufgaben gezielte Eingriffe
erfordern. Für deine Projekte empfehle ich etablierte Frameworks
und eigene Tests mit einer Datenbank; zusätzliche Schichten hängen
davon ab, wie umfangreich dein Projekt wird. Kapitelmarken
[00:00:00] Einstieg ins Thema objektrelationale Mapper [00:01:39]
Stefan Görgens und das Berichtswesen bei BMW [00:03:31] Von der
Elektrotechnik zur Informatik [00:07:48] Clean Code und die Arbeit
mit C# und .NET [00:12:37] Was ein ORM macht [00:14:13] Klassen und
Objekte auf Tabellen und Datensätze abbilden [00:17:06] Entity
Framework, NHibernate und JPA [00:19:11] Kosten, Installation und
die Wahl eines Frameworks [00:22:06] Grafische Designer und
Code-first [00:23:53] Das Datenmodell aus Klassen erstellen
[00:25:56] Schrittweise entwickeln und Migrationen verwalten
[00:27:42] Connection-String und DbContext [00:29:39] Konventionen
und Annotationen [00:34:49] Beziehungen und Kardinalitäten abbilden
[00:37:50] Änderungen speichern und den Kontext freigeben
[00:38:54] Große Datenmengen und direkte SQL-Befehle [00:39:53]
LINQ to Entities und weitere Abfragemöglichkeiten [00:43:49] SQL
verstehen und bei Performance-Problemen eingreifen [00:46:24]
SQL-Ausgaben und Logging [00:50:07] Aufwand und Grenzen eines ORMs
[00:52:07] Architektur und Schichten im Projekt [00:55:53] ORM und
Datenbank austauschen [01:03:16] Den DbContext erzeugen und seine
Lebensdauer steuern [01:06:35] Tests mit einer In-Memory-Datenbank
[01:09:11] Integrationstests und Fehler eingrenzen [01:13:01]
Etablierte Frameworks für eigene Projekte [01:13:56] Domänenmodell
und Data-Access-Layer [01:17:19] Quellen zu Entity Framework und
Literaturtipps [01:21:05] Clean Code und weitere prägende Bücher
[01:22:38] Weiterlernen während der Arbeitszeit [01:26:29]
Studierende betreuen und Wissen weitergeben [01:28:52] Kontakt,
Praktikum und Abschlussarbeit bei BMW [01:31:08] Verabschiedung
[01:31:47] Shownotes zur Episode Inhalt Die folgenden Fragen zum
Bereich der objektrelationalen Mapper gehen wir im Verlauf des
Interviews durch. Objektrelationale Mapper Was ist ein ORM? Warum
braucht man einen ORM bzw. sollte ihn verwenden? Was sind Beispiele
für bekannte ORMs? Mit welchen ORMs hast du selbst schon
gearbeitet? Was ist dein Lieblings-ORM und warum? Was sollte ein
ORM mindestens können? Wie konfiguriert man einen ORM? Wie setzt
man komplexe Datenbankabfragen mit einem ORM um? Wie integriert man
einen ORM am besten in eine Anwendungsarchitektur? Ab wann "lohnt"
sich der Einsatz eines ORMs im Projekt? Wie stark macht man sich
beim Einsatz eines ORMs von diesem abhängig? Sollte man einen ORM
einfach austauschen können? Wie wichtig ist das Beherrschen von
SQL, wenn man mit ORMs arbeitet? Sollten auch Azubis schon mit ORMs
arbeiten und warum (nicht)? Welche Nachteile haben ORMs? Welche
Literaturempfehlungen hast du für den Bereich ORMs?
Literaturempfehlungen Stephan empfiehlt für Einsteiger ins Thema
Moderne Datenzugriffslösungen mit Entity Framework 6:
Datenbankprogrammierung mit .NET und C#* von Dr. Holger
Schwichtenberg. * Und hier gibt es den ".NET-Doktor" live zu sehen.
Außerdem ist Stephan - genau wie ich - der Meinung, dass Clean
Code* auf keinem Entwicklernachttisch fehlen sollte ;-) * Links
Stephan erreichst du am Besten über Xing: Stephan Görgens Das
Karriereportal von BMW findest du hier, falls du Interesse an einem
Praktikum oder einer Abschlussarbeit hast: BMW Group - Karriere.
Der .NET-Doktor (Dr. Holger Schwichtenberg) Die BASTA! ist
sicherlich eine der interessantesten Konferenzen im .NET-Umfeld.
Und das ist die Beispielanwendung zum Entity Framework: World Wide
Wings (WWWings). Zusammenfassung Aus der Praxis bei BMW Für den
Einstieg in objektrelationale Mapper greife ich auf das Gespräch
mit Stefan Görgens zurück, der bei BMW im Berichtswesen für die
Qualität während der Produktion arbeitet. Seine Abteilung
entwickelt Software, mit der Qualitätsdaten erfasst und für
Berichte aus Datenbanken gelesen werden. Ein ORM gehört dort zum
Standard neuer Softwareprojekte. Görgens kam über eine
elektrotechnische Ausbildung und ein Elektrotechnikstudium zur
Softwareentwicklung. Nach einem Softwareprojekt für seine
Abschlussarbeit bei BMW studierte er angewandte Informatik bis zum
Master. Durch das Buch Clean Code beschäftigte er sich stärker
damit, wie sich Software testen und später weiterentwickeln lässt.
Im beruflichen Alltag arbeitet er vor allem mit C#, weil sein
Unternehmen auf .NET setzt. Wie ein ORM deine Objekte mit der
Datenbank verbindet Wenn du als Fachinformatiker:in
Anwendungsentwicklung mit einer relationalen Datenbank arbeitest,
müssen deine Objekte dauerhaft gespeichert werden. Ein
objektrelationaler Mapper, kurz ORM, übernimmt dabei das Zuordnen
zwischen der objektorientierten Programmiersprache und der
relationalen Datenbank. Für den einfachen Fall gelten folgende
Beziehungen: Eine Klasse entspricht einer Tabelle. Ein Objekt
entspricht einem Datensatz. Die Eigenschaften der Klasse
entsprechen den Spalten. Beziehungen zwischen Objekten werden als
Beziehungen in der Datenbank abgebildet. Dadurch kannst du mit den
Daten als Objekte arbeiten und sie beispielsweise in Listen
verwalten. Das Framework übernimmt Aufgaben, die du sonst selbst
programmieren müsstest, etwa Daten aus der Datenbank in passende
Objekte zu übertragen und Änderungen zurückzuschreiben. Das spart
Arbeit und verringert Fehler beim Datenzugriff. Ein einmal
erarbeiteter Ansatz lässt sich in weiteren Projekten wieder
einsetzen. Entity Framework und andere ORMs Im .NET-Umfeld arbeitet
Görgens mit Microsofts Entity Framework. Für seine Abteilung
sprechen die laufende Entwicklung und die verfügbaren Informationen
dafür. Auch interne Freigaben sind bei einem Produkt von Microsoft
unter den dortigen Bedingungen leichter zu bekommen. Als
Alternative nennt er NHibernate, das aus der Java-Welt stammt.
Kenntnisse daraus lassen sich auf Hibernate in Java übertragen. Im
Java-Umfeld gibt es außerdem JPA, die Java Persistence API: Sie
legt eine Schnittstelle fest, hinter der unterschiedliche
ORM-Provider wie Hibernate oder EclipseLink arbeiten können. Entity
Framework ist kostenfrei und wird als eigenes Paket installiert,
beispielsweise über NuGet in Visual Studio. Im Gespräch wird auch
die damals noch junge Core-Variante angesprochen, mit der
plattformübergreifendes Entwickeln möglich wird. Die grundlegenden
ORM-Konzepte gelten über .NET hinaus. Mit Code-first das
Datenmodell entwickeln Bei Code-first schreibst du deine Klassen
und legst einen Datenbankkontext an. Aus diesem Code erstellt
Entity Framework die Tabellen. Vorher solltest du dir Gedanken über
dein Datenmodell machen und es grob aufzeichnen. Für neue Projekte
empfiehlt Görgens diesen Weg, weil sich die Klassen im Code gut
überblicken lassen. Verständliche Namen und passende Ordner helfen
dir, später wieder ins Projekt einzusteigen. Die Dateien bleiben
als Text zugänglich. Ein grafischer Designer liefert beim Lernen
schnell ein Ergebnis. Görgens sieht dabei das Problem, dass viele
Schritte im Hintergrund ablaufen und Details erst in den jeweiligen
Eigenschaften sichtbar werden. Mit Code-first kannst du dein Modell
während der Arbeit weiterentwickeln. Migrationen übertragen
Änderungen auf die Datenbank. Entity Framework hält dabei fest,
welche Versionen angewendet wurden; Änderungen lassen sich auch
wieder zurücknehmen. Das passt zu einem schrittweisen oder
testgetriebenen Vorgehen. Konventionen und Beziehungen Entity
Framework erkennt vieles anhand seiner Konventionen. Eine passend
benannte ID-Eigenschaft wird beispielsweise als Schlüssel erkannt.
Über Annotationen oder Einstellungen im DbContext kannst du die
Zuordnung verändern, etwa wenn Tabellen anders heißen sollen. Auch
das automatische Bilden englischer Pluralformen für Tabellennamen
lässt sich beeinflussen. Ich empfehle dir, dich zunächst an die
vorgesehenen Konventionen zu halten. Dadurch bleibt leichter
nachvollziehbar, wie eine Klasse mit ihrer Tabelle zusammenhängt,
und du sparst dir zusätzliche Einstellungen. Beziehungen kannst du
über Eigenschaften und Sammlungen ausdrücken. Eine Liste von Kursen
in einer Klasse für eine:n Student:in stellt beispielsweise einen
Bezug zu diesen Kursen her. Bei n:m-Beziehungen kommt eine
Zwischentabelle ins Spiel. Hat die Beziehung eigene Eigenschaften,
etwa eine Uhrzeit, wird im Gespräch eine eigene Klasse dafür
vorgeschlagen. Wie viel du zusätzlich festlegen musst, hängt vom
Datenmodell ab. Ein über viele Jahre gewachsenes Schema kann mehr
Anpassungen erfordern. Mit dem DbContext arbeiten und Änderungen
speichern Der DbContext ist die zentrale Schnittstelle beim
Arbeiten mit Entity Framework. Er verwaltet die Entities und
kümmert sich um die Verbindung zur Datenbank. Dafür braucht er
einen Connection-String, der im beschriebenen Beispiel in der
Anwendungskonfiguration steht. Du kannst einen Kontext mit new
erzeugen und innerhalb eines using-Blocks damit arbeiten. Weil er
IDisposable implementiert, werden seine Ressourcen beim Verlassen
des Blocks freigegeben. Mehrere Kontexte können unabhängig
voneinander existieren. Änderungen werden zunächst lokal verwaltet.
Zum dauerhaften Speichern musst du ausdrücklich den entsprechenden
Aufruf auslösen, damit die geänderten Daten in die Datenbank
geschrieben werden. SQL, LINQ und große Datenmengen SQL-Kenntnisse
brauchst du auch beim Arbeiten mit einem ORM....
Kommentare (0)
Melde dich an, um einen Kommentar zu schreiben.