FOM - Fachhochschule für Oekonomie & Management Frankfurt am Main

 
Hausarbeit

                         FOM – Fachhochschule für
                         Oekonomie & Management
                               Frankfurt am Main

                                                          Datenbankmanagement
                                                                                3. Semester

                                                   Hausarbeit zum Thema

              Zugriff auf Datenbanken unter .NET mit dem
                                        Entity Framework

             Betreuer: Professor Dr. rer. pol. Dieter Litzinger, Erik Reischl

             Autor:     Max Jäger

             Frankfurt, den 06. Januar 2013
Inhalt

Inhalt
Abkürzungen                                                                       II

Abbildungen                                                                      III

Quelltexte                                                                       IV

1 Einleitung                                                                      1

2 Überblick                                                                       1
  2.1   Objektrelationale Mapper . . . . . . . . . . . . . . . . . . . . .         1
  2.2   Architektur des ADO.NET Entity Framework . . . . . . . . . .              2

3 Das Entitätenmodell                                                             3
  3.1   Entitäten und deren Beziehungen . . . . . . . . . . . . . . . . .         3
  3.2   Objektkontext . . . . . . . . . . . . . . . . . . . . . . . . . . . .     4
  3.3   Metadaten . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .     4
        3.3.1   Logische Schicht . . . . . . . . . . . . . . . . . . . . . . .    5
        3.3.2   Konzeptionelle Schicht . . . . . . . . . . . . . . . . . . .      5
        3.3.3   Mapping . . . . . . . . . . . . . . . . . . . . . . . . . . .     6
  3.4   Entwurf des Entitätenmodells . . . . . . . . . . . . . . . . . . .        6

4 Arbeiten mit Entitätsdaten                                                      7
  4.1   Abfragen eines konzeptionellen Modells mit LINQ to Entities . .           7
  4.2   Hinzufügen, Ändern und Löschen von Objekten . . . . . . . . .             8
        4.2.1   Hinzufügen von Objekten . . . . . . . . . . . . . . . . .         8
        4.2.2   Ändern von Objekten . . . . . . . . . . . . . . . . . . . .       9
        4.2.3   Löschen von Objekten . . . . . . . . . . . . . . . . . . .        9

5 Fazit                                                                          10

6 Literatur                                                                      11

                                        I
Abkürzungen

Abkürzungen
CSDL . . . . . . . . . . . Conceptual Schema Definition Language
EDM . . . . . . . . . . . . Entity Data Model
LINQ . . . . . . . . . . . Language Integrated Query
MSL . . . . . . . . . . . . . Mapping Schema Language
O/R-Mapper . . . Objektrelationaler Mapper
SSDL . . . . . . . . . . . . Storage Schema Definition Language

                                           II
Abbildungen

Abbildungen
 1   Entity Framework-Architektur . . . . . . . . . . . . . . . . . . .   2

                                  III
Quelltexte

Quelltexte
 1   SSDL-Abschnitt des EDM . . . . . . . . . . . . . . . . . . . . .       5
 2   CSDL-Abschnitt des EDM . . . . . . . . . . . . . . . . . . . . .       5
 3   MSL-Abschnitt des EDM . . . . . . . . . . . . . . . . . . . . . .      6
 4   Abfragen von Objekten . . . . . . . . . . . . . . . . . . . . . . .    7
 5   Hinzufügen eines Objektes . . . . . . . . . . . . . . . . . . . . .    8
 6   Ändern eines Objektes . . . . . . . . . . . . . . . . . . . . . . .    9
 7   Löschen eines Objektes . . . . . . . . . . . . . . . . . . . . . . .   9

                                   IV
Überblick

1      Einleitung

Bei vielen Anwendungen muss eine große Menge an Informationen gespei-
chert werden. Für die Speicherung dieser Daten werden häufig relationale
Datenbanken verwendet. Bei der Programmierung mit objektorientierten Pro-
grammiersprachen stehen Entwickler vor der Aufgabe, sowohl Klassenmodelle
zu entwerfen und Objekte und deren Beziehungen zu verwalten, als auch die
Daten in der Datenbank zu speichern.1 Der Zugriff auf Datenbanken lässt
sich aus Sicht der Programmierung auf mehrere Arten realisieren, von de-
nen eine die Verwendung eines objektrelationalen Mappers (O/R-Mapper) ist.
Diese Hausarbeit bietet nach einer kurzen Erläuterung der Funktionsweise
eines O/R-Mappers eine Einführung in das ADO.NET Entity Framework, dem
O/R-Mapper für die Programmiersprache C#.

