EF-Datenzugriff
EF v2 und Datenzugriffsarchitektur – bewährte Methoden
Tim Mallalieu
Themen in diesem Artikel:
-
Anwendung Entwicklung Formatvorlagen
-
Entwurfsmuster
|
In diesem Artikel werden die folgenden Technologien verwendet:
Microsoft Visual Studio 2010 ADO.NET Entity Framework Funktion CT1
|
Inhalt
David Hill in seinem Vorwort auf die neueste Muster &Empfehlungen Architecture Guidance, Witze, die der Schlüssel wird eine gute Architekt beantworten "Es hängt" lernen istDie meisten Fragen.
In diesem Artikel werde ich die Witz Herz dauern.
Wie können Sie die Entity Framework mit Ihrer Anwendungsarchitektur?
Gut, kommt es.
Entwickler wenden verschiedenste Entwicklungsphilosophien und Architekturstile an.
Dieser Artikel untersucht drei allgemeine Perspektiven im Hinblick auf die Anwendungsentwicklung und beschreibt, wie das Entity Framework in jeder davon eingesetzt werden kann.
Insbesondere ich betrachten die Formulare zentrierten, Modell zentrierten und Code-zentrierten Entwicklung Formatvorlagen und ihre Beziehung zu den Entity Framework.
Anwendung Development Formatvorlagen
Ich beginne mit einer Erläuterung der verschiedenen Entwicklung Formatvorlagen.
Diese Diskussion wird nicht starke Annahmen über bestimmte Methoden, die innerhalb dieser Entwicklung Stile angewendet werden können stellen, und ich beachten, dass Stereotypen zum Zweck der in diesem Artikel verwendet haben.
Die meisten Entwicklung Formatvorlagen mischen Elemente die Modelle beschrieben.
Abbildung 1 zeigt die relative Merkmale von den Modellen besprochen werden.
.gif)
Abbildung 1 Development Formatvorlagen und ihre zugeordneten Nachteile
Formulare zentrierte.
Der Schwerpunkt liegt im Format Formulare zentrierten (oder "Formulare-über-Data") der Entwicklung größtenteils auf die Konstruktion von der obersten Ebene (UI) Benutzeroberflächenelemente, die an Daten binden.
Die Microsoft-Entwicklungsumgebung für diese Formatvorlage ist häufig eine Drag & Drop Funktionalität in dem Sie eine Datenquelle definieren und dann systematisch Konstrukt eine Reihe von Formularen, die ausgeführt werden können erstellen, lesen, aktualisieren und Löschen von Operationen (CRUD) in der zugrunde liegenden Datenquelle.
Diese Erfahrung neigt dazu, sehr produktiv und für einen Entwickler intuitiv sein.
Die Kosten sind häufig, dass der Entwickler ein relativ hohes Maß an verschreibungspflichtige aus den Tools und Frameworks verwendeten akzeptiert.
Modell zentrierte.
Modell-zentrierten Entwicklung ist ein Schritt jenseits der forms-centric Ansatz.
In der Model-zentrierten Entwicklung ein Entwickler definiert ein Modell in ein visuelles Tool oder einige textbezogene domänenspezifischen Sprache (DSL) und verwendet dieses Modell als Quelle Generieren von Klassen für Dauerhaftigkeit eine Datenbank zu programmieren.
Diese Erfahrung ist häufig nützlich für Entwickler von Tools, die auf vorhandene Infrastruktur zusätzlichen Wert liefern erstellen möchten.
Außerdem ist oft nützlich für Organisationen, die eigene Standards für Ihre Anwendungsarchitekturen und Datenbanken vorzugeben.
Die Kosten für diesen Pfad wurde in der Vergangenheit in der Kapitalanlage erforderlich, um eine vollständige Funktionalität zu aktivieren.
Wie mit der Formulare zentrierten Erfahrung neigt dazu, geben Sie gewisse Flexibilität als Konsequenz der Betrieb in einer mehr vorgeschriebenen Welt ein Entwickler eine Modell-zentrierte Erfahrung nutzen.
Code-zentrierte.
Der Code-zentrierte Anwendung Entwicklung Formatvorlage ist die Wahrheit der Code.
Entwickler definieren permanente Klassen auf eigene.
Sie sich entscheiden, Ihre eigenen Datenzugriffsschicht zur Unterstützung dieser Klassen zu schreiben, oder Sie einige verfügbaren Dauerhaftigkeit dazu für Sie anbieten.
Der Hauptvorteil der Code-zentrierten Option besteht, dass Entwickler die größter Flexibilität erhalten.
Die Überlegung Kosten neigt dazu, auf den Ansatz für Dauerhaftigkeit ausgewählt fallen.
Wenn ein Entwickler eine Projektmappe, die Ihr die Unternehmensdomäne anstelle der Infrastruktur Persistenz konzentrieren können auswählt, kann die allgemeine Leistung dieses Ansatzes sehr hoch sein.
Erstellen einer Forms zentrierte Anwendung
In diesem Abschnitt ich werde durchlaufen zum Erstellen einer sehr einfachen Anwendung Formulare-orientierten Ansatz mit der Entity Framework.
Die erste Schritt ist die Erstellung einer Visual Studio Projekt.
In diesem Beispiel wurde eine Anwendung dynamische Daten erstellt.
In Visual Studio 2010, Sie wählen die Webanwendung Dynamic Data Entities, wie in Abbildung 2 dargestellt.
.gif)
Abbildung 2 Visual Studio 2010 neu im Dialogfeld Projekt mit Dynamic Data Entities Web Application Projekt Vorlage ausgewählt.
Die nächste Schritt ist dessen Angabe der Entity Framework als Datenquelle für die Anwendung.
Sie hierzu eine neue ADO.NET Entität Datenmodell Projektelement dem Projekt hinzufügen wie Sie sehen können, im Abbildung 3.
.gif)
Abbildung 3 Add New Item Dialog Box mit ADO.NET Entity Data Model Project Element ausgewählt
Nach der Auswahl dieses Projektelement, führen Sie die folgenden drei Schritte aus:
-
Wählen Sie zum Starten von einer Datenbank.
-
Wählen Sie die Datenbank zum Ziel.
-
Wählen Sie die Tabellen importieren.
Zu diesem Zeitpunkt Sie klicken Sie auf Fertig stellen und finden Sie in das Modell, das aus der Datenbank generiert wird, wie in Abbildung 4 dargestellt.
.gif)
Abbildung 4 Standard Entity Data Model aus der Beispieldatenbank erstellte
Nun, dass das Modell generiert wurde, mit ausgeführt es in die dynamische Anwendung ist so einfach wie konfigurieren das Formular an den Objektkontext registrieren, der in den Schritten erstellt wurde weiter oben.
In Global.asax.cs können Sie den folgenden Code im Kontext zeigen ändern:
DefaultModel.RegisterContext(typeof(NorthwindEntities), new ContextConfiguration()
{ ScaffoldAllTables = true});
Sie sollten jetzt können die Anwendung ausführen und eine funktionale Gruppe von Formularen über die persistenten Daten, sein, wie in Abbildung 5 dargestellt.
.gif)
Abbildung 5 Standard Dynamic Data-Website mit
In dieser Übung wird die einfachste Formulare datengesteuerten Erfahrung veranschaulicht.
Sie können jetzt beginnen, arbeiten wie die Präsentation aussehen soll und welche Verhaltensweisen Sie benötigen.
ASP.NET Dynamic Data-Framework verwendet CLR-Attribute im Namespace System.ComponentModel.DataAnnotations zum Bereitstellen von Anleitungen auf wie die Daten dargestellt werden können.
Beispielsweise können Sie ändern wie das Formular wiedergegeben wird, indem Sie eine Anmerkung, die eine Particluar-Spalte ausgeblendet.
Das Attribut lautet wie folgt:
Das Attribut "ScaffoldColumn" zeigt an, ob das Framework dynamische Daten die Spalte rendert.
Das ScaffoldColumn-Attribut können Sie in einem Fall, in denen eine Tabelle ist dargestellt werden, entscheiden sich außerhalb des rendering einer bestimmten Spalte.
Ist interessante Herausforderung in das aktuelle Szenario, wo und wann Sie eine Spalte-Attribut?
In diesem Beispiel wurden die CLR-Klassen, die durch dynamische Daten verwendet werden generiert, aus der Entity Data Model .
Sie können die generierten Klassen Attribut, aber dann werden alle Änderungen am Modell Verlust der Attribute verursachen.
Dynamische Daten können auch Sie Attribute angewendet, mithilfe von partielle Klassen, die Ihre Klasse Entitäten zugeordnet, jedoch dann verlieren Sie einige Lesbarkeit und Erkennbarkeit aufgrund von Verlust der Kapselung.
Entity Framework 4.0 wird ein Erweiterungsmodell bereit, die ermöglicht Entwicklern die Tools Oberfläche des Entity Framework Designer erweitern und fügen zusätzliche Metadaten, die in Code oder Datenbank Generation; verwendet werden könnenDiese Funktionalität ist jedoch nicht verfügbar in Visual Studio 2010 Beta 1.
Die Entity Framework Entwickler dynamische Daten arbeiten möchte kann eine sehr produktive Erfahrung haben.
Er kann mit einer Datenbank beginnen und Anmerkungen ein Modell mit den entsprechenden Metadaten Großteil dieses Erlebnis Laufwerk.
Nachdem das Modell in guter Form ist, kann der Entwickler auf der Benutzeroberfläche konzentrieren.
Weitere Informationen zum Verwenden von dynamischen Daten mit der Entity Framework, Bitte schauen Sie sich das offizielle Dynamic Data-Site.
Gedanken auf Forms zentrierte Anwendungen
Mit ASP.NET Dynamic Data und Entity Framework bietet eine äußerst produktive für die Entwicklung datenzentrischer Anwendungen.
Formulare-zentrierte Anwendungen sind jedoch nicht lokal auf dynamische Daten.
Viele Erfahrungen im Entwicklung für UI-erste Entwicklern ermöglichen, eine Anwendung erstellen, indem eine Reihe von Bildschirmen über eine Datenquelle erstellen in der Regel dieselben Merkmale aufweisen.
Entwickler Erfahrung stützt sich im Allgemeinen auf eine Kombination aus Entwurfs- und Erfahrungen, die eine bestimmte Architektur Formatvorlage vorzugeben.
Das Datenmodell entspricht häufig die Form der permanente Speicher (die zugrunde liegenden Tabellen), und es ist häufig fair etwas von UI-Metadaten (z. B. DataAnnotations im Fall von dynamische Daten), mit denen um die Benutzeroberfläche zu definieren.
Die Rolle der Entity Framework in eine Formulare zentrierten Erfahrung ist hauptsächlich als die Abstraktion über die zugrunde liegende Datenquelle.
Ein Entwickler eine True setzen, um alle Modellmetadaten definieren, die Sie express müssen Erweiterbarkeit Funktionen bieten.
Die Zuordnungsfunktionen ermöglichen ein Entwickler, die mid-tier Domäne Klassen umformen deklarativ ohne Infrastruktur Code eintauchen, nach unten.
Erstellen einer Modell-zentrierte Anwendung
Das Versprechen modellgesteuerte Entwicklung ist, dass Entwickler deklarativ ein Modell Ausdrücken können, der näher konzeptionelle Unternehmensdomäne als die Run-Time-Aspekte einer bestimmten Anwendung Architektur ist.
Zum Zweck der in diesem Artikel habe ich konzentrierte sich auf der Erfahrung mit eine einzelnen Entwurfsoberfläche, auf dem Sie die Domäne und Verwandte Metadaten definieren und aus dem Sie die Klassen und Speicher bereitstellen.
In Microsoft .NET Framework, 4, gibt es eine Reihe von Innovationen in Entity Framework Werkzeuge, die eine Objektmodell-zentrierte Erfahrung aktivieren.
Entity Framework Tools bietet eine grundlegende Erfahrung sowie die Funktionen für Framework-Entwickler, ISVs, und IT-Organisationen diese Funktionen zu erweitern.
Um die Benutzerfreundlichkeit zu veranschaulichen, werde ich durch eine einfache Anwendung alle nötig sind.
Ich mit einem neuen Projekt dynamische Daten erneut starten und eine ADO.NET hinzufügen werde Entity Data Model Projektelement.
Dieses Mal jedoch werde ich mit einem leeren Modell beginnen anstatt das Modell aus einer Datenbank erstellen.
Beginnen Sie mit einer leeren Oberfläche, können Sie aus dem Modell erstellen soll.
Ich werde eine sehr einfache Fitness-Anwendung mit nur zwei Entitätstypen Trainings und WorkoutType erstellen.
Datenmodelle für die Typen sind in Abbildung 6 dargestellt.
.gif)
Abbildung 6 Simple Entitätsdatenmodell
Wenn Sie ein Modell wie folgt im Entity Framework Designer definieren, ist keine Zuordnung oder speichern-Definition erstellt.
Entity Framework-Designer können jedoch jetzt Entwickler ein Datenbankskript aus diesem Modell zu erstellen.
Mit der rechten Maustaste auf die Designeroberfläche, können Sie generieren Skript von Datenbankmodell, wie im Abbildung 7 und den Entity Framework Designer eine Standarddatenbank aus das Entitätsmodell generiert.
Für dieses Modell einfacher werden zwei Tabellen definiert.
Die Namen der Tabellen übereinstimmen EntitySets, die im Designer definiert sind.
In der Standard-Generation wird die Datenbank erstellt Verknüpfungstabellen für viele-zu-viele-Beziehungen erstellen und verwenden ein Schema Tabelle pro Typ (TPT) zum Erstellen von Tabellen, die eine Vererbungshierarchie unterstützen müssen.
.gif)
Abbildung 7 Generieren eines Datenbank-Skripts aus dem Modell
Wenn Sie Datenbank-Skript aus Modell generieren aufrufen, eine neue T-SQL-Datei zum Projekt hinzugefügt und bietet dem Entitätsdatenmodell, die Sie erstellt haben die Entity Framework Metadaten mit gültigen Zuordnung und Informationsspeicher-Beschreibungen.
Sie können diese in Abbildung 8 dargestellt.
.gif)
Abbildung 8 der T-SQL-Datei aus dem Modell generiert
Wenn ein Entwickler Visual Studio Team Architect oder Team Suite verwendet wird, er bereitstellen und Ausführen der T-SQL-Skript innerhalb kann Visual Studio lediglich, indem Sie auf die Datei T-SQL, um es den Fokus erhält und dann F5 drücken.
Sie werden aufgefordert, die Zieldatenbank auszuwählen, und anschließend das Skript ausgeführt.
Zum gleichen Zeitpunkt ausgeführt Entity Framework Designer die Standard-Codegenerierung, Klassen basierend auf dem Modell zu erstellen wird die Entity Framework Designer erforderlich, um beschreiben die Zuordnung zwischen dem Modell der Datenbank und eine Beschreibung des Datenspeichers, die erstellt wurde.
Infolgedessen haben Sie jetzt eine stark typisierte Datenzugriffsschicht, die im Kontext der Anwendung verwendet werden können.
Zu diesem Zeitpunkt haben Sie gesehen, nur die Standardgruppe auftreten.
Erweiterbarkeit des Entity Framework Designers können Sie viele Aspekte der Erfahrung modellgesteuerte anpassen.
Die Datenbank-Generierung und Codegenerierung Schritte verwenden T4-Vorlagen, die zum Anpassen des Datenbankschemas und der Code, der erzeugt wird, angepasst werden können.
Der Generierungsprozess der gesamten ist ein Windows Workflow Foundation (WF) Workflow, der auch angepasst werden kann und Sie haben bereits gesehen zum Hinzufügen von Erweiterungen zu den Tools Oberfläche mithilfe von verwalteten Erweiterbarkeit Framework-basierten Visual Studio Erweiterbarkeit.
Ein Beispiel für diese Erweiterbarkeit sehen wir uns wie die code-generation-Schritt im Projekt geändert werden kann.
Mit der rechten Maustaste auf die Entwurfsoberfläche, können Sie neue Elemente generieren hinzufügen auswählen.
Dieser Befehl öffnet das Dialogfeld in dem Sie keines der installierten Vorlagen zum Projekt hinzufügen auswählen können.
Im Beispiel im Abbildung 9 ausgewählte Entity Framework POCO Codegenerator Vorlage (Hinweis: POCO Vorlage funktioniert nicht mit dynamischen Daten in Visual Studio 2010 Beta 1, aber es funktioniert in kommenden Versionen.) POCO (einfache alte CLR Objects) Klassen ermöglichen Entwicklern, nur die Elemente zu definieren, die Sie interessieren sich in deren Klassen und vermeiden diese Implementierung Details vom Framework Dauerhaftigkeit beschädigen.
Mit .NET 4.0 haben wir eingeführt POCO Unterstützung innerhalb der Entity Framework, und eine Möglichkeit, POCO Klassen erstellen, wenn Sie eine Modell-zentrierten oder datenzentrischen Entwicklung Formatvorlage ist mit der POCO Vorlage.
POCO Vorlage steht derzeit in ADO.NET Entity Framework Feature CTP 1, die von Data Platform Development heruntergeladen und mit Visual Studio 2010 Beta 1 verwendet werden kann.
.gif)
Abbildung 9 Add New Item Dialog Box
Indem der EF ADO.NET POCO Codegenerator Vorlage erhalten Sie einen anderen Satz von generierten Klassen.
Insbesondere können Sie eine Reihe von POCO Klassen als einzelne Datei pro Klasse, einer Hilfsklasse für Änderungen an verknüpften Elementen verwenden und eine eigene Kontextklasse generiert.
Beachten Sie, dass Sie etwas in das Modell nicht.
Sie haben lediglich die code-generation-Vorlage geändert.
Eine interessante Funktion, die in .NET 4.0 hinzugefügt ist die Fähigkeit definieren Sie Funktionen hinsichtlich der Entity Data Model .
Diese Funktionen werden in das Modell ausgedrückt und können in Abfragen verwiesen werden.
Überlegen Sie, eine Methode, um festzustellen, wie viele Kalorien in einer bestimmten Trainings gebrannt werden bereitstellen möchten.
Es gibt keine Eigenschaft für den Typ, der die Kalorien gebrannt erfasst definiert.
Sie konnte Abfragen die vorhandenen Typen und aufzählen dann die Ergebnisse berechnen die im Speicher; gebrannt Kalorienjedoch können mithilfe von Funktionen Modell definiert Sie Falten diese Abfrage in die Datenbankabfrage, die an den Informationsspeicher gesendet wird, daher ermöglicht eine effizientere Operation.
Sie können die Funktion in der EDMX (XML) wie folgt definieren:
<Function Name="CaloriesBurned" ReturnType="Edm.Int32">
<Parameter Name="workout" Type="Fitness.Workout" />
<DefiningExpression>
workout.Duration * workout.WorkoutType.CaloriesPerHour / 60
</DefiningExpression>
</Function>
Damit diese Funktion in einem LINQ Abfrage, müssen Sie eine Funktion im Code bereitstellen, die genutzt werden können.
Sie versehen diese Methode die Modell-Funktion anzugeben, die Sie verwenden möchten.
Wenn die Funktion funktionsfähig wenn direkt aufgerufen werden soll, sollten Sie den Textkörper implementieren.
Zum Zweck der in dieser Übung wir löst eine nicht unterstützte Ausnahme da wir zur Verwendung dieser Funktion in Form von erwarten LINQ Abfragen, die im Speicher abgelegt werden:
[EdmFunction("Fitness", "CaloriesBurned")]
public int CaloriesBurned(Workout workout)
{ throw new NotSupportedException(); }
Wenn Sie eine Abfrage alle High-Kalorie Training abgerufen, bei denen eine hohe Kalorie Trainings größer als 1.000 Kalorien ist dann erstellen möchten, können Sie die folgende Abfrage schreiben:
var highCalWorkouts = from w in context.MyWorkouts
where
context.CaloriesBurned(w) > 1000
select w;
Diese LINQ Abfrage ist eine gültige Abfrage, die die CaloriesBurned-Funktion kann jetzt nutzen und systemeigene T-SQL, die in der Datenbank ausgeführt werden, übersetzt werden.
Gedanken auf Modell-zentrierte Anwendungsentwicklung
Im degenerierte Fall, in denen ein Entwickler verwendet Modell erste Erfahrung und nicht die Schritte anpassen, ist den Modell-zentrierten sehr ähnlich wie das Formulare-zentrierten Erfahrung.
Das Modell, dem der Entwickler arbeitet, ist ein Modell auf höherer Ebene als das logische Datenmodell, aber es ist immer noch eine ziemlich datenzentrischen Ansicht der Anwendung.
Entwickler, wer Ihre Entitätsdatenmodell ausgedrückt werden weitere Metadaten zu Ihrer Domäne erweitern und anpassen, die Generierung von Code und/oder der Datenbank, können an einer Stelle stammen, in dem die Erfahrungen eine Ansätze in dem Sie die Metadaten für die Laufzeit definieren.
Dies eignet sich hervorragend für IT-Organisationen, die eine strenge Architektur und Codierungsstandards vorzugeben.
Es ist auch sehr nützlich für ISVs oder Framework Entwickler, die zum Beschreiben des Modells den Entity Framework Designer als Ausgangspunkt verwenden und dann eine breitere End-to-End-Erfahrung daraus generieren möchten.
Code-zentrierte Anwendungsentwicklung
Die beste Möglichkeit, Code-zentrierten Anwendungsentwicklung beschreiben ist die Cliché Zitat "der Code ist die Wahrheit." Der Schwerpunkt liegt in der Formulare-orientierten Ansatz zum Erstellen einer Datenquelle und Benutzeroberflächenmodell für die Anwendung.
Im Modell-orientierten Ansatz ist das Modell die Wahrheit: Definieren Sie ein Modell, und dann Generation erfolgt auf beiden Seiten (Speicher und die Anwendung).
Im Code-orientierten Ansatz wird Ihre Absicht im Code erfasst.
Eine den Herausforderungen der Code-zentrierten Ansätzen ist der Kompromiss zwischen Domänenlogik und Infrastruktur-Logik.
Object Relational Mapping (ORM) Lösungen in der Regel mit Code-zentrierten Ansätzen Hilfe, da Entwickler können Ihre Domänenmodell in Klassen Ausdrücken konzentrieren und lassen die ORM die Dauerhaftigkeit kümmern.
Wie wir im Modell-orientierten Ansatz gesehen haben, können POCO Klassen mit einer vorhandenen EDM-Modells (in entweder der erste Modell oder Datenbank erste Ansätze) verwendet werden.
Im Code-orientierten Ansatz verwenden wir etwas Code nur, wir mit nur POCO Klassen und keine anderen Elemente beginnen aufgerufen.
Code ist nur im ADO.NET Entity Framework Feature CTP 1, die von Data Platform Development heruntergeladen und mit Visual Studio 2010 Beta 1 verwendet werden können.
Berücksichtigen Sie die Fitness Anwendung nur Code replizieren.
Idealerweise würden Sie die Domäne Klassen im Code wie in Abbildung 10 definieren.
Abbildung 10 Trainings und WorkoutType Domäne Klasse
public class Workout
{
public int Id { get; set; }
public DateTime DateTime { get; set; }
public string Notes { get; set; }
public int Duration { get; set; }
public virtual WorkoutType WorkoutType { get; set; }
}
public class WorkoutType
{
public int Id { get; set; }
public string Name { get; set; }
public int CaloriesPerHour { get; set; }
}
Damit die Domäne Klassen mit Entity Framework arbeiten, müssen Sie eine spezielle ObjectContext definieren, die den Einstiegspunkt in das Entity Framework (ähnlich wie eine Sitzung oder Verbindung Abstraktion für die Interaktion mit der zugrunde liegenden Datenbank) darstellt.
Die ObjectContext-Klasse muss die EntitySets definieren, die Sie über LINQ-Abfragen erstellen können.
Hier ist ein Beispiel des Codes:
public class FitnessContext : ObjectContext
{
public FitnessContext(EntityConnection connection)
: base(connection, "FitnessContext")
{
}
public IObjectSet<Workout> Workouts {
get { return this.CreateObjectSet<Workout>(); } }
public IObjectSet<WorkoutType> WorkoutTypes {
get { return this.CreateObjectSet<WorkoutType>(); } }
}
Die Erfahrung Code schreibgeschützt wird eine Factoryklasse verwendet, um eine Instanz des Kontexts abzurufen.
Diese Kontextklasse über den Kontext wiedergibt und die erforderlichen Metadaten für die Ausführung zur Laufzeit erstellt.
Die Factory Signatur lautet wie folgt:
ContextBuilder.Create<T>(SqlConnection conn)
Zur Vereinfachung können Sie eine Factorymethode dem erzeugten Kontext hinzufügen.
Sie bieten ein statisches Feld für die Verbindungszeichenfolge und eine statische Factorymethode, Instanzen von einem FitnessContext zurückzugeben.
Erste die Verbindungszeichenfolge:
static readonly string connString = new SqlConnectionStringBuilder
{
IntegratedSecurity = true,
DataSource = ".\\sqlexpress",
InitialCatalog = "FitnessExpress",
}.ConnectionString;
Und hier ist die Factorymethode:
public static FitnessContext CreateContext()
{
return ContextBuilder.Create<FitnessContext>(
new SqlConnection(connString));
}
Mit diesem haben Sie genug, um damit den Kontext verwendet werden.
Sie können z. B. eine Methode wie die folgenden Abfragen alle Trainings-Typen schreiben:
public List<WorkoutType> AllWorkoutTypes()
{
FitnessContext context = FitnessContext.CreateContext();
return (from w in context.WorkoutTypes select w).ToList();
}
Wie bei Model-First-Erfahrung, ist es nützlich, um eine Datenbank aus der Code nur Erfahrung bereitstellen können.
Die ContextBuilder stellt einige Hilfsmethoden, die überprüfen können, ob eine Datenbank vorhanden ist, legen Sie, wenn Sie möchten, und Sie erstellen.
Sie können Code wie den folgenden Demo-Funktionalität mithilfe des Ansatzes Code nur eine Reihe einfache bootstrap schreiben:
public void CreateDatabase()
{
using (FitnessContext context = FitnessContext.CreateContext())
{
if (context.DatabaseExists())
{
context.DropDatabase();
}
context.CreateDatabase();
}
}
Zu diesem Zeitpunkt können Sie die Repository-Musters von Domäne-driven Design (TTT), um etwas in was wir bisher gesehen haben präziser zu formulieren.
Die Verwendung von TTT Prinzipien ist eine allgemeine Trend heute Anwendungsentwicklung, jedoch wird nicht versucht wird, definieren oder Verbreitung Domäne Entwurf hier gesteuert.
(Weitere Informationen, finden Sie in der Inhalte von Experten wie Eric Evans ( Domain-Driven Design: Übernehmen die Komplexität in das Herz von Software , Addison-Wesley, 2003) und Jimmy Nilsson ( anwenden Domain-Driven Design und Muster: Mit Beispiele in C#- und , Addison-Wesley, 2006).
Derzeit haben wir eine handschriftliche Domäne Klassen und eine spezielle ObjectContext.
Wenn wir dynamische Daten verwendet, zeigt wir einfach das Framework der ObjectContext.
Aber wenn wir eine stärkere Abstraktion der unser zugrunde liegenden Dauerhaftigkeit Layer berücksichtigen möchten und wir wirklich den Vertrag Operationen nur die sinnvolle Domänenoperationen einschränken, die eine tun möchten, können wir die Repository-Musters nutzen.
Für dieses Beispiel werde ich zwei Repositorys definieren: eine für WorkoutTypes und eine für Trainings.
Wenn Sie TTT Prinzipien befolgen, sollten Sie Ihrer Meinung nach über Aggregatfunktionen Root(s) Festplatte und Modellierung des Repositorys entsprechend überlegen.
In diesem einfachen Beispiel habe ich habe zwei Repositorys verwendet, um allgemeine Konzepte.
Abbildung 11 zeigt das WorkoutType-Repository, und Abbildung 12 zeigt das Trainings-Repository.
Abbildung 11 das WorkoutType-Repository
public class WorkoutTypeRepository
{
public WorkoutTypeRepository()
{
_context = FitnessContext.CreateContext();
}
public List<WorkoutType> AllWorkoutTypes()
{
return _context.WorkoutTypes.ToList();
}
public WorkoutType WorkoutTypeForName(string name)
{
return (from w in _context.WorkoutTypes
where w.Name == name
select w).FirstOrDefault();
}
public void AddWorkoutType(WorkoutType workoutType)
{
_context.WorkoutTypes.AddObject(workoutType);
}
public void Save()
{
this._context.SaveChanges();
}
private FitnessContext _context;
}
Abbildung 12 das Trainings-Repository
public class WorkoutRepository
{
public WorkoutRepository()
{
_context = FitnessContext.CreateContext();
}
public Workout WorkoutForId(int Id)
{
return (from w in _context.Workouts where w.Id == Id select w).FirstOrDefault();
}
public List<Workout> WorkoutsForDate(DateTime date)
{
return (from w in _context.Workouts where w.DateTime == date select w).ToList();
}
public Workout CreateWorkout(int id, DateTime dateTime, int
duration, string notes, WorkoutType workoutType)
{
_context.WorkoutTypes.Attach(workoutType);
Workout workout = new Workout() { Id = id, DateTime = dateTime, Duration = duration,
Notes = notes, WorkoutType = workoutType };
_context.Workouts.AddObject(workout);
return workout;
}
public void Save()
{
_context.SaveChanges();
}
private FitnessContext _context;
}
Eine interessante Sache zu beachten ist, dass die Rückgabetypen nicht IQueryable < T >; sindSie sind List < T >.
Es gibt Diskussionen über, ob Sie über die Begrenzungen der Dauerhaftigkeit Schicht IQueryable bereitstellen sollten.
Meiner Meinung nach ist, dass Verfügbarmachen IQueryable der Kapselung der Dauerhaftigkeit Layer und Kompromissen unterbricht die Grenze zwischen explizite Vorgänge, die im Speicher stattfinden und Operationen, die in der Datenbank auftreten.
Wenn Sie eine IQueryable < T > verfügbar machenaus dem Repository, die Sie haben keine Ahnung, beendet wird, einrichten eine Datenbankabfrage in Verfassen LINQ weiter oben im Stapel.
Diese Repositorys können nun einige Daten im Speicher hinzufügen.
Abbildung 13 zeigt zwei Methoden, die zum Erstellen der Beispieldaten verwendet werden könnten.
Abbildung 13 Methoden für Beispieldaten erstellen
public void AddWorkouts()
{
Console.WriteLine("--- adding workouts ---");
WorkoutRepository repository = new WorkoutRepository();
WorkoutTypeRepository typeRepository = new WorkoutTypeRepository();
WorkoutType squash = typeRepository.WorkoutTypeForName("Squash");
WorkoutType running = typeRepository.WorkoutTypeForName("Running");
repository.CreateWorkout(0,new DateTime(2009, 4, 20, 7, 0, 0),
60, "nice squash workout", squash);
repository.CreateWorkout(1, new DateTime(2009, 4, 21, 7, 0, 0),
180, "long run", running);
repository.CreateWorkout(2, new DateTime(2009, 4, 22, 7, 0, 0),
45, "short squash match", squash);
repository.CreateWorkout(3, new DateTime(2009, 4, 23, 7, 0, 0),
120, "really long squash", squash);
repository.Save();
}
Im Modell-First-Szenario verwendet wir Modell benutzerdefinierte Funktionen, um eine Methode zum Bestimmen wie viele Kalorien in einer bestimmten Trainings gebrannt werden, obwohl es ist keine Eigenschaft für den Typ, der die Kalorien gebrannt erfasst definiert bereitzustellen.
Mit dem Code nur Ansatz müssen Sie die Option zum Definieren Sie Funktionen Modell definiert hier keinen.
Sie können jedoch Verfassen von vorhandenen Trainings-EntitySet, eine Abfrage, die bereits den Filter hoch Kalorie kapselt zu definieren, wie hier gezeigt:
public IQueryable<Workout> HighCalorieWorkouts()
{
return (
from w in Workouts
where (w.Duration * w.WorkoutType.CaloriesPerHour / 60) > 1000
select w);
}
Wenn wir diese Methode auf die FitnessContext definieren, können wir dann es im Trainings-Repository folgendermaßen nutzen:
public List<Workout> HighCalorieWorkouts()
{
return _context.HighCalorieWorkouts().ToList();
}
Da die Methode auf dem Kontext ein IQueryable zurückgegeben, Sie weiter darauf verfasst haben könnte, aber ich habe, für die Symmetrie, zu nur entschieden rückgegeben Sie die Ergebnisse als Liste .
Gedanken über Code zentrierte Entwicklung
Die Code-zentrierte Erfahrung ist sehr interessant für Entwickler ihre Domänenlogik im Code möchten.
Die Code-zentrierte Erfahrung eignet sich gut für bietet ein Maß an Flexibilität und Klarheit zum Arbeiten mit anderen Frameworks.
Abstraktionen wie das Repository-Musters verwenden, kann diese Vorgehensweise Entwickler ein hohes Maß an Isolierung für den Layer Dauerhaftigkeit bereitstellen, die die Anwendung der Dauerhaftigkeit Schicht bekannt bleiben ermöglicht.
Letzte Thoughts auf Application Development Formatvorlagen
Diese sind die drei Anwendung Entwicklung Formate, die wir oft angezeigt werden.
Wie bereits erwähnt, besteht keine einzelne, true Klassifizierung von diese Entwicklung Formatvorlagen.
Sie liegen mehr auf ein Kontinuum von sehr ausführlichen sehr datenzentrischen und CRUD-zentrierten auftritt, Schwerpunkt Produktivität zu sehr Ausdrucksstark Code zentrierten Erfahrungen.
Für alle von diesen die Entity Framework an die Dauerhaftigkeit Schicht genutzt werden können.
Wenn Sie in der Formular-zentrierten und Modell-zentrierte Seite des des Spektrums Richtung bewegen, explizite Modell und die Möglichkeit zum Erweitern der Kette Modell und Tool helfen die Entity Framework insgesamt Entwicklerproduktivität verbessern.
Auf der Code-zentrierte Seite die Verbesserungen in den Entity Framework ermöglichen die Runtime aus dem Weg zu erhalten und werden lediglich ein Implementierungsdetail für Dauerhaftigkeit Dienste.
Tim Mallalieu ist der Einheit Produktmanager für Entity Framework und LINQ to SQL.
Er kann unter blogs.msdn.com/adonet erreicht.