2      Überblick

2.1      Objektrelationale Mapper

Ein O/R-Mapper ist eine Zwischenschicht zwischen einer relationalen Daten-
bank und einer Anwendung. In einer relationalen Datenbank gibt es Tabellen,
die über Relationen miteinander verknüpft werden können, und auf Anwen-
dungsseite gibt es in objektorientierten Programmiersprachen Klassen und
Objekte. Der O/R-Mapper übernimmt die Verbindung (Mapping) zwischen den
Tabellen der Datenbank und den Klassen der Anwendung. Ein O/R-Mapper
erzeugt aus Objekten SQL-Abfragen bzw. aus Ergebnissen von SQL-Abfragen
wieder Objekte. Hierbei werden einzelne Datensätze in der Datenbanktabelle
in einzelne Objekte umgesetzt, die Spalten der Datenbanktabelle werden in
die entsprechenden Eigenschaften der Objekte umgesetzt.2 Für das Verständ-
nis sind Kenntnisse in Bezug auf die Datenbank-Struktur und SQL-Abfragen
hilfreich, z. B. im Hinblick auf Geschwindigkeitsoptimierungen von Abfragen.3

1
    Vgl. Microsoft, (2012a), o.S.
2
    Vgl. Kansy, (2011), S. 20.
3
    Vgl. Mostarda, Sanctis und Bochicchio, (2011), S. 25.

                                             1
Überblick

2.2       Architektur des ADO.NET Entity Framework

Das ADO.NET Entity Framework ist in mehrere Ebenen unterteilt. Zentrale
Stelle ist der EntityClient Data Provider. Dieser stellt die Verbindung zwischen
den Klassen und Objekten in .NET und der Datenbank her.4 Hinterlegt sind
die dafür notwendigen Informationen im Entitätenmodell (EDM). Dieses ist in
drei Schichten aufgeteilt:5

    • die logische Schicht, die die Datenbankstruktur darstellt (Storage Model)
    • die konzeptionelle Schicht, die das Datenmodell darstellt (Conceptual
      Model)
    • die Zuordnungsschicht, die die logische und die konzeptionelle Schicht
      miteinander verbindet (Mapping)

    Quelle: Entnommen aus: http://msdn.microsoft.com/de-de/library/vstudio/bb399567, Zugriffsdatum: 2012-10-03

                            Abbildung 1:             Entity Framework-Architektur

4
    Vgl. Lerman, (2010), S. 14.
5
    Vgl. Mertins, Neumann und Kühnel, (2012), S. 1151.

                                                               2
Das Entitätenmodell

Mit den Informationen des EDM ist der EntityClient Data Provider in der Lage,
datenbankspezifische ADO.NET Data Provider anzusprechen und Zugriffe auf
unterschiedlichen Datenbanksystemen auszuführen.6

Innerhalb der .NET-Programmiersprachen bietet das Entity Framework dem
Entwickler zwei Möglichkeiten, um Daten abzufragen: LINQ to Entities und
Entity SQL. LINQ ist eine SQL-ähnliche Abfragesprache direkt auf Objektebene.
Entity SQL ist eine datenbankunabhängige SQL-Syntax. LINQ to Entities
hat sich mittlerweile als Standard-Abfragesprache etabliert, jedoch gibt es
Anwendungsfälle, in denen LINQ to Entities nicht möglich ist. Die Abfragen
bei LINQ to Entities müssen zur Kompilierzeit feststehen, wohingegen sich
eine Entity SQL-Abfrage dynamisch zur Laufzeit erzeugen und ausführen
lässt.7 Bei beiden Verfahren übersetzt der EntityClient Data Provider die
erzeugten Abfragen in die entsprechenden SQL-Abfragen und liefert einen
Datenleser zurück. Die Object Services übersetzen die gelesenen Daten in die
entsprechenden Objekte.8

3      Das Entitätenmodell

Nachdem die Architektur des Entity Frameworks erläutert wurde, werden nun
die einzelnen Bestandteile des Entitätenmodells erläutert. Hierzu zählen die
Klassen, mit denen der Entwickler programmiert, der Objektkontext, der die
Verbindung zur Datenbank herstellt, und die Metadaten, mit denen die Klassen-
und die Datenbankstrukturen abgebildet und verknüpft werden.9

3.1        Entitäten und deren Beziehungen

Entitäten sind Klassen, die Datenbanktabellen repräsentieren, deren Tabel-
lenspalten als Eigenschaften der Klassen abgebildet werden. Neben skalaren
Werten können Klassen über Navigationseigenschaften verfügen, die die Be-
ziehungen, die in der Datenbankbank als Relationen hinterlegt sind, abbilden.
6
    Vgl.   Lerman, (2010), S. 49f.
7
    Vgl.   Mertins, Neumann und Kühnel, (2012), S. 1200.
8
    Vgl.   Microsoft, (2012a), o.S.
9
    Vgl.   Microsoft, (2012a), o.S.

                                             3
Das Entitätenmodell

Hierüber kann von einer zu einer anderen Klasse navigiert werden, die mit dieser
über eine Zuordnung verbunden ist. Zudem verfügt jede Klasse über einen
Primärschlüssel, der eine Ausprägung dieser Klasse eindeutig identifizert.10

3.2         Objektkontext

Der Objektkontext verwaltet die Verbindung zwischen den Entitäten und der
Datenbank. Er überwacht die Änderungen an den Objekten, die Einhaltung
der definierten Beziehungen der Objekte untereinander und stellt über eine
SaveChanges-Methode die zentrale Funktion bereit, die Einfügungen, Änderun-
gen und Löschungen in die Datenquelle schreibt.11 Hierzu werden datenbanks-
pezifische Befehle generiert und ausgeführt, die die entsprechenden Änderungen
in der Datenbank vornehmen.12

3.3         Metadaten

Wie bereits in der Architektur dargestellt, besteht das Entitätenmodell intern
aus drei Schichten. Diese drei Schichten werden in einer gemeinsamen Datei mit
der Dateiendung .edmx gespeichert, die einen XML-Aufbau besitzt.13 Innerhalb
dieser Datei gibt es für jede einzelne Schicht einen eigenen Abschnitt.14

Durch diese Trennung ist es möglich, das gleiche Klassenmodell mit unterschied-
lichen Datenprovidern zu verwenden, indem lediglich das Datenbankmodell
und die Zuordnungen ausgetauscht werden. Über diese drei Schichten kann
das Entity Framework aus den Vorgängen, die auf die Entitäten angewendet
werden, die entsprechenden Vorgänge für die Datenbank ableiten.15
10
     Vgl.   Kansy, (2011), S. 81.
11
     Vgl.   Microsoft, (2012a), o.S.
12
     Vgl.   Microsoft, (2012b), o.S.
13
     Vgl.   Kansy, (2011), S. 27.
14
     Vgl.   Mertins, Neumann und Kühnel, (2012), S. 1162.
15
     Vgl.   Microsoft, (2012a), o.S.

                                              4
Das Entitätenmodell

3.3.1      Logische Schicht

Die logische Schicht beschreibt das physische Datenbankmodell. Darunter fallen
die Datenbanktabellen mit ihren Spalten, Datentypen, Primärschlüsseln und
Beziehungen untereinander. Die Beschreibung erfolgt mit der Storage Schema
Definition Language (SSDL).16

Für die Verdeutlichung der Zuordnung wird die Datenbanktabelle mit englischen
Bezeichnungen angegeben und die .NET-Klasse mit deutschen Bezeichnern. Eine
Tabelle wird über ein EntityType-Element definiert. Der Primärschlüssel wird
im Unterelement Key, die einzelnen Spalten in Property-Elementen definiert.
Jedes Property-Element hat mehrere Attribute, die z. B. den Namen, den
Datentyp oder die maximale Länge festlegen. Der Datentyp bezieht sich hierbei
auf den Datentyp des Datenbanksystems.17

                           Quelltext 1:     SSDL-Abschnitt des EDM
1    < EntityType Name = " Address " >
2         
3              < PropertyRef Name = " AddressID " / >
4         
5         < Property Name = " AddressID " Type = " int " Nullable = " false " / >
6         < Property Name = " Street " Type = " nvarchar " MaxLength = " 100 " / >
7         < Property Name = " Postcode " Type = " nvarchar " MaxLength = " 5 " / >
8         < Property Name = " City " Type = " nvarchar " MaxLength = " 100 " / >
9    

3.3.2      Konzeptionelle Schicht

Die Beschreibung der .NET-Klassen erfolgt in der konzeptionellen Schicht
mit der Conceptual Schema Definition Language (CSDL). Dieser Abschnitt
hat große Ähnlichkeit mit der Definition der logischen Schicht, jedoch gibt
es erwähnenswerte Unterschiede. Beispielsweise beziehen sich die Datentypen
hier auf die .NET-Datentypen und nicht mehr auf die datenbankspezifischen
Datentypen.18

16
     Vgl. Mertins, Neumann und Kühnel, (2012), S. 1163.
17
     Vgl. Mertins, Neumann und Kühnel, (2012), S. 1163.
18
     Vgl. Doberenz und Gewinnus, (2010), S. 1174.

                                                 5
Das Entitätenmodell

                             Quelltext 2:       CSDL-Abschnitt des EDM
1     < EntityType Name = " Adresse " >
2          
3               < PropertyRef Name = " AdressNr " / >
4          
5          < Property Name = " AdressNr " Type = " Int32 " Nullable = " false " / >
6          < Property Name = " Strasse " Type = " String " MaxLength = " 100 " / >
7          < Property Name = " PLZ " Type = " String " MaxLength = " 5 " / >
8          < Property Name = " Ort " Type = " String " MaxLength = " 100 " / >
9     

 3.3.3       Mapping

 Die Verbindung zwischen der logischen und der konzeptionellen Schicht wird
 mit der Mapping Schema Language (MSL) beschrieben. Die Tabellen werden
 auf die .NET-Klassen und die einzelnen Spalten auf die Eigenschaften der
 Klassen abgebildet.19

                              Quelltext 3:      MSL-Abschnitt des EDM
 1    < E n t i t y S e t M a p p i n g Name = " Adresse " >
 2            < E n t i t y T y p e M a p p i n g TypeName = " Adresse " >
 3                    < M ap pi ng F ra gm en t StoreEntity Set = " Address " >
 4                            < ScalarPr operty Name = " AdressNr " ColumnName = " AddressID " / >
 5                            < ScalarPr operty Name = " Strasse " ColumnName = " Street " / >
 6                            < ScalarPr operty Name = " PLZ " ColumnName = " Postcode " / >
 7                            < ScalarPr operty Name = " Ort " ColumnName = " City " / >
 8                    
 9            
10    

 3.4        Entwurf des Entitätenmodells

 Dem Entwickler stehen zwei Ansätze zur Erzeugung des Entitätenmodells zur
 Verfügung: Database-First oder Model-First. Beim Database-First-Ansatz wird
 zunächst die Datenbank mit allen Tabellen, Spalten, Primär- und Fremdschlüs-
 seln erzeugt. Danach kann das Entitätenmodell aus dieser Datenbank generiert
 werden. Der Model-First-Ansatz geht den umgekehrten Weg, bei dem zunächst
 das Klassenmodell erstellt und daraus die Datenbank erzeugt wird.20
 19
      Vgl. Mertins, Neumann und Kühnel, (2012), S. 1165.
 20
      Vgl. Doberenz und Gewinnus, (2010), S. 1178f.

                                                     6
Arbeiten mit Entitätsdaten

4       Arbeiten mit Entitätsdaten

Als meistgenutzte Abfragesprache des Entity Frameworks hat sich LINQ to
Entities etabliert. Dieses Kapitel bietet einen Überblick über die Möglichkeiten,
mit dieser Abfragesprache sowohl Daten aus der Datenbank auszulesen als auch
dort anzulegen, zu ändern oder zu löschen. Um Daten aus der Datenbank aus-
zulesen oder dort zu speichern, muss zunächst eine Instanz des Objektkontextes
erstellt werden. Darüber ist der Zugriff auf alle Entitäten des Entitätenmodells
möglich.21

4.1       Abfragen eines konzeptionellen Modells mit LINQ
          to Entities

Als Beispiel für eine Abfrage von Objekten dient die Klasse Adresse, die bereits
bei der Beschreibung der Schichten des Entitätenmodells verwendet wurde. Es
wird zunächst ein Objekt der Klasse DbContext erzeugt, das den Objektkontext
repräsentiert. Danach wird aus dem soeben erzeugten Kontext eine Liste von
Adressen ausgelesen, bei denen Testingen als Ort hinterlegt ist. Hierdurch
findet also gleichzeitig eine Filterung statt. Diese Liste wird der Variablen
adressen zugewiesen. Danach werden alle Adressen auf der Kommandozeile
ausgegeben.

                           Quelltext 4:     Abfragen von Objekten
1    // D a t e n b a n k k o n t e x t erstellen
2    using ( DbContext context = new DbContext () )
3    {
4         // alle Adressen aus " Testingen " auslesen
5         var adressen = context . Adresse . Where ( a = > a . Ort == " Testingen " ) ;
6         // gefundene Adressen auf der Kommandozeile ausgeben
7         adressen . ForEach ( a = > Console . WriteLine ( a ) ) ;
8    }

21
     Vgl. Mostarda, Sanctis und Bochicchio, (2011), S. 55f.

                                                7
Arbeiten mit Entitätsdaten

 4.2       Hinzufügen, Ändern und Löschen von Objekten

 Das Entity Framework protokolliert alle Änderungen an den Objekten. Wird ein
 neues Objekt angelegt, so wird der Status auf added gesetzt. Werden Objekte
 aus der Datenbank gelesen, bekommen diese den Status unchanged. Wird eine
 Eigenschaft gesetzt, so wird der Status auf modified gesetzt. Durch diesen
 Mechanismus weiß das Entity Framework, welche Art von Befehl es für die
 Datenbank erzeugen muss. Innerhalb der SaveChanges-Methode wird der Status
 des Objektes wieder auf unchanged gesetzt.22

 4.2.1      Hinzufügen von Objekten

 Um der Datenquelle Daten hinzuzufügen, wird eine neue Instanz der ent-
 sprechenden Entitätsklasse erstellt, mit den entsprechenden Werten befüllt
 und dem Objektkontext hinzugefügt. Es muss darauf geachtet werden, dass
 alle Eigenschaften, die keine Null-Werte zulassen, auch gesetzt sind. Nach-
 dem die Instanz dem Objektkontext hinzugefügt wurde, kann auf diesem die
 SaveChanges-Methode aufgerufen werden, die die Daten der erzeugten Instanz
 in der Datenbank abspeichert.23

                           Quelltext 5:   Hinzufügen eines Objektes
 1    // D a t e n b a n k k o n t e x t erstellen
 2    using ( DbContext context = new DbContext () )
 3    {
 4         // Adress - Objekt erstellen und Eigenschaften festlegen
 5         Adresse adresse = new Adresse () ;
 6         adresse . Strasse = " Musterstraße 1 " ;
 7         adresse . PLZ = " 12345 " ;
 8         adresse . Ort = " Testingen " ;
 9         // die Adresse dem Objektkontext hinzufügen
10         context . AddObject ( adresse ) ;
11         // Speichern
12         context . SaveChanges () ;
13    }

 22
      Vgl. Microsoft, (2012b), o.S.
 23
      Vgl. Microsoft, (2012b), o.S.

                                              8
Arbeiten mit Entitätsdaten

 4.2.2       Ändern von Objekten

 Um einen Datensatz zu ändern, muss zunächst ein Datensatz aus der Daten-
 quelle ausgelesen werden. Nachdem dies geschehen ist, können die gewünschten
 Änderungen durchgeführt werden, indem die Eigenschaften gesetzt werden. Zu
 beachten ist, dass beim Setzen von Eigenschaften der Status des Objektes auch
 auf modified gesetzt wird, wenn der gleiche Eigenschaftswert gesetzt wird. Durch
 den Aufruf der SaveChanges-Methode wird der Datensatz in der Datenbank
 geändert.24

                                  Quelltext 6:        Ändern eines Objektes
 1    // D a t e n b a n k k o n t e x t erstellen
 2    using ( DbContext context = new DbContext () )
 3    {
 4         // die erste Adresse aus " Testingen " auslesen
 5         var adresse = context . Adresse
 6                                       . Where ( a = > a . Ort == " Testingen " )
 7                                       . First () ;
 8         // die Straße der gefundenen Adresse ändern
 9         adresse . Strasse = " Am Test 1 " ;
10         // Speichern
11         context . SaveChanges () ;
12    }

 4.2.3       Löschen von Objekten

 Für das Löschen von Objekten stellt der Objektkontext die Methode DeleteOb-
 ject zur Verfügung. Beim Aufruf dieser Methode mit einem Objekt wird dieses
 in der Datenbank als zu löschen gekennzeichnet. Erst durch den Aufruf der
 SaveChanges-Methode wird der Datensatz auch wirklich aus der Datenbank
 gelöscht.25

                                 Quelltext 7:         Löschen eines Objektes
1     // D a t e n b a n k k o n t e x t erstellen
2     using ( DbContext context = new DbContext () )
3     {
4          // die erste Adresse aus " Testingen " auslesen

 24
      Vgl. Microsoft, (2012b), o.S.
 25
      Vgl. Microsoft, (2012b), o.S.

                                                          9
Fazit

 5        var adresse = context . Adresse
 6                          . Where ( a = > a . Ort == " Testingen " )
 7                          . First () ;
 8        // die gefundene Adresse löschen
 9        context . DeleteObject ( adresse ) ;
10        // Speichern
11        context . SaveChanges () ;
12    }

 5        Fazit

 Das Entity Framework bietet eine gute Möglichkeit, auf eine Datenbank zu-
 zugreifen, und dabei in dem für den Programmierer gewohnten Kontext von
 .NET zu bleiben und mit Klassen und Objekten zu arbeiten. Dadurch kann
 eine schnelle Entwicklung erfolgen, und durch die Unterstützung einer Ent-
 wicklungsumgebung, wie z. B. Visual Studio, lassen sich Fehler vermeiden. Der
 Entwickler muss sich nicht mehr mit dem Verwaltungsaufwand zum Herstellen
 einer Verbindung zur Datenbank, zum Auslesen der Daten und Übertragen in
 die Entitäten beschäftigen.26

 Es gibt zudem diverse Datenbanksysteme, mit denen sich der Entwickler ausken-
 nen müsste. Das Entity Framework stellt die Erzeugung korrekter SQL-Abfragen
 unter Berücksichtigung der datenbankspezifischen Besonderheiten sicher. Da-
 durch nimmt es ihm die Arbeit ab, datenbankspezifische Abfragen erzeugen zu
 müssen.27

 Jedoch sollte immer der spezifische Anwendungsfall betrachtet werden, ob
 der Einsatz des Entity Frameworks sinnvoll ist. Bei Massenaktualisieren zum
 Beispiel ist das Entity Framework nicht das beste Verfahren, da hierbei der
 gesamte Verwaltungsmechanismus viel Performance kostet.28

 26
      Vgl. Lerman, (2010), S. 1f.
 27
      Vgl. Mostarda, Sanctis und Bochicchio, (2011), S. 25.
 28
      Vgl. Mostarda, Sanctis und Bochicchio, (2011), S. 26.

                                                10
Literatur

6     Literatur
    1. Doberenz, Walter und Thomas Gewinnus (2010): Datenbank-
       Programmierung mit Visual C# 2010: Grundlagen, Rezepte, Anwen-
       dungsbeispiele. Microsoft Press Deutschland. isbn: 978-3866454460.
    2. Kansy, Thorsten (2011): Programmieren mit dem ADO.NET Entity Fra-
       mework. Microsoft Press Deutschland. isbn: 978-3866454613.
    3. Lerman, Julia (2010): Programming Entity Framework. O’Reilly Media.
       isbn: 978-0596807269.
    4. Mertins, Dirk, Jörg Neumann und Andreas Kühnel (2012): SQL Server
       2012: Das Programmierhandbuch. Inkl. ADO.NET 4.0 Entity Framework.
       Galileo Computing. isbn: 978-3836219440.
    5. Microsoft (2012a): Entity Framework-Architektur. url: http://msdn.
       microsoft . com / de - de / library / vstudio / bb399567 (besucht am
       03. 10. 2012).
    6. — (2012b): Hinzufügen, Ändern und Löschen von Objekten (Entity
       Framework). url: http : / / msdn . microsoft . com / de - de / library /
       bb738695 (besucht am 10. 10. 2012).
    7. Mostarda, Stefano, Marco De Sanctis und Daniele Bochicchio (2011):
       Microsoft Entity Framework in Action. Manning. isbn: 978-1935182184.

                                      11
Ehrenwörtliche Erklärung

Hiermit versichere ich, dass die vorliegende Hausarbeit von
mir selbstständig und ohne unerlaubte Hilfe angefertigt wor-
den ist, insbesondere, dass ich alle Stellen, die wörtlich oder
annähernd wörtlich aus Veröffentlichungen entnommen sind,
durch Zitate als solche gekennzeichnet habe. Ich versichere
auch, dass die von mir eingereichte schriftliche Version mit der
digitalen Version übereinstimmt. Weiterhin erkläre ich, dass
die Hausarbeit in gleicher oder ähnlicher Form noch keiner
anderen Prüfungsbehörde vorgelegen hat.

Frankfurt am Main, den
6. Januar 2013                                        Max Jäger
Sie können auch lesen
NÄCHSTE FOLIEN ... Stornieren