Transkripte
1. Einführung: Willkommen zu diesem neuen Kurs Entity Framework
Core, einer vollständigen Tour. Mein Name ist Trevor Williams und ich bin
Softwareingenieur und Dozent mit über zehn Jahren Erfahrung
in der Entwicklung von Anwendungen und in der Lehre von
Menschen, wie man das macht In diesem Kurs lernen
Sie Entity Framework Core kennen,
und dies ist Microsofts Flaggschiff
Data Access Framework oder
ORM for dot t.
In diesem Kurs werden
wir nun einige Dinge
durchgehen, die
Sie von
Ihren Mitbewerbern und
Ihren Kollegen abheben werden, wenn es
darum und dies ist Microsofts Flaggschiff
Data Access Framework oder ORM for dot t.
In diesem Kurs werden
wir nun einige Dinge
durchgehen, die
Sie von
Ihren Mitbewerbern und
Ihren Kollegen abheben werden geht , wie Sie bei
der Erstellung
von.net-Anwendungen mit
Ihren Datenbanken interagieren . Wir werden das
Entity Framework untersuchen und untersuchen, wie es Ihnen
hilft,
Anwendungen in.net schneller zu erstellen, wie es Ihnen
hilft,
Datenbankerstellungen und -änderungen
mit einfacher C-Sharp-Syntax zu verwalten Datenbankerstellungen und -änderungen . Das ist richtig. Verwendung von
Entity Framework Core. Sie
müssen nicht unbedingt in SQL einsteigen
oder ins
Management Studio gehen oder ins
Management Studio um Ihre Datenbank zu bearbeiten, und am Ende dieses Kurses werden
Sie ein
gutes Verständnis dafür haben, werden
Sie ein
gutes Verständnis dafür haben wie all dies
durch Migrationen,
den Datenbankkontext
und Datenbankmodelle verwaltet wird den Datenbankkontext
und Datenbankmodelle Sie werden verstehen,
wie Sie Linkabfragen schreiben, um mit Ihren
Datenbankobjekten und Tabellen zu interagieren, werden viele
andere erweiterte Funktionen
von Entity Framework Core kennenlernen von Entity Framework Am Ende dieses Kurses sollten
Sie mit
Entity Framework vertraut
sein und wissen, sollten
Sie mit
Entity Framework vertraut
sein wie es Ihnen ermöglicht, Linkabfragen zu
schreiben und mit Ihren Daten zu interagieren. Ein bisschen Geschichte zum
Entity Framework. Es wird
seit 2008 in DottFramework entwickelt, aber es hat sich weiterentwickelt und
weiterentwickelt und Moment sind wir bei D
five oder Dt COR five Die Bibliothek,
die derzeit in
einem stabilen Zustand verwendet wird, ist also die derzeit in
einem stabilen Zustand verwendet wird EF Core Five, was wir untersuchen
werden Bald
wird es jedoch EFC Six geben, und das meiste, was
wir
hier lernen werden , wird
übertragbares Wissen sein Nun ein bisschen mehr
darüber, was EF COR ist. Es ist ein
objektrelationaler Mapper. Ich habe vorhin das Akronym ORM verwendet. Dafür steht es. Objektrelationaler Mapper. Es handelt sich also um eine
Open-Source-Bibliothek mit APIs, die Ihnen
die Interaktion
mit der Datenbank erleichtern Ihnen
die Interaktion
mit der Wir werden in diesem Kurs zwar SQL
Server verwenden, viele Funktionen von FCR
können auf
andere Datenbanken wie Post
Resca und Cuaide und my ca ausgedehnt werden. Das
Erlernen von C bietet
also viele
Vorteile, da es Es hilft Ihnen,
sich wiederholenden Code zu reduzieren
und ermöglicht es Ihnen, sich
auf andere Dinge in
Ihrer Anwendung zu konzentrieren ,
während der Code durchgehend sauber und konsistent bleibt. Es ist auch
unternehmenstauglich. Das ist richtig. Wenn Sie eine große
Anwendung erstellen und
Angst haben, zu
viele Abfragen zu haben und mesischen Code zu
haben, ist
FCR perfekt für Sie, weil
es nett und kompakt ist Es ermöglicht Ihnen,
die Syntax in C scharf zu halten, und es ist stabil genug, um unter extremen
Bedingungen zu funktionieren Ich weiß, du schaust dir
diesen Kurs an und fragst dich, ob dieser Kurs wirklich für mich
ist? Nun, wenn Sie etwas über
FCR erfahren möchten , sind Sie hier genau richtig Wenn Sie sich mit C-Sharp auskennen und über
Datenbankkenntnisse verfügen, sind
Sie hier genau richtig Wenn Sie
moderne Arten der Interaktion
mit Ihrer Datenbank
mithilfe von Technologie erlernen möchten, sind Sie hier definitiv
richtig. Am Ende dieses
Kurses werden Sie
keine Schwächen haben und
es gibt keine Bedrohungen. Du kannst nur
immer besser werden. Worauf wartest du also noch? Ich freue mich,
Sie in diesem Kurs zu haben, und wir sehen uns in
der nächsten Vorlesung.
2. Setup: Hey, Leute, willkommen zurück.
In dieser Lektion werde
ich Ihnen einfach zeigen, was
Sie benötigen , um Ihre Umgebung
für diesen Kurs einzurichten. Ich bin also bereits hier auf der
Visual Studio-Website.
Sie können dorthin gelangen, indem Sie
sutudo.microsoft.com sagen Und was wir verwenden werden
, ist die Visual Studio IDE Community
Edition Nein, das ist die
Flaggschiff-IDE, die uns Microsoft
für.net-Entwicklung
zur Verfügung gestellt uns Microsoft
für.net-Entwicklung
zur Es ist also perfekt
für diesen Kurs. Wenn Sie diese Community Edition jedoch nicht
auf einem Windows-Computer verwenden können diese Community Edition jedoch nicht
auf einem Windows-Computer verwenden und einen MAC verwenden, dann haben sie die MAC-Version. Wenn Sie keinen MAC verwenden, können
Sie
Visual Studio-Code verwenden
, der ebenfalls
völlig kostenlos als Open Source
verfügbar und für jedes
Betriebssystem verfügbar ist . Die Dinge, die ich in diesem Kurs
machen werde unterscheiden sich, wenn Sie
Visual Studio-Code verwenden, aber ich werde mein Bestes tun, mir unterwegs
Notizen zu machen, um sicherzustellen, dass Sie die Operationen
ausführen können. Nachdem Sie
Visual Studio heruntergeladen
haben, erhalten Sie
zumindest die Möglichkeit, das Installationsprogramm herunterzuladen Nach dem Start dieses Installationsprogramms wird
Ihnen ein
Bildschirm angezeigt, der dem folgenden ähnelt. Jetzt habe ich
es bereits auf meinem Computer, und was Sie sehen, sind die verschiedenen Workloads, die
ich bereits installiert habe Für diesen speziellen Kurs benötigen Sie nicht so viele. Wenn Sie bereits die haben
, die ich Ihnen zeigen werde, können
Sie diesen Schritt überspringen. Aber wenn Sie hier sind
und
wissen müssen, was Sie kaufen müssen. Sie benötigen diesen.net-Workload für die
plattformübergreifende Entwicklung, das uns die
eigentlichen, Sie wissen schon, die Basisbibliotheken
für.net-Kernentwicklung an
die Hand gibt Basisbibliotheken
für.net-Kernentwicklung an
die Und wir werden eine
kleine Webaktivität durchführen. Es wäre also eine gute
Idee, einfach auch
das AP-Netz und die
Webentwicklung zu erledigen. Sie benötigen also mindestens diese beiden. Je mehr Sie klicken,
desto mehr werden natürlich installiert, sodass Sie nicht so viele anklicken
müssen, wie
Sie sehen, dass ich hier angekreuzt habe Also AP-Netz- und Webentwicklung sowie
plattformübergreifende. NET-Entwicklung Sie können also weitermachen
und diese installieren. Jetzt müssen
Sie diesen Schritt abschließen, insbesondere wenn Sie Visual Studio und
einen Windows-Computer nicht verwenden , denn wenn Sie Visual Studio-Code verwenden
möchten, müssen Sie
das SDK im Hintergrund installieren Das kommt mit
Visual Studio, oder? Aber wenn Sie
Visual Studio nicht noch einmal verwenden, können
Sie das SDK
herunterladen, sodass Sie einfach hierher
gelangen können, indem Sie
zu Microsoft Co. gehen . Und
von dieser Landing Page können
Sie auf der Downloadseite
der.t5 navigieren , Sie das SDK
erhalten werden Sie können auch
die Laufzeiten abrufen , da wir sie für das Hosting
benötigen, aber zumindest benötigen
Sie das SDK Okay. Jetzt, nachdem alles installiert und eingerichtet
wurde, möchten
Sie nur sicherstellen
, dass alles installiert ist. Sie können also zu
Ihrer Befehlszeile gehen,
unabhängig davon, welches Betriebssystem gerade aktiviert ist, und dann
einfach.net H eingeben. In Ordnung? Wenn Sie das tun, werden
Sie sehen, ob Sie
einen Ausdruck
auf dem Bildschirm sehen , der ungefähr so
aussieht, dann sind Sie auf dem richtigen Weg Es wird Ihnen also sagen, welche
SDK-Version Sie haben, und es zeigt Ihnen einfach all die verschiedenen Befehle
, die Sie verwenden können Sie können
diese Befehle also tatsächlich verwenden, wenn eine
neue.net-Kernanwendung
erstellen, und vor allem, wenn Sie
Visual Studio-Code verwenden, werden
Sie
die .net-Befehle
definitiv ein bisschen häufiger verwenden die .net-Befehle
definitiv ein In Ordnung. Also das war's wirklich für
die Einrichtung der Umgebung. Dies ist ein fünfminütiges Video, aber es wird
wahrscheinlich ein paar Stunden oder
ein paar mehr Minuten dauern ein paar mehr Minuten dauern wenn Sie es von Grund auf neu
einrichten, aber es wird nicht zu lange dauern. Sobald
Sie fertig sind und überprüfen
können, ob Sie
alles installiert haben, können
Sie mit
der nächsten Lektion fortfahren. Okay.
3. Die Lösung einrichten: Hallo Leute, willkommen
zurück in dieser Lektion.
Wir werden damit beginnen, unsere Lösung für das
Projekt oder für diesen Kurs einzurichten . Und wir werden mit einer leeren Lösung
beginnen. Ich werde also weitermachen und
auf Neues Projekt erstellen klicken und einfach nach
der leeren Lösungsvorlage suchen . Und das ist die, die
wir auswählen werden. Also mach weiter, klicke auf Weiter. Und ich werde die Lösung
Entity Framework Net Five
nennen ,
richtig, was auf den
Kurs hindeutet, den wir gerade machen Und wenn ich meinen Standort festgelegt habe, werde ich
weitermachen und auf Erstellen klicken. Und einfach so haben
wir Visual Studio mit unserer leeren Lösungsdatei. Wir werden
damit beginnen , der Lösung ein neues
Projekt hinzuzufügen. Also werde ich ein neues Projekt hinzufügen
und dann werde ich
eine Konsolenanwendung hinzufügen, und dann werde ich
eine Konsolenanwendung hinzufügen weil
wir eine Konsolen-App verwenden
werden , um
die Grundlagen von
Entity Framework Core durchzugehen die Grundlagen von
Entity Framework Core Stimmt das? Bevor wir Faszination
des Internets
und dem beschäftigen, möchte
ich, dass uns mit der ganzen Faszination
des Internets
und dem beschäftigen, möchte
ich, dass wir verstehen,
was FCR kann, denn wenn wir
es von einer Konsolen-App aus verstehen, dann
sind die Möglichkeiten grenzenlos wenn wir
kompliziertere Anwendungen erstellen müssen Wir werden also weitermachen, auf
Konsolenanwendung klicken, auf Weiter klicken und diese One Entity
Framework Net Five Console App
nennen Framework Net Five Console Also los, klicken Sie erneut auf Weiter. Wir streben fünf
als Zielrahmen an, und dann machen wir weiter und erstellen. Okay. Gerade jetzt, wo unsere
Konsolen-App erstellt wurde. Wir werden
zwei weitere Projekte erstellen, und das werden
wirklich Klassenbibliotheken sein. In der Unternehmensentwicklung eines der
Grundprinzipien ist
eines der
Grundprinzipien die Trennung von Belangen, was bedeutet,
dass wir die Anwendung haben wahrscheinlich , die
wahrscheinlich die Fäden zieht und
mit dem Benutzer spricht. Aber dann brauchen wir andere Projekte , in denen wir
datenbankbezogene Objekte speichern werden und datenbankbezogene
Konfigurationen getrennt werden. Deshalb fügen wir zwei weitere Projekte in
Form einer Klassenbibliothek hinzu. Also ich habe hier links
die Klassenbibliothek. Sie können immer scrollen, aber Sie können bei Bedarf
suchen und immer
daran denken, dass wir es
mit C Sharp zu tun haben. In Ordnung? Also für die Klassenbibliothek werden
wir
das erste One
Entity Framework
Net Five Dot Data nennen . Und dann ist es immer noch das
Ziel-Framework ist immer noch t fünf, und dann klicken wir auf Create. Und zu guter Letzt, werden
wir weitermachen und eine weitere Klassenbibliothek
hinzufügen, und diese wird
Dot Domain sein. Also die gleiche
Namenskonvention, die wir für
Entity Framework Net
Five Dot Domain haben , oder? Und es ist immer noch
ein.t5-Zielframework, und dann machen wir weiter und Das ist es also wirklich
für unser Lösungs-Setup. Also werden
wir wieder mit drei Projekten arbeiten, zumindest im Moment, mit drei
verschiedenen Projekten. Dieses hier, die Konsolen-App, die es als Benutzeroberfläche
auflistet, können
Sie hier als
Ausgabetyp einer ausführbaren Datei sehen. Es weiß also, dass es
ausgeführt werden soll oder dass es etwas
tun sollte. Das ist so, dass die
Kernkonfiguration oder Projektdateien eingerichtet
werden, denn
wenn Sie sich diese anders als
die Klassenbibliothek ansehen, werden
Sie feststellen, dass diese nur das Ziel-Framework
enthält. Dieser weiß, dass es sich um ein
Ziel-Framework und dass
es sich um eine ausführbare Datei handelt. Das ist nur ein wesentlicher Unterschied
zwischen den beiden, oder? Dieser wird also darstellen wo wir unseren praktischen Code
schreiben werden, aber dann werden wir hier
unsere Domain und
Datenobjekte einrichten . Nun, Domain wird unsere
Datenmodelle für Klassen haben, und dann werden Daten
unsere Datenkonfigurationen
und Dateien haben . Wenn wir also etwas Spaß haben, werden
wir
anfangen ,
einige der Tabellen zu modellieren , die wir
für diesen Kurs verwenden werden.
4. Erstelle die Datenmodelle mit EF Core: Ihr seid willkommen zurück.
In dieser Lektion werden
wir also damit beginnen,
unsere Datenbanktabellen zu modellieren. Was ich jetzt auf dem Bildschirm habe, ist ein Datenbankdiagramm oder ein
ERD-Entitätsbeziehungsdiagramm. Es hat ein paar Namen, und es gibt ein paar
Darstellungen davon. Das grundlegende Konzept
besteht jedoch darin, dass es sich um ein Diagramm handelt das die verschiedenen Entitäten
oder Tabellen innerhalb einer Datenbank zeigt und zeigt,
was die
Primärschlüsselspalte ist , was die anderen Felder sind, und das dann zeigt, dass
zwischen zwei Tabellen
eine sogenannte Fremdschlüsselbeziehung
besteht zwischen zwei Tabellen
eine sogenannte Fremdschlüsselbeziehung Hier zeigt es, dass wir Teams und Ligen haben Das sind zwei Tische. Die Liga hat eine ID, die wir zu
einer automatisch inkrementierenden
Ganzzahl machen werden, und sie hat einen Namen Und dann hat ein Team auch eine ID, auch als Namen, aber dann hat
es eine Liga-ID Diese Liga-ID
nennen wir einen Fremdschlüssel
für die Liga. Eine Mannschaft gehört zu einer Liga. Das ist die Beziehung. Wenn Sie
mit Datenbanken vertraut sind, wissen
Sie bereits,
was vor sich geht. Wenn Sie sich nicht so gut auskennen,
ist das kein Problem. Ich hoffe, Sie verstehen
zumindest das Konzept hinter diesem Diagramm. In Ordnung. Was wir jedoch tun wollen, ist solche Tabellen innerhalb von EFC
einzurichten Wir möchten FCO verwenden, um eine Datenbank zu modellieren , die diese Tabellen
generiert Sie haben also unterschiedliche
Konventionen, wenn es darum geht,
auf der Grundlage einer Datenbank zu entwickeln Wir können es also zuerst mit der Datenbank machen, das
heißt, jemand hat die Datenbank
entworfen und dann fangen wir die
Anwendung zu
erstellen, oder Sie haben zuerst Code, was zwar impliziert,
dass der Code an erster Stelle steht, es aber wirklich bedeutet,
dass wir den Code
schreiben, der dann in die Datenbank
umgewandelt wird. Auf diese Weise ändern wir, wenn wir später
etwas ändern müssen, einfach
den Code, und dann können wir das inkrementelle Änderungen
an der festgelegten Datenbank
vornehmen lassen . Und EFC unterstützt beide.
Das ist das Schöne daran Für den
Großteil dieses Kurses werden
wir uns also zuerst mit dem Code
befassen und herausfinden, wie wir
geringfügige oder
schrittweise Änderungen vornehmen können geringfügige oder
schrittweise Änderungen während wir den Code
modifizieren Aber wir werden uns ansehen
, wie man
eine bestehende Datenbank in
einen EFC-Dateisatz zurückentwickeln kann, oder? Genug geredet,
lassen Sie uns darauf eingehen. Also
werden meine Datenmodelle oder Domänenmodelle am Ende in das
Domain-Projekt aufgenommen, oder? Also werde ich
diese Standardklasse loswerden , die wir damit haben, und ich werde weitermachen
und eine neue Klasse hinzufügen, und ich werde
das Klassenliga nennen. Im Allgemeinen rate ich meinen Schülern
immer, wenn Sie eine Datenbank
erstellen,
versuchen Sie, mit den Datenbanken
mit
den wenigsten Abhängigkeiten zu beginnen und dann weiterzumachen weil Sie keine Tabelle
erstellen möchten, die
zwei oder drei
Fremdschlüssel hat, die sich
auf andere Tabellen beziehen und diese
Tabellen noch nicht existieren. Denn in dieser Situation ist
League eine eigenständige Tabelle,
was bedeutet, dass League da ist Eine Liga wird es zumindest momentan
ohne Teams geben, aber die Mannschaft
hängt von der Liga ab. Ich möchte, dass die Liga zuerst existiert. Erstelle diese Klasse,
ich werde sie
öffentlich machen , damit andere
Projekte darauf zugreifen können. Und dann werde
ich darin die beiden
Eigenschaften ID und Name haben. Also sagen wir public
int ID, public string name. Sie sehen hier,
besonders wenn Sie mit den
Datentypen in SQL
vertraut sind , werden
Sie feststellen, dass wir hier kein
Var-Zeichen sehen . Wir
sagen Zeichenfolge. FCR wird in der Lage sein,
das native C-Sharp
welcher Datentypen zu übersetzen das native C-Sharp
welcher Datentypen In die entsprechenden
SQL-Datentypen. Das werden wir später sehen. Das ist einer der Vorteile. Wir können unser natives
C-Sharp in unserer FCO-Anwendung verwenden , und die Übersetzung die Datenbank
erfolgt für uns anonym Ein weiterer wichtiger
Punkt, auf den Sie hinweisen sollten, sind die Namenskonventionen und die Unterstützung, die Sie von
FCO erhalten , wenn Sie
bestimmte Konventionen einhalten Im Allgemeinen
wird eine ID-Spalte als ID bezeichnet. Manchmal qualifizierst du dich vielleicht und sagst Liga-ID oder
Tabellennamen-ID. Nun wird COR
eine dieser Konventionen identifizieren
und
daraus automatisch schließen, dass es sich dabei um
Ihren Primärschlüssel und Ihre automatisch
inkrementierende
QL-Identitätsspalte
handelt Ihren Primärschlüssel und Ihre automatisch , richtig? Es erkennt
also automatisch Namenskonvention und teilt SQL mit, dass dies
die Primärschlüsselspalte ist Wenn Sie also den Pfad dieser
allgemeinen Benennungskonvention
abnutzen , müssen Sie zusätzliche Konfigurationen vornehmen,
damit das funktioniert. Für mich ist es also einfacher, einfach mit FCR
zu arbeiten,
als das F-Kabel bei einem weiteren Durchgang zu erzwingen Es ist nicht die schwierigste
Sache,
aber warum sollten Sie sich mehr
Arbeit gönnen, wenn es so einfach sein kann einfach ID sagst,
wirst du wissen, dass das der Primärschlüssel
ist und alles andere für mich
einrichten Jetzt erstelle ich die nächste Tabelle oder
die nächste Klasse steht für die
nächste Tabelle, das ist Team. Ich füge das gerade
zum Domain-Projekt hinzu. Team ist der Name, und
dann wieder Team,
öffentlich, wird auch ID und Name
haben. Wie wir gesehen haben,
hat es dann aber eine dritte Spalte, nämlich die Liga-ID. Das steht für einen Fremdschlüssel. Nun, was wir tun werden,
wenn wir einen Fremdschlüssel haben, müssen
wir zwei Eigenschaften hinzufügen. Erstens der Tabellenname oder der Name der
Tabelle, für die dies
ein Fremdschlüssel ist , und die ID. Noch einmal die Namenskonvention. zweite wäre eine
Navigationseigenschaft und in den meisten Fällen werden Sie sehen, wie
sie das virtuell machen. Lass uns das einfach hinzufügen. Öffentliche
virtuelle Liga ist Datentyp der Klasse, die wir gerade mit demselben Namen erstellt haben. Das ist in Ordnung. Aber aus
der Kombination dieser Werte kann F schließen, dass die Übereinstimmung mit dem
Tabellennamen und dem Wort ID bedeutet, dass dies ein
Fremdschlüssel für diese Tabelle ist Ordnung. Wenn
Sie also einen Fremdschlüssel in SQL Server einrichten mussten, wissen
Sie, dass Sie
reingehen und die Spalten auswählen müssen, und Sie müssen
dies tun und Sie müssen das
tun. Und es
gibt ein paar Schritte. Das ist alles was es braucht. Halten Sie
sich an die Benennungskonvention und verwenden Sie diese
Navigationseigenschaft. Und FCO wird einfach sagen:
Okay, ich weiß, dass dies ein Fremdschlüssel
ist, und ich weiß, dass ich die zugehörigen Details über
diese Eigenschaft automatisch
zu diesem Datensatz hinzufügen oder automatisch
präsentieren
kann hinzufügen oder automatisch die zugehörigen Details über
diese Eigenschaft automatisch
zu diesem Datensatz hinzufügen oder automatisch
präsentieren über
diese Eigenschaft automatisch
zu diesem Datensatz Später werden wir es sofort sehen, wenn
zu viele Informationen angezeigt Aber ich versuche
Ihnen nur zu zeigen, dass
FCR Ihnen von Anfang an einen Großteil
der Arbeit abnehmen wird,
sobald Sie diese
grundlegenden Namenskonventionen einhalten Anfang an einen Großteil
der Arbeit abnehmen wird,
sobald Sie Okay. Also das war's
eigentlich fürs Erste. Wir haben die Klassen erstellt,
die die Tabellen in der Datenbank repräsentieren sollen. Natürlich
entsprechen die Spaltennamen den Datentypen Konzept her dem was wir von
ihnen in der Datenbank erwarten würden Und später, wenn wir zurückkommen, werden
wir uns ansehen, wie
wir den DB-Kontext, den Anbieter und
die
tatsächliche Verbindung zur
Datenbank eingerichtet haben Anbieter und
die
tatsächliche Verbindung zur , weil nichts
davon momentan existiert Es gibt keine Datenbank. Wir modellieren es nur und sagen:
Nun, das ist das,
was ich speichern möchte. Wenn wir also zurückkommen, werden
wir sehen, wie wir den
Link zur Datenbank
tatsächlich eingerichtet haben. Okay.
5. Eingeben des Data und der Verbindungs-String: Unsere Jungs waren zurück und das Ziel dieser
Lektion ist es,
unsere Datenklasse so einzurichten , dass sie weiß, dass sie eine Verbindung zu
unserer Datenbank herstellen muss. In Ordnung. Also, zu unserer Datenklasse müssen
wir ein
paar Bibliotheken hinzufügen, damit sie tatsächlich
mit dem Netz-Framework interagieren kann. Entschuldigung, mit Entity Framework. Weil im Moment
niemand etwas weiß. Wir sprechen gerade
über Entity Framework. Es heißt Entity Framework, weiß
aber nichts
über Entity Framework. Lassen Sie mich einfach damit beginnen, diese Standardklasse zu
löschen, und ich werde zu
den neuen Gate-Paketen springen und uns zu
Bros gehen und
nach dem
zentralen SQL-Server für
Entity Framework suchen zentralen SQL-Server für
Entity Framework Bevor ich also weitermache und das gleich
installiere,
lassen Sie mich das einfach erklären Sie haben Microsoft
Entity Framework Core. Dies ist die
Basisbibliothek für alle. Ich denke, jede Variante
hängt von dieser ab. Wenn Sie es sich ansehen, ist es
ein moderner objektbasierter Mapper dafür. Er unterstützt
Linkabfragen, Änderungsverfolgung
und funktioniert mit einer
Reihe von Datenbanken, CQL-Servern, Azure,
CQight-Postern Sie erkennen
, dass Sie von UGT tatsächlich
verschiedene Bibliotheken
erhalten
können, um die verschiedenen Datenbanken zu unterstützen . In unserem Fall verwenden wir
Microsoft k Server. Aber wenn ich nach
Entity Framework Core suchen und mir einfach die
verschiedenen Varianten
ansehen würde, die wir auf unserem K-Server sehen, wir sehen im Speicher, wir würden CQight sehen Wenn Sie Postgres sehen,
werden Sie MCL sehen. Ich werde nicht alle
durchgehen,
aber der Punkt ist, dass,
welche Datenbank Sie auch immer unter der Haube haben,
es
höchstwahrscheinlich eine Bibliothek
gibt, es
höchstwahrscheinlich eine Bibliothek
gibt sie unterstützt, und Sie können sie von New
GT bekommen Ordnung. Wie gesagt, heute arbeiten wir nur
mit SQL Server, also lassen Sie uns weitermachen
und diesen installieren, also werde ich ihn
einfach herunterladen. Und dabei
wird es Ihnen all die anderen Abhängigkeiten zeigen ,
die es hat, oder? Aber das ist in Ordnung. Wir können einfach weitermachen
und auf Okay klicken, alle
Lizenzvereinbarungen
akzeptieren und Sie
es in unserem Projekt installieren
lassen. Jetzt, wo es in unserem Projekt
installiert ist. Wenn ich in der CSP-Datei zurückblicke, klicke ich
einfach auf
die Projektdatei für die Daten für
das Datenprojekt Sie werden hier sehen, dass wir jetzt
diese
Paketreferenz installiert haben diese
Paketreferenz installiert Alternativ
hätten Sie auch weitermachen und diese
Zeile ähnlich wie diese schreiben können. Es könnte sagen,
Node-Paketreferenz , den Namen
der Bibliothek und die Version, an der
Sie interessiert sind, und dann einfach
bauen und es wird automatisch
die Abhängigkeiten für Sie abrufen. Das hätte es also auch tun können, aber lassen Sie uns weitermachen mit NewG Also kann ich das alles schließen. Und der nächste Punkt auf der Tagesordnung wäre die Schaffung des
sogenannten DB-Kontextes. Also möchte ich
eine weitere Klasse erstellen und dann werde ich
diese Klasse Football League
Football League Context oder
Football League DB-Kontext nennen diese Klasse Football League
Football League . Wir neigen dazu, das so einzuordnen, dass DB-Kontext nur bedeutet, dass es
der Kontext oder die Verbindung ist . Sagen wir einfach, Kontext ist
gleich Verbindung. DB-Kontext bedeutet sozusagen
DB-Verbindungsdatei. Und dann teilen wir Ihnen nur
mit, um
welche Datenbank es sich handelt. Es ist keine
Namenskonvention an sich. So mache ich
es. Ich erkläre dir nur, warum ich
es so nenne. Also werde ich diesen
öffentlichen Klassen-DB-Kontext erstellen, und dann erbt jeder DB-Kontext
vom Standard-DB-Kontext,
der von EF Core
kommt Sie haben also unterschiedliche
DB-Kontexte, Sie haben einen DB-Kontext, Sie haben einen Identitäts-DB-Kontext, wenn Sie eine Benutzerauthentifizierung wünschen Aber vorerst bleiben wir einfach beim
grundlegenden DB-Kontext,
Control und Dot, und
dann
weiß ich, dass ich eine
Nutzungsanweisung für das Entity Framework benötige. Kern. Das ist jetzt zufrieden. Ich kann es über die Tische erzählen. Denken Sie daran, dies wird die Verbindung
zur Datenbank
darstellen. Also, was auch immer in
der Datenbank ist ,
muss hier dargestellt werden. Wir haben die Modelle, die die Tabellen
in der Datenbank
repräsentieren. Jetzt haben wir den Link
zur Datenbank, wir müssen diesen Link über die Tabellen
informieren. Also ich möchte Public DB Set sagen. Und dieses DB-Set-DB-Set bedeutet
nur, dass der Satz von Zeilen oder Datensätzen wirklich
eine Tabelle in der Datenbank ist. Du bist dem
Team nachempfunden, in Ordnung. Und dein Name ist Teams. Sie können
es also quasi so lesen, sagen Sie einfach, dass genau
verstehen, was Sie
schreiben, während Sie weitermachen. Nein, ich brauche eine Abhängigkeit. Ich muss hier einen Verweis
auf das Domain-Projekt hinzufügen. Also gehe ich einfach zu,
Sie könnten darauf klicken, aber ich hatte schon einmal Probleme
damit, also mache ich einfach weiter und mache es manuell, klicke auf Abhängigkeiten, füge Projektreferenz hinzu und füge
dann das Domänenprojekt hinzu, klicke, und dann können wir einfach weitermachen und unsere Verwendungsanweisungen
verwenden. Dann werde ich einfach diese Zeile
duplizieren und
dasselbe für eine Liga tun ,
die die DB für Liga festgelegt hat, wir nennen es Ligen
in der Datenbank. Ich habe ein Datenbankset
für Teamobjekte, wir nennen das Teams Dadurch wird wiederum eine Tabelle namens Teams
generiert oder mit ihr interagiert,
und alles, was sich
in der Tabelle Teams befindet wird serialisiert oder ,
wird serialisiert oder in die von uns definierte native
Teamklasse
konvertiert Als Nächstes möchte ich es tatsächlich
über eine Datenbank informieren, und dafür müssen wir eine so genannte Verbindungszeichenfolge ausführen Verbindungszeichenfolgen würden also im Allgemeinen, wie in einer Webanwendung, wie in einer Webanwendung,
weitergegeben, sodass Sie die Verbindungszeichenfolge
in der Webanwendung
haben und sie über die
Konfigurationseinstellungen
in den Kontext weitergegeben wird. Wir haben diesen
Luxus momentan nicht, also machen wir es einfach manuell, also werde ich Override schreiben. Und dann ist es so,
dass der DB-Kontext
, der unsere EFC-Klasse ist, eine Reihe von
Funktionen
enthält, die wir tatsächlich
überschreiben und mit denen wir
unser eigenes Ding machen können denen wir
unser eigenes Ding machen Aber die, an der ich
interessiert bin, ist die Konfiguration. Das heißt,
was soll ich tun, wenn Sie den DB-Kontext
konfigurieren ? Ich werde es überschreiben. Ich muss
nichts auf der Basis überschreiben oder mit der Basis
interagieren, aber ich werde ihr
sagen, dass der Options Builder UCL-Server Sie sehen, das ist mit freundlicher Genehmigung
unseres Punktservers, FCR-Bibliothek, oder? Also uEQL-Server. Und wir werden hier unsere
Verbindungszeichenfolge eingeben hier unsere
Verbindungszeichenfolge Da es sich um eine Demo-App in der Anfangsphase handelt,
machen wir das alles. Aber natürlich führe ich Sie
durch das Ganze, damit Sie verstehen, warum wir es so
machen. Eine Verbindungszeichenfolge
besteht also aus einigen Teilen. Wir sagen, die
Datenquelle ist gleich, und dann würden wir den Server
angeben. Ich verwende also Local DB, einen lokalen Server
, der in Visual Studio
integriert ist, und Sie können über den SQL
Server-Objekt-Explorer auf lokale
DB-Datenbanken zugreifen , den Sie aufrufen können, und da ist er. In Ordnung. Lokales D B, Backslash, Backslash, und dann sagen wir
SQL Local D. B. Machen Sie Nehmen Sie sich einfach etwas Zeit und machen Sie es genau so,
wie Sie es hier sehen, sogar mit den Klammern
und allem, dem doppelten Backslash und all dem Als Nächstes haben wir
den ersten Katalog
und das ist im Grunde der
Name der Datenbank Wie nennen wir
die Datenbank? Ich nenne es Football
League Underscore FCR. Das ist unsere
Verbindungszeichenfolge. In Ordnung. Damit haben
wir die Einrichtung
des Datenproviders und die
Einrichtung der Verbindung
zur Datenbank abgeschlossen des Datenproviders und die . Nun, diese Datenbank
existiert natürlich noch nicht, oder? Also habe ich einen Link zu
etwas eingerichtet , das so ziemlich nicht
da ist. Und ich habe gesagt, dass diese Tabellen in einer festgelegten Datenbank existieren
müssen, die, wie wir gerade
sagten, nicht existiert. Also werde ich ganz
schnell
im SGO-Server-Explorer nachschauen , um Ihnen zu zeigen , dass es dort wirklich
nicht existiert Ich habe ein paar Testdatenbanken, und wie Sie sehen können, sind
sie nicht da Wenn wir also zurückkommen, werden wir FCO verwenden, um diese Datenbank zu generieren
, damit wir anfangen können, mit ihr zu
interagieren
6. Migrations Datenbankerstellung: Hey, Leute, willkommen zurück.
In der letzten Lektion hatten
wir also unseren DV-Kontext eingerichtet
, der, wie gesagt, unsere
Verbindung zur Datenbank ist In dieser Lektion werden wir uns zunächst mit Migrationen befassen, das sind unsere Anweisungen
zur Datenbank Unsere erste Migration wird darin bestehen, die Datenbank zu erstellen, da bei
einer Migration immer die Frage gestellt wird, was existierte, was ist jetzt? Was ist anders? Lassen Sie mich Anweisungen geben, um
diese Änderungen vorzunehmen. Zu diesem Zeitpunkt gibt es nichts. Was jetzt da ist, ist also nichts, und dann werden die Anweisungen das generieren, was da sein sollte. Stimmt das? Um unsere Migrationen durchzuführen, benötigen
wir also ein anderes Tool aus
unseren neuen Gate-Paketen,
und diese Bibliothek besteht
buchstäblich aus Tools, oder
? benötigen
wir also ein anderes Tool aus
unseren neuen Gate-Paketen, und diese Bibliothek besteht
buchstäblich aus Tools, oder Wir brauchen FC zwei. Gehe
rüber zu New Gate, ich gehe weiter und klicke auf Tools und lade
das herunter und das kommt
automatisch mit Design
und einigen anderen Bibliotheken, aber ich werde einfach
weitermachen und das installieren lassen. Nach der Installation
muss ich eine
Projektreferenz zwischen
der Konsole und unserem Datenprojekt einrichten, muss ich eine
Projektreferenz zwischen
der Konsole und unserem Datenprojekt einrichten der Konsole und unserem Datenprojekt denn wenn wir einen Befehl
zum Aktualisieren der Datenbank ausführen, müssen
wir ihn für
das Startprojekt
oder das Hauptprojekt ausführen lassen , und das Hauptprojekt muss über die anderen
Projekte mit, Sie wissen schon, der Verbindung und
dem DB-Kontext usw. Bescheid wissen. Also werde ich einfach
weitermachen und eine Projektreferenz
zur Konsole
hinzufügen für beide eine Projektreferenz
zur Konsole
hinzufügen, weil wir
auf die Domänenobjekte zugreifen müssen. Wir müssen auch auf
die Domain und den
DB-Kontext zugreifen können , oder? Also mache ich einfach
weiter und füge das hinzu Und wenn wir dann wissen, dass das
alles erledigt ist, können
wir eine Migration durchführen. Um Migrationen
mit Visual Studio auszuführen, möchten
wir zur
Paketmanager-Konsole gehen Sie können also zu Tools gehen, Sie erhalten den Paketmanager und Sie sehen die Paketmanager-Konsole Ich habe
meine bereits
hier unten in diesem Panel zur Verfügung , und natürlich können Sie die Panels alle nach oben
verschieben. Lass mich das einfach wiederholen. Bevor wir mit
den Migrationen beginnen, möchte
ich nur, dass wir uns
den Umfang
der Optionen ansehen, die uns zur Verfügung stehen In dieser Paketmanager-Konsole kann
ich sagen, holen Sie sich
Hilfe und geben
Sie dann Entity Framework und geben Sie dem
ein paar Sekunden Zeit. Dann wird ein nettes Dokument
generiert,
das Dann wird ein nettes Dokument
generiert uns alles
zeigt, was mit dem
Entity Framework
möglich ist dem
Entity Framework
möglich Es beginnt mit einem Einhorn und es
erzählt uns von der Bibliothek Es gibt uns alle
Kommandos und wofür sie verwendet werden Dieselbe Liste, auf die ich
gerade in GT hingewiesen habe, ist hier
mit Dokumentation verfügbar Also, wie gesagt, wir
werden eine Migration hinzufügen und dann müssen wir
die Datenbank nach
jeder Migration aktualisieren . Ich habe bereits erwähnt
, dass Sie zuerst den
Code und nicht die
Datenbank zuerst haben . Wenn Sie also zuerst Code erstellen,
nun ja, das ist die Datenbank zum Hinzufügen von
Migrationsupdates. Wenn Sie zuerst mit der Datenbank arbeiten, sollten Sie den FO-DB-Kontext scannen,
was im Grunde bedeutet, dass ich mir die Datenbank
ansehe und die Klassenmodelle auf der
Grundlage dessen, was ich
in der Datenbank sehe,
generiere . Sie sehen also, dass ihnen eine
ganze Reihe von Optionen zur Verfügung stehen. Sie können den DV-Kontext und
Scripto die Migrationen skripten. Wenn Sie immer noch altmodisch sind, die Migration
zu generieren, benötigen Sie ein SQL-Skript . All das können Sie
mit diesen Tools tun. Lassen Sie uns also weitermachen. Ich
lösche einfach dieses CLS,
lösche die Konsole und
dann
weiß ich, füge eine Migration hinzu Das
Standardprojekt
muss also wieder das ausführende
Projekt in der Lösung sein Und ich werde
sagen, Migration hinzufügen. Und dann werde
ich ihm einen Namen geben. Also der Name, normalerweise sollten
Sie einen
vernünftigen Namen verwenden
, den Sie oder jemand anderes haben. Nun, fangen wir
mit jemand anderem an. Jemand anderes kann
kommen und sagen: Okay, das war die allgemeine
Vorstellung von dieser Migration. Sie sollten auch einen vernünftigen Namen
verwenden denn wenn Sie in den
Urlaub gefahren sind und zurückkommen, möchten
Sie
auf diese Migration zurückblicken und verstehen, warum sie
durchgeführt wurde und wofür sie war. Nennen Sie die Migration also nicht X oder einfach etwas Dummes, sondern
geben Sie ihr eine Bedeutung Also als ob hier nichts wäre. Ich habe keine Migrationen,
keine Datenbank. Noch. Ich möchte das
erste Migration nennen. Ich schreibe auch gerne
meine Namen. Wenn Sie Leerzeichen verwenden, müssen Sie zusätzliche
Vorsichtsmaßnahmen treffen, wenn Sie,
Sie wissen schon, die
Namen wiederverwenden müssen und so weiter Also verwende ich nur Kamelhüllen. Sie können
Unterstriche verwenden, was auch immer, aber ich mag keine Leerzeichen
in diesen Namen Also werde ich diese Migration
hinzufügen. Es wird das Projekt erstellen, und der Build ist erfolgreich, aber ich habe einen Fehler. Lesen wir also diesen Fehler.
Und in diesem Kurs werde
ich nicht
vor Fehlern zurückschrecken, weil ich weiß , dass viele Leute die Fehler
hassen, die
sie in EFC bekommen Manchmal sind sie
nicht ganz klar
und es ist schwierig, einige dieser Fehler zu beheben Ich werde also nicht vor Fehlern
zurückschrecken. Wenn überhaupt, werde ich
bewusst
einige Fehler heraufbeschwören , damit wir sie gemeinsam
durchgehen können Aber hier geht
es nur darum , dass
das Startup-Projekt, also die Konsolen-App, nicht auf das
Designprojekt verweist, Mit anderen Worten, ich muss ein Paket
in der Konsolen-App
installieren. Also ein einfacher Weg, das zu erledigen. Natürlich können Sie zu New Gate
gehen, aber ich werde versuchen,
es über die Projektdatei zu tun. Ich werde eine neue
Artikelgruppe erstellen und ihr
eine Paketreferenz geben, um das Kerndesign des
Microsoft Dot Entity
Frameworks einzubeziehen . Und ich stelle nur
die Version ein, von der
ich weiß, dass ich sie
im restlichen Projekt verwende. Diese Version kann
je nachdem, wann Sie den Kurs
absolvieren, variieren. Wenn Sie also diesen
Weg einschlagen, ist das in Ordnung. Wenn nicht, können Sie jederzeit zu New Gate
gehen und
das Entity
Framework-Designpaket hinzufügen das Entity
Framework-Designpaket wie wir es für alle
anderen Pakete getan haben. nächste sehr wichtige
Schritt besteht darin,
sicherzustellen , dass wir unser
Datenprojekt ausgewählt haben. Ich habe gerade eine Liste gesehen,
um das Rauschen
und die Fehler in diesem Abschnitt zu beseitigen , aber ich
möchte nur darauf hinweisen, dass das Standardprojekt hier das Projekt sein
muss , in dem Sie den DB-Kontext
haben, für uns sind das Daten. Ich mache
weiter, wähle Daten aus und drücke dann
einfach nach oben
, was mich zum Befehl add
migration initial
migration bringt . Machen Sie weiter und versuchen Sie es
erneut, und dieses Mal haben
wir unsere Migration erstellt. Schauen wir uns nun
an, was wir hier haben. Wir haben unseren Ordner
namens Migrationen, und er enthält mindestens eine Datei mit dem Namen der
Migration, die wir ihr gegeben haben Beachten Sie, dass ein
Zeitstempel darauf ist. Wir haben auch diesen anderen
, der der Kontext-Snapshot ist. Im Grunde wird die
Datenbank zu
diesem Zeitpunkt so aussehen, und wir haben unsere Migrationsdatei. Nehmen wir uns etwas Zeit, um genau zu verstehen, was in einer Migrationsdatei enthalten
ist. Normalerweise hätten
Sie in SQL also SQL-Anweisungen geschrieben: Tabelle
erstellen, erstellen, nun ja, tut mir leid, Datenbank erstellen und
dann Tabelle erstellen. Dann geben Sie alle
Felder und die Einschränkungen ein. Wenn Sie ein Drehbuch schreiben würden. Wenn Sie das
Management Studio verwendet hätten, hätten
Sie geklickt und alles wäre im Hintergrund
generiert worden. Nun, eine Migrationsdatei
ist quasi eine Repräsentation all
dieser Aktionen, aber mit einem klaren C-Kontext und
aufbauend auf dem, was wir
das Builder-Muster genannt haben , oder? Wenn Sie es
sich also nur ansehen, sieht
es kompliziert aus, aber lehnen Sie sich
einfach zurück, atmen Sie
tief durch und betrachten Sie es als Entwickler, Sie werden feststellen, dass
alles, was es Ihnen
sagt,
Sinn macht, oder? Der Migration Builder, das ist ein Objekt, das hier übergeben
wird, Tabelle erstellen. Der Name ist vom Tisch,
Lecks, richtig? Und dann
wird es automatisch dafür sorgen,
dass es etwas kreiert. Also, obwohl
ich
im DV-Kontext vorgeschlagen hatte, tut mir leid, ich versuche hier nur, viel zu
sagen Ich hatte ursprünglich vorgeschlagen
, dass wir bei der
Erstellung der Klassenmodelle mit der geringsten Abhängigkeit beginnen Denn wenn wir mit
Team beginnen würden und das Team eine Abhängigkeit von
dieser Navigationseigenschaft für
Liga und Liga
gehabt
hätte dieser Navigationseigenschaft für , dann wäre
das
ein kleiner Fehler gewesen Es wäre also klug
von uns gewesen, eine Liga zu gründen. Dann ist League schon da wenn wir
Dinge erschaffen, die League brauchen Okay. Nun, im DB-Kontext habe ich diese Reihenfolge nicht unbedingt
befolgt. Ich habe sie einfach
zufällig aufgelistet. Ich habe
sie also nicht unbedingt in der Reihenfolge aufgelistet, sie erstellt werden sollten,
weil
ich natürlich gewollt hätte, dass Ligen
vor Teams erstellt werden Wenn Sie sich jedoch die Migration ansehen
, sie bereits durchgeführt
und festgestellt, dass Ligen keine Fremdschlüssel haben, Teams
schon Ligen müssen also
erstellt werden, bevor es Teams tun. Das ist so ziemlich das,
was FCR gerade getan hat. Es erstellt also
die Tabelle. Es gibt ihr die
Spalten ID und Name. Und wenn Sie
noch einmal genau hinschauen und sich an die
Namenskonventionen halten, wird
ID automatisch zu einer
Ganzzahl, die
keinen Nullwert zulässt, und es handelt eine automatisch inkrementierende CQL-Serveridentität All das wurde generiert weil wir das Wort oder
den Namen ID für diese Spalte verwendet haben FOR kam zu dem Schluss, dass wir dies als unseren Primärschlüssel haben wollten Und dann wirst du
hier sehen, wo es heißt, dass
der Spaltentyp eine Zeichenfolge ist Das ist ein scharfes C, aber in der Datenbank machen
wir es zu NTR Alles klar? Lass
das einfach ein wenig einwirken. Dann fahren wir fort und
fügen die Einschränkungen , die
diesen Schlüssel tatsächlich zum Primärschlüssel machen, nämlich in der ID-Spalte. Dann werden diese Aktionen wiederholt. Migration Builder, Tabelle erstellen, Teams
erstellen, die
Spalten erneut erstellen,
ableiten, was der
Primärschlüssel ist,
und dann die Liga-ID als Ganzzahl hinzufügen, aber dann geht es noch einen Schritt weiter mit den
Einschränkungen, wo es
den Primärschlüssel und
den Fremdschlüssel erstellt,
der die Liga-ID der
Spalte mit den Ligen der Haupttabelle
und
der Hauptspalten-ID verknüpft Sie sehen also, all das wird abgeleitet, wenn wir unsere eigenen
Namenskonventionen verwenden Es kann
vorkommen, dass Sie, wissen
Sie, vom Kurs abweichen müssen ,
und das ist verständlich,
aber lassen Sie es nicht so sein
, dass Sie immer Ihr eigenes Ding
machen gegen QR kämpfen
und dann am Ende
doppelt so viel Arbeit machen, wenn
QoR mehr als glücklich ist, die ganze Arbeit für Sie zu
erledigen Nachdem Sie all das erstellt haben, wird
ein Index für diese
Fremdschlüsselspalte erstellt ein Index für diese
Fremdschlüsselspalte Jetzt werden Sie auch
feststellen, dass es zwei
gibt. Leider gibt es in
dieser Migrationsdatei zwei Methoden. Wir haben so ziemlich
alles getan wenn ich die
Datenbank aktualisiere oder
die Datenbank
aktualisiere.
Das ist es, was ich tun möchte. D bedeutet, dass, wenn ich diese Migration
aus der Datenbank rückgängig machen soll, genau das getan werden sollte. D ist genau wie up das Gegenteil von D, der Code, der sich in up befindet wird
etwas tun, das dem
Code, der gerade ausgeführt wird, völlig entgegengesetzt ist,
weil es Zeiten gibt, in denen
Sie eine Datenbankänderung vornehmen und dann sagen: Oh, das ist nicht wirklich das, was ich tun wollte,
dann nehmen Sie eine Änderung vor. Aber wenn Sie diese Änderung vornehmen
möchten, ist das
manchmal leichter
gesagt als getan. Also zumindest sagt FCR, nun,
ich sage der Datenbank,
was zu tun ist ich sage der Datenbank , wenn die
Migration abgeschlossen ist, und ich werde Ihnen auch
sagen, was Sie nicht tun sollen
oder was zu tun ist, wenn diese
Migration rückgängig gemacht wird All das ist also
in dieser Datei automatisiert. Okay. Okay, jetzt, wo wir
die Migration haben. Wir werden diese
Lektion beenden, indem wir den
magischsten und wahrscheinlich
wichtigsten
Befehl von allen ausführen magischsten und wahrscheinlich , nämlich die Datenbank zu aktualisieren. Bis jetzt haben wir unsere Datenbank also immer noch
nicht. Wir machen weiter und geben
Update Hyphen Database ein. Drücken Sie die Eingabetaste und lassen Sie es erstellen. Und dieser Befehl
sieht sich
die Migrationen an , von denen
er wahrscheinlich weiß und dann
die Migrationen, von denen er
nichts weiß,
und setzt
dann einfach an die Migrationen, von denen er
nichts weiß, diesem Punkt fort
und führt die zukünftigen Migrationen aus und führt Hier sehen Sie, dass es heißt, Migration
anwenden, und dann wird
mir mitgeteilt, welche Migration angewendet wurde, wenn fünf angewendet worden
wären, fünf angewendet hätten, aber es gibt nur eine,
sodass ich weiß, dass
sie erfolgreich durchgeführt wurde. Wenn ich also
in meiner Datenbankliste zurückblicke, sehe
ich die Datenbank jetzt mit
dem Namen, den ich
in dieser Verbindungszeichenfolge definiert habe, Football League EF Core. Wenn ich die Tabellen erweitere, sehe
ich den
EF-Migrationsverlauf
, der im Grunde eine
Tabelle in der Datenbank ist,
in der die Migration nachverfolgt wird , der im Grunde eine
Tabelle in der Datenbank ist, . So können Sie feststellen, bis zu welcher
Version sich Ihre Datenbank befindet. Richtig? Und dann habt ihr
Ligen und wir haben Teams Und wenn du nachschaust, siehst du Schlüssel, okay, das ist also
der Primärschlüssel Und du siehst hier, dass
League ID ein Fremdschlüssel ist. All das wurde dank dieser Migration für uns in
der Datenbank eingerichtet . In der nächsten
Lektion werden wir uns nun
ansehen, wie wir für
diese Migration ein Skript
hätten erstellen können , da Sie vielleicht nicht unbedingt die Datenbank
aktualisieren und so weiter ausführen und FCR
die vollständige Kontrolle über
alles in der Datenbank überlassen möchten Datenbank
aktualisieren und so weiter ausführen und FCR
die vollständige Kontrolle über
alles in der Datenbank überlassen vollständige Kontrolle über
alles in der Datenbank Aber es gibt eine Möglichkeit,
ein SCO-Skript auf der Grundlage
dieser Anweisungen
zu generieren,
und Sie könnten ein SCO-Skript auf der Grundlage
dieser Anweisungen
zu generieren, es dann selbst ausführen Also, wenn wir zurückkommen, werden
wir uns das ansehen.
7. Migration erstellen: Leute, willkommen zurück.
In dieser Lektion werden
wir also über die Erstellung von
Skripten für unsere Migration sprechen Die Fallstudie
dafür, warum Sie Skripte erstellen sollten , anstatt, Sie wissen schon, eine
Migrationsdatei
zu generieren und dies vom Paketmanager aus zu erledigen , wäre
vielleicht nur
die Trennung
von Steuerelementen Vielleicht gibt es einen
Datenbankadministrator , der für
Datenbankänderungen zuständig ist. Sie, der Entwickler,
würden
diese Datenbankänderungen also nicht vornehmen, aber Sie haben die Migration
gegen Ihre lokale Datenbank durchgeführt. Sie müssen es ihm geben, damit er es in
der Umgebung machen kann. Du weißt, es gibt
verschiedene Situationen , die
darüber entscheiden können, ob du es
so machen kannst , wie wir
es gerade im vorherigen Video gemacht haben. Oder Sie müssten für
die Migration ein Skript erstellen und sie übergeben. Nichtsdestotrotz werden wir
lernen , wie man
die Migration skript, und das ist ein sehr
einfaches Verfahren. Wir haben also nur eine Migration, sodass das Skript nicht
das komplizierteste sein wird. das Skript wächst, gibt es bestimmte Verhaltensweisen, die entsprechend hinzugefügt
werden, und das Skript wächst mit den verschiedenen Migrationen, richtig? Später können wir uns das noch einmal ansehen
, aber im Moment wollen
wir nur sehen, wie wir diese Migration skripten
würden In der
Paketmanager-Konsole ist es also ziemlich einfach. Sie sagen einfach Skriptmigration mit
Bindestrichen. Es
wird den regulären Build ausführen und dann die SQL-Datei generieren ,
die all diesen Befehlen
entspricht Da haben wir's. Sie werden hier
sehen, dass geprüft
wird, ob die Tabelle mit dem
Migrationsverlauf Null ist, dann fahren Sie fort und
erstellen Sie diese Tabelle. Dann starten wir die Transaktion und erstellen die
Tabellen entsprechend. Wir bekommen den Index, wir fügen die
Migration, die gerade ausgeführt
wurde, in
die Migrationshistorie gerade ausgeführt
wurde, in
die Migrationshistorie ein, oder? Das ist es. Also noch einmal, dies wird wahrscheinlich
geschehen, wenn Sie die Verantwortung für die Datenbankänderungen
oder
die Datenbankerstellung,
was auch immer es ist, an eine andere Person
in Ihrem Team in
der Organisation übertragen möchten die Verantwortung für die Datenbankänderungen
oder
die Datenbankerstellung,
was auch immer es ist, an eine andere Person ,
und das ist es, was FCO erlaubt
8. Reverse Engineer: Hey, Leute, willkommen zurück.
In dieser Lektion werden
wir uns also damit
befassen, wie wir eine bestehende
Datenbank
zurückentwickeln können . Wir haben also wieder einmal
Code, in den wir den Code schreiben
können, der die Datenbank
generiert. Aber in manchen Situationen haben
Sie vielleicht bereits eine Datenbank , die Sie in Ihre Klassenmodelle integrieren möchten in Ihre Klassenmodelle integrieren so wie wir
es bis jetzt gemacht haben In dieser Lektion
werden wir uns das ansehen, und Sie hätten zur Kenntnis genommen dass ich bereits ein neues Projekt
erstellt habe Sie können das also tun, wenn Sie den Anweisungen folgen
möchten, aber das ist nicht unbedingt
erforderlich, da wir uns den Befehl
nur
ansehen
und genau sehen werden , was er bewirkt. Deshalb habe ich dieses
neue Console-Up-Projekt erstellt, das ausschließlich
dazu dient, die Datenbank zu strukturieren,
damit Sie
genau sehen können, damit Sie
genau sehen können Also werde ich es zu
meinem Startprojekt machen und wir werden zum Paketmanager
übergehen Und zur Auffrischung werde
ich sagen, holen Sie sich Hilfe, und wir werden uns
den Befehl
zum
Gerüst für die Datenbank ansehen den Befehl
zum
Gerüst für die Hier ist also die Liste
der Befehle,
und wir sehen hier, dass wir „Gerüst-DB-Kontext“
sagen können Das ist also der Punkt, auf den
wir in dieser
Lektion achten werden in dieser
Lektion achten Wenn wir also ein Gerüst erstellen wollen, kopiere
ich es einfach und füge es als nächsten
Befehl ein, den ich ausführen werde, und wir werden
dieselbe Datenbank verwenden, an der wir in diesem
gesamten Kurs
arbeiten, nämlich unsere Football
League-Datenbank Ich werde es
in die Modelle integrieren, richtig? Also muss ich den Anbieter angeben
. Also Hyfen Provider. Also das ist ein Parameter. Anbieter, und unser
Anbieter wird Microsoft Dot Tit Framework
Core Dot SQL Server sein. Alles klar? Also das ist der Name
unseres Pakets und das ist unser Anbieter. zeigt also nur, dass dieser
Scaffold-DB-Kontextbefehl
für andere Datenbanken verwendet werden kann , bei denen es sich
nicht unbedingt um SQL Server handelt Ordnung. Also
spezifizieren wir den Anbieter und dann
müssen wir ihm die Verbindung geben, die ganze Verbindung,
hier wäre die gleiche Verbindung,
die wir so ziemlich in unserem B-Kontext
verwenden. Sie müssen also nur
eine Verbindungszeichenfolge formulieren. Da ich bereits einen habe, werde
ich
ihn nicht von Grund auf neu eingeben Ich werde es einfach kopieren
, weil
wir, wie gesagt, dieselbe Datenbank verwenden. Aber egal, um welche Datenbank es sich handelt, Sie schreiben eine Verbindungszeichenfolge. Datenquelle
entspricht dem Server, sie
entspricht im ursprünglichen Katalog dem Namen
der Datenbank, da sie sich möglicherweise auf einem anderen
Server befindet. Sie muss sich nicht
unbedingt auf demselben Server befinden. Sie möchten also nur die Tatsache zur
Kenntnis nehmen, dass Sie
diese Verbindungszeichenfolge
entsprechend dem Speicherort der Datenbank schreiben diese Verbindungszeichenfolge
entsprechend . Also werde ich
Anführungszeichen öffnen und meine Verbindungszeichenfolge
eingeben. Schließe Anführungszeichen. Also noch eine Sache
, die wir tun wollen, bevor wir versuchen, diesen Befehl
auszuführen. Wir wollen sicherstellen
, dass unser Projekt auf dieselben
Bibliotheken verweist, die wir
einrichten mussten , als wir
unser erstes Gerüst oder unsere
ersten Migrationen durchführten, oder? unser erstes Gerüst oder unsere
ersten Migrationen durchführten, oder Wenn wir also einen Blick
zurück in die Daten werfen, stellen wir fest, dass
wir auf den Kill-Server
verweisen mussten und dass wir auf die verweisen mussten. Tools
und das Design
der Toolreferenzen All das
wird benötigt. Ich werde einfach die
gesamte Artikelgruppe nehmen. Kopieren Sie und gehen Sie dann zu unserem neuen Projekt und fügen Sie es ein
und erstellen Sie dann einen schnellen Build. Und nachdem das erfolgreich
war, kehren
wir zur Paketmanager-Konsole zurück. Ich werde nur noch einmal
überprüfen, ob der Anbieter korrekt ist und
die Verbindung korrekt ist. Ich werde sicherstellen
, dass das Standardprojekt oder das Zielprojekt das Projekt ist das wir das Gerüst erstellen
möchten Und dann drücke ich die Eingabetaste.
In Ordnung. Und nachdem ich die Eingabetaste gedrückt
hatte, gab
mir das Gebäude eine T-Warnung und dann eine sehr tödliche Ausnahme. Nun, wie ich schon sagte, werde
ich
in diesem Kurs nicht vor Fehlern
zurückschrecken. Ich denke, es ist sehr wichtig
, die Fehler zu erkennen und sie zu beheben. Dieser Fehler besagt also, dass beim Versuch, eine Verbindung
zum Server herzustellen, ein Netzwerkfehler eine Verbindung
zum Server herzustellen, ein Netzwerkfehler
aufgetreten ist. Das bedeutet also, dass etwas mit meiner Verbindungszeichenfolge
nicht stimmt. Und ich glaube, ich weiß, was es ist. Es ist der doppelte Schrägstrich , weil wir hier
den doppelten Schrägstrich verwenden müssen, um die Verbindungszeichenfolge
im wörtlichen Kontext zu
schreiben im wörtlichen Aber dann brauche
ich statt
des Paketmanagers diesen doppelten Schrägstrich nicht Ich werde es entfernen und dann werde
ich es erneut versuchen Und dieses Mal habe ich keinen Fehler. Ich habe dieselbe Warnung erhalten,
aber ich habe keinen Fehler. Und wenn Sie einen Blick hinter
meine Paketüberwachungskonsole und in das Projekt werfen, werden
Sie
eine Reihe von Dateien
sehen . In Ordnung? Schauen wir uns also an, wofür
jeder von ihnen steht. Also werde ich einfach alles
zusammenbrechen lassen
, was nicht unbedingt notwendig ist. Und dann
schauen wir uns den Kontext an. Also hat es eine Kontextdatei generiert. Dieselbe Kontextdatei
, die wir manuell erstellt haben, nur um sie zu generieren. Sie gab ihr den Namen, der auf der Datenbank
basiert. Ich habe ihm die Vererbung
des DB-Kontextes gegeben, es hat zwei Konstruktoren,
einen Parameter s, einen mit dem Parameter, der
Optionen von
irgendwo aus einer anderen Anwendung akzeptiert Optionen von
irgendwo aus ,
das ist in Ordnung Wir haben unsere DB-Sets beide virtuell
erstellt, und dann haben wir dieselbe
Dekonfigurationsmethode, oder? Wenn ich also einen direkten
Vergleich anstellen würde, würden Sie feststellen, dass
meins zwar viel mehr oder immer viel einfacher
ist Es ist wirklich
dasselbe, oder? Wir haben die Dekonfiguration
und dann heißt es, wenn keine
Optionen konfiguriert sind, wird diese
Verbindungszeichenfolge eingefügt, genau wie wir es getan haben Es gibt
uns jedoch diese Warnung,
die dieselbe
Warnung ist, die wir
in der Paketmanager-Konsole gesehen haben in der Paketmanager-Konsole Es heißt nur, dass Sie vermeiden
möchten,
Ihre Verbindungszeichenfolge direkt in den Kontext wie diesen einzufügen. Und wie ich schon sagte,
wir machen das provisorisch, weil
es nur eine Konsolen-App ist, also platzieren wir es einfach genau dort, damit es funktioniert Ordnung. Aber in einer
größeren Anwendung würde
es sich in einer anderen Datei befinden
und bei Bedarf weitergegeben werden. Sie werden auch eine andere Methode zur Kenntnis nehmen
, mit
der wir uns noch nicht ganz
befasst haben, aber wie gesagt, Sie können die
meisten, wenn nicht alle Methoden überschreiben,
die standardmäßig
aus der DB-Kontextklasse stammen, und diese andere Methode bezieht
sich auf die Modellerstellung. Das heißt also
im Grunde nur , dass wir die Anation haben die relationale Kollation die die Zeichensätze festlegt, die
wir
für diese Datenbank verwenden werden,
und dann heißt es weiter, dass wir
für diese Datenbank verwenden werden, und dann heißt es weiter Model Builder Dot
Entity Team einen Index hat, und es hat eine Liga
mit vielen Teams und hat ein ausländisches Gedächtnis nur indem man die
Namenskonvention befolgt, Als wir
die Datenbank erstellt haben, alles irgendwie für uns impliziert oder
es hat es bei der Migration getan In dieser Situation
betrachtet es eine bestehende Datenbank
und versucht dann, die Regeln für die Erstellung
dieser vorhandenen Datenbank
oder die Interaktion mit
ihr zu
formulieren dieser vorhandenen Datenbank
oder die Interaktion , die eingehalten werden
müssen Ordnung. Auf die gleiche
Weise, wenn wir diesen Datenbanknamen
ändern und Ihnen dann sagen würden, dass Sie eine Migration durchführen
sollen, würde
es sich tatsächlich all diese Regeln
ansehen ,
um zu wissen, wie man eine Migration für eine
brandneue Datenbank durchführt, aussieht wie die, auf der
sie basiert. Ich sage Ihnen,
FCR ist sehr, sehr intelligent
und macht Es zieht
im Hintergrund eine Menge Fäden für Sie. Ordnung, so sieht der DB-Kontext also
wirklich aus. Und wenn wir uns dann
unsere generierten Klassen ansehen , sehen
Sie, dass wir
eine Teilklasse erhalten, wir erhalten ein Hash-Set, das
die Sammlung des Teams darstellt. Darauf komme ich gleich zurück. Aber wir bekommen dieses Konstrukt und
wir erhalten dieselben Eigenschaften. Und wenn wir nach einem Team suchen, sieht
es praktisch genauso aus,
wie wir es bei unserem eigenen gemacht haben. Das heißt also, dass wir auf
dem richtigen Weg sind, oder? Wir haben immer noch diesen
Fremdschlüssel und die Navigationseigenschaften
zur Liga,
die ebenfalls virtuell ist Gehen wir zurück zu dem,
was die Ligaklasse hat.
Wir sehen hier, dass wir
eine zusätzliche Eigenschaft haben , die wir nicht in unsere eigene eingebaut Also werde ich einfach die ursprüngliche Liga ansprechen. Das ist die, die wir
geschaffen haben, oder? Und dann hat das Gerüst, das über ein
Gerüst gebaut wurde , diese
zusätzliche Eigenschaft,
nämlich eine Ansammlung Nun, das Konzept hier ist, dass es einer zu viel ist. Das wissen wir. Wir haben es geschaffen, und wir werden später eines zu viel
durchgehen, aber ich möchte nur
hervorheben, dass
es hier bedeutet es hier ,
dass eine Liga Zugang zu vielen Teams
haben wird. Ein Team gehört zu einer Liga. Aber eine Liga hat viele Teams.
Das ist eins zu vielen. diese
Navigationseigenschaft also auf eine Sammlung eingestellt war, oder es
hätte auch eine Liste
sein können, standardmäßig die Sammlung verwendet Bei der Erstellung hätten
wir Liste sagen können, wir hätten sagen können, dass ich zählbar bin Aber der Punkt ist, dass es sich die Sammlung verwandter
Artikel zu dieser Entität handelt also nur eine Liga erhalte, könnte
ich
alle Teams einbeziehen, und das würde mir
den Kummer ersparen , zwei separate Abfragen stellen zu
müssen,
tut mir leid, um die Teams
und die Liga zu ermitteln, zu der
sie Also gut, es ist ein sehr mächtiges Zeug, das so zu machen Also können wir
diese
Navigationseigenschaft später zu unserer eigenen hinzufügen , aber ich
wollte nur hervorheben, was genau erstellt wurde
und was genau gemacht wird und was genau gemacht Und so ziemlich das war's mit dem Gerüst in der Datenbank
. Es gibt noch andere kleine Dinge,
die Sie wahrscheinlich tun können, aber auf der grundlegendsten Ebene, wenn es eine Datenbank gibt, vielleicht mit dem
Aufbau eines SC-Servers begonnen hat oder es Teil eines
älteren Projekts oder eines älteren Systems ist und
Sie es überarbeiten möchten, möchten
Sie einfach anfangen, daran zu arbeiten ohne von vorne
anzufangen Dann können Sie diesen Befehl verwenden, um die Datenbank in
Form dieser Modelle einzubinden Und dann, durch den Kontext, können
Sie von Anfang an
damit anfangen, damit zu arbeiten . Okay. Okay.
9. View mit Entity Framework Core Tools: Hallo Leute, willkommen
zurück in dieser Lektion Wir werden uns
die FCO-Powertools ansehen und herausfinden, wie sie uns
helfen können , unsere
Datenbank mit Visual Studio zu visualisieren Nun, ich habe
vorhin
ein Datenbankdiagramm gezeigt, wo wir im SQL Server Management
Studio
waren, und ich habe dieses vorhin
ein Datenbankdiagramm gezeigt, wo wir Diagramm Null generiert , nur um
die Datenbank darzustellen , die wir zu dem Zeitpunkt erstellen
wollten Möglicherweise
haben Sie nicht unbedingt diesen Luxus,
und ich sage nicht, dass Sie sich das
Management Studio
holen müssen , aber mit den
EFC-Power-Tools über Visual Studio können
Sie ein
ähnliches Diagramm erstellen und sehen, wie FCO Ihre Datenbank
oder die Datenbank, mit der
es verbunden ist, visualisiert . Lassen Sie uns also anfangen. Wenn Sie Visual
Studio haben, ist das gut. Sie gehen einfach zu Erweiterungen, Sie gehen zur Verwaltung von Erweiterungen. Und wenn dieser Dialog erscheint, suchen
Sie einfach nach
FCO-Elektrowerkzeugen, und wenn Sie es in
den Suchergebnissen sehen, klicken
Sie einfach auf Herunterladen Okay. Danach
müssen wir Visual Studio neu starten, damit Sie das schnell erledigen können. Jetzt, nach dem Schließen von
Visual Studio, wird
der Extension Manager gestartet und die Installation
abgeschlossen. Wenn Sie
diese Funktion noch nicht installiert haben , müssen Sie den DG ML
Editor ,
der wahrscheinlich
mit Visual Studio installiert wurde , möglicherweise nicht ausführen. Aber wenn Sie diesen
Schritt ausführen, ist das kein Problem. Fahren Sie einfach fort und
klicken Sie auf Ändern,
damit die Abhängigkeiten übernommen werden. Und sobald dieser Vorgang abgeschlossen ist, können
Sie Visual
Studio erneut öffnen und dann werden
wir feststellen, dass wir, wenn
wir mit der rechten Maustaste auf ein Projekt klicken, ein neues Menüelement
in Form von FQ-Powertools sehen in Form von FQ-Powertools Sie werden also eine
Reihe von Optionen sehen, von denen
einige genauso aussehen wie was wir
bis zu diesem Zeitpunkt
mit den verschiedenen
Migrationen und
Gerüsten und
Forward Engineering besprochen haben mit den verschiedenen
Migrationen und .
All diese Dinge sind mit
diesen FQ-Powertools
tatsächlich möglich, All diese Dinge sind mit
diesen FQ-Powertools
tatsächlich möglich diesen FQ-Powertools ohne dass die Befehle
geschrieben werden müssen. dieser
speziellen Lektion möchte ich mich jedoch darauf konzentrieren, das Kontextdiagramm Deshalb wollen
wir natürlich auch hier sicherstellen, dass wir uns in
einem Projekt befinden , das
den DB-Kontext hat. Wir klicken mit der rechten Maustaste,
gehen zu FC Power Tools und sagen dann
DB-Kontextdiagramm hinzufügen. Und dann wird es eine neue Datei mit dem
Erweiterungspunkt dgML
generieren und
wir bekommen unser Diagramm Also dachte ich, ich
könnte auswählen, aber eigentlich ist es nur das
Herumziehen Sie sehen also, es gibt uns diesen DB-Kontext in
Form eines Diagramms,
gibt uns das Team, die
verschiedenen Eigenschaften, und wir können auf die Eigenschaft klicken oder
den Mauszeiger darüber bewegen , um
mehr Informationen dazu zu erhalten Es ist der Primärschlüssel, und er ist nicht bemerkenswert Sie sehen all diese
Anmerkungen oder alle Metadaten sind
direkt hier verfügbar, wenn Sie mit der Maus darüber fahren Und wenn wir mit der Maus über die Tabelle fahren, ist
es so ziemlich dasselbe Von Visual Studio aus können
wir dieses
Tool verwenden, um
genau zu visualisieren , was zu einem bestimmten Zeitpunkt in
unserer Datenbank passiert bestimmten Zeitpunkt in
unserer Datenbank Nun, da wir nur zwei Tabellen richtig
haben. Nun, dieses Diagramm
mag nicht so
aufregend erscheinen , wie es
wahrscheinlich sein könnte. Aber Sie können sich einfach
etwas Zeit nehmen, um es sich anzusehen. Sie können die
Steuerung gedrückt halten und scrollen, um Ansicht ein wenig zu vergrößern, oder Sie können
einfach den
Zoom hier oben ändern,
und Sie können sich
die Legende ansehen, in einfach den
Zoom hier oben ändern, und Sie können sich
die Legende ansehen der darauf hingewiesen wird, was die verschiedenen Symbole oder
die verschiedenen Farben sind Sie sehen hier, Rot steht für
eine Navigationseigenschaft. Was ist das
lila oder bläulich, tut mir leid, ich bin
etwas farbenblind, aber diese violette Farbe
steht für die Fremdschlüssel und dann für die hervorgehobenen
Primärschlüssel und dann für die verschiedenen
Eigenschaften. Sie können sich also etwas Zeit
nehmen,
wissen Sie, nehmen Sie es auf, Sie können
die verschiedenen Arten von
Beziehungen sehen die verschiedenen Arten von
Beziehungen Aber wenn unsere Datenbank wächst, werden
wir uns das noch einmal ansehen und uns
ansehen, wie FCR daraus ableitet, welche Art von Beziehungen und unterschiedlichen Anmerkungen zu verschiedenen Eigenschaften wir
im Laufe der Zeit haben,
und dann können wir sehen,
wie sich dieses Diagramm weiterentwickelt.
10. Verbose: Hey, Leute, willkommen
zurück. In dieser Lektion werden
wir FCR mit
einigen zusätzlichen Optionen
einrichten, um mehr Details
darüber zu veröffentlichen, was es tut COR ist eigentlich standardmäßig
ganz normal, aber wir wollten etwas Lärm machen denn wenn wir unsere Befehle
ausführen, möchte
ich, dass wir eine
visuelle Darstellung
des Q haben , das
orchestriert wird , und der
verschiedenen Operationen, die im Hintergrund ausgeführt
werden während wir unser Ding machen Was wir hier also tun werden, ist den Options
Builder so zu erweitern, dass er weiß, dass er sich anmelden
muss Und ich lasse ihn in der richtigen Zeile
auf der Konsole protokollieren Da wir also eine
Konsole verwenden, befindet sie sich auf der rechten Seite. Also melden wir uns an, um
die rechte Zeile zu konsolen. Und ich werde der
Konfiguration, sagen wir,
der Pipeline hinzufügen, was protokolliert werden
soll. Ich möchte, dass der
Befehlsname
der DB-Logger-Kategorie protokolliert wird, sodass wir eine
Darstellung
dessen sehen können , was genau getan wird. Und ich werde das
erweitern, um es
wissen zu lassen , dass wir eine Protokollebene wollen. Ich wollte ein Log-Level sagen. Punktinformationen. Und ich denke, ich muss sie mit
einbeziehen. Sie werden auch eine Bibliothek für
Punkterweiterungen von Microsoft enthalten. Ich glaube, ich habe
mich gerade selbst überholt. Es ist also eine neue DB-Logger-Kategorie, und dann schließen wir hier eine
lockige Klammer Und dann haben wir die Informationen auf der
Protokollebene und dann schließen wir dort die
Klammer Schauen Sie sich also diese Zeile an
. Entschuldige dich dafür Wir protokollieren also in der
rechten Zeile der Konsole, im neuen Array, und dann geben wir einfach die
Befehlszeile genau dort ein, den Befehlsnamen DV-Logger-Kategorie
, und wir teilen dem System mit, dass wir Informationen auf Protokollebene haben wollen Das bedeutet also, dass wir bei allem, was
es tut, Spucke
auf die Konsole
sehen wollen Spucke
auf die Konsole
sehen Eine weitere Sache, die ich einbeziehen
werde, ist die Aktivierung der Protokollierung sensibler
Daten Dadurch können wir sehen oder es teilt FCR mit, dass
alles, was im Hintergrund
passiert, von dem Sie wahrscheinlich nicht
möchten,
dass Ihr Frontend-Benutzer
es sieht, wir es sehen wollen Es ist unsere App, die wir gerade lernen, also können wir
das zumindest ohne Risiko tun, aber Sie würden das nicht unbedingt auf einem
Produktionsserver tun
wollen, aber es hilft
in bestimmten Situationen beim Debuggen Jetzt, wo wir das
alles verkabelt haben, werde
ich einfach zur Konsole
springen Sie
müssen diesen Schritt nicht unbedingt ausführen. Ich habe einfach etwas Code
geschrieben
, damit wir anfangen können, mit F zu
interagieren, sodass Sie genau sehen können, worauf das
alles hinauslaufen würde. Aber in den nächsten Videos werden
wir den
ganzen Code gemeinsam durchgehen. Aber vorerst
möchte ich Ihnen nur
ein Beispiel für die
zusätzliche Protokollierung zeigen. Auf dem Bildschirm sehen Sie also
die Konsolenanwendung. Und wenn Sie genau hinschauen, werden
Sie feststellen, dass die Protokolle ausgespuckt
werden Wir haben also Informationen zu
diesem Zeitstempel. Wir haben diesen Befehl und dann
zeigt er Ihnen, dass wir einen DB-Befehl
ausführen,
der Parameter war. Was also
natürlich passieren würde, wenn wir die
sensible Protokollierung
nicht aktivieren ist, dass
Sie diese Parameter nicht sehen würden. also die sensible
Protokollierung aktivieren,
werden, wie gesagt, einige Details angezeigt, die aus,
Sie wissen schon, Sicherheitsgründen weggelassen worden
wären , daher die titelsensitive
Protokollierung, oder? So können wir genau sehen, welche
Werte übergeben werden, und die Größe des Werts, den Typ, das Befehls-Timeout, und dann sehen wir, wie das
tatsächlich
generierte SQL
in diese Tabelle eingefügt wird , die Werte, und dann nimmt es
einfach diesen Parameter. Es wird
dieser Wert also nicht direkt eingegeben. zeigt also nur,
dass FCR aktiv die
Parametrisierung durchführt, was eine Schlüsselkomponente im Kampf gegen
SQL-Injection als
Sicherheitslücke ist ,
die viele Leute auszunutzen versuchen, viele Leute auszunutzen versuchen Es parametrisiert also
die einfache Abfrage,
und dann wählt es einfach die ID von dort aus und
aktualisiert
die Bereichsidentität und dann wählt es einfach die ID von dort aus und
aktualisiert
die Bereichsidentität ID von dort aus und
aktualisiert
die Aber im Moment werde ich
nicht zu
sehr ins Detail gehen ,
was das Skript macht Ich möchte nur hervorheben
, dass wir jetzt in
der Lage sind , dass
wir beim Schreiben unserer FC-Befehle aktiv
das SQL sehen können , das im Hintergrund
generiert wird. Wir sehen auch, dass die Laufzeit
bis zu 61 Millisekunden beträgt. Es kann jedoch vorkommen eine Abfrage zu
lange läuft und Sie sich fragen warum Sie sie wahrscheinlich optimieren
müssen All diese Dinge können Sie
tun, wenn Ihnen diese Art der Protokollierung
zur Verfügung steht. Okay.
11. Einfache Insert: Okay. Hey, Leute, willkommen zurück. In dieser Lektion werden
wir uns also ansehen, wie wir mit EF COR ein einfaches Einfügen und
Auswählen von Res
durchführen können . Nun kommen wir zu unserer vorherigen
Lektion, in der wir uns mit
der ausführlichen Protokollierung und dem
Hinzufügen zusätzlicher
Informationen zur Konsole befasst haben der ausführlichen Protokollierung und dem
Hinzufügen zusätzlicher
Informationen zur Konsole Sie hätten gesehen, dass ich
diesen Code hatte, den wir untersuchen und zu verstehen
versuchen
werden Also die erste Zeile, auf die ich Sie hinweisen
möchte, und das ist wieder
die Programmpunkt-CS-Datei in unserer Konsolen-App. In Ordnung. In der ersten Zeile, auf die ich Sie hinweisen
möchte, instanziiere
ich
unseren DB-Kontext Ich habe also einen privaten statischen
Football League-DB-Kontext. Und nur für den Fall , dass
Sie sich fragen, woher dieser Name kommt, das ist der Name
unseres DB-Kontextes hier. Denken Sie daran, dass ich
gesagt habe, dass diese Datei die Verbindung
zur Datenbank
darstellt. Sie hat die
Verbindungszeichenfolge, und nun ja, sie kennt die Elemente oder die Entitäten
in der Datenbank. Diese gesamte Klasse, wenn unsere
Datenbank unsere Verträge erweitert, gibt uns
diese Klasse den Gateway-Zugriff auf
die Datenbank und ermöglicht es uns, mit den
verschiedenen Entitäten zu interagieren. Wir müssen also ein
Objekt davon instanziieren lassen. Nun, in einem normalen Dot-Nic-Kern, nun, lassen Sie mich nicht sagen,
normaler Dot-Nic-Kern. In einer größeren
Dot-Nic-Core-Anwendung wie einer Webanwendung oder sogar
einer Blazer-Anwendung würden
Sie nicht sehen, dass dies auf diese Weise gemacht
wird Sie würden sehen, wie es injiziert
wird. Aber noch einmal, wir sind hier, um
etwas über die
Syntax von F Core zu lernen. Deshalb versuche ich, mich in diesem
speziellen Kurs nicht auf
diese anderen Aspekte der
Entwicklung zu konzentrieren diese anderen Aspekte der . In Ordnung. Also instanziieren wir unseren
Football League DB-Kontext. Ich rufe den Objektkontext auf. Ihnen wären verschiedene
Vorschläge unterbreitet worden,
sodass Sie den auswählen können, der Ihrer Meinung nach aussagekräftiger
dafür ist was dieses
Objekt darstellen muss Aber Kontext ist fast wie
das Universalwort, das die
Datei bezeichnet, die
mich mit der Datenbank verbindet, oder Daher wird es im Namen
der Klasse und sogar
im Objektnamen verwendet . Auch hier
ist die Benennung subjektiver. Das ist also in Ordnung, wenn Sie andere Ideen
haben. Also instanziieren wir es einfach hier. Und dann gehen wir zum Hauptteil über. Also wie wir
es in der Klasse gemacht haben, ist
das global für jede
andere Funktion, die wir
in dieser Klassendatei verwenden werden. nun etwas
zu einer Tabelle hinzuzufügen, wäre
die Syntax Kontext. Noch einmal das Objekt, das eine Verbindung
zur Datenbank
darstellt. Also sagen wir Kontext, Punkt. Die Tabelle, mit der wir
zu interagieren hoffen, und dieses Wort Ligen bezieht sich wirklich auf das, was
wir die Tabellen hier genannt haben Alles klar? Also das sind Ligen Also, wenn ich
das von Grund auf neu eintippe, sage
ich Kontext, Punkt, ich möchte
eine Reihe von Optionen sehen Ich kann hinzufügen, ich kann eine Synchronisation hinzufügen. Ich kann eine Reihe von Dingen tun, aber dann werden Sie die
verschiedenen Eigenschaften sehen, und einige der Eigenschaften
würden die Tabellennamen beinhalten. Es gibt Ligen, und wenn ich ein bisschen
weiter
nach unten scrolle, gibt es Teams So viele DB-Sets wir in der Kontextdatei
definiert haben , wir können hier
direkt darauf zugreifen , wann immer wir mit diesen Tabellen interagieren
müssen Also Kontext-Ligen, und was will ich
dann
mit der Ligatabelle machen In dieser Situation möchte
ich hinzufügen. Wenn wir uns nun die Anzeigenfunktion
ansehen, werden
Sie hier sehen, dass
die Überlastung den Brunnen
erwartet ,
nicht die Überlastung. Der Parameter,
der von
der Anzeigenfunktion erwartet wird,
ist eher vom Typ League, und er sagt nur,
dass er eine Liga-Entität erwartet. Mit anderen Worten, es wird
ein Objekt vom Typ Liga erwartet . Das ist also das Schöne an F
Court, weil es uns erlaubt, scharf C zu bleiben , weil
wir in der Q-Syntax so etwas wie Einfügen in Ligen
und dann Werte schreiben
und dann
die Werte auflisten müssen, und das ist, wenn
wir nicht
die Spalten und dann die Werte spezifizieren würden so etwas wie Einfügen in Ligen
und dann Werte schreiben
und dann
die Werte auflisten müssen, und dann Werte schreiben
und dann
die Werte auflisten und das ist, wenn wir nicht
die Spalten und dann die Werte spezifizieren die Spalten und dann die Werte Und ja, diese Syntax
wäre sinnvoll,
aber sie in C
Sharp setzen und dann konvertieren und dann all das tun zu müssen ,
FC sagt nur, bleib in C Sharp, ich habe den Objektkontext. Ich erhalte die Tabelle, die Sie hinzufügen möchten, und dann geben Sie mir die
Daten, die Sie hinzufügen möchten Also habe ich hier eine
Fußballliga aus Jamaika hinzugefügt, aber dann können wir das ändern und englischen
Premier League versuchen. Ordnung. Also, League
instanziiert ein Objekt und wir übergeben
die Eigenschaften, und League hatte wirklich
nur ID-Namen Da ID also bereits primär
inkrementiert wird, müssen
wir keinen Wert für die ID angeben Wir können sicher darauf zugreifen, müssen
aber beim
Hinzufügen
keinen Wert angeben . In Ordnung. Lassen Sie uns also
diesen Befehl ausführen und sehen, was passiert. Die Protokolle hier zeigen
uns, dass
dieser Befehl
erfolgreich ausgeführt wurde.
Es hat dieser Befehl
erfolgreich ausgeführt wurde 112 Millisekunden und die
Parameter und alles eingegeben Und dann ist hier die
CQL-Syntax, die generiert wurde. Fügen Sie also in Ligen die Spaltennamen,
dann die Werte und dann den Wert ein,
und dann
wurde das Objekt einfach entsprechend aktualisiert Nun, eine weitere Leitung, auf die ich hinweisen
möchte, ist die Linie 14, die ultimative Leitung
, die Sie anrufen müssen Egal, was Sie tun, wenn Sie
denken, dass Sie
mit der Datenbank interagieren. Sobald Sie Daten manipulieren, also Daten hinzufügen oder aktualisieren oder löschen, müssen
Sie Safe Changes aufrufen weil all diese Methoden funktionieren und ähnliche Methoden für
das Aktualisieren und Löschen Sie verfolgen eigentlich nur,
welche Änderungen vorgenommen werden müssen, aber sie verfolgen
sie im Speicher Stimmt das?
Solange die Anwendung diesen
speziellen Vorgang verarbeitet, verfolgt
sie ihn nur
im Speicher, also, okay,
ich weiß, dass ich das hinzufügen muss.
Ich muss das aktualisieren. Ich muss das löschen. Aber
bis Sie die Änderungen
speichern,
heißt das eigentlich, das SQL generieren, an die Datenbank
senden und das versuchen,
und dann machen wir einen
Rollback, falls etwas fehlschlägt, und teilen dem Benutzer mit,
was passiert ist. Alles klar? Also
genau dafür sind die Änderungen speichern da. Und dann haben wir
Save Changes A Sync genannt, aber dann gibt es auch das Speichern von Änderungen ohne
AC, das ist in Ordnung. Ich werde es ohne AC verwenden da es sich nicht um eine
asynchrone Funktion handelt Ich werde es einfach halten. Aber sobald Sie
asynchrone Programmierung verwenden, können
Sie immer die
A-Sync-Version dieser Methoden müssen natürlich in einer
asynchronen
Methode platziert werden in einer
asynchronen
Methode platziert Also habe ich einfach alle
meine Methoden in die
A-Sync-Versionen ausgetauscht meine Methoden in die
A-Sync-Versionen und die
Hauptfunktion in eine A-Sync-Aufgabe umgewandelt Und aus diesem Grund kann ich
jetzt sagen
, Gewicht hinzufügen, Synchronisieren,
Gewichtung, Änderung speichern ist ein Synchronisieren Nun noch etwas, ich
möchte das
nur ein bisschen genauer erläutern. Denn genau hier füge ich das Objekt direkt
zum Parameter hinzu. Das ist vielleicht nicht
immer der Fall, denn vor allem in
größeren Anwendungen, denn vor allem in
größeren Anwendungen,
wenn ein Benutzer das Formular
absendet dann in einer Webanwendung das Formular absendet, erhalten
Sie alle
Daten aus dem Formular in einem Objekt, das Sie an die Datenbank
übergeben müssen. Sie
möchten es nicht unbedingt
aus dem Formular abrufen und
dann eine
neue Liga schreiben und dann versuchen jede Eigenschaft
mit jedem Wert erneut einzugeben. Sie können also immer einfach Subq Sevar
League is equal to
initialisieren, und dann kann ich
eine neue Instanz von League initialisieren Lassen Sie mich das einfach tun, um langes Tippen zu
reduzieren. Da haben wir's. Und dann
kann ich dem eine Liga geben. Man merkt, dass ich ein
Fußballfan bin, oder? Also La Liga. Das
wäre also die spanische Liga. Jetzt, wo ich mein Objekt habe, das die Liga
repräsentiert, die ich der Datenbank hinzufügen
möchte, kann
ich sagen, AC hinzufügen und das Objekt
übergeben. Es ist also wirklich so einfach. Sie können Ihr Objekt
an anderer Stelle erstellen, es dann hinzufügen und dann, wenn Sie
die Änderungen speichern , wird es
in die Datenbank übernommen. Nun möchte ich Sie
auch darauf
hinweisen , dass
dieses Objekt nach dem Speichern der Änderungen automatisch
mit seinem neuen Wert aktualisiert wird . Lassen Sie mich also einen
Breakpoint hinzufügen und starten. Und was ich hier tun werde,
ist ein Überwachungsfenster zu starten
und das
Liga-Objekt dort zu platzieren, damit wir
seine Werte verfolgen können , während wir Zeile
für Zeile Schritt vorgehen Alles klar? Lass mich das einfach anheften, etwas größer
machen,
damit wir es sehen können. Also erster Satz, es
ist noch nichts passiert. League ist Null. Dann gehe ich zu Schritt
Und dann würdest du sehen g eine ID von Null
und den Wert Liga hat. Und dann werden die
Änderungen gespeichert,
und dann gehen wir noch einmal einen Schritt weiter. Und wenn Sie sich das Objekt ansehen, werden
Sie sehen, dass es jetzt den ID-Wert
hat. Das ist also
praktisch, wenn Sie
Operationen haben , die
verkettet sind, oder? Weil Sie vielleicht
eine Operation haben, bei Sie der Datenbank etwas
hinzufügen müssen, und dann benötigen Sie diesen Wert, diesen neuen ID-Wert
, um vielleicht die Details dieses
Datensatzes auf der nächsten Seite
anzuzeigen Ich sende also ein Formular ab, Sie bearbeiten es in der Datenbank und
dann bringen Sie mich auf die
Seite, auf der die Daten angezeigt werden. Ich habe gerade eingereicht, was es aus der Datenbank
liest. Nun, hier ist
das praktisch, denn dann kann ich die Datenbank
direkt nach Abschluss des
Vorgangs anhand dieser Datensatz-ID
abfragen direkt nach Abschluss des
Vorgangs anhand dieser Datensatz-ID . Ich drücke einfach F fünf
, um mit der Ausführung fortzufahren. Und wieder einmal sehen wir hier unsere
sehr freundliche
Nachricht , dass
diese Daten zur Datenbank hinzugefügt wurden. Nein, nur der
Veranschaulichung halber, wollen
wir, wie gesagt, einige der
Fehler sehen, die wir bekommen könnten Ich werde
versuchen,
diesem Objekt
einen ID-Wert hinzuzufügen , bevor es der Datenbank
hinzugefügt wird Ich weiß also, dass die ID
gerade sieben war. Also werde ich einen Ausweis eingeben. Es spielt wirklich keine Rolle welcher Wert, denn
wenn
etwas anderes als Null ist,
wird beim Hinzufügen ein Fehler ausgegeben. Ich
wollte also nur wissen, welche Art von Feedback wir von EFC erhalten
werden, oder? Also lass es einfach laufen
und lass es tun,
was es tun muss Und dann siehst du
hier, dass es fehlschlägt, und wir bekommen hier
diesen Fehler. Es heißt, dass ein Fehler aufgetreten ist. CQ-Ausnahme kann keinen expliziten Wert
für die Identitätsspalte
einfügen , wenn das Einfügen von
Identitäten deaktiviert ist Sie sehen also, wir
bekommen buchstäblich einen dieser Fehler, die wir gesehen hätten, wenn wir versucht hätten, dies direkt
in SQL zu tun Wenn es nicht derselbe Fehler ist, dann ist er sehr
ähnlich formuliert. In Ordnung. Also das ist die Art
von Feedback, die EF COR uns geben wird,
wann immer wir das versuchen. Und wir werden hier in
unserem Konsolenprotokoll sehen , dass
es einfach fehlgeschlagen ist. Es sagt dir nur, dass du gescheitert bist
und fügt in das ein, dass gerade fehlgeschlagen ist. Alles klar? Also wenn ich weitermache, wird die Hinrichtung
entsprechend enden. In Ordnung. Also machen wir Schluss
und ich möchte nur noch
ein Beispiel dafür geben, noch
ein Beispiel dafür wie die Arbeit mit Entity Frameworks das Leben einfacher machen
kann. In dieser Situation möchte
ich also eine neue Liga hinzufügen, und wir nennen
sie Syrien,
das ist italienische Liga, und
wir fügen die Liga hinzu, als ob wir wissen, dass wir das tun müssen, dann speichern wir die Änderungen. Aber dann benötige ich Informationen von dieser Liga, um eine weitere Operation
durchzuführen. In dieser Situation
möchte ich Teams hinzufügen. Also muss
ein Team natürlich in einer Liga existieren, oder? Ich benötige also die Informationen
aus der Liga, die
gerade gegründet wurde , um diese Teams zusammenzustellen. Also werde ich dieses Liga-Objekt
an diese Methode übergeben. Und dann beachten Sie, dass wir Änderungen speichern
müssen,
weil wir jedes Mal, wenn
wir eine
Operation für den Kontext ausführen , Änderungen speichern müssen ,
damit sie in der Datenbank
wirksam werden. Also, ich habe diese Methode bereits
erstellt, ich habe eine statische AC-Aufgabe erstellt, und ich nenne sie „
Teams mit Liga-ID hinzufügen“. Nun, ich nenne es mit Liga-ID. Lassen Sie mich einfach die Liga entfernen Lassen Sie mich die ID entfernen, weil ich in diesem Beispiel zwei verschiedene
Operationen zeige, und Sie werden sehen warum, und es wird ein Parameter
vom Typ Liga akzeptiert, nämlich die Liga. Ordnung. Also kannst du einfach
weitermachen und das replizieren Und dann versuche
ich mit dieser Methode etwas anderes Anstatt eines
Objekts, das dann hinzugefügt werden soll, mache
ich eine Liste von Objekten und füge dann einen Bereich hinzu. Das wird nun
die Fähigkeit
von FCR nutzen , Massenoperationen
durchzuführen Nun, ein
bisschen Massenoperationen,
es ist eine Funktion, die es FC ermöglicht
, mehrere Operationen, wie zum Beispiel
Addiervorgänge usw. in einer Q-Anweisung zusammenzufassen
und herauszuholen. Aber dann entschied das Team, dass
es
bei
einer kleineren Anzahl von
Datensätzen effizienter wäre , einfach
einzelne SQL-Anweisungen auszuführen. Ab einem bestimmten Schwellenwert wird
Ihnen jedoch eine
SQL-Anweisung mit allen
Informationen angezeigt. Das ist nur ein
bisschen darüber, wie diese Massenoperationen im Hintergrund
funktionieren. Aber bei dieser Methode definiere
ich eine Liste von Teams, und jedem einzelnen
gebe ich seinen Namen. Das sind also Lüftungsöffnungen, und diese Liga-ID ist die ID, die von
unserem Liga-Objekt kommt. Stimmt das? Und dann wäre das
nächste Team eine Sim, die dem gleichen Format folgt. Aber dann beim dritten
, Aroma, mache
ich etwas anderes. Anstatt
den Fremdschlüssel zu verwenden, verwende
ich jetzt das
eigentliche Navigationsobjekt und verwende das übergebene Objekt
erneut Also werden wir
genau sehen, wie das funktioniert. Also, das wäre
der traditionelle Weg. Sie haben den Fremdschlüssel, Sie geben den Fremdschlüsselwert und er ist zufrieden, oder? Aber dann verwende
ich in diesem Team nicht
den Fremdschlüssel,
sondern das eigentliche
Objekt zur Übergabe. Schauen wir uns also an, was das bewirken würde. Also werde ich beim
ersten Speichern der Änderungen
einen Haltepunkt setzen , und dann können wir uns den Vorgang Schritt für Schritt
ansehen. Also habe ich auch die Uhr
für die Teams hinzugefügt, oder? Lassen Sie mich einfach Schritt für Schritt durchgehen die Liga
wurde noch nicht gegründet. Verwenden Sie also Schritt für Schritt F zehn, damit ich nicht zum Kontext
übergehen muss. Ich weiß, dass wir unseren Ausweis von acht haben. Wenn wir in unser Liga-Objekt schauen, sehen
wir, dass es entsprechend aktualisiert wurde. Dann werde ich F 11
verwenden, um auf
diese Methode einzugehen , bei der
Teams jetzt definiert sind. Ich werde nur Schritt für Schritt ihre Entstehung
durchgehen. Und wenn ich mir dann
die Liste der Teams ansehe, sehe
ich, dass ich alle
mit ihren jeweiligen IDs habe, und dann ist Roma hier mit dem aktuellen Navigationsobjekt statt der Liga-ID. In Ordnung? Also die Liga-ID für Rom ist Null, aber die Liga-ID für alle anderen ist erwartungsgemäß acht. Die Navigationseigenschaft
für alle anderen ist jedoch Null, und für Soma hat sie ihre
Navigationseigenschaft Lassen Sie uns nun sehen, was passiert,
nachdem wir die Änderungen gespeichert haben. Ich
drücke einfach fünf, damit wir sehen
können
, welche Logs ausgegeben werden Und Sie sehen, dass die erste
Einfügeoperation genau hier
mit der Liga
stattfindet Oh nein, das. Dieser ist von
der Liga. Das tut mir leid, oder? Dann sehen wir, wie eine weitere für die erste Mannschaft
passiert, und wir sehen die ID, die Liga-ID von acht
und den Namen, der als
Liga-ID-Name übergeben wird, richtig? Und dann stellen
Sie fest, dass es sich bei der letzten Anweisung um
dieselbe SQL-Anweisung handelt. Es bekommt die Acht,
es weiß, dass es Aroma ist, und es macht dieselbe
Art von Einfügung. Das wird Ihnen nur zeigen, dass
Sie
den tatsächlichen Fremdschlüsselwert eingeben können und er wird natürlich das
tun, was
er mit der Einfügung
tun muss, oder Sie könnten
das ganze Objekt eingeben oder Sie könnten
das ganze Objekt eingeben
und es wird trotzdem folgern, dass das Objekt seinen Primärschlüssel hat Das
ist also offensichtlich ein verwandtes Objekt, also wäre der Fremdschlüssel das Primärschlüssel-Offset-Objekt
und alle anderen Daten FCR macht das also im Hintergrund für
Sie. Ich wollte nur
die verschiedenen Möglichkeiten hervorheben , wie Sie einen Datensatz
einfügen können , der von
einem Fremdschlüssel abhängig ist Nun, es gibt noch ein paar andere
Dinge, die Sie tun können, aber manchmal sind
sie nur mit Erfahrung
möglich, aber zumindest, wenn Sie die Grundlagen
verstehen,
wie
man der Datenbank etwas hinzufügt. Und beachten Sie, dass ich hier Änderungen hinzufügen, speichern und dann erneut
hinzufügen und
Änderungen speichern musste, weil ich das hinzufügen musste , damit der Schlüssel generiert
werden
konnte, damit ich diesen
Vorgang ausführen konnte. Alles klar? Auf der anderen Seite, wenn ich so
etwas gemacht hätte und mir die Zeit
genommen hätte, es mir anzusehen. Ich habe es einfach überarbeitet, damit ich nicht rumsitzen
und mir beim Tippen zuschauen Aber ich
initialisiere immer noch eine neue Liga und dann habe ich ein Team.
Dieses neue Team hat einen
Namen Bern München, und dann gebe ich dieses
Liga-Objekt weiter Beachten Sie, dass ich zwischen
diesen beiden Zeilen keine Änderungen
speichere, nicht wahr
? zwischen
diesen beiden Zeilen keine Änderungen
speichere, nicht wahr Also erste Liga, neues Team, und es bekommt dieses
neue Liga-Objekt. Und dann füge ich nur noch
das Team hinzu und speichere die Änderungen. Und beachten Sie den Unterschied
zwischen dieser Anzeige und den vorherigen Anzeigen-ACC-Zeilen Sie haben natürlich die Möglichkeit, die Tabelle
zu markieren, mit der
Sie interagieren möchten Wenn ich also sage, dass
Kontext-Punkt-Ligen eine Synchronisation hinzufügen und dann ein Teamobjekt übergeben
, wäre das ein
automatischer Fehler. Warum? Weil
der Werbebetrieb wieder einmal eine
Art Liga
erfordert, oder? Ich kann also kein Teamobjekt weitergeben
. Ich hätte natürlich sagen können, dass Teams und alles in Ordnung
wären. Aber wenn ich die Tabelle nicht
spezifizieren würde, würde
Entity Framework
automatisch wissen, dass, okay, das ist ein Teamobjekt oder es ist eine Liste von Teamobjekten,
wie wir es hier unten gemacht haben, wo ich nur gesagt habe, dass
Kontext Punkt hinzufügen Bereich in der Teamliste
übergeben wurde. Es weiß also, dass
es eindeutig nach
der entsprechenden Tabelle
für diesen Datentyp suchen wird . Sie müssen
das also nicht unbedingt tun, zumindest wenn es
um den Kontext geht, Sie müssen
die Tabelle nicht
ständig angeben . In Ordnung. Aber ich möchte
darauf hinweisen, dass, wenn ich das mache und dann
eine Änderung speichere, es tatsächlich
die abhängige Eigenschaft erstellt und dann automatisch
das Team mit diesem Fremdschlüssel erstellt . Schauen wir uns also diese Operation
an. Wenn Sie sich also ansehen,
was sie generiert hat, werden
Sie feststellen, dass sie zuerst
den Befehl zum Erstellen
der Liga ausgeführt hat. Dort erstellt es
die Bundesliga, und dann erhält es diese ID, und dann fährt es fort und
führt die aus, um das Team zu erstellen , indem es
den neuen Fremdschlüssel
an dieses neue Team weitergibt den neuen Fremdschlüssel
an dieses neue Team SCEF CR zieht nur all
diese Fäden für Sie. Alles nur, weil
ich es gesagt habe, ich will ein neues Team, und dieses Team ist Teil
einer Liga, deren ID ich nicht
kenne Also hieß es, kein
Problem. Ich habe das. Es macht weiter, erstellt
die Liga, erhält die ID, erstellt das Team und teilt dir dann einfach mit, dass
alles erledigt ist. Wenn Sie sich also das Teamobjekt
ansehen würden, würden
Sie alle Daten sehen, die sich
auf das Team und die Liga beziehen . Wenn wir also zurückkommen, werden
wir uns
mit einigen ausgewählten Abfragen befassen ,
denn bis jetzt haben
wir nur Daten eingegeben
, Daten eingegeben
, Daten eingegeben. Schauen wir uns nun an, wie wir die Daten aus
der Datenbank lesen und
in unserer Anwendung anzeigen
können . Okay.
12. Einfache Select: Leute, in dieser Lektion werden
wir
über einfache Auswahloperationen sprechen . Bevor ich weitermache, möchte
ich nur darauf
hinweisen, dass wir
einiges aus dem
einfachen Einfügen gemacht einiges aus dem
einfachen Einfügen haben
und ich sie
in einzelne Methoden extrahiert habe. Also habe ich den Code entfernt
und
sie irgendwie kommentiert, und
sie irgendwie kommentiert sodass Sie, wenn
Sie darauf zurückblicken, sehen können, was wo
passiert. Alles klar? Also habe ich sie einfach
kommentiert , weil wir nicht ständig
dieselben alten Daten
hinzufügen und hinzufügen wollen . Jetzt ist es an der Zeit, dass wir uns
mit der Auswahl befassen, also werde ich
sie einfach trennen, zur Seite legen, und dann können wir weiter
daran arbeiten, sie zu umgehen. In Ordnung. Also, wenn wir über Auswahl sprechen, wäre
das das R in CRD Ich weiß also nicht, ob ich dieses Akronym verwende , bevor ich zu diesem Thema
spreche, aber CRD Create Read
Update Delete, Das ist ein Akronym, das in der
Datenbankentwicklung
weit verbreitet ist in der
Datenbankentwicklung
weit verbreitet Es steht im Grunde für
die vier Operationen, die Sie in jeder Anwendung immer an einer
Datenbank ausführen Sie erstellen Daten, und
das haben wir uns gerade angesehen, als wir
uns das Einfügen angesehen haben,
das heißt, Sie werden
Daten lesen,
was bedeutet, dass Sie die Daten abrufen möchten , die
sich in der Datenbank Das werden wir jetzt tun, und später werden wir uns das U und das D
ansehen,
die für
Update und Delete stehen Wenn wir nun
Daten aus unserer Datenbank abrufen wollen, denken
wir darüber nach, so
genannte Linkabfragen
oder Linkanweisungen zu
formulieren genannte Linkabfragen
oder Linkanweisungen Link ist die Abkürzung für
Language Integrated Query. Es ist im Grunde ein Dialekt. Ich nenne es einen Dialekt von Sharp C. Auf diese Weise können Sie eine Abfrage mit C Sharp schreiben, und dann
wird FC das natürlich in QL übersetzen Lass uns anfangen. Die erste und einfachste
Sache, die Sie tun können. Die einfachste Linkabfrage
zum Abrufen von Daten aus der Datenbank wäre und ich werde einfach eine Variable
definieren. Ich möchte also, dass alle
Ligen zurückkommen, und ich sage, Regus
entspricht
dem Kontext, also der Verbindung zu dem Kontext, also der Verbindung zu der Datenbanktabelle, an der ich
interessiert bin, nämlich Und das sagt ihm
, wie es in der
DB-Liste der Ligen aussieht. Aber dann will ich es in einer Liste haben. Also werde ich Punkt zu Liste sagen. Dann wird es mich bitten, eine bestimmte Bibliothek
einzubeziehen. Ich werde nur kontrollieren, ob
Sie sehen, es
sagt mir, dass ich dafür den
Punktlink des Bibliothekssystems benötige. Ich mache einfach
weiter und füge das hinzu
, der Fehler verschwindet. Und einfach so, wie
ich es gesagt habe, wähle einen Stern aus der
Tabelle namens Ligen Das ist so ziemlich alles. Stimmt? Was dann passieren wird
, ist, dass Kontext eine Verbindung
zur Datenbank herstellt. Es geht in die
Ligatabelle und dann heißt es in
dieser Liste:
Extrahieren Sie die Daten, bringen Sie sie in einer Tula-Form zurück, aber materialisieren Sie sie dann in
einer Liste von Liga-Objekten Genau so, wie wir die Liste der Teams
erstellt hatten, wo ist sie, hier ist
meine Liste der So wie wir
die Liste der Teams erstellt haben, ist
es genauso, wie sie für uns in die
Liste der Ligen einfließen wird für uns in die
Liste der Ligen Ich werde also für jede Liga eine
machen,
und ich werde sagen, für
jede Liga in Ich möchte die rechte Linie
trösten. Ich verwende also nur Bindestrich und
verwende einen Bindestrich, um die ID vom Namen zu trennen Ordnung. Also lassen Sie uns
einen Blick darauf werfen. In Ordnung. Und wenn wir uns die Ausgabe ansehen, sehen
wir hier die Anweisung
, die ausgeführt wurde Wählen Sie ID und Namen aus den
Ligen als L aus, richtig? Das ist also im Grunde
die SQL-Anweisung, die Sie einfach von der Konsole
kopieren, in Ihr Management
Studio
wechseln und ausführen könnten Ihr Management
Studio
wechseln und ausführen Das ist also sehr praktisch, wenn Sie Probleme
beheben, vielleicht haben Sie eine
Abfrage geschrieben und Sie erhalten
nicht die gewünschten
Ergebnisse zurück. Sie können jederzeit
diese SQL-Anweisung abrufen und versuchen zu entschlüsseln, warum dieser
Cle falsch formatiert ist. Noch einmal, das ist ein
sehr mächtiges Tool. Wenn wir uns jedoch die
ausgedruckten Objekte
ansehen , sehen
wir alles, was sich in der Datenbank
befindet. Beim Testen sind wir wahrscheinlich ein paar, zu oft
in die Earth Strap
Premier League eingestiegen , auch in
die Premier League, aber dann sehen wir auch alle
anderen Ligen Das ist es, was wir bekommen, wenn
wir einfach Kontext und
Tabellenname sagen und sie
mir als Liste geben Nun, einige wichtige Dinge, die es zu beachten gilt, wenn es
um die Syntax geht .
Das nennen wir die
ausführende Anweisung. Ohne das würde diese
Abfrage also nicht ausgeführt werden. Das würde einfach sagen: Nun, legs ist jetzt nur das Hash-Set oder das DB-Set aus der Tabelle
namens legs, richtig? Wenn wir sie also auf die To-Liste setzen, heißt es dort tatsächlich, ich führe
die Abfrage aus,
zähle sie auf und schicke
sie als Objekte zurück Also wenn wir so etwas
wie
die To-Liste weglassen
und das dann trotzdem ausführen sollten wie
die To-Liste weglassen
und das dann trotzdem ausführen Diese Abfrage würde
erst ausgeführt werden , wenn sie tatsächlich
die Vierer-Each-Schleife startet. Es wäre hier also einfach wie
in einem Zustand der Stase. Und wenn wir dann
anfangen , jeweils vier durchzugehen,
dann würde es sagen:
Okay, okay, lass mich gehen und sie
holen, damit ich sie
aufzählen kann Die Gefahr,
es auf diese Weise zu tun, besteht darin, dass die Verbindung für die Dauer
dieser jeweils vier Schleifen
geöffnet bleibt für die Dauer
dieser jeweils vier Schleifen
geöffnet Nun, mit nur vielleicht 15 Datensätzen
, scheint
das keine große Sache zu sein. Ich meine, okay, gut.
Aber wenn Sie dann
eine größere Datenbank durchsuchen, haben
Sie diese Verbindung geöffnet. Und stellen wir uns einfach
jede Verbindung
zur Datenbank als eine teure Operation in jedem System vor, oder? Sie möchten
das also so weit wie möglich reduzieren. Und Sie
möchten auch nicht, dass eine Verbindung zu lange oder
länger als nötig geöffnet ist. Also wenn wir die
Aussage so machen und wir könnten sogar einen
Teil der Ligen
loswerden und einfach sagen, für jede VR-Liga im
Kontext Ligen Der Punkt ist, dass dies
tatsächlich zu
einer Art Sperre führen würde , und zwar zu einer sehr
ineffizienten Tatsächlich nimmt die Zeit zwischen
dem
Durchgehen der einzelnen Elemente zu,
je mehr Operationen Sie für Reach ausführen müssen Zeit zwischen
dem
Durchgehen ,
und dann bleibt
die Verbindung natürlich bestehen und es wird noch
teurer Ich weise nur darauf hin,
dass Sie es vielleicht versuchen und es funktioniert, aber es ist nicht der
effizienteste Weg, dies zu tun. Der effizienteste und intelligenteste Weg, dies noch einmal zu
tun,
wäre, diese Ausführungsoperation zu starten, sie iterieren zu
lassen
und die Liste abzurufen, und dann wird diese Liste
nicht im Speicher gespeichert Diese Verbindung ist nicht
in der Nähe der Datenbank, und danach können Sie all
Ihre Operationen und Manipulationen an den
Daten durchführen. In Ordnung Also das war's wirklich für
die einfachen Auswahlabfragen. Ich habe den ganzen Code irgendwie extrahiert und in diese Methode eingefügt, bei der
es sich um eine statische Void-Methode handelt. Dieser verwendet also keine
asynchronen Operationen. Wir müssen
es also nicht zu einer asynchronen Aufgabe machen, oder? Es ist also eine einfache Leere. Und was ich getan habe,
ist hervorzuheben , welches gut und
welches ziemlich schlecht ist. Also nicht alles, was
funktioniert, obwohl es funktioniert, hat
es einige grundlegende
Auswirkungen von
denen Sie sich vielleicht nicht bewusst sind, aber deshalb bin ich hier, um
Ihnen aufzuzeigen, wie am besten
verschlingen können.
13. Filtern von Datensätzen: Hallo Leute, willkommen
zurück in dieser Lektion.
Wir werden uns ansehen, wie
wir unsere Abfragen filtern können. Nun, die Fallstudie zum
Filtern liegt auf der Hand, oder? Was wir uns bei
der einfachen Auswahl angesehen haben, ist, dass wir alle auswählen und dann durch alle
iterieren Es gibt Situationen,
in denen Sie nicht alle, sondern nur bestimmte Datensätze haben möchten, und genau das
werden wir uns zuerst ansehen Also habe ich eine
Methode mit Abfragefiltern erstellt. Und bevor ich weitermache, möchte
ich hervorheben, dass ich gesagt
habe, dass wir diesen ungültig erklärt haben, weil
bei dieser Methode nichts Synchrones passiert Nun, dank Entity
Framework Core müssen
wir A-Sync auflisten Und wenn ich das kontrolliere, muss
ich das nur mit der
Anweisung für Entity
Framework Core hinzufügen . Und dank dessen kann
ich das jetzt synchron machen Und addieren Sie das Gewicht
vor dem AC-Anruf. Lassen Sie uns also zu
unseren Abfragefiltern übergehen. Wenn wir also einen Abfragefilter
hinzufügen wollen
und ich sage, Ligen
ist gleich oder Kontext,
Punkt, die Tabelle, an der wir
interessiert sind, also Ligen,
dann Punkt, und ich habe Zugriff eine Reihe von Methoden
auf dieser Seite Wenn ich also sagen wollte, gib mir alle Ligen, in denen der Name einem Wert entspricht, dann kann ich Punkt, wo und dann diese
Funktion einen Parameter annehmen, der wie ein Prädikat
aussieht oder es ein Prädikat oder
ein Lambda-Ausdruck ist. Das Format für
einen Lambda-Ausdruck ist
also , dass Sie ein Ich werde
es Q nennen. In den meisten Beispielen im Internet werden
Sie sehen, dass sie Q verwenden. Es gibt
jedoch keine Vorgabe, was dieses Token sein muss Natürlich behandeln Sie es
wie einen Variablennamen. Also, wenn du Q benutzen willst, wenn du League benutzen willst, weißt
du, was auch immer es ist. Wenn ich also Q sage und dann
dieser Lambda-Pfeil folgt, dann kann ich Q jetzt verwenden, um einen beliebigen
Datensatz in der Tabelle
darzustellen Das ist also das Format
des Lambda-Ausdrucks. Wenn ich x benutzen würde, ist das Gleiche. Wenn ich das
Wort Liga herausschreiben würde, würde ich nur betonen, dass
es eigentlich
egal ist, wie man es nennt, sie werden alle auf die gleiche Weise funktionieren
. Vielleicht würde sich das
besser lesen lassen, denn
es heißt wieder Datenbank, gib mir die Tabelle, nenne Ligen und gib mir die Aufzeichnungen, in denen jede Liga
einen Namen hat , der einem bestimmten Wert
entspricht Wenn wir sagen wir Siri finden wollten, dann
würde das so aussehen Noch einmal, dieses Token
hätte Q sein können, es hätte x sein können, es
hätte Y sein können, es
hätte Z Es ist
also nicht wirklich wichtig,
was Sie als dieses Token verwenden Wenn ich das mache, wird
es erst ausgeführt, wir wieder
einmal
mit unserer To-Liste enden. Da wir die
A-Sync-Version der To-Liste haben, können
wir sagen, dass man mit List A synchronisiert werden soll, und dann
warte ich das ab und
mache die Methode natürlich zu einer A-Sync-Aufgabe. Nachdem ich all das getan
habe, werde ich
diesen Vorgang wiederholen , wobei
ich sie einfach alle auf der Konsole
ausdrucken werde . Ich warte auf diesen
Funktionsaufruf und natürlich, und ich warte, bevor
alles andere passiert. Ich werde diese
Dinge nur reparieren, bevor ich weitermache. Also wenn wir das nennen, wird
es weitergehen und in
der Tabelle nachschauen , wo diese
Bedingung erfüllt ist. Das wird also wahr oder falsch
sein, also entweder erfüllt es
die Bedingung oder nicht. Wenn es die Bedingung erfüllt hat, wird
es der Liste hinzugefügt und schließlich hierher zurückgebracht. Lassen Sie uns also diese Abfrage ausführen
und sehen, was wir bekommen, richtig? Und dann sehen wir, dass
es zurückkommt. Unser einziger
Rekord kommt zurück. Wenn wir uns die SQ genau
ansehen,
stellen wir fest, dass es sich nur um eine
einfache Auswahlabfrage handelt, aber sie fügt diese WERE-Klausel mit dieser Bedingung hinzu. In Ordnung. Jetzt habe ich fest codiert. Beachten Sie, dass im Gegensatz zu
den anderen
Zeiten ,
als Sie die Parameter gesehen haben nur der tatsächliche Wert
in die Abfrage eingefügt wurde, und das liegt daran, dass er fest codiert
war. Ich habe also erwähnt, dass
Parametrisierung ein
guter
Schutz vor CQL-Injection ist guter
Schutz vor CQL-Injection Der Grund, warum FCR in
dieser Situation keine
Parametrisierung verwendet hat , ist , dass es sieht, dass ich
derjenige bin, der den Wert aus dem Code fest codiert Ich würde also keine SQL-Injektion direkt
in
meinen eigenen Code einfügen SQL-Injektion direkt
in
meinen Also natürlich, okay,
es ist sicher, weil mein Meister derjenige
ist, der das getan hat, also muss es in Ordnung sein, oder? Aber die Realität ist
, dass
Sie in normalen Situationen wahrscheinlich das bekommen
, wonach Sie suchen, von
woanders, oder? Lassen Sie uns hier also ein
bisschen kreativ werden. Also werde ich
diese Funktion ein wenig anpassen, und ich werde Console richtigen Zeile als
Interleague bezeichnen Also fordere ich diesmal
den Benutzer dazu auf. Also noch einmal, das
ist eine Konsolen-App aber in einer
Webanwendung oder so weiter Normalerweise gestatten Sie dem Benutzer,
darzustellen oder zu bestimmen,
was er benötigt, oder? Und Sie führen die
Filterung entsprechend durch. Also fordere ich den Benutzer auf, und dann werden wir
die Antwort in dieser Variablen speichern die Antwort in dieser Variablen Und dann ist das die
Variable, die ich verwenden werde , um die Abfrage auszuführen Also werde ich sagen, dass
der Lambda-Ausdruck,
ein Punktname, dem Liganamen
entspricht. In Ordnung? Wir könnten auch
sagen, Punkt ist gleich, weil wir uns einfach auf
die C-Sharp-Funktionen verlassen könnten , die wir wahrscheinlich
in einer regulären Anweisung verwenden würden, aber Sie stellen fest, dass das
wie eine Anweisung aussieht , oder? Es ist dieselbe Art
von logischem Operator , den Sie
in einer Bedingung verwenden würden Denn auch hier handelt es sich nur um eine Bedingung, die wahr oder gut sein
muss, sie muss wahr sein,
um in die Liste aufgenommen zu werden. Stimmt das? Also haben wir uns jetzt
irgendwie damit gebrüstet Jetzt können wir ein bisschen mehr
damit interagieren. Also werde ich das ausführen und wir werden die Eingabeaufforderungen
sehen Ich habe
Syrien bereits betreten. Ich drücke die Eingabetaste. Und dann hat es 83 Millisekunden gedauert rauszugehen und es anzusehen,
jetzt hat es den Liganamen
parametrisiert Und dann wird es mit dem Parameter ausgeführt. Sie sehen also,
das ist wieder einmal eine
Art Schutz vor CQL-Injection durch
die Parametrisierung, wir bekommen Jetzt haben wir nur eine
Liga mit diesem Namen, aber wir hatten mehrere Also werde ich es
noch einmal mit etwas versuchen ich weiß
, dass es mehrere Datensätze
zurückgeben wird Wir versuchen es erneut mit der Premier League mit den
roten Streifen, und die Filterung
bringt jetzt alle Datensätze zurück. Sie sehen, dass es funktioniert. Es bringt
jeden einzelnen zurück
, der genau diesen Namen hat. Und denken Sie daran, dass wir dieses Mal nicht das
doppelte Gleichheitszeichen verwendet haben. Wir haben das Sharp C verwendet,
weil das eine Zeichenfolge ist, also sagten wir, Punkt
entspricht dem Namen der Liga Es ermöglicht uns also
, die C-Sharp-Syntax, mit der wir
in anderen Teilen
unseres Codes vertraut
sind, direkt in die Abfrage zu schreiben mit der wir
in anderen Teilen
unseres Codes vertraut
sind , und den
Rest erledigt sie einfach für uns Lassen Sie uns nun hier
noch ein Experiment durchführen. Es gibt Situationen
, in denen Ihr Filter möglicherweise nicht so exakt wie
wahr oder falsch ist. Es könnte sich um eine Art Fuzzy-Logik handeln, bei der Sie wissen
möchten, ob sie etwas enthält,
besonders wenn wir es mit Wörtern zu
tun haben, oder Bei einer typischen Suche könnten
Sie also einen Teil des Wortes oder einen Teil
des
Ausdrucks
eingeben , nach dem Sie suchen, und dann würden Sie passende Ergebnisse
sehen Also habe ich die Eingabeaufforderung erweitert um einen
Interliga-Namen oder einen Teil davon
zu sagen, und dann werden wir zwei Abfragen machen Also nehme ich das alles
und dupliziere
es und was ich machen werde, ist ein exaktes Spiel und das andere ein
Teilspiel. Bei den partiellen Übereinstimmungen werde
ich also nicht sagen, dass Punkt gleich ist, sondern
dass Punkt enthält Denn
wenn wir in Sharp C versuchen würden
herauszufinden, ob eine Zeichenfolge eine andere Zeichenfolge enthält, würde das bedeuten,
dass Punkt enthält Das ist es also, was ich in diesem
Werteausdruck
übergehen werde . Also lassen Sie uns einen Blick darauf werfen. Also verwende ich einfach Ich
gebe
eine Zeichenfolge ein, nach der gesucht werden soll. Ich werde
Premier eingeben, oder? Ich weiß,
dass ich keine Liga habe , die exakt
mit Premier übereinstimmt. Wir haben also bereits gesehen, dass die
genauen Spiele funktionieren. Aber ich tippe
einfach Premiere ein. Und dann werden Sie feststellen, dass beide Abfragen ausgeführt werden
. Es wird also
sagen, es hat das ausgeführt, es sucht nach Premier. Also dieser hat die Verschleißklausel für den Liganamen Premier.
Natürlich gibt es keine. Aber dann
hat dieser den Liganamen wie oder den Chartindex. Der
L-Punktname ist größer als Null. Es wird also einfach eine nette Abfrage
erstellt, um zu sagen, ich suche nach etwas wie was in dem
Parameter steht. Alles klar? Und dann sehen wir
all unsere Ligen, in denen
das Wort Premier
wieder auftaucht. In Ordnung. Das ist also eine weitere Möglichkeit, wie Sie Ihre Abfragen filtern
können. Wenn es jetzt darum geht, können
Sie den Inhalt verwenden,
tut mir leid, oder Sie können EF-Funktionen
verwenden. Also werde ich das
einfach duplizieren
und diesen Teil empfehlen, also das ist Option eins Eine andere Option wäre
, die Funktion zu verwenden. Also ich brauche immer noch das Token, muss es
immer noch initialisieren, aber ich werde EF-Funktionen
sagen Punkt. Und dann siehst du hier, ich kann Contains, ich kann tun und eine Menge
anderer Funktionen, die mir zur Verfügung stehen
würden , wenn ich direkt SQL machen
würde. Einige von ihnen sind genau
hier, um sie für uns zugänglich zu machen. Also werde ich das
Gleiche tun , weil das
eher dem entspricht, wonach wir suchen. Ich werde so sagen und dann werde ich einen
Hundenamen sagen. Die Methode benötigt also, was ist der Ausdruck
oder was ist die Zeichenfolge? Was ist die Datenbankspalte
, mit der ich vergleiche. Und dann
wäre der zweite Parameter das Zeichenkettenmuster. Wenn ich
ein bestimmtes Muster eingeben wollte, wenn Sie sich
mit Farben auskennen, dann
wissen Sie, dass Sie , wenn
Sie es mit
so etwas zu tun haben, diesen Platzhalter haben Ich könnte also Premier Modulus sagen,
was bedeutet, dass es
mit dem Wort Premiere beginnt Wenn wir den Modulus voranstellen, endet
er mit dem Wort Premier Was auch immer Sie in SQL
für diesen Modulus für
dieses Wildcard-Bit getan
hätten , Sie können es innerhalb
der Zeichenfolge tun und es wird es einfach
aggregieren und den Ausdruck genau so
erzeugen,
wie wir es erwarten würden In unserer Situation, weil wir es
mit dieser Variablen zu tun haben, muss
ich etwas ausgefallener Ich möchte nicht fest programmieren
, wonach wir suchen. Ich werde hier nur
eine Interpolation verwenden und einfach
den Wert eingeben, der aus
der Eingabe kommt Also sagen wir, gib mir
alle Ligen, bei denen der Name diesem
Suchmuster entspricht. In Ordnung. Also lass mich das noch
einmal machen, damit wir sehen
, was das ergibt Dieses Mal tippe ich
La ein. Ich weiß es nicht.
Ich habe keine Liga. Ich weiß nicht, in welcher
anderen Liga in der Datenbank
die Buchstaben LA stehen könnten,
aber wir sehen, dass La Liga zurückgegeben
wird. Und wenn wir uns diese
Abfrage noch einmal ansehen, stellen wir fest, dass sie uns das Format vorgibt und dann
sagt, wie der Name lautet. Dieser Parameter. Sie sehen also
, das sieht ein bisschen sauberer aus als das
, was die Contains-Abfrage generiert ,
aber am Ende des Tages werden uns
beide sehr ähnliche, wenn nicht sogar dieselben Ergebnisse liefern. Das war's also für ein
kleines Experiment mit dem Filtern unserer Abfragen. Wenn wir zurückkommen, werden
wir uns ansehen, wie wir Daten aggregieren
können, vielleicht eine, die erste und die Liste,
die letzte und die Liste, wir bilden die Summe von allem in der Liste, solche Dinge Wenn wir also zurückkommen, werden
wir uns das ansehen.
14. Zusätzliche Ausführungsmethode: Hey, Leute, willkommen zurück.
Das Ziel dieser Lektion ist es also, einige der anderen Methoden,
die
uns über Lincoln FCR zur Verfügung stehen,
zu
verstehen oder zu schätzen zu und zu verstehen,
wie sie genau funktionieren Ich habe also bereits eine
neue Methode entwickelt, und zwar für zusätzliche
Ausführungsmethoden Ich habe hier also eine Aussage , die genau wie
eine Select-Anweisung aussieht aus unseren
früheren Aktivitäten
stammt wo wir einen Kontext haben, der wohin führt,
und ich sage nur,
dass sie A enthält. Nun, die Fallstudie für eine
Aggregatfunktion oder dieser zusätzlichen
Ausführungsmethoden
wäre , dass Sie wahrscheinlich nicht die ganze Liste
wollen. Wahrscheinlich möchten Sie, dass etwas gegen die Liste
unternommen wird, oder Sie möchten die Liste auswählen? Wenn wir also über
Aggregatfunktionen in C sprechen, sprechen
wir über Dinge
wie Min, Max ,
Anzahl, einige, diese
Arten von Operationen, die uns
alle
durch diese zusätzlichen
Aggregatfunktionen zur Verfügung stehen . Nun, eine andere Sache, die
Sie wahrscheinlich
tun möchten, ist, den ersten oder
den letzten in einer Liste zu bekommen, solche Dinge, richtig? Also werde ich das nur als kurzes Beispiel verwenden
. Und was wäre, wenn ich
die allererste Liga
haben wollte , deren Name den Buchstaben A enthält? Nachdem ich all
diese Aussage gesehen und den Filter
hinzugefügt
habe, würde ich sie mit
einem ersten oder einem Standard beenden. Sie werden hier sehen, dass
wir natürlich
die Async-Methoden haben und für jeden AC gibt es
eine Nicht-AC-Version Aber es ist nicht unbedingt
andersherum. Also hat nicht jede Methode
ein Async-Gegenstück, aber das werden Sie später sehen Okay. Also hier kann ich sagen, ich will einen ersten oder einen Standard oder
ich kann den ersten sagen. Der Unterschied zwischen „
First“ und „First “
oder „Standard“ besteht darin, dass
wir immer zuerst erwarten, eine Liste zu sehen, und es
wird die erste sein. Wenn also nichts zurückgegeben
wird, wird eine Ausnahme ausgelöst. Es wird die Ausführung
mit einem Fehler beenden. Alles klar? First oder default over wird sagen, ich werde versuchen, den ersten zu bekommen und wenn es nichts zu holen gibt, gebe ich Null zurück ohne die
Ausführung zu diesem Zeitpunkt zu beenden. In Ordnung, also zuerst oder Standard
ist wahrscheinlich ein bisschen sicherer. Und dann bekommen
wir einfach
die eine Liga zurück , die ganz oben
auf der Liste steht. Ordnung. Nun,
wir könnten das
vereinfachen, denn
was wir
hier sagen wollen, ist, mir
die Arbeitsklausel zu geben und dann die Bedingung eintragen
und mir dann die erste besorgen. Ich hätte das eigentlich
einfach machen können. Ich hätte sagen können, dass
Ligen standardmäßig den ersten Stern haben, diese Bedingung Das ist eine Ausführungsmethode. Denken Sie daran, den ganzen Weg
zurück zu unserer einfachen Auswahl gegangen zu sein. Sing Context Dot Leg
macht eigentlich nichts, aber sobald wir
diese Methode anwenden, wird sie ausgeführt Wir haben dasselbe mit
der To-Liste und der Ware gesehen. Aber in dieser Situation kann
ich einfach sagen, zuerst als Standard markieren und dann diese Bedingung
und dann wird die Abfrage entsprechend
ausgeführt. Also werde ich einfach
ausbrechen und Ihnen
einige andere häufig
verwendete Ausführungsmethoden zeigen . Also werde ich diese Zeile durch
eine einfache Anweisung
ersetzen , die unsere Datenbank hier setzt, richtig? Und natürlich können wir,
sobald wir den DB-Satz haben, auf die
Ausführungsmethoden zugreifen. Also lass uns
sie einfach der Reihe nach durchgehen. Also haben wir uns den Tost schon
angesehen. Wir wissen, dass die
Tolls die
Selcti-Anweisung ausführen wird Selcti-Anweisung ausführen Wir haben auch den ersten
und den ersten R-Standard, und wir haben gerade
den Unterschied zwischen
den beiden besprochen ,
also können wir sagen, dass Leaks zuerst
eine Synchronisation oder zuerst R
eine Synchronisation vorgeben und auch hier gibt es nicht asynchrone
Versionen dieser also können wir sagen, dass Leaks zuerst eine Synchronisation oder zuerst R
eine Synchronisation vorgeben und auch gibt es nicht asynchrone
Versionen Je nach Ihrer Situation verwenden
Sie vielleicht den A-Sync, vielleicht nicht den A-Sync, aber ich werde es einfach
konsistent halten und
beim A-Sync bleiben Wir haben auch die Standardeinstellung Single
oder Single. Single macht das, was das erste tun würde, außer dass es
zuerst eine Liste sieht und dann einfach das erste
auswählt,
wortwörtlich das Erste aus der Liste. Single funktioniert
ähnlich wie der erste Wenn es nach einer sucht, erwartet es
zuerst eine Liste und
nimmt dann die erste. Wenn keine Liste zurückgegeben wird, wird ein Fehler ausgegeben Single erwartet, dass nur
ein Datensatz zurückgegeben wird. Was auch immer Sie
erwarten, dass nur ein
Datensatz zurückgegeben wird Wenn es mehr als einen sieht, wird
es auch eine Ausnahme auslösen Single löst
die Ausnahme einfach nicht aus, sondern gibt unter ähnlichen
Umständen den
Standardwert zurück . Sie können immer mehr
nachlesen, wenn Sie einfach Maus über die Methode fahren Dadurch erhalten Sie eine gewisse
Information darüber, was sie tut Wenn es nun um einige
der traditionellen
Aggregatfunktionen geht , die wir wahrscheinlich aus
SQL kennen, sehen Sie count Sie können also sagen, dass die Anzahl der Punkte sinkt, und Sie werden
die Zählabfrage ausführen Sie haben eine lange Zählung,
Sie haben das Minimum, Sie haben das Maximum, Sie haben S, Sie haben eine Reihe von anderen. Wie ich schon sagte, du kannst
immer einfach Leagues
Dot oder Context Dot Table Dot sagen , und dann kannst du
durchblättern und du wirst
die Fülle der Methoden sehen , die dir
zur Verfügung stehen Sie können wählen, ob Sie sie verwenden möchten
, wenn Sie sie benötigen. Aber sich hinzusetzen und
zu versuchen,
sie alle auf einmal durchzugehen , mag anstrengend
sein, aber zu jedem Zeitpunkt glaubt
man, eine Idee im Kopf zu haben Sie können jederzeit einfach den Punkt kontrollieren
und einfach
durchschauen und sehen, welches
dieser Fleischsorten Sie zu dem
Zeitpunkt benötigen Eine weitere Ausführungsmethode, bei der es sich nicht unbedingt eine Abfragemethode
wie eine dieser handelt, um
eine Abfragemethode
wie eine dieser handelt, die
aber für
eine Datenbankgruppe ausgeführt wird, besteht darin, einen Sync zu finden Diese Methode wird eigentlich einfach
anhand eines Werts suchen, also dieser Wert wird der Schlüsselwert
sein, oder? Findet also eine Entität mit
einem bestimmten Primärschlüssel. Wenn Sie also sagen, einen Sync suchen, Ihnen erwartet, dass Sie einen
beliebigen eindeutigen Bezeichner eingeben wird von
Ihnen erwartet, dass Sie einen
beliebigen eindeutigen Bezeichner eingeben, also diese Tabelle, und dann wird dieser Datensatz
zurückgebracht. Es wird ihn entweder zurückbringen
oder Null zurückbringen, richtig? Oder es gibt den
Datensatz zurück oder gibt Null zurück. So funktioniert die
Suche nach einer Synchronisation. Lassen Sie uns also versuchen, es auszuführen und genau zu
sehen, wie das für uns funktionieren
würde. Also habe ich zu Beginn dieser Methode einen Breakpoint gesetzt, und ich werde sie einfach Schritt für Schritt
durchgehen damit wir sehen können, wie das
C-Quel generiert wird. Ich glaube, wenn es
zu Single und
Single oder Standard oder
zumindest zum ersten Mal kommt , wird
es wahrscheinlich einen
Fehler bei einer dieser Optionen auslösen, aber lassen Sie uns Schritt für
Schritt sehen,
was genau passiert. Also habe ich meine Fenster
nebeneinander gestellt, sodass wir jeden Schritt sehen
können. Wenn wir also sagen, dass
wir auflisten sollen , machen wir weiter und
führen diese aus, und dann sehen wir hier
, dass wir
die Auswahlabfrage erhalten , mit der wir bereits
vertraut sind. Also werde ich das Erste machen. Sie sehen also, es
bekommt den ersten Platz, es ist der beste. Aus der Liga. In Ordnung. Also das macht der erste. Und die erste oder die Standardeinstellung, wenn ich mich nicht irre, generieren
wir so ziemlich
das gleiche SQL wie das erste Aber wie gesagt, wenn zuerst
nichts angezeigt wird, wird eine Ausnahme ausgelöst Nun, Single
wird definitiv eine Ausnahme auslösen weil es nur einen Datensatz
erwartet, aber es bekommt die Liste
und sagt eine Single. Wenn wir also mit diesem Schritt weitermachen, wird diese
Ausnahme ausgelöst. Da haben wir's. Die Ausnahme ist also, dass die Sequenz
mehr als ein Element enthält , weil erwartet wurde, dass nur ein Element zurückgegeben
wird, oder? Also werde ich diese Ausführung einfach
beenden und diese Zeile
kommentieren, damit wir mit dem
Rest der Ausführung fortfahren können. Also habe ich die Ausführung
gegen alle anderen Methoden fortgesetzt , und Sie werden auf der rechten Seite sehen, einige von ihnen
erfolgreich waren, andere nicht. Also ein einziger singulärer Standard und so ziemlich all diese
mathematischen Fehler,
wirklich, weil, naja, ich mache hier nicht wirklich etwas
mathematisches. Ich muss sicherstellen, dass ich den
Mittelwert von etwas finde, das Maximum von etwas
finde Offensichtlich
passiert das nicht wirklich , wenn ich einfach Ligen
sage, oder? Aber der Punkt ist, dass dies einige zusätzliche Methoden
sind , die Sie verwenden können
, wenn Sie Ihre komplexeren Operationen ausführen Und wenn Sie nach rechts schauen, werden
Sie das bis zum Bett sehen, als wir
gefragt haben, wann wir nach der Zählung gefragt haben und wir nach einer langen Zahl gefragt
haben.
Der Unterschied zwischen
den beiden bestand darin, dass wir Cont Star für
das Babybett und dann Cont Big Star
für den langen Kegel
ausgewählt Der einzige wesentliche Unterschied besteht
wirklich darin, dass count
eine ganze Zahl zurückgibt und dieser eine große
Ganzzahl Sie wissen also, je nach Größe
der Datenbank Sie vielleicht nie
Long Count oder Big in SQL verwenden, aber die Methode ist trotzdem
da. Das ist es also wirklich mit
den Ausführungsmethoden. Im Laufe der Zeit könnten wir Verwendung für sie
finden. Und andernfalls müssen wir vielleicht
mit ihnen interagieren. Aber im Moment tun wir das nicht. Ich werde
all diejenigen auskommentieren , die
wahrscheinlich Fehler verursacht haben, und ich möchte nur, dass wir
das Q sehen , das generiert wird,
wenn wir versuchen, es zu finden. Wir sehen hier also, dass die
Ausführung des Fundes darin besteht , dass ein Top-Ergebnis gefunden wird,
bei dem diese Bedingung erfüllt ist. Das alles
wird also wieder für uns generiert. Und höchstwahrscheinlich werden
wir diese ID sowieso nicht fest codieren, diese ID würde
von irgendwoher kommen, weißt
du, wenn jemand in deiner Benutzeroberfläche auf
Bearbeiten klickt. Sie müssen wissen, welchen
Datensatz sie bearbeiten wollen. Sie müssen diesen Datensatz
suchen, ihn
zurückgeben und ihn dann dem Benutzer
präsentieren. Das ist also eine Fallstudie dafür
, wann Sie diesen Fund verwenden würden. Das war's also für uns uns zusätzliche
Ausführungsmethoden ansehen. Wie Sie gesehen haben, gibt es
eine viel längere Liste als die, die wir hier
durchgemacht haben. Aber Sie haben diese
vier Referenzen, und ich bin mir sicher, dass Sie sie in Zukunft gut
gebrauchen werden.
15. Alternative LINQ Syntax: Hey, Leute, willkommen
zurück. In dieser Lektion werden
wir uns mit der
alternativen Link-Syntax befassen. Bisher haben
wir uns also mit
Links in Form
dieser Ausführungsmethoden und
verschiedener
Lambda-Ausdrücke befasst dieser Ausführungsmethoden und , die wir in einigen von
ihnen platzieren
können, um unsere Operationen auf unsere
Bedürfnisse zuzuschneiden Nun, das ist in Ordnung, die
Verwendung der
Lambda-Ausdrucksmethode ist völlig in Ordnung, und wie Sie sehen können, kann
sie in
einer Zeile geschrieben werden , nett und sauber Es gibt jedoch eine
alternative Syntax , die einige Entwickler
vielleicht etwas
intuitiver finden , da sie dem
herkömmlichen SQL ein bisschen ähnlicher ist, aber sie ist immer noch C-scharf Das ist also
die erste Methode , mit der ich Links
geschrieben habe, bevor ich vertraut gemacht habe Lambda-Ausdrücke
entdeckt habe oder
mich damit Und ich habe den Code hier für Sie
vorbereitet, also werde ich Sie nur durch ihn führen Also schauen wir uns dieses Mal die Teams
an, oder? Und dann sagt unsere Syntax hier, dass
es sich um ein Token handelt. Das könnte also sein, weißt du, wir haben Q in unseren
Lambda-Ausdrücken verwendet Das steht für so
etwas wie das Q. Wir könnten Team sagen, wir könnten
Q sagen . Ich meine ich. In Ordnung. Also von mir rein, und dann sagen wir die Tabelle ,
in der wir suchen möchten Also kontextualisieren Sie die
Teams und wählen Sie dann aus. Also, wie ich schon sagte, es sieht ein
bisschen mehr nach Q aus, weil es tatsächlich einige dieser
SQL-Schlüsselwörter hat, oder? Es ist nur ein bisschen
rückwärts, weil es ein Stern aus der Tabelle ausgewählt
worden wäre Stern aus der Tabelle ausgewählt
worden Und dieser ist von
Datensatz in Tabelle, Datensatz
auswählen, oder wir könnten sagen,
wählen Sie etwas Bestimmtes aus Aber das werden wir uns später ansehen. Also, wenn ich diese Abfrage
mache, werde ich die Teams
abfragen, richtig Das heißt also, dass ich das in eine Liste
umwandeln muss. Aber lassen Sie uns ausführen
und sehen, was wir bekommen, und dann können wir es im
Laufe der Zeit verfeinern. Wenn Sie sich das ansehen, hat es diese Abfrage tatsächlich ziemlich perfekt
ausgeführt, oder? Es gab uns unsere Select-Aussage und gibt uns unsere Teams
zurück. Wir mussten also nicht ausdrücklich
sagen, dass wir es auflisten und
versuchen sollten, es zu konvertieren. Nun, einer der Vorteile, wir sie als Liste haben,
ist, dass, wenn sie in
der Form von Streitereien vorliegt,
unsere Fähigkeit, sie bis zu
einem gewissen Grad zu manipulieren , begrenzt
ist, oder? Wenn ich mir also Teams ansehe, gibt es
hier bestimmte Funktionen , die einzigartig für
i quarable
sind, und es gibt bestimmte Funktionen
, die Listen gelten, die Sie wahrscheinlich
später in Ihrer Codierung verwenden
möchten und die Sie nicht wirklich bekommen können wenn Sie es
mit einer iquarable zu tun haben. Also von Zeit zu Zeit ich das
alles einfach in Klammern
und sage dann to list, und dann
gibt mir das einfach meine Liste zurück, die ein bisschen nativer
zu dem ist, was ich
am Ende des Tages in meinem C-Sharp-Code machen möchte . zu tun,
muss ich natürlich meine Methode
von void auf AC task ändern , oder Dann bekommen wir unsere Liste,
und wie Sie sehen können, funktionieren die Liste,
die Sammlungstypen, ziemlich ähnlich, aber wie gesagt,
es gibt bestimmte Dinge, die
uns
die Liste bietet , nämlich eine abfragbare Aufzählung, und die andere Art von
Auflistungssammlungen oder
Sammlungstypen in C
sharp, sie tun es einfach nicht Aber natürlich ist die
Situation bei jedem anders. Verwenden Sie diejenige, die
zu Ihrem Kontext passt. Lassen Sie uns das nun erweitern. Wir haben uns auch mit
Abfragen befasst, oder Entschuldigung. Wir haben uns auch mit dem
Filtern unserer Anfragen befasst. Im Moment
macht das nur einen Standard-Select-Star. Stimmt das? Aber was wäre, wenn wir eine
Award-Klausel wollten? Nun, wir würden sagen,
von mir in der Tabelle, und ich werde hier einfach die Grenze
durchbrechen. Es sieht also etwas lesbarer aus. Wo, und Sie werden
sehen, dass es diese
Keywords für uns irgendwie hervorhebt. Also wo I, was für einen Ausdruck oder
einen beliebigen Datensatz in der Datenbank steht. Also kann ich sagen, wo mein
Name gleichbedeutend ist, und dann meine Daten eingeben. So wie
wir in der Lage
waren ,
eine Variable oder einen statischen Namen oder irgendwas von diesen Dingen einzufügen
oder, wissen Sie , können
wir
das alles hier tun Lass mich sehen, ob das überhaupt funktionieren
würde. Ich werde versuchen zu sagen, wo ich nenne oder lassen Sie mich sagen,
wo EF wie funktioniert. Und dann
wäre das, was ich nicht nenne. Und dann haben wir
den Liganamen
, für den ich nur kurz nach dieser
Methode fragen werde , auch das wäre der Teamname Geben Sie also den Teamnamen ein. Lass mich einfach den
Namen des Verbs ändern. Und da haben wir's. Also fragen wir nach dem
Teamnamen und einem Teil davon. Und dann sagen wir
aus der Teamtabelle wo Punkt
wie Punktname funktioniert, richtig Unser Ausdruck, und
dann wollen wir auswählen, und dann wollen wir
all das in eine Liste aufnehmen, um zu unseren
variablen Anruf-Teams
zurückzukehren. Also das wird natürlich
funktionieren. Ich möchte nur
die Tatsache hervorheben, dass wir
die alternative Syntax genauso
verwenden können die alternative Syntax wie unseren Lambda-Ausdruck Also hier teste ich
es und gebe B A Y als Teil des Teamnamens Wir sehen unsere Select-Anweisung mit der Anweisung, die für uns
generiert wird, und wir bekommen
Bar und Municx zurück, da es das einzige Team ist, das BAY enthält Das ist also noch einmal
unsere alternative Syntax. Was auch immer Sie mit
dem Lambda-Ausdruck tun können, Sie können es auch in
dieser Art von Syntax tun Ich persönlich finde
die Lambda-Ausdrücke
jedoch etwas einfacher Seitdem ich mich mit ihnen
vertraut gemacht habe, höre eigentlich auf,
meine Abfragen so zu schreiben habe ich seit Jahren keine
Anfragen mehr geschrieben ehrlich zu sein, habe ich seit Jahren keine
Anfragen mehr geschrieben, aber es ist gut, wenn Sie alle
Ihre Optionen
und Alternativen kennen , falls erforderlich.
Okay.
16. Einfache Update-Abfrage: Hallo Leute, willkommen
zurück in dieser Lektion Wir werden uns mit der
Durchführung eines Aktualisierungsvorgangs befassen. Der allgemeine
Arbeitsablauf für eine Aktualisierung besteht
nun darin, dass Sie den Datensatz,
den Sie ändern möchten,
abrufen , dann die Änderung vornehmen und dann die Änderungen speichern. Das ist also ein typischer Arbeitsablauf. In jeder Anwendung, die Sie verwenden
, passiert das
hinter den Kulissen. Sie geben an, dass Sie einen Datensatz bearbeiten möchten
, es sucht diesen Datensatz,
präsentiert ihn Ihnen, nimmt Änderungen daran vor, und wenn Sie dann
auf Speichern klicken, haben
Sie die
Änderungen am Datensatz vorgenommen, und beim Speichern diese
Änderungen in die Datenbank übernommen. Ordnung. Schauen wir uns also zunächst Abrufen der Aufzeichnungen an Was wäre, wenn wir etwas ändern wollten? Und wir haben welche, lass mich einfach
gehen und mir unsere Ligen ansehen. Wir haben hier einige doppelte
Werte. Ich glaube, wir haben drei Rekorde in der Football League mit den roten
Streifen. Und ja, das tun wir. Wir haben also Ausweise ,
zwei, drei und
vier sind identisch. Also werde ich einfach
die Namen einiger
davon ändern , richtig? Also werde ich
die Namen von dreien ändern. Es ist ein Duplikat, aber im
Nachhinein stellen wir fest, oh, das
hätte wirklich die schottische
Premiership sein sollen , oder? Wir wissen also, dass wir den Datensatz mit der ID drei
ändern wollen. Also, was ich tun werde
, um
den Datensatz abzurufen , ist SVR League, z entspricht dem Kontext, Ligen finden und
ich verwende einfach eine Wenn ich eine Synchronisation verwende, muss
ich meine
Methode natürlich in eine A-Sync-Aufgabe umwandeln, und dann warte ich hier darauf Also
sagen wir, suchen Sie eine Synchronisation
und denken dann daran, dass wir nur den Primärschlüssel
übergeben müssen ,
damit wir wissen, dass wir einen
Datensatz mit der ID drei wollen. Also, wenn wir die Liga haben, möchte
ich
den Namen League Dot ändern.
Ich möchte, dass dieser Name jetzt
schottische Premiership lautet . Dann speichern wir unsere Änderungen. Wir haben uns also bereits die
Speicheränderungen angesehen, die beim Einfügen derselben Speicheränderungen vorgenommen wurden Jedes Mal, wenn Sie Daten in der Datenbank
erweitern möchten, müssen
Sie dies aufrufen, um den Befehl
zu bestätigen Dann möchte ich
das Ergebnis ausdrucken oder ich möchte es zurückdrucken, um diesen Datensatz
zu überprüfen Ich werde einfach eine
Methode namens get record erstellen, die speziell
dazu dient, diesen Datensatz zu finden. Ich habe es hier oben definiert, oder ich sage einfach Varg, geh und finde den gleichen Datensatz Also nach den Änderungen beim
Speichern hätte es die
Verbindung zur Datenbank geschlossen Ich
warte einfach auf Get Record, das heißt, den Datensatz
abzurufen und ihn
dann wieder auf
den Bildschirm zu drucken, nur um zu zeigen, dass der Aktualisierungsvorgang erfolgreich
war. Geben wir dem also ein Ziel. Wenn ich das Programm ausführe, sehen
wir hier,
dass es die Auswahl durchführt, dort sucht
es, also ruft es den Datensatz also ruft es den Datensatz ab
und führt dann das Update durch, sodass es den Primärschlüssel
und den neuen Wert
für diesen Datensatz beibehält und den neuen Wert
für diesen Datensatz Und dann führt es
diese Aktualisierungsanweisung aus, setzt den Namen auf die
Werte in diesem Parameter, wobei sich die ID in
diesem Parameter befindet, und dann geht es
weiter und aktualisiert Und dann öffnet
unser Get-Record
natürlich einfach
die Auswahlabfrage erneut, das ist eine Selquy und gibt uns diesen Datensatz zurück. In Ordnung Also lass uns das nochmal versuchen und ich werde
nichts ändern. Ich werde
den gleichen Datensatz hinterlassen. Ich werde
dieselbe Änderung vornehmen und alles wird
gleich bleiben. Und dann lass uns sehen,
was passiert ist. Dieses Mal haben wir keine
Aktualisierungserklärung. Nimm das zur Kenntnis, oder? Wir haben keine
Aktualisierungserklärung weil sie feststellt, dass
jede Änderung, die ich vornehme, es sich nicht wirklich um eine Änderung handelt. Das ist bereits der Wert in
der Datenbank. Es wird sich also nicht die Mühe machen
, seine Zeit damit zu verschwenden, zu sagen: Oh, ich muss etwas ändern. CEFCO entscheidet sich auf intelligente Weise ,
keine Verbindung zur Datenbank herzustellen und
einen Befehl auszuführen, von
dem es feststellt, dass er nicht benötigt
wird Nun, was ermöglicht diese
Art von Änderung, was
bedeutet, dass FCR erkennt, dass die Daten,
die wir
für dieses Feld präsentieren, anders sind,
sodass es dann weiß, dass die Änderungen gespeichert werden müssen bedeutet, dass FCR erkennt, dass die Daten,
die wir
für dieses Feld präsentieren, anders sind ,
sodass es dann weiß, dass die sodass es dann Das nennt man Tracking, oder? Wir schauen uns Tracking an und später
kein Tracking. Aber nur als kurze Vorschau Wann immer wir
Objekte ändern, verfolgt
FCR tatsächlich
im Speicher, welche Objekte es hat, wenn an
ihnen
Änderungen vorgenommen wurden . Wenn wir also
sagen, Änderungen speichern, wird
es buchstäblich sagen: Okay,
ich kann sehen, dass wird
es buchstäblich sagen: Okay, hier eine Änderung vorgenommen
wurde ,
ich muss diese Änderung übernehmen usw. Das ist es also, was uns das Tracking
ermöglicht. Nun, es gibt andere
Dinge, mit denen wir ein Update
durchführen können, weil
ein Update vielleicht nie so
einfach ist, wie den exakten Wert
zu finden , nur
eine Eigenschaft zu ändern und dann
einfach die Änderungen zu speichern. Oft wissen wir nicht, was sich geändert hat, wenn vor allem Benutzer Benutzeroberflächen haben und
mit einem Formular interagieren, wenn
wir ihnen erlauben, die Daten
zu bearbeiten vor allem Benutzer Benutzeroberflächen haben
und
mit einem Formular interagieren,
wenn
wir ihnen erlauben, die Daten
zu bearbeiten. Wir können das also nicht mit Sicherheit
wissen, okay, wir werden nur den Namen aktualisieren und wir werden nur dies und das
aktualisieren. Wir wissen nicht, ob
sie vielleicht
bei der Bearbeitung eines Teams die
Liga und den Namen ändern. Wir wissen es nicht. dieses andere Beispiel verwende
ich Team. Also habe ich unsere Methode von
Update Record in Simple
Update League Record umbenannt . Es ist also klar, dass
wir es mit
der Liga zu tun haben und es
war ein einfaches Update, und jetzt haben wir
einfach den Teamrekord aktualisieren. Schauen wir uns also die Alternative
an. den Fall
,
dass jemand, der
eine Weboberfläche verwendet , das Formular eingereicht
hätte, bedeutet das, dass wir bereits
alle Informationen über
den Datensatz haben alle Informationen über , die wir
zu diesem
Zeitpunkt benötigen, sodass wir ihn nicht
vor dem Update suchen müssen,
weil wir ihn bereits gefunden
haben vor dem Update suchen müssen,
weil wir ihn bereits gefunden bevor wir
ihn dem Benutzer zeigen. Jetzt hat der Benutzer die Daten eingereicht und wir haben die neuen Daten. In Ordnung. Also werde ich das simulieren, indem ich einen brandneuen Brunnen baue, ein Objekt vom Typ Team, richtig? Und dann werde ich
diesmal eine ID angeben. Bis jetzt haben wir keinem
unserer Objekte
wirklich IDs gegeben, da
diese automatisch inkrementiert werden Wir müssen uns jedoch darüber Klaren sein, dass wir
, wenn
eine ID vorhanden ist, natürlich
die Datenbanktabellen nach
dem Datensatz mit dieser ID durchsuchen die Datenbanktabellen nach
dem Datensatz mit dieser ID Also gehe ich rüber
zum Teamtisch. Und was ich tun werde, ist manuell einzufügen, nur
damit wir durch
dieses lokale Aktivitätsteam
kommen können . Es ist in der Red
Strip Premier League, aber ich werde es mit
ein paar Rechtschreibfehlern einfügen ,
oder? Es ist Tivoli Das ist Tivoli, und ich werde es mit
der falschen Liga-ID angeben, weil es nicht
in Liga acht ist, und anhand der Teams
in Liga acht können
wir das vermuten, können
wir Es ist nicht in Syrien, also
müssen wir diese Art
von Update machen, Nehmen wir also an, dass dies
von einem Benutzer
fälschlicherweise eingegeben wurde , und dann
nimmt ein anderer Benutzer diesen Fehler auf
und macht sich daran, ihn falsch
zu schreiben wäre also
das Formular vorgelegt
worden und dann hätten sie
die Korrekturen vorgenommen, und dann hätten sie das Formular
eingereicht Das Objekt, das sie eingereicht
hätten, würde also
ungefähr so aussehen ,
wo die ID 7 ist, das ist die ID für
dieses Team, ja. Und der Name, der korrigiert
wurde, ist Tivoli Gardens FC mit einem O statt AW, das ist
eine korrekte Schreibweise Und dann
wäre die Liga-ID jetzt die Red Stripe
Premier League, richtig? Verwenden wir also League ID zwei. Wir sehen, dass wir noch ein
Duplikat haben, aber das ist in Ordnung. Lass uns einfach
League mit ID zwei benutzen. Das ist also das Update, das
dieser Benutzer einreicht. Nun, wie bekommen wir diesen neuen
Datensatz in die Datenbank? Nun, wir können sagen, Context
Dot League Teams. Wir haben es mit
Teams Dot Update zu tun. Wir haben also eine Aktualisierungsmethode, die genau wie die
Anzeige
ein Objekt des Datentyps verwendet , der der Tabelle entspricht. Wir haben also unser Teamobjekt. Ich stelle fest, dass es keine asynchrone Version davon gibt, es gibt keine
asynchrone Version Wir haben die Single- und wir
haben die Batch-Version, und wir haben uns bereits den Batch-Bereich angesehen Wenn wir
also ein paar
davon aktualisieren müssen, haben wir einfach die Liste übergeben und sie wird
alle für uns erledigen Im Moment
schauen wir uns nur die Single an. Und danach müssen
wir
unseren Kontext Dot Save Changes aufrufen . Und dafür verwenden wir den
A-Sync. Und natürlich
muss ich das
synchronisieren und dann sind all unsere
Probleme gelöst. Schauen wir uns an, was passiert , wenn wir
diese Art von Update weitergeben. Sie werden sehen, dass es sich um eine
ähnliche Operation handelt. Niemand, es wird nicht
noch einmal aktualisiert , weil es die ID sieht. Es weiß also, dass es
ein Team mit der ID 7 gibt, und dann wird es automatisch
suchen, nun, es muss
es nicht finden,
weil die Aktualisierungsanweisung besagt, dass Liga-ID geändert wird, Name geändert wird, wobei
die ID der ID
entspricht Name geändert wird, wobei
die ID der ID
entspricht, die es in der Aufzeichnung gesehen hat
. Also macht es das alles
automatisch, sobald die
Datensatz-ID da ist. Lassen Sie uns also
eine Reihe von Permutationen durchgehen. , wenn wir diese ID nicht angeben Was würde eigentlich passieren, wenn wir diese ID nicht angeben würden Und ich werde einfach
eine andere Fußballmannschaft benutzen, also Ciba United, und das ist auch in der Premier League mit den
roten Streifen Lassen Sie uns das versuchen
und den Unterschied feststellen. Das hatte keinen Ausweis. Wir haben den Ausweis herausgenommen und ihn als
Anspielung genommen. Nehmen Sie das zur Kenntnis. Der Aktualisierungsbefehl
oder die Aktualisierungsfunktion
besagten also , dass ich dazu keinen
Primärschlüssel sehe,
dieser existiert eindeutig noch nicht
in der Datenbank, also füge ich ihn ein. Nun, ich werbe
das nicht als Alternative
zur Einfügung an Ich möchte
sie sehr getrennt halten. Wenn ich etwas einfüge, verwende
ich die Funktion Hinzufügen Wenn ich aktualisiere, verwende ich
die Aktualisierungsfunktion, oder ich verfolge es einfach entsprechend, aber das Tracking ist nicht
immer eine Option wie wir es in
unseren Anwendungen sehen Aber eines ist zu beachten: Wenn diese ID nicht vorhanden
ist, wird sie hinzugefügt. Aus diesem Grund stellen wir immer
sicher, dass die
ID-Informationen in ein Formular aufgenommen werden, damit diese ID
bei
der Übermittlung im Datensatz enthalten ist , damit wir die Aktualisierung
ordnungsgemäß durchführen können. Das ist also ein sehr
wichtiger Punkt, den es zu beachten gilt. Und ein weiteres Experiment besteht darin, eine ID
einzugeben, die nicht existiert. Also wenn dieser ID-Wert
völlig falsch ist. Ich habe zehn, und wir wissen,
dass wir nur naja,
keine acht Teams haben , richtig, oder Teams mit der ID acht. ID Ten ist also völlig falsch. Es wird versuchen, das Update durchzuführen, aber dann wird beim Speichern der Änderungen eine
Ausnahme ausgelöst, die
besagt, dass der
Vorgang fehlgeschlagen ist , naja,
es wurde erwartet, dass er
mindestens eine Zeile betreffen würde,
aber null davon betroffen war. Möglicherweise wurden die
darin enthaltenen Daten geändert . Sie können hier also sehen, dass es Ihnen nicht wirklich
genau sagt, was falsch ist. Wir wissen, dass das falsch
ist, weil der ID-Wert nicht existiert. Und es heißt, dass
es dachte, es würde mindestens eine Änderung vornehmen,
aber nichts ist passiert. Es ist also nicht wirklich sicher,
was passiert sein könnte. Sie müssen die Dokumentation
lesen. Aber wie gesagt, ich
möchte herausfinden, was
diese Fehler verursachen kann , sodass wir, wenn wir leicht vage
Fehler wie diesen
bekommen, vermuten können, dass, okay, mit einigen
der Daten, die ich
hier irgendwo
angegeben habe, etwas
nicht stimmt der Daten, die ich
hier irgendwo
angegeben habe, Das war's also wirklich für
das Update. Wie Sie sehen können, ist es eine ziemlich
einfache Operation. Sie haben wieder zwei Möglichkeiten. Sie können den Datensatz suchen, ihn ändern und
dann die Änderungen speichern.
Durch die Nachverfolgung kann COR dann feststellen,
dass dieser Datensatz geändert wurde, also muss ich die
Aktualisierungsanweisung dafür erstellen. Denn selbst wenn wir eine Liste von ihnen
haben, nur eine aktualisiert werden
muss,
wenn wir nur an einer Änderung vorgenommen wird
es wissen, dass nur eine aktualisiert werden
muss,
wenn wir nur an einer Änderung vorgenommen haben, oder? Und die Alternative, wissen Sie oder eine andere Situation, könnte sein, Tracking nicht
unbedingt eine Option ist. Und der Datensatz, den wir
aktualisieren müssen, wird zu diesem Zeitpunkt nicht
von FCR nachverfolgt,
sodass wir diese
Aktualisierungsmethode verwenden können, bei sodass wir diese
Aktualisierungsmethode verwenden können, nach
dem Datensatz gesucht und
die Aktualisierungsanweisung
automatisch generiert wird Datensatz gesucht und
die Aktualisierungsanweisung
automatisch generiert die Aktualisierungsanweisung
automatisch Wenn keine ID vorhanden ist, fährt die Aktualisierungsmethode fort und fügt den
neuen Datensatz hinzu. Okay.
17. Einfache Query: Und wir sind zurück. Bis jetzt haben
wir uns
alle Buchstaben
in CRD angesehen , außer dem
D, das Löschen bedeutet Also haben wir uns angesehen
, wie man etwas erstellt. Wir haben einige Zeit damit verbracht, uns anzusehen wie wir Daten abrufen können und
welche verschiedenen Möglichkeiten es gibt. Wir haben uns gerade angesehen, wie wir
aktualisieren, und jetzt möchten wir wissen, wie wir
Daten aus unserer Datenbank löschen oder entfernen. Ich habe also bereits zwei Methoden
eingerichtet,
eine, um ein einfaches Beispiel für das
Löschen zu zeigen, und eine weitere, bei der wir
einen Löschvorgang anzeigen , wenn
verwandte Daten vorhanden sind. Alles klar? Also das einfache Löschen. Werfen wir einen Blick auf die Optionen , die uns zur Verfügung stehen. Und ich werde einige Zeit
mit der Tabelle verbringen , weil
wir einige Aufräumarbeiten müssen Erstens haben wir
hier und hier Duplikate. Und dann
wollen wir wahrscheinlich auch die Bundesliga entfernen. Das
werden wir heute also tun. In Ordnung. Also, wenn ich
Kontext-Punkt sage und eine Tabelle auswähle. In diesem Fall heißt
es also Leagues Dot, und dann fange ich an, Löschen
oder besser gesagt, meinen Fehler entfernen zu tippen , wir werden sehen, dass wir zwei Optionen
haben Wir haben den Bereich entfernt und wir
haben den Bereich entfernt. Entfernen Sie also Deals, die
nur einen Datensatz nach dem anderen hinzufügen und aktualisieren, und dann gelten die
Bereichsoperationen für große Mengen. Alles klar? Wenn ich also
„entfernen“ sage und mir nur ansehe, was für eine Entfernung
erforderlich ist, werden
wir sehen, dass die
gesamte Entität entfernt werden muss. Ordnung. Wenn Sie also
eine Q-Anweisung schreiben, würden
Sie normalerweise sagen, dass Löschen
aus Tabelle, die wir vielleicht identifizieren
, gleich eins ist. In Ordnung. Und dann wird es einfach
den Datensatz
suchen, der der Bedingung
entspricht, die mir gegeben wurde, und ihn löschen. Und ohne diese Bedingung wird es eigentlich
einfach den Tisch abwischen. Zumindest gibt es hier
ein Sicherheitsnetz, in dem
wir entweder die Entität oder die Liste
der zu entfernenden Entitäten
angeben müssen , was bedeutet, dass wir uns sehr bewusst bemühen müssen , zu wissen
, ob wir diese Entität während der Laufzeit entfernen
wollen Das Risiko, die Datenbank zu löschen
, ist in dieser
Situation also deutlich reduziert. In Ordnung. Also natürlich, wenn
wir
die Entität angeben müssen , die entfernt werden
soll. Und wenn Sie sich nur die Dokumentation
ansehen, heißt
es, dass das Entfernen die Entität in einen Zustand versetzt ,
der
als gelöscht bezeichnet wird. Es markiert es also als gelöscht, aber wie Sie wissen,
passiert nichts, bis wir Save
Changes aufrufen. Wenn ich also
eine Entität für diesen Datensatz angeben muss, dann muss ich natürlich
suchen, was ich löschen muss. Also werde ich direkt
darüber eine Zeile einfügen , wo ich die Liga mit
der ID vier vier
finde , weil das eines meiner
Duplikate ist, oder? Und dieser hat
keine verwandten Aufzeichnungen. Das ist also eine einfache Löschung. Einfach den
mit der ID Vier finden, wenn wir ihn haben, dann können wir sagen, das ist der, den ich entfernen
möchte. Und dann sagen wir, wie
wir wissen, Änderungen speichern. Natürlich verwenden wir den
ASIC, um eine s Zwei hinzuzufügen, die Methodendeklaration, Alles
klar, und los geht's Also, wenn ich das nenne und ich werde mich vorerst nur
zu diesem zweiten Anruf äußern vorerst nur
zu diesem zweiten Anruf Wenn ich diese Operation ausführe, sehen
wir, wo
die Auswahlabfrage zum
Abrufen des Datensatzes zerrissen wurde, und dann ging sie raus und sagte, lösche dieselbe
Abfrage aus den Ligen, die wir kennen und lieben Mit dieser WERE-Klausel
stellen Sie natürlich sicher, dass wir die
Tabellen in der Datenbank nicht löschen Ordnung. So funktioniert ein
einfaches Löschen wirklich. Der Grund, warum ich
zwischen einem einfachen Löschen
und einem Löschen mit Beziehungen
unterscheide zwischen einem einfachen Löschen
und einem Löschen mit Beziehungen ,
ist, dass
ein Löschvorgang bei
verknüpften Datensätzen etwas sensibler wird heißt, es gibt eine
Einstellung namens kaskadiertes Löschen, was bedeutet, dass, wenn ich den Datensatz
mit einem Primärschlüssel
entferne, jeder andere Datensatz, der
einen Fremdschlüssel zu diesem hat , ebenfalls gelöscht
wird Ordnung, es wäre also fast so,
als würde man dich aus einer Datenbank löschen Also werden alle Karten, die Sie jemals besessen haben, und alle
Informationen
, die Sie betreffen , auch
aus verschiedenen Teilen
der Datenbank gelöscht aus verschiedenen Teilen
der Datenbank Während das
in manchen Situationen gut sein
kann, kann es
in anderen sehr gefährlich sein. In Ordnung. Also in dieser Situation, wenn ich
Bundesliga mit der ID neun lösche, wiederhole
ich einfach den gleichen Code aus dem Symbol Löschen. Was einen Unterschied macht
, ist, dass ich weiß, dass ich
mindestens eine Mannschaft habe , die mit der Bundesliga
verwandt ist, oder? Das heißt, wenn ich Bonds Liga
entfernen würde
, würde
auch diese Mannschaft entfernt werden Genauso,
wenn ich Syrien entfernen würde, dann würden ein, zwei, drei
Teams entfernt werden. Kehren wir nun zu
unserer Migrationsdatei zurück , nur
damit wir
die Einschränkungsregeln verstehen können , als die Tabelle mit vier Teams erstellt und die
Fremdschlüsseleinschränkung hinzugefügt wurde Standardmäßig wurden
referenzielle Aktionen nacheinander ausgeführt. Es gibt noch andere Optionen
, die wir hier festlegen könnten. Es könnte also „Einschränken“ heißen,
was bedeutet, dass Sie
keinen
Datensatz löschen können, der verwandte
oder abhängige Datensätze enthält. Auf Null setzen bedeutet, dass alle anderen Datensätze und
alle zugehörigen Datensätze
gesetzt werden alle zugehörigen Datensätze Der Fremdschlüsselwert wird
nun auf Null gesetzt, oder? Nehmen wir an, wir löschen
das übergeordnete Objekt und
setzen einfach alle
Fremdschlüsselwerte auf Null. Und dann hast du keine Aktion
, also, naja, es heißt, ignoriere die Einschränkung und dann noch eine,
die Standard sagt, was danach einfach einen
Standardwert setzen würde, oder? Also werde ich es
bei der Standardkaskade belassen, aber auch hier ist das vielleicht nicht immer die
beste Situation Und manchmal zeigt Ihnen der
Kern von
Entity Framework bei der Generierung der Migration
tatsächlich an dass, wenn ich Cascade dort einfüge, es zu
bestimmten Fehlern kommen kann ,
weil, wissen Sie,
diese Tabelle von diesem und
dem abhängig sein könnte , und Sie erhalten eine
Situation wie einen Zirkelverweis oder verschiedene Tabellen, die auf
denselben Daten basieren. CO wird Sie also
in Situationen warnen , in denen Ihr
Datenbankdesign für diese Art
von Einschränkungsregel möglicherweise nicht optimal ist. In Ordnung. uns also versuchen, die Lassen Sie uns also versuchen, die Bundesliga zu löschen, von der wir wissen, dass sie eine ähnliche
Mannschaft hat, und sehen wir, was passiert. Wenn wir uns also
das generierte Qua ansehen. Es sieht nicht anders
aus als das, was wir
beim vorherigen gesehen haben Sie
fragen sich also wahrscheinlich, okay, wo der zweite Löschvorgang
für den zugehörigen Datensatz ist. Lassen Sie uns überprüfen, ob das passiert ist. Wenn ich also Teams aktualisiere, ist die
Bundesliga weg,
tut mir leid, Ligen, und wenn ich dann Teams aktualisiere, bedeutet
das, dass Burn
Munich auch weg ist Die Kaskade hat also stattgefunden, aber unsere Logs
zeigen nur eine Löschung Das liegt daran, dass sich eine Kaskadenregel wirklich im
Datenbanktechniker
befindet Es ist nicht unbedingt
eine CA-Anweisung , die
generiert wird. In Ordnung. Diese
Migrationsregel wurde also wirklich in der Datenbank
festgelegt, als
wir die Migration beeinflussten. Die Datenbank selbst
weiß, dass die Regel darin besteht, alle zugehörigen Datensätze zu löschen. Das hat zu diesem Zeitpunkt also nichts
mit FCR zu tun. Das ist also eine der
gefährlichen potenziell gefährlichen
Situationen, auf die Sie achten
müssen , wenn Sie eine Datenbank
entwerfen, Ihre Migrationen
einrichten und Ihre
Löschvorgänge ausführen Seien Sie sich bewusst,
dass standardmäßig kaskadiert angezeigt wird, aber Sie können das jederzeit durch Konfigurationen überschreiben
, indem Sie „
Standardmäßig einschränken “ oder etwas
Ähnliches angeben Das war's also wirklich für
unsere Löschvorgänge, wie Sie sehen können, es ist
ziemlich einfach Wir müssen nur gehen und den Datensatz
abrufen. Höchstwahrscheinlich
hätten wir die ID für den Datensatz, den wir sowieso löschen
müssen Wir rufen
ihn ab und
sagen ihm dann einfach , dass es der Datensatz ist, den
wir entfernen wollen ,
speichern unsere Änderungen
und fertig.
18. Tracking Vs. Kein Tracking: Hey, Leute, willkommen
zurück. In dieser Lektion werden
wir uns ohne
Tracking befassen, damit wir besser
einschätzen können was
im Hintergrund passiert. Ich habe bereits
Code geschrieben, mit dem Sie hier pausieren und ihn
replizieren können , aber
ich werde
Ihnen zeigen, was
jede Zeile tut Wir beginnen mit der Methode Tracking
statt ohne Tracking Bei dieser Methode habe ich
zwei Anweisungen, eine, bei der wir
Wert aus der Datenbank abrufen, und ich rufe
sie einfach mit Tracking auf, und dann eine weitere, bei der ich sie ohne Tracking
erhalte. Wenn Sie sich die beiden Zeilen
genau ansehen, werden Sie
feststellen, dass
der Unterschied darin besteht, dass ich in der Aussage Punkt als Tracking verwende. Die erste ist das, was wir
gewohnt sind, Punktteams zu kontextualisieren. Ich will den ersten Datensatz
, der die ID zwei hat. Richtig? Das
hätte fast leicht ein Fund sein außer dass das An-Tracking nicht
funktioniert, wenn
wir einen Fund verwenden. Alles klar? Also, wenn wir versuchen würden herauszufinden
, ob wir löschen
und aktualisieren und so weiter hätten, wir in
diese Art von Erklärung ein Tracking einbauen. Daher habe ich
die erste oder die Standardversion geschrieben. Und dann habe ich es aus Konsistenzgründen beide Male
gemacht, oder? Also ohne Tracking kann ich sagen, gib mir das Team. Also
verfolge es nicht, nachdem du es mir gegeben hast, bitte verfolge es nicht im Speicher, aber ich will die erste oder die
Standardnummer mit der ID 8. Nun, so wie es
geschrieben ist, scheint das nicht intuitiv zu sein, weil
Sie wahrscheinlich sagen werden, warum sage ich nicht, geben Sie mir das
erste Team mit AS-Tracking. Die Realität ist, dass nach der
ersten oder Standardanweisung das
alles so ziemlich das Objekt
wird, nach dem
wir suchen. Also, mit anderen Worten, das
Einzige, was ich tun kann erste Stern voreingestellt ist und
nun ja, wir benutzen das Ass. Also werde ich
das einfach in Klammern setzen. Also, nachdem diese Anweisung
ausgeführt wurde, richtig? Und ich muss das nur
tun, weil es acc ist, wenn es nicht acc wäre, dann hätte ich das nicht tun müssen, aber am Ende einer
ersten Standardoperation werden
wir anfangen, mit
den tatsächlichen Feldern zu
interagieren , die
sich im Objekt befinden Deshalb kann das
Ano-Tracking einfach nicht
nach dieser Aussage kommen Also müssen wir
dem DB-Kontext
, der in die Teamtabelle schaut, mitteilen , dass die Elemente
nicht verfolgt, aber ich will den ersten
, der diese Bedingung erfüllt. Das ist die Aussage.
Nun, der wahre Vorteil Nichtverfolgung besteht darin
, dass Speicherplatz etwas
mehr freigegeben wird und die
Leistung beschleunigt wird, denn Sie können sich vorstellen, dass FCR
100 Datensätze überwachen muss, wenn
Sie 100 Datensätze abrufen , alle mit Tracking, können sich vorstellen, dass FCR
100 Datensätze überwachen muss, wenn
Sie 100 Datensätze abrufen, alle mit Tracking,
dann
muss FCR 100 Datensätze überwachen, und das nur auf eine Anfrage Was passiert mit all den
Hunderten von Datensätzen, mit denen Sie möglicherweise im System jonglieren,
richtig Dann muss
die FCR-Engine also im Laufe der Zeit arbeiten, um all
diese Daten ständig zu
verfolgen Also in einer einfachen Operation, wie wenn Sie
vielleicht nur die Liste lesen, als würden Sie Ihrem Benutzer Dinge in
der Datenbank auflisten Sie können immer einfach
sagen, kein Tracking , weil Sie kein Tracking durchführen müssen. Dinge, die in einer
einfachen Liste stehen, oder? Zu dem Zeitpunkt jedoch,
wenn Sie im Begriff sind, eine Änderung
vorzunehmen und
eine Aussage wie diese machen, dann ja, das Tracking
wird da sein. Du machst weiter und entfernst
es oder sogar im Update wäre
das Tracking
nach dem Fund verfügbar, wäre
das Tracking
nach dem Fund verfügbar sodass es uns leid tun könnte, das ist eine falsche Methode,
sodass wir,
los geht's, die Änderung vornehmen könnten , und dann wird es in dem Moment nachverfolgt , um gespeichert zu werden, oder? Aber bei großen
Lesevorgängen können
Sie das
Ano-Tracking immer verwenden, um
die Aufmerksamkeit zu reduzieren , die FCR jedem
abgerufenen Datensatz
widmen muss jedem
abgerufenen Datensatz
widmen Was ich nach dem
Abrufen mit
und ohne Tracking getan habe , ist, dass
ich Änderungen an
ihren jeweiligen Namen vorgenommen habe Dann werde ich Ihnen zeigen , dass wir uns die Einträge tatsächlich
ansehen können Wir haben also dieses Ding namens Change Tracker als
Teil des Kontextes, das uns im Grunde nur
Informationen
darüber zeigt , welche Entität verfolgt
wird, welchem Status sie sich unmittelbar
vor den Speicheränderungen befindet, und dann werden wir
es
uns nach dem Speichern noch einmal ansehen . Ich habe das nur vorsichtshalber gemacht, aber ich bin mir sicher, dass es danach
trotzdem aktualisiert wird danach
trotzdem aktualisiert Aber wir werden sehen. Alles klar. Also lass uns weitermachen und ausführen. Ich habe in der Zeile zum Speichern
der Änderungen einen Breakpoint gesetzt und die
Variablen sind in der Uhr. Ich habe also die Einträge
vor dem Speichern und nach dem Speichern. Wenn ich mir also vor dem Speichern
die Einträge anschaue, erhalte ich
die Ergebnisansicht
und es wird mir angezeigt, dass nur einer der Datensätze,
die es verfolgt
, geändert wurde, oder? Wenn ich also expandiere, werden Sie sehen, dass der
Entitätsstatus hier geändert wurde. Wir haben tatsächlich einige
Aufzählungen von FCR erhalten, wo wir
Entitätsstatus Punkt sagen können und Sie haben geändert,
hinzugefügt Alles, was
in einem groben Kontext so ziemlich möglich
wäre, wir können sagen, welche
Änderung
gespeichert werden soll oder
in welchem Zustand sie sich befindet , kurz bevor sie gespeichert werden soll Wir sehen hier, dass sich der
Datensatz mit der ID zwei in einem modifizierten Zustand
befindet. Datensatz mit der ID zwei war der, den wir mit Trucking
abgerufen haben Wir haben die Änderung vorgenommen, und kurz vor dem Speichern
wird festgestellt, dass
es die einzige
ist, die gespeichert werden muss, da wir den
Datensatz mit der ID acht nicht verfolgt
haben Also egal, welche
Änderung wir daran vorgenommen haben, es ist einfach egal. Das wäre also das Szenario, das uns zu dieser Situation
gebracht hat, in der
wir den Rekord haben würden, wir wissen alles
über den Rekord, aber dann müssen wir dem Kontext
sagen, dass dieses Team oder dieser Datensatz aktualisiert werden
muss,
und dann wird es
anfangen, ihn zu verfolgen. Solange es hier war,
wurde es also nicht verfolgt. Dieses Objekt befindet sich im gleichen
Zustand wie dieses Objekt, nur dass es nicht von EFC verfolgt wird Wenn wir jedoch
die Anweisung zur manuellen Aktualisierung
für ohne Nachverfolgung eingeben würden , würde es, es hier eintrifft, wenn es hier eintrifft,
auch als
modifizierter Datensatz aufgeführt, der gespeichert werden muss Ordnung. Also werde
ich einfach diesen
Schritt hinter und dann zwei weitere Schritte ausführen, damit wir Einträge nach dem Speichern
und Einträge nach dem Speichern
sehen können . Jetzt
verfolgt es nur noch die Tatsache, dass es diesen Eintrag vor dem Speichern hatte
. Nein, es befindet sich in einem unveränderten Zustand. Nachdem wir die Änderungen gespeichert haben, werden
sie also von dem
Zustand, in dem sie sich befanden hinzugefügt, gelöscht oder geändert wurden, verschoben
und sie werden in
einen unveränderten Zustand versetzt. Das bedeutet also, dass Entity Framework es immer noch verfolgt, oder? Sobald es
hier in den Einträgen aufgeführt ist, bedeutet
das, dass es verfolgt wird. Es kann also vorkommen
, dass Sie auf Parallelitätsprobleme
stoßen,
wenn Sie vielleicht
einen Vorgang ausführen Parallelitätsprobleme
stoßen wenn Sie vielleicht und dann
die Änderungen am Datensatz speichern
und dann wahrscheinlich
direkt danach erneut versuchen, ihn zu bearbeiten, und dann
erhalten Sie möglicherweise eine Fehlermeldung dass dies bereits von EF Course
verfolgt wird Das ist also eine
dieser Situationen. Also manchmal müssen Sie dafür
sorgen, dass es nicht mehr verfolgt werden kann, aber wir werden
nicht auf dieses Ausmaß Komplikationen eingehen,
zumindest nicht jetzt Im Moment
wollen wir uns nur darauf konzentrieren, was Tracking
anders macht als kein Tracking Wie ich schon sagte, in
einem Szenario, in dem Sie Daten nur für
Lesezwecke benötigen, dann ist das Fehlen von Tracking ein sehr effizientes
Szenario für Sie. Okay.
19. Ein--: Hallo, Leute, willkommen
zurück in dieser Lektion. Wir möchten kurz unsere
Eins-zu-Viele-Beziehung
überprüfen und herausfinden,
wie FCR uns das Leben erleichtert, wenn es darum geht, diese
Art von Beziehung zu definieren und uns die Interaktion
mit verwandten Datensätzen zu ermöglichen Nur zur Zusammenfassung Wir haben unsere Ligatabelle als dieses Datenmodell
definiert, und wir haben unsere Mannschaftstabelle auf der rechten
Seite definiert Wir wissen also, dass FCO anhand
unserer Namenskonvention zunächst den Schluss
ziehen konnte, dass zwischen diesen beiden eine
Fremdschlüsselbeziehung bestand Was ist diese Namenskonvention? Nun, zunächst
hätte ich angegeben, dass der Feldname
Liga-ID ist. In Ordnung. Also haben wir die Tabelle mit dem Namen
League und den Fremdschlüssel. Allein durch den Namen League ID wurde
daraus geschlossen, dass es eine
Fremdschlüsselbeziehung gibt Nur als Beispiel Wenn ich
diese
virtuelle Navigationseigenschaft nicht mit einbeziehen würde, würde das System trotzdem wissen, dass
es einen
Fremdschlüssel gibt, allein aufgrund der Namenskonvention , die ich
an dieser Stelle verwendet habe Nun, aufgrund des verwendeten
Datentyps verwende
ich t und t kann
standardmäßig nicht Null sein. Sie würden also erkennen,
dass die
generierte Migration einen Nullwert haben würde Hier war die
League-ID die Spalte
und ein Nullzeichen fällt, was bedeutet, dass sie in der Datenbank nicht
Null sein darf Nun, C Sharp unterstützt
nullfähige Datentypen. Wenn ich das mit einem Fragezeichen sagen würde, dann wäre das
automatisch nullwertfähig Also werde ich nur zur Veranschaulichung
eine Migration durchführen. Das ist also unsere Migration, die
Migration hat die
Liga-ID auf Null gesetzt. Und dann sieht
es in dieser
neuen Migrationsdatei irgendwie anders
aus als in der vorherigen, und wir werden weitere Migrationen
durchführen Ich konzentriere mich also noch nicht auf das, was
wir gerade betrachten. Ich möchte nur hervorheben, dass der Alter-Spalte jetzt angezeigt wird ,
dass nullable gleich true
ist, und das
alles nur, weil wir
dieses Fragezeichen gesetzt haben Ich meine, wenn Sie
den Datentyp nullwertfähig machen, dann weiß
FCR, dass
er
in SQL null ist oder dass es wahr sein sollte Es heißt also, dass der neue Typ des
alten Typs TS ist,
aber jetzt ist er nullwertfähig aber Das ist also eine
der Möglichkeiten, wie wir
einen Fremdschlüssel nullwertfähig machen können Warum sollten Sie also einen Fremdschlüssel in die Lage
versetzen wollen? In einer Situation wie dieser kannst du
vielleicht ein
Team ohne Liga haben. Später
fügen wir also weitere Tische hinzu, eine der Tabellen, die wir hinzufügen
werden, ist ein Trainer, ein Trainer kann ein Trainer sein. Nun, technisch gesehen
kann ein Coach auch ohne
Team Trainer sein , weil ich von
Beruf Trainer bin, aber ich habe momentan kein
Team-Coaching. Ich bin also in der Trainertabelle, aber ich habe einfach kein Team. Zu diesem Zeitpunkt müsste
diese
Team-ID also Null sein, wenn ich zu diesem Zeitpunkt nicht in einem Team
angestellt bin . Das ist also nur ein kurzes Beispiel , das wir uns später ansehen werden. Aber vorerst möchte
ich mich nur auf die Tatsache konzentrieren, dass
wir diesen Fremdschlüssel auf Null setzen können. Nun, zurück zu
unserem Team, dem Datenmodell, habe
ich eine geringfügige Anpassung vorgenommen,
bei der ich
die Ganzzahl für den Fremdschlüssel entfernt die Ganzzahl für den Fremdschlüssel und sie
nur durch die Navigationseigenschaft ersetzt habe Das wird auch versuchen, ein lesbares Fremdschlüsselfeld zu
generieren Das einzige Problem dabei ist, dass
das Fremdschlüsselfeld zwar in
der Datenbank generiert
wird , ohne dass
die Eigenschaft in der Klasse enthalten ist, es gibt keine Möglichkeit,
diesen Integer-Wert tatsächlich abzurufen oder
mit diesem ID-Wert zu interagieren, oder? Deshalb ist es für mich einfach, das Leben einfacher
zu machen, es ist einfach am besten, mit beiden zu
interagieren. Nun, ich habe das bekannt gemacht, aber ich
möchte diese Kette nicht unbedingt beibehalten Also werde ich in der Paketmanager-Konsole
die Migration entfernen Das haben wir wahrscheinlich schon früher gesehen,
als
wir uns alle Optionen oder alle Befehle angesehen haben
, die wir ausführen können. Um diese Aktion auszuführen, heißt
es, sie ist genau
hier, entfernen Sie die Migration. Beim Entfernen der Migration
wird also immer versucht, die letzte oder die zuletzt
durchgeführte Migration zu
entfernen. Da ist also unsere
letzte Migration. Ich kann einfach sagen, Migration entfernen, und die Datei wird gelöscht. Bitte beachten Sie jedoch, dass
wenn sie sagen, es zurückgesetzt wurde und es
alles tut, von dem es
weiß, dass es nötig ist Die einzige Sache
ist jedoch, dass die Migration etwas schwieriger wird
, wenn Sie
die Migration bereits
in die Datenbank übernommen haben , wenn Sie
die Migration bereits
in die Datenbank und ich sie entfernt habe Aber das ist etwas, das
wir uns auch ansehen werden, also machen Sie sich
darüber noch keine Gedanken Nun, eine weitere Sache, auf die ich bei
diesen Beziehungen mit Fremdschlüsseln hinweisen
möchte diesen Beziehungen mit Fremdschlüsseln ist die Tatsache, dass
ich auf
der Liga-Seite eine Immobilie hinzufügen kann, die
eine Sammlung von Objekten ist, von
denen ich weiß, dass sie miteinander verwandt sind. Als wir
die Datenbank auf die Beine gestellt haben, haben
Sie wahrscheinlich zur
Kenntnis genommen, dass es in
der Liga eine Sammlung Sie wahrscheinlich zur
Kenntnis genommen, dass es in
der gibt, und zwar eine
Sammlung Das kann also eine Sammlung sein. Es kann aufzählbar sein,
es könnte eine Liste sein. Es liegt wirklich an Ihnen, aber wir schließen daraus einfach, dass es sich um eine
Sammlung von Teamrechten Und ich nenne es einfach
Teams, das heißt, dass die Liga automatisch
auf die Liste der
Teams zugreifen kann automatisch
auf die Liste der
Teams zugreifen , die mit ihr verwandt sind.
Also denk mal drüber nach. Im Allgemeinen, wenn du
die Liga und dann
alle Teams in der Liga willst die Liga und dann
alle Teams in der Liga , müsstest
du die Liga vielleicht anhand der
ID finden und dann
die Mannschaftstabelle kuratieren
, um zu sagen,
gib mir alle Teams mit
der Liga-ID, richtig Oder du bekommst einfach alle
Teams mit der Liga-ID, aber dann musst du dich in der
Ligatabelle zusammenschließen , um
die
Details der Liga zu erhalten , in der sie
spielen Also machen wir das schon, weil ich
, wenn
ich mit der Mannschaft zusammen bin, die Details der Liga herausfinden kann, in
der die Mannschaft involviert
ist Das werden wir uns später ansehen. Richtig? Aber wenn ich nur
diesen Sammeltyp hier eintrage, kann
ich sagen, gib mir
die Liga mit der ersten
ID und füge
alle Teams hinzu. Also automatisch erhalte ich die Liga, ich
erhalte den Namen
und ich erhalte alle
2030 Teams, die mit der
Liga verknüpft
sind, alles in einem Objekt. Das ist also ein weiterer Vorteil. Also werde ich diese Eigenschaft
hinzufügen und sie dabei belassen. Sie können dasselbe
in Ihrem Modell tun. Und das Letzte, worauf ich wirklich hinweisen
möchte, ist, dass ich noch einmal betonen
möchte, wie wichtig es die
Namenskonventionen einzuhalten Wenn Sie sich nicht an
die Namenskonventionen halten, kämpfen
Sie tatsächlich
gegen ein System , das
Ihnen helfen soll, die Dinge besser zu machen In dieser speziellen Situation beziehe
ich mich also auf
den Fremdschlüssel. Schöpfung, weil Sie vielleicht
andere Ideen haben , wie Sie diese
Fremdschlüsselspalte nennen
möchten. Und ich werde nicht nein sagen. Ihre Geschäftsregeln erfordern
möglicherweise, dass
Sie einen anderen Spaltennamen verwenden. Aber dann wird es
schwierig, denn wenn ich diese Liga FK nennen wollte, und ich weiß, dass
das einen anderen Code
knacken würde , den ich an anderen Orten
habe. Aber wenn ich das tun würde,
würde beim
Ausführen der Migration immer noch eine Spalte mit dem Namen
League ID
generiert werden, weil FC seiner eigenen Konvention
folgt, und dann wird
das eine zufällige Spalte sein. Eine zufällige Spalte namens
League FK, die
absolut nichts
mit dem Fremdschlüssel zu tun hat absolut nichts
mit dem Fremdschlüssel Also noch einmal, ich
möchte nur wiederholen diese
Namenskonventionen, dann wird das Leben für euch
viel einfacher sein In der nächsten Lektion werden
wir uns nun mit der
Viele-zu-Viele-Beziehung befassen, und ich werde mich eingehender mit
einigen
der großartigen Dinge befassen , die FCR für Sie tun kann
20. Many-To-Many viele Beziehungen hinzufügen: Hey, Leute, willkommen
zurück. In dieser Lektion wollen
wir anfangen, uns
viele zu viele Beziehungen anzusehen. Bei der Definition von
Viele-zu-Viele-Beziehungen
liegen nun viele naja,
viele Datensätze vor, sich
auf
viele Datensätze beziehen In unserem Kontext
unserer Fußball-App
oder Fußballdatenbank müssen
wir die Tatsache
berücksichtigen,
dass es viele
Spiele zwischen vielen Mannschaften geben wird So viele Teams werden im Laufe einer Saison gegen
viele andere Teams spielen . Ich habe auf dem Bildschirm eine nette
nützliche App namens Raw Dot IO. Es ist eine Web-App und die Nutzung ist
völlig kostenlos. Und wir werden
unsere Datenstruktur
visualisieren Also werde ich einfach
Rechtecke verwenden, nett und einfach, und ich werde das eine Liga
nennen und wir werden dieses eine
Team nennen Wir wissen also, dass wir
Ligen haben, die sich auf Teams beziehen. Schön und einfach, sie einfach mit
einem R zu verbinden. Alles klar? Also haben wir eine
Liga und wir haben ein Team. Nein, ich brauche eine neue
Einheit in der Mischung, und ich werde sie Mach
nennen. Jetzt wird
ein Match zusammengesetzt, und ich werde nur die Felder und die Entitäten
ausschreiben . Wir wissen schon, was
in der Liga und im Team ist, aber dieses
Spiel wird eine ID haben. Natürlich. Es wird
auch eine Heim- und eine Auswärtsmannschaft geben. Wir können nein sagen, ich weiche
irgendwie von der Namenskonvention
ab, oder? Also Heimmannschaft, Auswärtsmannschaft, und wir werden
wahrscheinlich Zeit haben. Wie ich schon sagte, wir werden am
Ende dieselbe Heimmannschaft haben, dieselbe Mannschaft wird
mehrmals
Heimmannschaft sein und dieselbe Mannschaft wird mehrmals
Auswärtsmannschaft sein, aber sie
treten gegeneinander an. Diese
Viel-zu-Viele-Beziehung benötigt also wirklich das,
was wir eine Linkertabelle
nennen . Das ist eine Tabelle
, die zwischen
den beiden
verwandten Tabellen platziert wird die zwischen
den beiden
verwandten Tabellen In dieser speziellen
Situation ist
das Viel-zu-Viel-Problem jedoch wirklich eine Angelegenheit zwischen vielen Teams
und vielen Teams Das heißt, wir haben Team, das zweimal mit dieser Tabelle
zu tun hat.
Also, verzeihen Sie mir, wenn Sie neu
in der Datenbankentwicklung sind, aber so ist das halt. Manchmal hat man
zwei Fremdschlüssel für dieselbe Tabelle aus
einer anderen Tabelle, richtig? Eine Tabelle hat hier also zwei
Fremdschlüssel. Wir haben einen Fremdschlüssel
für die Heimmannschaft, aber einen
Fremdschlüssel für die Auswärtsmannschaft. Aber das heißt
wirklich, dass viele Teams mit
vielen Teams verwandt sind, viele zu vielen. Ordnung. In Ordnung. Nachdem ich nun
visualisiert habe, wie
diese Datenbankstruktur und diese neue Tabelle aussehen müssen diese Datenbankstruktur , können
wir
die Modelle dafür erstellen Also habe ich weitergemacht und
eine brandneue Klasse erstellt , die
ich Match nennen werde Und genau wie ihre Gegenstücke wird sie
bestimmte Namenskonventionen haben Bevor ich weitermache, möchte ich
nur darauf hinweisen, dass jede einzelne Tabelle oder jedes
Modell grundsätzlich diese ID hat Und dann gibt es Zeiten
, in denen Sie
mehrere Felder haben , die sich wahrscheinlich in allen Tabellen
wiederholen, wie vielleicht, wenn Sie Audits
durchführen oder, wissen
Sie, Sie haben ein Erstellungsdatum, diese Art von Feldern, die vielleicht jeder
haben muss, weil offensichtlich alle unsere Felder, nach
derselben Konvention, all unsere Tabellen, tut mir leid, wir haben ein Feld namens ID. Nun, ich möchte das nicht in jeder
einzelnen Zeile
wiederholen, denn, wissen Sie, wenn wir 20 Tabellen haben, dann sind
das 20 Kopien derselben Codezeile. Ich neige also dazu, etwas
hinzuzufügen, was ich nenne, lass es mich Come on nennen, und dann füge ich innerhalb von come
on
eine Klasse hinzu, die ich Base
Domain Object nenne. Das ist auch keine
Namenskonvention. Ich nenne es einfach
Basisdomänenobjekt. Die Leute nennen es
basiertes Datenobjekt, Leute nennen es
Basisobjekt, was auch immer es ist. Aber das wird wirklich
nur
eine öffentliche abstrakte Klasse sein . Ich mache es nur abstrakt,
denn wenn es abstrakt ist, kann
ich
es nicht von selbst instanziieren Es ist wirklich ausfallsicher für mich, muss es
aber nicht
unbedingt sein Aber ich nehme
diese ID-Eigenschaft, platziere sie innerhalb des
Basisdomänenobjekts, und dann
kann jede andere Entität vom
Basisdomänenobjekt erben Auf diese Weise
muss ich die Felder nicht unbedingt wiederholen Wenn sich der Feldname ändert, zumindest die gemeinsamen
Felder für alle, muss
ich
die Aktualisierung nur an einer Stelle vornehmen, aber jeder erbt
von diesem einen Ort, sodass jeder das Feld erhält Ordnung, also werde ich
das
einfach für viel tun . Also kein Spiel. Hat standardmäßig ein ID-Feldteam. Und ich werde es nicht aus dem Team
entfernen, aber ich werde es dem Team erben
lassen Und dann
werden Sie jetzt feststellen, dass es
anfangen
wird, sich darüber zu beschweren, dass
es die ID
sowohl hier als auch in der geerbten Klasse sieht Das bedeutet, dass ich die ID sicher aus dieser Klasse
entfernen kann. Das ist also nur ein kleiner Trick , den Sie, wenn Sie noch nicht
üben, können, um
sicherzustellen, dass Sie den Code nicht zu oft
wiederholen. Alles klar? Also lass uns weitermachen. Wir
haben die Match-ID. Jetzt brauche ich eine Immobilie, die meine Heimmannschaft
repräsentiert. Ich nenne
es Heimteam-ID. Das ist wieder einmal ein Bruch mit der Namenskonvention. Im vorherigen Video hätte
ich erwähnt, wie wichtig
Namenskonventionen sind. Aber es gibt Situationen in denen man
die Namenskonvention
einfach nicht einhalten kann ,
denn wenn ich die ID der
Heimmannschaft und der Auswärtsmannschaft anrufe , weiß
CR es nicht oder es wird
nicht dass das bedeutet, dass ich mich auf die
Mannschaft beziehe und das bedeutet, dass
ich mich auf die Mannschaft beziehe Wir werden gleich sehen, wie wir
damit umgehen können. In Ordnung. Also habe ich nur die
restlichen Eigenschaften hinzugefügt, ich habe die
Navigationseigenschaften hinzugefügt, die jedem Fremdschlüssel
entsprechen. Wir haben also einen Fremdschlüssel, wir haben einen Fremdschlüssel und
dann habe ich das Datum und die Uhrzeit. Also habe ich auf Datum
statt Uhrzeit umgestellt , weil Datum und Uhrzeit
erfassen können. Wir werden also das Datum
und die Uhrzeit des Spiels kennen im
Gegensatz zu meinem ursprünglichen
Design, in dem nur die Uhrzeit angegeben war. Jetzt haben wir diese neue
Klasse oder dieses neue Modell definiert. Wir wissen, dass wir
den DB-Kontext erweitern müssen . Wir
müssen es wissen lassen. Ich werde das einfach
duplizieren und
das neue Modell zum DB-Set hinzufügen und ich nenne es Matches. Aber ich muss
etwas extra tun. Also habe ich mich erneut von den empfohlenen
Namenskonventionen gelöst. Ich muss etwas zusätzliche Arbeit leisten
, um es wissen zu lassen, dass hey, du ein Fremdschlüssel
sein solltest. Lassen Sie uns also
das Teammodell so anpassen , es weiß, dass es zwei Listen haben
sollte, eine Liste namens Heimspiele und eine Liste namens Auswärtsspiele. Denken Sie jetzt daran, dass wir
etwas Ähnliches für eine Liga gemacht haben. Wir haben ein Team, das sich auf
die Ligatabelle bezieht. Wir wissen also, dass eine Mannschaft einer Liga
angehört. Eine Liga
hat jedoch mehrere Teams. die gleiche Weise kann ein Spiel also Heimmannschaft
und eine Auswärtsmannschaft
haben. Also eins, eins, eins nach dem anderen
für einen beliebigen Rekord oder eine Reihe. Aber dann
kann eine Mannschaft viele Auswärts
- und Heimspiele haben. Deshalb müssen
wir sicherstellen, dass wir diese Eigenschaften für die Listennavigation angeben. Darauf aufbauend müssen
wir Entity Framework darüber
informieren , dass all diese Verkabelung bedeutet, dass es eine
wichtige Beziehung zwischen Team und Spiel gibt. Bis jetzt war uns das alles natürlich immer noch nicht bewusst Ich werde also damit beginnen
, unsere Methode zur
Modellerstellung zu überschreiben Also haben wir die Konfiguration. Das heißt, wann immer
Sie
den Kontext einrichten , sollten Sie
Folgendes tun. Nun, das heißt,
wann immer Sie das Modell
erstellen
oder eine Migration durchführen, Sie
bei
der nächsten Migration
sicher, stellen Sie
bei
der nächsten Migration
sicher, dass Sie diese
Regeln haben. In Ordnung? Also nicht, dass bei jeder Migration der Code für diese wiederholt
wird, aber es bedeutet einfach, dass ich immer, wenn
Sie
die Datenbank aufbauen und
mit der Datenbank umgehen, genau das tun wollte. Dafür ist diese Methode
also wirklich da. Also werde ich
diese Standardzeile entfernen, und dann müssen wir dem
Model Builder
mitteilen, dass es
sich um unsere Entität handelt. verwenden wir die Fluent-API An dieser Stelle verwenden wir die Fluent-API, um bestimmte Regeln zu
definieren, und Sie werden sehen, warum sie Fluent-API
genannt wird Also unsere Einheit heißt Team, und dann
breche ich nur die Grenze, damit wir
nicht zu weit gehen Also sagen wir Punkt, und dann werden Sie hier
eine Menge Optionen sehen. Jetzt habe ich mich
hinreißen lassen und
jede Kombination ausprobiert, aber nicht jede Kombination
funktioniert wirklich. Also musst du einfach
irgendwie wissen, was du tust. Also in dieser Situation
möchte ich sagen, dass mein Team viele
hat. In Ordnung. Und dann definieren wir einfach
einen Lambda-Ausdruck, Punkt, und ich sage Heimspiele Eine Mannschaft wird
viele Heimspiele haben. Das ist wahr. Dann gehen wir mit einem
zur nächsten Zeile. Was wir
an dieser Stelle folgern werden, nein,
ist, dass Sie
viele Heimspiele mit einem Punkt haben werden , und dann sehen wir
Eigenschaften von
den Heimspielen oder von der Match-Entität, sehen Sie das Deshalb ist es
fließend, weil jede Zeile
auf der vorherigen Zeile basiert Eine Mannschaft hat also viele Heimspiele, und dann hat die ganzen Spiele oder ein ganzes Spiel in einem
Spiel nur eines, und ich werde sagen, wenn ich es mit Heimspielen zu
tun habe, dann hat es nur eine Heimmannschaft Stimmt das? Und dann muss ich ihm
das sagen und es hat wieder
einen
Fremdschlüssel-Lambda-Ausdruck, M-Punkt,
und dann kann ich angeben, und dann kann ich angeben welcher Fremdschlüssel das
ermöglicht, das hat viele mit einer Beziehung
, von der ich ihm erzähle Ich werde sagen, dass der
Fremdschlüssel die ID der Heimmannschaft ist. Und ich hoffe, dass Sie
langsam erkennen, dass Sie Ihre Kolumnen richtig
benennen. Wenn es FCR nicht helfen kann,
herauszufinden, was Sie wollen, hilft
es Ihnen, herauszufinden,
was Sie später tun müssen Ich werde auch eine Einschränkung
hinzufügen um zu sagen, dass sie erforderlich ist, und zum Abschluss werde ich das Verhalten beim Wiederherstellen definieren. Wir haben
das Undelete-Verhalten bereits besprochen da wir wissen, dass es sich um eine
Konfiguration für die Datenbank Ich werde Cascade sagen. Das heißt, wenn ich ein Team lösche, möchte
ich, dass alle Spiele
dazugehören Vielleicht möchtest du das
tun oder auch nicht , denn vielleicht möchtest
du
für die Archive die Mannschaft
und alle Spieldaten behalten . Das hängt natürlich von Ihnen und Ihren
Geschäftsregeln ab. Also werde ich das alles für das
Auswärtsteam wiederholen . Und du wirst sehen, dass
beide identisch sind. Der einzige Unterschied besteht wirklich darin
, dass ich Spiele und
Auswärtskolumnen dort platziert habe, wo
sie die Startspalten waren. Und das ist
so ziemlich alles, um
die Regeln für so viele
zu viele Beziehungen zu definieren . Es gibt also
einige Male, in denen Sie sich
möglicherweise die
Hände schmutzig machen müssen. In dieser Situation ist
es sehr einzigartig,
weil wir erstens bei unseren Fremdschlüsseln nicht der Benennungskonvention
folgen, und zweitens ist es dieselbe Tabelle, die zweimal auf eine andere Tabelle
bezieht. In einer anderen Situation,
und sagen wir, ich werde Ihnen hier nur
ein offenes Szenario vorstellen. Wir hatten einen Tisch, um die Produkte
aufzubewahren. Wir hatten einen Tisch, an dem Kunden
aufbewahrt wurden, und dann haben wir
einen weiteren Tisch, an dem die Produkte
aufbewahrt wurden, die die
Kunden bestellt haben. So viele Kunden können viele Produkte
bestellen. Diese mittlere
Tabelle muss also die Kunden-ID und
die Produkt-ID enthalten. Ordnung? Denk
über das Szenario nach. In diesem Szenario ist es
eine nette, saubere Beziehung. Es ist einfacher, eine Beziehung zu definieren als das, was
wir hier tun mussten. Und dann müssen
Sie in dieser
Situation wirklich nur die Eigenschaft
Listennavigation in eine
der beiden Tabellen einfügen . Und dann würde FCR einfach
daraus schließen, dass
eine Kundenprodukttabelle generiert werden muss Entschuldigung, ich habe gerade damit angefangen, aber es sollte
zum Beispiel eine Tabelle mit
Kundenproduktbestellungen erstellt werden, weil Sie ihr
gerade gesagt haben, dass der Kunde eine Produktliste haben
würde
und Produkte eine Kundenliste haben würden Es wird also
automatisch wissen, dass ich eine mittlere
Tabelle für so viele zu viele erstellen muss, und es wären buchstäblich
viele, wenn die Liste zu viel wäre. Es gibt also verschiedene
Szenarien und jedes Szenario kann seine
eigenen Macken Das ist die Eigenart eines Szenarios, und ich denke, es ist gut das schwierigere Szenario zu spielen, weil Sie
zumindest sehen können, was möglicherweise vorhanden
sein muss, falls Sie auf Schwierigkeiten stoßen und Ihr Szenario nicht
so einfach ist, wie es sein könnte nun, nach all dem, was
gesagt und getan Lassen Sie uns nun, nach all dem, was
gesagt und getan ist, unsere
Migration durchführen und sehen, was wir bekommen Das ist also unsere Migrationsdatei. Es erstellt die
Tabelle namens Matches. Wir haben unsere Spalten
definiert
und dann haben wir die Einschränkungen, die dem Team auferlegt
werden
, die auf unsere Beziehungen in anderen
Schlüsselbereichen hinweisen, richtig? Fremdschlüssel Nummer
eins steht also zwischen
der Spalte AA Team
und er ist zwischen den Teams und dieser ID
und löscht die Kaskade, und
für die Heimmannschaft ist es genauso Ordnung. Nachdem das
alles erledigt ist, lassen Sie uns unsere
Datenbank aktualisieren. In Ordnung. Also, wenn du deine Datenbank aktualisiert
hättest, so wie ich es gerade getan habe, dann hättest du diesen Fehler
bekommen. Wenn nicht, dann schreib
mir eine Nachricht und lass mich
wissen, dass du es nicht getan hast. Aber diese Nachricht kam gerade auf, und wie ich schon sagte, ich werde
Fehler nicht meiden , denn
solche
Dinge machen den Leuten Angst vor dieser Art
von Technologie Es sagt uns also, dass es den
DB-Befehl, die Tabelle erstellen,
nicht ausgeführt Und wenn ich ganz nach unten scrolle, heißt es,
ich führe eine Einschränkung ein
oder führe diese Einschränkung ein , kann zu mehreren Zyklen oder
mehreren
kaskadierenden Pfaden führen Zyklen oder
mehreren
kaskadierenden Pfaden Mit anderen Worten, es bedeutet, dass es für die Datenbankstruktur
problematisch sein kann,
wenn diese Referenz die
Löschaktion für diese beiden Fremdschlüssel kaskadiert diese Referenz die
Löschaktion für diese beiden Fremdschlüssel kaskadiert die Datenbank manuell entwerfen, könnten
Sie das vielleicht umgehen,
weil ich noch nie
direkt von SQL Server vor so könnten
Sie das vielleicht umgehen,
weil ich noch nie etwas gewarnt
wurde ,
aber FCR lässt
Sie nur wissen, dass das
problematisch sein kann, und es ist problematisch sein kann, und es ein Fehler aufgetreten, wenn versucht wird, das für Sie zu
tun Was wir also tun können und was wir tun
werden, ist,
diese Migration einfach zu entfernen,
und auf Vorschlag von EFC , dass dieses
Löschverhalten problematisch ist, werde
ich einfach eine Einschränkung vornehmen Mit anderen Worten,
Sie können
ein Team nur entfernen , wenn Sie zuvor alle Spiele entfernt
haben .
In Ordnung. Und ich verstehe, wo das
vernünftig ist, denn als
ich vorhin gesagt habe, dass man ein Team
löscht, werden automatisch die Spiele
gelöscht, die problematisch sein
könnten, oder? Und vor allem, wenn
ein Team auf
der Heimmannschafts-ID
oder der A-Team-ID stehen könnte der Heimmannschafts-ID
oder der A-Team-ID Und dann, wissen Sie, wird
das dazu führen, dass Daten für Teams
gelöscht
werden, die sich noch im System befinden. Das war also eine schlechte
Designentscheidung meinerseits. Kein Problem. I R hat uns gewarnt,
aber
ich möchte Ihnen noch einmal helfen zu verstehen, was dieser
Fehler wirklich bedeutet. Wenn Sie also sehen, dass ein
solcher Fehler auftritt,
liegt das vielleicht daran, dass wir das
Löschverhalten ändern
müssen. Denken Sie daran, dass es standardmäßig kaskadiert wird. Selbst wenn wir hier nicht Cascade
definiert hätten
, wäre dieser Fehler wahrscheinlich
trotzdem aufgetreten Daher ist es wichtig zu
verstehen, wie Sie diesen
Fehler beheben können, falls Lassen Sie uns also versuchen,
diese Migration erneut hinzuzufügen. Und dieses Mal sehen Sie
, dass es eingeschränkt ist. Das ist in Ordnung. Lassen Sie uns
die Datenbank aktualisieren. Und dieses Mal, wenn ich
fertig bin und es mir
in unserem SQL Object
Server Explorer ansehe , sehen
wir, dass wir
unsere ID und
unsere beiden Fremdschlüsselspalten haben , die nicht lesbar sind Das ist eine Möglichkeit, eine Beziehung von Minute
zu Minute
aufzubauen Wie ich schon sagte, es kann
je nach Ihrer Situation unterschiedlich sein. Angesichts der Struktur
der Datenbank mussten wir genau das tun,
um all dies zu erreichen. Dies sind natürlich allgemeine
Richtlinien. Wenn Sie Ihre
Viele-zu-Viele-Beziehung aufbauen, können
Sie sich grundsätzlich an
diese Richtlinien halten , und
Sie können sie erstellen, egal wie kompliziert oder
einfach sie auch sein mag.
21. Adding: Hallo Leute, wir kommen in dieser Lektion
zurück, wir werden über Eins-zu-Eins-Tabellenzuordnungen oder
Eins-zu-Eins-Beziehungen sprechen Eins-zu-Eins-Tabellenzuordnungen oder
Eins-zu-Eins-Beziehungen Ich habe also bereits ein neues Entitätsmodell
erstellt, und wir rufen einen Trainer an, und ein Coach
wird verwendet, um
das Einzelgespräch mit einem Team darzustellen ,
weil in unserer Situation, in unserer Datenbank, ein Trainer jeweils nur
einem Team angehören
kann,
und natürlich einem und natürlich Hat einen Trainer, oder? Aber wenn der Trainer morgen gefeuert
wird, dann sagen wir einfach
, das Team hat vielleicht
keinen Trainer und dieser Trainer
hat vielleicht kein Team. Also, wissen Sie, diese Art von einzigartigen
Geschäftsregeln oder Einschränkungen können die Regeln bestimmen, die wir eingeben, oder unser
Datenbankdesign. Lassen Sie uns also weitermachen. Wir haben bereits, dass der
Coach vom
Basisdomänenobjekt erbt, wie gesagt, Basisdomänenobjekt stellt das
Basisdomänenobjekt stellt diese ID-Eigenschaft standardmäßig zur Verfügung, sodass wir uns auf
all die anderen Eigenschaften konzentrieren können all die anderen Eigenschaften , die für
den Coach einzigartiger sind Die erste Eigenschaft
für einen Coach ist also, wie Sie wahrscheinlich
vermutet haben, der Name Nun, ich werde nicht zu
kompliziert mit der Datenbank, aber wir wissen, dass wir einen Coach haben, ein Coach wird einen Namen haben An dieser Stelle werde ich
keine weiteren
Details zu diesem Trainer angeben. Aber ich werde die Tatsache mit einbeziehen, dass dieser Trainer eine
Eigenschaft namens Team-ID hat. Diese Team-ID
wird also, wie
der Name schon sagt, der
Fremdschlüssel zur Teamtabelle sein. Jetzt muss unser
Team oder die Tabelle unserer Mannschaft in gewisser Weise
einen Trainer repräsentieren. Und was ich hier
tun werde, um es
ganz einfach zu halten , ist, nur den Trainer zu
referenzieren. Also einfach so, der Trainer wird Teil
einer Mannschaft sein oder, du weißt schon, mit einer Mannschaft
verwandt sein, und der Trainer, auch
die Trainertabelle , weiß
, dass er mit einer Mannschaft verwandt ist. Ich werde dafür sorgen, dass das auf Null gesetzt werden kann. Nun, als ich
über die Regeln und so weiter gesprochen
habe, ging ich durch das
Szenario, dass der Trainer in der Tabelle existieren
kann,
ohne ein Wenn ich
das also nicht nullbar mache, dann wird es erforderlich sein Das ist nicht immer erforderlich,
denn wenn er gefeuert wird, ist
er immer noch Trainer,
nur ohne Team Also mache ich es lesbar, damit die Migration weiß
, dass das in der Datenbank Null sein kann Gleichzeitig weiß
es
in unserer Teamtabelle
einfach dadurch, dass es,
okay, das auf Null gesetzt werden kann, sodass es dafür keinen
zusätzlichen Aufwand betreiben muss Jetzt
helfen Ihnen die
Navigationseigenschaften erneut dabei, die Details
der zugehörigen Entitäten abzurufen Wenn ich also ein Team zusammenstelle, kann
ich mir die Details
der Liga ansehen, in der es spielt Ich kann die Details
des Trainers erfahren. Und ich kann mir alle
Spiele besorgen, wenn ich muss. Aus Sicht des Trainers muss ich, wenn ich mir den Trainer ansehe,
nur eine Team-ID angeben. Wenn ich also wollte,
könnte ich eine
Navigationseigenschaft hinzufügen, ich würde sie einfach kopieren und einfügen um schneller voranzukommen Ich könnte
hier einfach
die Navigations-Eigenschaft für das Team einbauen die Navigations-Eigenschaft für das Team , sodass ich,
wenn ich einen Trainer
habe, auch
die Details der Mannschaft und all
die Spiele
und alles andere angeben kann , Schauen wir uns also
die Migration an , die wir daraus generieren
können In Ordnung, bei meiner Migration
wurde das Trainerteam eins zu eins hinzugefügt. Unsere Migration ist also generiert, und wir können einfach einen
kurzen Blick darauf werfen und sehen, dass
wir die neue
Tabelle namens Coach bekommen. Und falls Sie es bemerkt haben, haben
wir tatsächlich einen
der wichtigeren Schritte übersprungen Ich weiß nicht, ob Sie
es bemerkt haben, aber wir haben das,
was ich ihm beigebracht habe, als wichtigen
Schritt zur Erstellung einer Tabelle
übersprungen aber wir haben das,
was ich ihm beigebracht habe, als wichtigen
Schritt zur Erstellung einer Tabelle
übersprungen, nämlich die Aufnahme
in unseren DB-Kontext Wir haben
unsere neue Tabelle mit dem Namen
Coach oder Coaches nicht in unseren DB-Kontext aufgenommen Schauen wir uns das jetzt an. Die Tatsache, dass ich
einer Tabelle,
die sich im DB-Kontext befindet, gesagt habe , dass sie auf diese
Klasse oder eine Klasse,
die Migration oder natürlich verweist , wird einfach
weitermachen und eine Tabelle erstellen , die diesen Tabellennamen darstellt. Dieser Name wird also auf der
Grundlage des
Eigenschaftsnamens generiert , der Coach lautet. Das ist also vielleicht nicht der beste
Ansatz, wenn wir bei
unserer Benennungskonvention Standard halten wollen,
denn bis jetzt haben
wir immer
jeden Tabellennamen pluralisiert Ich weise nur darauf hin
, dass
EFCR durch das Hinzufügen dieser
Navigationseigenschaft automatisch
die gesamte Migration rund um
die
Erstellung einer Tabelle für diese
Navigationseigenschaft einfügt oder gesamte Migration rund um
die Erstellung einer Tabelle für diese
Navigationseigenschaft Also werde ich
die Migration einfach entfernen, weil wir den Standard
beibehalten wollen Und ich werde
es dem DB-Kontext hinzufügen. Wir haben also eine Tabelle namens Coach. Sie die Migration wiederholen,
können
wir uns ein bisschen besser darüber im Klaren sein,
was generiert wird Ich weise also nur auf bestimmte Dinge
hin, die FCR
hinter den Kulissen tun wird , auch
wenn Sie einen Schritt verpassen Sie wollen also
gewissermaßen bewusst vorgehen,
aber FCR wird
bestimmte Annahmen
für Sie treffen , je nachdem, wie es
weiß, dass es funktionieren muss Lassen Sie uns weitermachen und
das aktualisieren und das ist erledigt. Deshalb möchte ich auch nur darauf
hinweisen, dass das Erstellen eines Index ein
bisschen anders aussieht als das, was wir bis zu diesem Zeitpunkt gesehen haben, und dass es einen Filter hat. Die Team-ID ist nicht Null. es sich nur ansehen, fragen
Sie sich wahrscheinlich,
okay, was das bedeutet, zumal wir
der Tabelle gesagt haben , dass die
Team-ID nullwertfähig ist Nun, wenn wir uns
die Anweisung ansehen, für
den Create-Index generiert
wurde, erstellen wir den eindeutigen Index diese Spalte, wenn
er nicht Null ist Sobald also ein Wert da ist, bedeutet
das, dass Sie diesen Wert mit keinem anderen Coach wiederholen können. Das ist so ziemlich das,
was es sagt, aber es ist trotzdem erlaubt, Null zu
sein. Okay. Also das ist es wirklich um eine
Eins-zu-Eins-Beziehung aufzubauen. Auch hier
wäre das
Szenario, wenn Sie
wissen, dass Sie möchten, dass
eine Entität nur einmal mit
einer anderen Entität verknüpft wird. Und es gibt verschiedene
Szenarien, in denen Sie
Eins-zu-Eins-Beziehungen haben. Es könnte auch sein, dass man vollständig von einem anderen
abhängig
ist, das heißt, es könnte ein Szenario sein, in
dem wir
einen Trainer nur dann im System haben wollen , wenn
er mit einem Team verbunden ist. Abgesehen davon, dass er einem Team
zugeordnet ist, sollte
er auch nicht in der Datenbank enthalten sein. Sie haben also
auch dieses Szenario, aber auch hier sind Ihre Geschäftsregeln und
Ihre Anforderungen ausschlaggebend für die Entscheidungen, die Sie während Ihres Entwurfs
treffen.
22. Generiere neue Entity: Hey, Leute, willkommen zurück.
Hier ist ein kurzes Video. Ich möchte Ihnen nur zeigen, wie Sie Ihr
Datenbankdiagramm aktualisieren
können. Wir haben also
einige Änderungen vorgenommen. Wir haben neue Tabellen
hinzugefügt, neue Beziehungen hinzugefügt, und ich möchte
Ihnen nur zeigen, wie Sie
die visuelle Darstellung
Ihrer Datenbank aktualisieren können die visuelle Darstellung
Ihrer . Und
es ist ziemlich einfach. So wie beim
ersten Mal, Sie wiederholen einfach diesen Schritt und es wird ein neues
Diagramm erstellt und es für Sie geändert. Sie klicken also einfach mit der rechten
Maustaste auf Ihr Projekt. Sie gehen weiter und gehen
zu FCR Power Tools fügen ein DB-Kontextdiagramm Es wird einfach
weitermachen und
ein brandneues für Sie generieren , und Sie werden es hier sehen Wir haben also unsere neuen Einheiten
in Form von Trainern, und Sie werden feststellen, dass
die Pfeile
Ihnen die Kardinalität
dieser Beziehungen zeigen , sodass Sie auf
Anhieb erkennen können, dass dies von FCR als
eins zu eins angesehen
wird Das ist eins zu viel
und das ist auch eins zu viel Sie werden auch feststellen, dass die
Navigationseigenschaften
aktualisiert wurden , wenn es in einem Spiel eine
Auswärts- und eine Heimmannschaft gibt. Die Mannschaft hat jedoch
Listen mit Auswärtsspielen. Und wenn Sie mit der Maus über
einen dieser
Blöcke oder Eigenschaften fahren, wird Ihnen natürlich angezeigt, um welche Kategorie es sich
je nach Spiel
handelt, um welche Kategorie es sich handelt, es sich handelt, um welche Kategorie es sich handelt, um welche Kategorie es sich um eine Spielliste handelt Das ist also ein hervorragendes
Referenzdiagramm jemanden, der die einzelnen Klassen vielleicht nicht
unbedingt
versteht oder nicht unbedingt die einzelnen Klassen
durchforsten möchte, um genau zu
sehen, was vor sich geht Dieses nette Übersichtsdiagramm ist eine hervorragende Möglichkeit,
sich darüber
zu informieren , welche Referenz was ist und wie diese Beziehungen gebildet
werden.
23. Einfügen von entsprechenden Daten: Hey, Leute, willkommen
zurück in dieser Lektion. Wir werden
einige Beispiele dafür durchgehen, wann
wir Datensätze hinzufügen müssen
, die Beziehungen aufweisen. Als wir uns also unsere Einsatzszenarien angesehen haben, wir uns tatsächlich eines angesehen,
und ich habe es weiter unten wiederholt, nämlich neue
Teams mit Liga hinzuzufügen. In diesem Szenario hatten wir eine
Liga, die es noch nicht gab, und dann hatten wir ein Team, das auch noch nicht existierte, also die Gründung, richtig? Und dann haben wir
dieses Team hinzugefügt , während wir das Liga-Objekt übergeben
haben. Und dann ist uns aufgefallen, dass beim Aufruf von „Änderungen hinzufügen und speichern Aufruf von „Änderungen hinzufügen und speichern“ die Liga erstellt wurde,
die es noch
nicht gab, und dann
automatisch
die
Fremdschlüsselbeziehung mit dem Team eingefügt wurde. Sie können also
das eingefügte Video erneut aufrufen und überprüfen, was passiert ist, als
wir diesen Vorgang durchgeführt haben Jetzt habe ich ein paar
andere Szenarien , die wir gerne
durchgehen würden Eines ist, wenn wir ein neues
Team mit der Liga-ID hinzufügen. Und ich denke, dieses Szenario ist wahrscheinlich
eher ein aussagekräftiges Szenario was in
einer Softwaresituation passieren würde Nun, wenn wir
ein neues Team
hinzufügen, ein neues Team mit Liga-ID hinzufügen, wird
das wahrscheinlich
passieren , vielleicht über eine
Weboberfläche, oder? Jemand tippt
einen Teamnamen und würde dann
wahrscheinlich über
eine Drop-down-Liste angeben , zu welcher Liga dieses Team , zu welcher Liga dieses Team
gehört Sie hätten also
dieses Szenario, wenn Sie vom Benutzer verlangen würden, beide gleichzeitig
einzugeben, den Teamnamen
und den Liganamen Dann könnten Sie ja
weitermachen und
die Objekte manuell erstellen und dann eine Änderung speichern und
beide werden übernommen. Ein anderes praktischeres Szenario wäre
jedoch, dass
Sie die Liste der
Ligen haben und wenn sie aus dieser Liste
auswählen, würden
sie, Sie wissen schon, die ID
der
ausgewählten Liga sowie
den Namen der Mannschaft
, der sie beitreten,
schicken ausgewählten Liga sowie lassen. Wir haben also bereits einige
Ligen in unserer Datenbank. Lass mich einfach gehen und sie
schnell holen. So können wir einfach
simulieren, welche IDs die potenziellen IDs
wären , aus
denen ein Benutzer auswählen Nehmen wir an, sie wollten
eine neue Fußballmannschaft von Serre hinzufügen eine neue Fußballmannschaft von Serre Dann würde unser Code eher
so aussehen. Wir müssten
dieses Liga-Objekt nicht erstellen, aber wir würden das Team erstellen und dann würden wir
die Liga-ID von acht übergeben. In diesem Szenario existiert die
Liga also bereits. Wir wissen, dass es eine ID ist. Wir
fügen es dem Team hinzu. Wir fügen diesem brandneuen Team den Namen
hinzu, und dieses Team wird
nach Fiorentina gehen, und dann können wir
weitermachen und es hinzufügen,
und dann
wird diese Beziehung stark Einer der Vorteile von
Beziehungen und nun ja, relationale Datenbanken
sind darauf ausgelegt, diese
Konsistenz
der Daten irgendwie durchzusetzen Wir verringern das Risiko
drastisch, wenn es überhaupt noch existiert,
dass eine Liga , die es nicht gibt, einem Team
zugeordnet wird Ich habe mir also bereits die Tatsache angesehen , dass wir eine Kaskadenlöschung durchführen Wenn wir die Liga löschen, würden
alle Teams
gelöscht, oder? Aber dann kann ich kein Team hinzufügen
, das
mit der Liga verwandt ist und die ID 50 hat, obwohl wir gesehen haben
, dass acht das Maximum ist. CO, nun ja, die Datenbank selbst wird zurückweisen, dass
COR es versucht, die Datenbank gibt einen Fehler aus und dann
kehrt sie zurück Das ist also einer der Vorteile, wenn diese Art
von starker referentieller Integrität in Ihren Tabellen
durchgesetzt Es gibt
Leute, denen das nicht gefällt, aber Sie verwenden eine
relationale Nutzen Sie es zu Ihrem Vorteil. In Ordnung, also das erste Szenario. Bei Orwell zwei, Szenario eins, als wir einfach
das gesamte Objekt
einfügen und beide hinzufügen konnten und die Beziehung
wäre erstellt worden oder die zugehörigen Daten wären im Hintergrund erstellt
worden Unser anderes
,
praktischeres Szenario wäre,
wenn wir die ID
des zugehörigen Datensatzes erhalten und sie dann
an den Datensatz weitergeben , den
wir erstellen möchten Unser nächstes Szenario
wäre, wenn wir eine neue Liga mit Teams hinzufügen wollen . Auch das könnte
ein Szenario sein, in dem du die Liga
erstellst und, weißt du, du gibst dem Benutzer die
Möglichkeit eine neue Liga hinzuzufügen, alle Teams hinzuzufügen und sie
dann einmal einreichen. Das heißt, in dieser Situation müssen
Sie
das Objekt für
die Liga erstellen und den Teams
mitteilen,
dass dies der Fall ist Ähnlich wie der
Anzeigenkontext
beide Objekte neu hinzugefügt und dann die relationalen Werte
eingerichtet hätte , wäre
es hier
dasselbe Szenario. Ich habe also bereits diese Funktion
ausgeführt, bei der ich eine neue
Liga mit Teams hinzufüge, und dann
entspricht ein R-Team einer neuen Liste von Teams Sagen wir einfach, dass der Benutzer dies eingereicht hat, ebenso wie der Name
für diese neue Liga. Du kannst also erkennen, dass ich es
kopiere und einfüge, oder? Also diese neue Liga ist CFA, Abkürzung für Man Island
Football Association Lass uns damit arbeiten. Und das sind einige der
Teams, die in CFA spielen würden. Wenn wir also diese neue Liga hinzufügen, die ein Objekt
vom Typ Liga ist und ihren Namen und
ihre Liste von Teams
hat, erledigt
Entity Framework den
Rest, wenn wir die Änderungen speichern In diesem nächsten Szenario versuchen
wir, Datensätze für unsere
vielen zu vielen Tabellen zu
erstellen. Denken Sie also daran, dass
Spiele unsere Haupttabelle zu
viele sind, an der viele Teams
gegen viele Teams spielen werden, oder? Diese Funktion
definiert also einfach eine Liste vom Typ Spiel und sie enthält einige Spiele
mit der ID der Auswärtsmannschaft, ID der
Heimmannschaft und dem
Datum des Spiels. Alles klar? Also, ich
mache hier zwei für eins weil wir uns eins
ansehen, wie man den Rekord für
die vielen zu vielen
erstellt. Und denken Sie daran, dass unsere Match- oder unsere
Viele-Viele-Tabelle im Allgemeinen sowohl
die ID als auch die
Navigationseigenschaft enthalten würde . So wie wir das Objekt für
die
Navigationseigenschaft einfügen und es der Datenbank
hinzufügen
könnten die
Navigationseigenschaft einfügen und es , ist
es hier genauso. In einem
praktischeren Szenario würden
diese Teams jedoch bereits existieren, wenn
wir ein Spiel hinzufügen. Wir müssen also sicherstellen, dass wir die IDs korrekt
referenzieren Mit einer
Benutzeroberfläche beschränken
Sie natürlich die
Werte, die der Benutzer eingeben
kann, auf Werte
, die
höchstwahrscheinlich
gültige Werte sind, um Probleme zu vermeiden, die
entstehen können wenn die Datenbank
versucht, die Datensätze einzugeben Alles klar? Also das ist Teil eins der 241 in diesem Szenario. Der nächste Teil ist die Tatsache, dass
ich diesen zusätzlichen Bereich verwende. Also, Ponto, wir haben immer
nur Werbung gemacht. Stimmt? Hinzufügen steht für eins. Wir übergeben nur ein Objekt, wenn wir „
Hinzufügen“ oder „Synchronisation hinzufügen“ sagen. Wenn wir jedoch sagen,
Bereich oder Bereich zur Synchronisation hinzufügen, können wir eine
Sammlung von Werten übergeben, und alle werden einfach
hinzugefügt, sobald wir die Änderungen gespeichert haben. Traditionell werden
Sie dies
in älteren Versionen wahrscheinlich in eine Schleife für
jede Schleife
einfügen und für
jeden in der Liste hinzufügen
, hinzufügen, hinzufügen und
dann Änderungen speichern. Nun, in unserem letzten Szenario passiert hier nichts wirklich
Besonderes. Wir wissen bereits, wie
man einen Datensatz hinzufügt. Und die Tatsache, dass
wir in
diesem Szenario eine
Eins-zu-Eins-Beziehung haben ,
ändert nichts an der Tatsache, dass
es
derselbe Code ist, nur einen Datensatz hinzuzufügen. Wir haben also einen Trainer und dieser Trainer
heißt Joseph Marino, und er wird das dritte Team
trainieren Denken Sie jetzt daran, dass es sich hier
tatsächlich um ein nutzbares Feld handelt. Nehmen wir also an, wir hatten zwei Trainer und einer
hatte kein Team Also ich
sage Antonio Conte, und dieser Trainer hat
kein Team, oder? Auf die gleiche Weise kann ich Joseph Marino
mit der Team-ID
hinzufügen, ich kann Conte
ohne das Team hinzufügen Das Einzige ist
, dass er gewissermaßen ein Waise
sein wird , er wird in der Tabelle
existieren, aber er hat keine
Beziehung zu Sobald er eingestellt ist, aktualisieren
wir einfach seinen Datensatz und er hat den entsprechenden
Datensatz für das Team So wie es aussieht, wenn ich das ausführe sehen
wir
, dass beide Trainer ohne Fehler eingetragen werden. Antonio ohne seinen Teamausweis, genauso wie Joseph
Marino mit seinem eigenen Also hatte ich
die anderen Funktionen kommentiert. Lassen Sie mich die Kommentare entfernen, und dann werden
wir einfach
alle ausführen und genau sehen,
was im Code passiert Also lass uns das nochmal versuchen. Also gut, alles wurde ohne Erde
ausgeführt. Also wir sehen, dass wir die
Bundesliga an der Spitze hinzufügen. Wir fügen Barn Munich hinzu, wir fügen Florentina hinzu,
wir fügen CFA hinzu Sie können also sehen, dass der FCR, selbst
als wir die Objekte zusammengefasst haben, wieder einmal auf intelligente Weise
wusste,
welche Abhängigkeit
die Abhängigkeit ist. Fügen Sie diese ein, um ihre
Bereichsidentität zu erhalten
und diese dann zu verwenden, um alles
einzufügen, was noch an sie angehängt FCR, selbst
als wir die Objekte zusammengefasst haben, wieder einmal auf intelligente Weise
wusste,
welche Abhängigkeit
die Abhängigkeit ist. Fügen Sie diese ein, um ihre
Bereichsidentität zu erhalten
und diese dann zu verwenden, um alles
einzufügen, um ist. Hier sehen wir also, dass wir Rivoli United neben CFA hinzufügen
. CFA hat also eine ID von 11, und aus diesem Grund haben Rivoli und
Waterhouse Dieses Szenario sah vor, dass wir
der Liste der Teams eine Liga hinzufügen der Liste der Teams eine Liga Bei der Partie mit den Spielen,
bei denen wir Spielraum hinzugefügt haben, siehst
du, dass sie einfach
durchgegangen ist und jedes Spiel einzeln
hinzugefügt wurde. Sie fragen sich wahrscheinlich,
warum es nicht einfach
eine Insert-Anweisung erstellt und diese Zeile für Zeile ausgeführt hat. Nun, das geht auf
die Massenoperationen zurück. Das FCT entschied, dass es sich wahrscheinlich nicht lohnt, diese Befehle zu stapeln, es sei denn mit einer
bestimmten Anzahl von Datensätzen zu tun ,
Sie haben
es Aus diesem Grund werden Sie bei
kleineren Befehlen oder einer geringeren Anzahl von Datensätzen
feststellen, dass einzelne
SQL-Anweisungen für
sie ausgeführt werden Das ist
es also wirklich, wie wir verwandte Daten einfügen können verwandte Daten einfügen Auch dies mag
unintuitiv erscheinen, da wir die Daten
hart codieren und eine
Konsolenanwendung verwenden jedoch daran,
dass Sie in einem
Webanwendungsszenario Denken Sie jedoch daran,
dass Sie in einem
Webanwendungsszenario Ihr Benutzerformular angegeben
hätten, das
Sie einschränken oder einschränken würde, sodass nur
Datenwerte
eingefügt werden, von denen Sie wissen, dass
Sie sie nur
Datenwerte
eingefügt werden, von denen Sie wissen, dass zum Ausführen
der Speichervorgänge benötigen Wenn sie also
diese Formulare ausfüllen und abschicken, würden
Sie diese Daten extrahieren. Wenn es so ist, dass sie
eine neue Liga mit einer
Liste von Teams gründen würden , nun,
wir sehen, wie wir
das ganz einfach bewerkstelligen können. Stimmt das? Dies sind nur Richtlinien was
im Backend passieren kann.
Sobald Sie die Daten haben, die das Formular oder der Benutzer lieber über das Formular
eingereicht hätte, wissen
Sie, wie man es erstellt
und dann an FCR sendet und
FCR den Rest
erledigt.
Okay
24. (Eager Loading) mit entsprechenden Daten: Hallo Leute, willkommen
zurück in dieser Lektion.
Wir werden uns ansehen, wie wir
mit einem Befehl
Daten aus mehreren Tabellen abrufen können . Ein Szenario
dafür wäre, wenn Sie einen Bericht oder
eine Anzeige von Daten
haben , die
Sie durchführen müssen, aber dann sind die Daten,
die Sie
anzeigen müssen ,
auf mehrere Tabellen verteilt. Erstens, hier
kommt die referenzielle Integrität ins Spiel, weil Sie wissen, dass Sie
die zugehörigen Daten
jederzeit
aus einer anderen Tabelle abrufen können die zugehörigen Daten
jederzeit
aus einer anderen Tabelle Aber wenn Sie
mit der traditionellen Qua-Methode vertraut sind, wissen
Sie auch,
dass Sie
entweder eine Form der Verknüpfung durchführen müssen Form der Verknüpfung durchführen Es könnte rechts sein,
es könnte links sein, es könnte inerisch sein, aber Sie
müssen
in dieser Qua-Abfrage irgendeine Form von Verknüpfung ausführen, um die zugehörigen
Daten abzurufen Es unterscheidet sich nicht wesentlich
von dem, was wir mit unseren
einfachen Auswahlabfragen gesehen
hätten , außer dass wir uns noch ein paar Dinge
ansehen werden Ich habe hier also die einfache
Auswahlabfrage als Referenz, und wir wissen, dass wir sie damit
ausführen, um sie aufzulisten, und auf diese Weise erhalten wir unsere Daten. Schauen wir uns
einige Szenarien an, die ich zusammengestellt habe,
um zu sehen, wie wir mit dem gesamten Konzept
der Einbeziehung verwandter
Daten oder
des Eager-Loadings herumspielen
können . Zunächst
werden wir uns ansehen, wie wir viele
verwandte Datensätze erhalten können. Und das Szenario hier
ist: Was wäre, wenn wir alle
Ligen und alle Teams haben wollten Und denken Sie einfach darüber nach,
diese Daten einem Benutzer anzuzeigen , oder? Sie haben die Liste der Ligen und vielleicht sehen
Sie die Teams, wenn
Sie auf die Liga klicken . Alles klar? Also, du willst alle Ligen
und alle damit
verbundenen Teams
zurückbekommen , vielleicht alles in einem Anruf, aus welchem
Grund auch immer,
dein Szenario könnte bestimmen, warum du diese Art von Core schreiben
müsstest Es gibt kein Problem. Entity Framework Core
ermöglicht es uns, alles zu tun. Wir würden also
einfach eine einfache Auswahl machen, wir sagen, dass
Ligen gleich sind, und dann warten wir auf unseren Kontext
, der unsere Ligen
nennt, und dann sagen wir einfach,
aufzulisten Das wäre also das, was wir
tun, um die Ligen zu bekommen. Jetzt wollen wir die Teams, die mit den
Ligen
verbunden sind , oder? Vor unserer Aufgabenliste haben
wir also eine weitere Funktion namens Include, die
wir verwenden können Include ermöglicht es uns, einen Lambda-Ausdruck einzugeben. Sie sehen also, wie
Lambda-Ausdrücke funktionieren. Nein, Sie sehen, dass sie nicht
nur für Filter usw. gelten. Es gibt bestimmte Funktionen
, die Lambda-Ausdrücke verwenden. Und Sie können immer anhand des Datentyps, der Expression Funk ist, erkennen, dass ein Lambda-Ausdruck
verwendet wird , , und dann würden Sie die Liga oder
das Objekt der
Tabelle sehen , an der Sie sich Ordnung? Also sagen wir
im Grunde, was möchtest du, dass ich einschließe? Das ist es,
worum es im Moment geht, und ich möchte Q Punkt einbeziehen, und dann würde ich Teams sagen. Also gleich auf Anhieb werden
wir sehen, wie dieser
Steinbruch betrieben wird, um uns im Grunde einen
ausgewählten Stern aus
den Teams
zurückzugeben , deren
innere Verknüpfungen auf
den Team-IDs mit den Team-IDs der Liga-ID oder der
Liga-ID oder in der Teamtabelle Liga-ID
aus der Ligatabelle
übereinstimmen Schauen wir uns also schnell
die generierte SQL-Anweisung an die generierte SQL-Anweisung Und dort sehen wir select, und dann listet es alle
Spalten aus beiden Tabellen auf. Also Ligen ist L und Teams ist T, also wählt es alle
Spalten zwischen L und T aus,
und dann wird
die Liga-ID, die der Teamliga-ID entspricht
, für Teams
beitreten übrig gelassen die der Teamliga-ID entspricht Aufgrund der
referenziellen Integrität,
die wir durchgesetzt haben, weiß
F C also eindeutig, wie diese Abfrage
zu formulieren ist, um zu wissen, welche Spalten in der
linken Verknüpfung einander zugeordnet werden sollen Beachten Sie, dass sie einen Left Join verwendet. Das heißt, wenn es
eine Liga in der
Datenbank gibt , die
keine Teams hat , weil wir
die Ligatabelle abfragen, wird diese Liga
zurückgebracht Das
Ziel des Teams wird es jedoch sein. Lassen Sie mich am Ende
der Ausführung einfach einen Breakpoint
setzen . Also kannst du sehen
, wie das aussehen wird. Also das sind die Daten, die in diesem League-Objekt
zurückkommen. Und wenn ich es erweitere, dann siehst
du ID zwei, Red Star Premier League und
die Teams, die in der
Reds Premier League spielen, sowie
alle Details. Diese Mannschaft hat also keinen Trainer. Es hat die ID Sieben. Sie sehen, dass es mit der ID zwei mit League
verwandt ist, und Sie können den Namen herausfinden. Also genau dort kannst du
Liga-Objekt Punkt Teams
Punkt sagen und es wird einfach auf
alles zugegriffen , was du willst
vom Liga-Objekt aus Das ist also die Stärke
unseres eifrigen Ladens. Wir haben also einige
andere Beispiele, die wir durchgehen wollen,
nur um Ihnen zu zeigen, wie Sie kombinieren können
und welche verschiedenen Dinge Sie
je nach Situation tun können. Wir haben uns also angesehen,
viele Datensätze mit ihren vielen verwandten
Datensätzen zu sammeln, richtig? Wir bekommen also alle Ligen und die Liste der Teams pro Liga Das ist vielleicht nicht der Fall.
Vielleicht möchten Sie nur einen Datensatz und einen
Bezugsdatensatz abrufen oder, Sie wissen schon, eine Liste
verwandter Datensätze, aber nur einen Datensatz. In dieser Situation wollen
wir also ein Team
und die Angaben zum Trainer haben. In diesem Fall werde
ich sagen, dass unser Team ebenbürtig ist und wir warten auf unseren Kontext. So nennt es hier unsere Methoden. Wenn Sie sich also den Kontext ansehen, den
Punktteams beinhalten. Aber wie wir festgestellt haben, selbst wenn wir
Kontext-Punkt-Teams sagen, tut
es nichts, bis wir
diesen ausführenden Befehl ausführen. Also, ich habe gesagt, dass ich
nur einen will. Und wenn Sie sich erinnern, wäre der
Weg, einen zu bekommen entweder Single oder Standard
oder First oder Standard. In diesem Fall setze ich
zuerst oder Standard. Also ich will ein Team mit
der ID, sagen wir, zwei, und den Trainer für
das Team mit der ID zwei. Oder sagen wir drei. Ich glaube, ich habe den Bus mit Ausweis drei eingesetzt. Wir können einfach zurückgehen und nachsehen. Also Team mit ID
drei. Da haben wir's. Also sage ich Punkt einschließen setze
dann meinen
Ausführungsbefehl ein, in diesem Fall der Standard mit
dem
ersten Stern ist, weil
das die Ausführung ist. Ich will nur einen. Der
erste Stern verwendet standardmäßig den Lambda-Ausdruck, in dem
ich angeben werde, dass das Team mit der ID
gleich sein soll. Drei. In Ordnung. So verketten Sie
diese Befehle. Ich unterbreche nur die
Grenze, damit Sie sehen können, wo jede Funktion wirklich
beginnt, oder? Also Context Dot Teams, gebt
mir alle Teams. Bitte geben Sie den Trainer an, aber dann möchte ich nur
den ersten oder den
Standardtrainer , bei dem die ID drei
entspricht. Schauen wir uns also an was wir bekommen, wenn wir das
ausführen. Ordnung, also Q, das
generiert wird, ist ziemlich
einfach. Wählen Sie oben aus und wir sehen dieselbe Art von Verknüpfung
, die gerade stattfindet. Aufgrund der ersten Standardeinstellung wählen
wir also die oberste aus, und dann haben wir diese WERE-Klausel,
um
nach unten zu filtern , wo die
Team-ID drei sein muss. Ich hoffe also, Sie sehen, dass sich das
gemeinsame Thema durchsetzt. Also bin ich wieder im Code
oder im Wachfenster. Und Sie sehen hier den Bus Die Navigationsleiste enthält
alle Details des Wagens. Das ist also die Stärke
unserer Inklusion. Und auf eine Sache
möchte ich hinweisen,
nämlich etwas, das
frustrierend sein kann, wenn Sie nicht
wissen, was passiert Wo Sie die
erste oder die Standardeinstellung platzieren, hat viel damit zu tun, ob die
Anweisung funktioniert oder nicht Es wird dir nur eine Fehlermeldung geben. Wenn ich also
Context-Punkt-Teams dann zuerst oder Standard setze, kann
ich kein Include nach
einem First oder Default machen ,
weil ein First oder Default daraus
wirklich ein Objekt vom Typ Team macht, und dann kann ich nur auf
die Eigenschaften zugreifen. Weil ich den A-Sync verwende
, der
offensichtlich nicht angezeigt wird, lassen Sie mich den ASIC abnehmen
und es Ihnen zeigen Wenn ich Punkt sage, erhalte ich eigentlich nur
die Eigenschaften, das Zuhause stimmt mit der ID überein, oder? Also wenn es das ist, was kommt ,
wenn es das ist, was
nach dem ersten oder dem Standard kommt, dann
ist Include eindeutig nicht in dieser Liste. Und so haben wir zu diesem Zeitpunkt diesen
Syntaxfehler. In meinen frühen Tagen wusste
ich das nicht zu schätzen,
und ich dachte immer, dass das
Entity Framework fehlerhaft ist, aber die
Reihenfolge ist wirklich wichtig, oder? Sie möchten also all die
datenbankbezogenen Dinge erledigen
und dann Ihre Ausführungsanweisung
zum
Schluss stehen lassen . In Ordnung. Also noch einmal, wir
holen die Teams,
nehmen den Trainer und dann zuerst oder standardmäßig, und diese roten Linien
sind da, weil ich den A-Sync
brauche,
und los geht's. Ordnung, Leute. In
unserem nächsten Szenario werden
wir uns also mit der Inklusion von Enkelkindern
befassen Wenn wir also
über Enkelkinder sprechen, ist das nur eine Frage
der Hierarchie , die erste Tabelle, die
wir Nehmen wir an, die erste Tabelle, die
wir abfragen, ist
die übergeordnete Dann ist die erste Tabelle
oder die nächste Tabelle , die wir einbeziehen, die untergeordnete Aber dann können wir
mehrere Includes haben. allen Kindern
handelt es sich also um solche mit direkten Fremdschlüsselbeziehungen zu der abgefragten Haupttabelle Das sind also Kinder. Sie können also mehrere
Includes nur für die Kinder haben. Es kann jedoch vorkommen
, dass
Sie zusätzliche
Daten von dem Kind benötigen, und dann müssen Sie
in einer anderen Tabelle nachschauen, die sich auf dieses Kind bezieht. In dieser Situation müssen
wir also die Teams und dann
die Spiele zusammenstellen. Und wenn wir dann
die Spiele bekommen, wissen Sie, bekommen
wir entweder Heim-
oder Auswärtsspiele. Aber dann brauchen wir die Daten
der gegnerischen Mannschaft. Wenn ich also die Heimmannschaft bin, benötige
ich die Daten
der Auswärtsmannschaft. Wenn ich die Auswärtsmannschaft bin, benötige
ich die Daten
der Heimmannschaft. Ich werde also auf
die Enkelkinder eingehen müssen ,
weil Spiele die Navigationseigenschaften sowohl für die Heimmannschaft als
auch
für die Auswärtsmannschaft
haben werden Navigationseigenschaften sowohl für die Heimmannschaft als
auch
für die Auswärtsmannschaft
haben Heimmannschaft als
auch
für die Auswärtsmannschaft Also noch einmal, wir lassen unsere
Ausführungsmethode zum Schluss und führen alle unsere Includes ,
bevor wir den
letzten Teil aufrufen Also werde ich
mit vier Include-Spielen beginnen,
vier unsere
Auswärtsspiele. In Ordnung. Also bin ich Team Nummer eins. Wir wollen alle
AA-Spiele sehen. Und dann können wir das sehen. Aber wenn wir dann
die Auswärtsspiele mit einbeziehen, sehen wir
nur die Details der Mannschaft, die wir haben, aber ich weiß
nichts anderes als die ID der Heimmannschaft. Also kann ich verketten und sagen, dann Include und
Include gibt mir Zugriff auf die Eigenschaften
des Kindes. Include gab mir also Zugriff auf die Navigationseigenschaft
der Tabelle oder des Objekts
, das die Tabelle darstellt. Ich habe mir Zugriff auf diese
Navigationseigenschaft gewährt. Jetzt möchte ich diesem Kind eine
Navigationseigenschaft hinzufügen. Also kann ich sagen, dann füge den Lambda-Ausdruck hinzu und verwende ihn noch
einmal und sage Q Punkt, und ich kann nach der
Heimmannschaft suchen. Da haben wir's. Also habe ich Tagesspiele und Auswärtsspiele,
was
vom Typ Match ist. Ich möchte Einzelheiten
über die Heimmannschaft angeben. Okay. Auf der anderen Seite, und ich habe vorhin gesagt, dass alle Kinder Seite an Seite
einbezogen werden können. Also habe ich das mit einbeziehen, und dann habe ich das
dann mit einbeziehen, richtig? Also, was ich tun werde, ich möchte das Problem nicht
verwirren Lassen Sie mich Ihnen
mehrere Includes für
mehrere
Navigationseigenschaften zeigen , bevor ich Ihnen die Enkelkinder zeige Wir haben also gerade ein Beispiel
für das Enkelkind gesehen, oder? Aber ich mache nur
einen Schritt zurück und zeige Ihnen, dass Sie sagen können, dass
Sie
so oft hinzufügen können, wie Sie möchten, um direkt
verwandte Eigenschaften
einzubeziehen so oft hinzufügen können, wie Sie möchten, um direkt
verwandte Eigenschaften
einzubeziehen Also kann ich sagen, gib mir die Mannschaften und für
jede Mannschaft, die du mir besorgst bekommen sie ihre eigenen Spiele und
all ihre Heimspiele. noch einmal, wenn es ein Heimspiel ist, wenn
es ein Auswärtsspiel ist, benötige
ich die Details
der Heimmannschaft. Wenn es ein Heimspiel ist, benötige
ich die Daten
der Auswärtsmannschaft. Dann kann ich sagen, nachdem Sie
die Heimspiele mitgezählt haben, möchte
ich, dass Sie auch die
Details der Heimmannschaft angeben. Und genauso möchte
ich, dass Sie, wenn
es sich um ein Heimspiel handelt, die Details der Auswärtsmannschaft angeben. Und dann können wir unsere Hinrichtung
nennen. Also egal, ob wir es zuerst
oder Standard oder Auflisten nennen, aber der Punkt ist, das ist unsere Anfrage, um
unsere Enkelkinder Und dann
ist es so, dass Sie das tatsächlich
verketten können ,
denn Sie wissen schon, je nach Datenbank-Setup haben
Sie möglicherweise
mehrere Tabellen mit Kindern über Kindern oder
Fremdschlüsseln über Fremdschlüsseln Solange ein
Fremdschlüssel involviert ist, können
Sie sagen, dann einschließen,
Sie können einbeziehen. Denken Sie dann aber daran, dass Sie mit
Include direkt auf die Fremdschlüssel
verweisen können , die sich auf die Haupttabelle
beziehen. Und dann können Sie für jedes
Include sagen,
dann Include , und dann können Sie Include und
Include
fortfahren. Und beachten Sie, dass Einschließen
mich nicht davon abhält , danach ein
Include zu machen, denn selbst wenn ich das
alles in einer Zeile machen würde, ist
es etwas weniger lesbar, weshalb ich
es in zwei Zeilen aufgeteilt habe. Aber sehen Sie, ich meine, geben
Sie mir die Teams. Schließt die Auswärtsspiele mit ein.
Dann füge das hinzu. Dann gehe ich zurück zu Include. Aber offensichtlich kann das
dann include
nur dem Include folgen, weil ich
dann nicht nach einer
Tabelle einschließen kann , die nicht die Navigationseigenschaft
hat, nach der ich
suche und die ich erwarte, sie
zu finden, oder? Also füge ich die
Wegübereinstimmungen hinzu und sage dann,
wenn du die Wegübereinstimmungen bekommst,
dann füge ich wenn du die Wegübereinstimmungen bekommst, die Heimmannschaft
für die Wegübereinstimmungen hinzu. Dann mache ich weiter und sage, dass man auch so ziemlich
die Heimspiele mit
einbezieht. Und wenn Sie das mit einbeziehen, möchte ich,
dass Sie auch die Details der
Auswärtsteams angeben. Nachdem du das
alles formuliert hast, will
ich nur den
mit der ID eins. Also lassen Sie uns das ausprobieren
und sehen, was wir bekommen. Lassen Sie uns also zunächst auf das generierte
SQL
achten . Wir haben alle Tabellen
, die wir bekommen. Sie sehen also, wählen Sie T Null, T vier, T zwei, all das ist da. Und dann haben wir von, aber
dann benutzt es eine Unterabfrage. Also fragen wir die Teams ab, bei denen
die ID gleich eins ist, und nennen das t Null. Dann lassen wir Join that aktiviert und dann
wählen wir aus Spielen aus, und dann fügen wir
es wieder zu Teams zusammen Richtig? Die Komplexität
von SQL hängt also davon ab, wie die
Beziehungen wirklich eingerichtet sind. In dieser Situation ist
es fast wie ein Zirkelverweis, weil
ich mir ein Team ansehe und dann sage ich, weißt du, wenn ich mir Spiele ansehe, geh
bitte zurück und
bring das Team zurück. Es geht also quasi zurück zur Mannschaftstabelle, die
gerade abgefragt wurde Aber das ist einfach eine Situation
,
mit der wir arbeiten müssen , wenn wir
solche Dinge tun. Alles klar? Aber andererseits müssen
Sie sich nicht den Kopf verletzen, wenn Sie versuchen, das
herauszufinden, weil
FCO es für Sie generiert hat Nun, was es zurückgibt, ist die Mannschaft mit Spielen
und Gegnern, und das
hätte eine Entschuldigung für das Team sein sollen Aber dann haben wir die
AA-Spiele, was nur eines ist. Also hat dieses Team mit ID eins
, also Juvento, nur ein AA-Spiel und ein
Heimspiel. Okay, gut Beim Auswärtsspiel
kennen wir uns aus. Das ist impliziert, weil wir die Auswärtsspiele mit
aufgenommen haben. Wir wissen also, dass wir das Auswärtsteam sind. Jovents ist das richtige Team.
Den brauchen wir nicht Wir brauchten jedoch die
Daten der Heimmannschaft, und die haben wir bekommen. Hier sehen wir also, dass
es InterMilan ist. Und ich denke, dass Jvento
gute Chancen hat , weil sie nicht einmal einen Trainer
haben Dann könnte Javent das Auswärtsspiel
gewinnen. Wenn wir uns die Heimspiele ansehen, ist
es dieselbe Situation Wir sind die Heimmannschaft. Das sind die Heimspiele. Javent
ist also offensichtlich die Heimmannschaft. Aber wenn wir uns die Auswärtsmannschaft ansehen, sehen
wir, dass die
Auswärtsmannschaft Asma ist und der Trainer Null ist,
aber dann, wenn wir den Trainer mit
einbezogen hätten Was wäre also, wenn wir
den Trainer mit einbeziehen wollten? Also, das ist noch eins, lass uns das
einfach machen. Also was wäre, wenn wir für jedes Team,
das
wir aufnehmen, sehen wollen, wer der Trainer ist. Wir wollen die Angaben zum Trainer. Also kann ich noch einmal sagen, fügen
Sie dann hinzu Also, wenn
Sie die Heimmannschaft einbeziehen, möchte
ich, dass Sie dann Q einbeziehen, und dann sehen Sie, dass es einfach die Kette
entlang geht und mir
die
Navigationseigenschaften gibt , je was als Nächstes in der Reihe steht. Also kann ich einfach sagen, dann
den Trainer mit einbeziehen. Und dann werden
die Details des Trainers
dieser Mannschaft zurückgebracht . Also lass mich das einfach nochmal machen. Und wir
schauen uns gerade die Heimspiele an, also sehen wir, dass wir die Heimmannschaft
sind. Ein A-Team ist A Roma, und der Trainer von
Sarma ist Joseph Moreno.
Das ist also ein guter Trainer Wir müssen
unser Bestes geben , um das Spiel zu Hause zu gewinnen
. Auf diese Weise können Sie also Ihre Includes verketten, um sicherzustellen, dass Sie
alle Daten aus allen
verknüpften Tabellen erhalten . Und das ist eine weitere
Stärke der ordnungsgemäßen Implementierung der
relationalen Integrität und der Zusammenarbeit mit FQ Natürlich versucht er, Ihnen
das Leben
so einfach wie möglich zu machen so einfach wie möglich zu Also das hat einfach
eine ganze Reihe von Joins und
Inner Joins für dich reduziert eine ganze Reihe von Joins und
Inner Joins , denn
wenn wir uns das SQL ansehen, ist es einfach ein bisschen größer geworden,
weil wir jetzt
Inner Join oder Left
Join zum Coach auf dem Tisch machen müssen . Mir ist aufgefallen, dass es
innere Form und links für Summe steht. Es weiß also automatisch
, dass es ein Links-Join ist,
wenn es Nullwerte erlaubt,
weil das bedeutet
, dass auf dieser Seite der Tabelle möglicherweise nichts Wenn es jedoch nicht nullbar
ist, macht
es einfach einen inneren Fehler,
weil es weiß, dass sie absolut übereinstimmen
müssen, damit ich etwas
zurückbringen kann ich etwas
zurückbringen Ich hatte diese beiden anderen
Beispiele vorgesehen,
aber ich denke, wir haben sie mit
diesen drei irgendwie ausgeschöpft, weil
diese drei ziemlich
umfassend sind was sie darstellen
, und was Sie tun können, wenn
es Hier steht, mit Filtern haben wir hier schon gefiltert Aber die Hauptidee dahinter dir eines mit
Filtern zu
zeigen, wäre, wenn ich sagen würde, alle
Teams mit Heimspielen zu bekommen. Es ist also eine einfache Abfrage. Wir warten auf Kontext-Punkt-Teams, und ich werde die
WHERE-Klausel für meinen Filter hinzufügen, und dann
sage ich hier nur Heimspiele, denen wir wissen, dass die
Anzahl der Listenpunkte größer als Null ist. Das heißt, Sie geben
mir alle Mannschaften , die
mindestens ein Heimspiel haben, und ich möchte ihren
Trainer mit einbeziehen. Und natürlich ist es A. Das ist
also die SQL-Anweisung
, die für uns generiert wird. Sie können sich natürlich hinsetzen und
es sich ansehen , wenn Sie möchten. Aber dann sehen wir, dass
drei Mannschaften zurückkommen die keine
Heimspiele geplant sind. Wenn Sie sich die Daten ansehen, könnten Sie in Versuchung geraten, zu sagen: Nun, warum haben wir nicht einfach überprüft,
ob Heimspiele Null sind Und ich meine, ich würde das verstehen weil wir sagen, dass
Heimspieles.com größer als Null ist Was wäre, wenn ich gesagt hätte
, wie viel entspricht Null, da das die
Daten sind, die wir sehen, aber wie genau
wäre FCO in der Lage, dieses
Listenobjekt in Null zu übersetzen Denn denken Sie daran, dass SQL
nichts
darüber weiß, dass Listen und
Listen Null sind Wenn wir uns also
die SQL-Anweisung ansehen dafür generiert wird, nun, erstens kommen keine
Daten zurück, oder? Diese Abfrage, unabhängig davon, welche
Abfrage generiert
wird, bringt also keine
Daten zurück, die wir erwartet hatten. Nein, wenn wir uns die generierte
SQL-Abfrage ansehen,
stellen wir fest, dass es sich um eine reguläre
Auswahlabfrage mit der linken Verknüpfung handelt, aber dann
wirft dieser Filter sie einfach ganz nach oben. Das ist natürlich eine
Art zu sagen, ich kann nicht verstehen,
was ich in dieser Situation vergleichen soll, oder? Also, obwohl wir vielleicht keinen Syntaxfehler oder
irgendeine Form von Warnung erhalten
haben , wollen
wir nur vorsichtig sein, wenn wir unsere
Filter hinzufügen, und, wissen Sie, wir könnten
etwas übereifrig wie wir das machen
, und das ist Es ist gut zu experimentieren,
aber seien Sie vorsichtig. Das ist also wirklich für
uns, um zu untersuchen
, wie man verwandte Datensätze abfragt. Und wie üblich
werde ich
diese Methode einfach dabei belassen , damit Sie später darauf verweisen
können. Ich werde einfach aufräumen, was
wir nicht durchgemacht haben, und Sie haben diese Beispiele, die
Sie anschließend überprüfen können.
25. Projektionen und anonymisierte Datentypen: Hallo, Leute, willkommen
zurück in dieser Lektion. Wir werden uns
Prognosen und
anonyme Datentypen ansehen . Jetzt beschäftigen Sie sich wahrscheinlich mit
diesem Thema und fragen sich, okay, worüber genau
wir hier sprechen? Eine Fallstudie hierfür wäre , dass Sie alle
Ihre Modelle sicher haben, aber dann benötigen Sie spezifische
Daten aus einer Abfrage, und mehr noch, dass dies
die einzige Datenmenge ist , die
Sie zurückgeben möchten. Alles klar? Sie möchten also ein benutzerdefiniertes Objekt
haben, bei dem nur Datenbits aus
dem gesamten Datensatz zurückgegeben werden, und das ist alles, was Sie wirklich in Ihrem System speichern
möchten . Lassen Sie uns also
einige Beispiele durchgehen, wissen
Sie, wann Sie
wahrscheinlich so
etwas tun müssten . Ordnung, ich werde Ihnen drei Szenarien
zeigen denen Sie wissen müssen,
wie Sie mit einer Auswahl umgehen müssen. Das erste ist, wenn wir eine Immobilie auswählen
wollen. Wie gesagt, vielleicht
fragen wir die gesamte Teamtabelle ab Sagen wir also Teams. Und egal, ob es sich um ein
Team oder mehrere Teams handelt, das Prinzip würde ziemlich dasselbe
bleiben, wo wir sagen müssen, dass wir den Kontext, das Prinzip würde ziemlich dasselbe
bleiben,
wo wir sagen müssen, dass wir den Kontext, die
Punkte und die Teams zusammenstellen müssen. Und dann lassen Sie uns in dieser Situation mit
einer Liste arbeiten, richtig, auf die
wir natürlich warten müssen. Nein, ich will nicht alles
aus dem Team herausholen, weil wir wissen, dass
wir eine Liste von Objekten
mit Namen und Liga-ID bekommen
werden . Und wenn wir dann
noch die anderen Dinge mit einbeziehen , richtig? Das alles will ich nicht. Was wäre, wenn ich nur die Namen wollte
? Ich wollte nur die Liste der Namen. Ich wollte keine
komplexen Objekte oder irgendetwas anderes, oder? In diesem Szenario müsste
ich also eine Auswahl hinzufügen. Ich würde also sagen,
im Kontext
wählen Teams Punkte aus. Und wenn ich das mache, kann
ich meinen
Lambda-Ausdruck verwenden, um anzugeben, welche Eigenschaft
ich auswählen möchte Wenn ich also den Namen auswähle und
dann die beiden Listen ausführe, dann ist das nur eine Liste
von Zeichenketten. In Ordnung. Weil Name eine Zeichenfolge ist
und ich sagte, ich will die Liste
aller Namen des Teams. Also erhalte ich die Liste
vom Typ Zeichenfolge. Und das gilt für
so ziemlich jeden, den Sie tun. Wenn ich also alle
Liga-IDs aus der Mannschaftstabelle haben wollte, dann würde ich eine Liste von
ganzen Zahlen
bekommen , die k beim Verschwinden angeben Da haben wir's. Eine Liste von ganzen Zahlen, weil die
Liga-ID eine Ganzzahl ist Und so
würde es für alles gehen. Liste der Trainer. In Ordnung. So gehen Sie also bei der
Auswahl einer Immobilie vor. Das Szenario könnte nun sein , dass Sie nicht nur eine Immobilie
möchten. Sie möchten mehrere Eigenschaften, und vor allem
möchten Sie wahrscheinlich mehrere Eigenschaften aus mehreren Tabellen. In Ordnung. Schauen wir uns also die
anonyme Projektion an. Was wäre, wenn ich
alle Teams auswählen und
alle Trainer einbeziehen möchte? Und alles, was ich wirklich
zurückwollte, war die Liste von Nun,
ich, die den
Teamnamen und den Namen des Trainers enthält. Das ist alles, was ich wirklich will. Wir wissen also aus unseren
früheren Erfahrungen mit
den Includes , dass am
Ende so etwas passieren würde,
lassen Sie mich sagen, Dot Include. Und dann werde ich sagen,
stellen Sie sicher, dass Sie mir die Trainerdetails oder das Trainer-Objekt
zusammen mit der Mannschaft geben. Aber dann möchte ich mehrere Dinge
auswählen. Ich kann das nicht trennen. Das funktioniert nicht.
Ich kann keinen Punkt sagen. Wir wissen also in SQL, wann
Sie bestimmte Spalten benötigen. Alles, was Sie tun müssen, ist Spalte, Spalte eins,
kommen Spalte zwei usw. usw. usw. zu
sagen , alles vor dem FM Das ist hier nicht wirklich
eine Option. Deshalb sprechen wir Projektion in
einen anderen Datentyp. Also im Handumdrehen, was Sie
tun dürfen, ist so etwas wie Neues, und dann können Sie
ein brandneues Objekt direkt
in dieser Select-Anweisung öffnen . Ordnung. Und wenn
du mit der Maus drüber fährst, heißt
es, es ist ein anonymer Typ Wir wissen, dass Sharp C
stark typisiert ist, oder? Also ist alles in C Sharp
stark typisiert. Es ist entweder eine Zeichenfolge, es ist
ein Int oder so. Aber in dieser Situation sage
ich nur neu, es gibt kein,
nach dem Neuen gibt es nichts zu sagen
, was ich wusste, oder? Also ist es nur ein neues Leerzeichen. Aber dann stellen Sie fest, dass es keine Fehler
gibt und es ihm einen anonymen Typ zuweist Es weiß also nicht, um
welchen Datentyp es sich handelt. Es weiß nur, dass es sich um einen
Typ handelt, den ich definieren möchte, und es hat eine Eigenschaft vom
Typ Zeichenfolge namens Name. Es erbt also bereits
den angegebenen Namen. Neben dem Feld. In dieser Situation steht
Q also für das Team. Wenn ich also spezifisch sein wollte, müsste
ich sagen, dass der
Teamname dem Q-Punktnamen entspricht. Und wenn ich dann
noch einmal mit der Maus darüber fahre , siehst du, dass es sich weiterentwickelt hat Da steht: Dieser anonyme Typ hat eine Eigenschaft namens Teamname Ordnung. Also, was wäre, wenn ich auch den Namen des Trainers haben
wollte Also kann ich kommen oder mich trennen
, denn nein, das ist ein Objekt. Lassen Sie mich das
einfach in
eine neue Zeile aufteilen , damit Sie sehen
können, wo alles
passiert, wo alles beginnt
und endet. In Ordnung. Also hier wird unser neues Objekt definiert. Wir haben also Lambda Dann projizieren wir in
diesen neuen anonymen Typ und definieren anhand des Ziels, welche Feldnamen er hat
und welche Werte er erhält Der Teamname erhält also einen Que-Namen und dann den Namen des Trainers Und lassen Sie sich nicht
von der Tatsache einschüchtern , dass das,
was Sie eingeben nicht nachrichtendienstlich ,
denn wir
machen das wieder Und es wird einfach bei
uns funktionieren, Punkt,
und dann kann es Punkt Trainer
Punktname sagen Es wird also zwei Eigenschaften geben, den Teamnamen und den Namen des Trainers. Wenn ich mit der Maus über Teams fahre, siehst du nur eine Liste
dieses anonymen
Datentyps, okay? Und dann
projizieren wir es einfach in eine Liste. Danach kann
ich sagen, jeweils vier, und ich mache
hier einfach jeweils eine Vier, um sie
für jeden Punkt in
der Liste der Teams auszudrucken für jeden Punkt in
der Liste der Teams Ich kann den Punkt mit der rechten Linie trösten. Und das Team ausdrucken und den
Punkt Teamname eingeben, und ich mache einfach einen Kuchen als Trennzeichen Trainer und
Punkt Selbst nach dieser
Projektion und dieser sehr zufälligen und
spontanen Erstellung dieses anonymen Objekts können
wir also problemlos auf die
Eigenschaften zugreifen, die definiert wurden Wenn ich also seine Definition ändere, verliert das Objekt aus den Augen, dass
der Teamname
eine Eigenschaft war, oder? Also ich denke, das ist so
flexibel, wie C sharp nur sein kann, und es kann manchmal sehr praktisch sein
, das zu tun. Alles klar? Nun, dafür gibt es eine
Fallstudie, und sie kann sehr nützlich sein,
wie ich gerade sagte, aber ich persönlich bevorzuge eine
stark typisierte Projektion, was bedeutet,
dass ich immer weiß
, mit welchen Objekttypen ich interagiere,
wenn ich eine Abfrage ausführe Also, wie gesagt, es könnte einen Fall geben, in dem
Sie ein benutzerdefiniertes Objekt benötigen, und das ist gut für ein
On-the-Fly-Szenario In einem größeren Projekt möchten
Sie jedoch etwas mehr
Kontrolle haben, als nur
diese neuen anonymen Objekte
überall zu haben . Was Sie also tun möchten, ist eine stark typisierte Klasse zu
haben, und ich werde einen neuen
Ordner innerhalb der Domain erstellen Es sollte nicht
innerhalb der Domain sein, aber lassen Sie uns einfach damit arbeiten Ich nenne es einfach Models. Mit Recht, Sie würden wahrscheinlich ein neues Projekt erstellen
wollen, aber das ist ein sehr
kleines Demo-Projekt. Ich werde nicht mit einer
Reihe von Projekten in den
Wilden Westen gehen . Aber in einem größeren Projekt möchten Sie das
nicht in
einem eigenen Bereich haben und es nicht
mit Ihren Domainobjekten vermischen. Aber ich nenne die Modelle , weil sie in Wirklichkeit
Modelle der Daten sind. Das ist also ein Modell
der Datenbankdaten, aber was ich dann erstellen
werde, ist ein Modell von
wahrscheinlich ähnlichen benutzerdefinierten Daten
, von denen ich weiß, dass ich sie erwarte. Nehmen wir an, ein Modell wäre ein CLA namens Team
Detail. In Ordnung? Also Team Detail wird
ein paar Eigenschaften haben. Nehmen wir an, Teamdetail hat
den Namen des Teams. Es wird den Namen
des Trainers haben und es wird den Namen der Liga
haben. Das sind drei verschiedene
Datenpunkte, die wir jemals durch eine normale Abfrage erhalten könnten. Wir müssten
alles über den Trainer und alles
über den Liganamen angeben. Und dann kann es beim
Empfangen ziemlich nervig werden, wenn wir Teamtrainer sagen
müssen. Sie möchten also nur ein Objekt
haben , in dem alles
nur für Sie da ist. Deshalb nenne ich
es ein Modell. In Ordnung? Also können wir in
diese stark typisierte Abfrage projizieren. Also werde ich einfach diese erste Abfrage
kopieren. Lassen Sie mich einfach
das Ganze erklären. Und ich werde für das Team
etwas hinzufügen und hinzufügen. Denken Sie also daran, es ist Ihre Anfrage . Welche Daten Sie auch
benötigen, Sie holen sie sich. Also ich brauche das Team, tut mir leid,
das Ligateam. Also schauen wir uns die
Mannschaftstabelle an und wir bekommen die
Trainerdetails aufgenommen, und wir bekommen die
Ligadetails. Und dann
wähle ich
eine neue Instanz von Teamdetails aus. Wir waren also oben anonym, aber jetzt wissen wir,
worum es im Folgenden geht. Das Teamdetail hat einen Namen. Es hat auch den Namen des Trainers und dann den Namen der Liga. Ich werde Q
League Dot Name sagen. Übrigens, wenn wir uns
ansehen, was zurückgegeben wird, wissen
wir mit Sicherheit, dass wir Objekte
vom Typ Teamdetail
bekommen. Wir müssen also nicht
raten und buchstabieren und sagen, welchem Datentyp
ich dieses Mal rechnen kann. Oder wir müssen nicht
unbedingt zur Definition gehen, um zu sehen,
welche Felder zu dem Zeitpunkt, als der
Entwickler das getan hat, alle Felder
im anonymen Typ
waren Zeitpunkt, als der
Entwickler das getan hat, alle Felder
im anonymen Typ , denn wenn wir eine
stark typisierte Klasse haben, können
wir uns immer nur diese Klassendefinition
ansehen Und wenn wir erst einmal wissen, dass wir
diesen Datentyp haben, wissen wir von
Anfang an, wie wir
damit umgehen können. In Ordnung. Also werde ich das alles miteinander verbinden und dann schauen
wir uns die verschiedenen
QO-Anweisungen an, die
jeweils ausgeführt werden und welche Daten
zurückkommen Ordnung. Also, wenn wir
in unsere Konsole schauen, können
wir das langsam
durchgehen. Unser erster Befehl
war die Auswahl einer Immobilie. Wir sehen, dass es heißt,
wählen Sie den Namen T aus dem Team aus. Alles klar? Einfach. Sie möchten eine Eigenschaft
oder eine Spalte. So wird es
gemacht. Kein Problem. In der nächsten
sagten wir, wir wollten Namen und den Namen der Mannschaft
und den Namen des Trainers. Wir haben lediglich gesagt, diesen anonymen Typ
ausgewählt und die gewünschten
Spalten spezifiziert. FCR generierte genau
die Anweisung benötigt wurde, um
genau diese Daten zu erhalten Also hat es den
Namen t als Teamnamen ausgewählt, was der Alias ist, richtig? Also haben wir den
Feldnamen
innerhalb unseres Typs oder des anonymen Typs anders genannt . Nun, es gab den Alias für
die Spalte innerhalb der SQL, und dann wurde es entsprechend links
join gelassen. Wir sind mit
dem Include bereits vertraut. Ich weise also nur auf die Ausrichtung
der
Kolumnen hin , die wir wollen. Und dann sind das die
Teams, die zurückgekommen sind. Wir sehen, dass Juventos Conte hat, Rom hat Joseph Marina, und alle anderen sind leer. Nun, für die nächste mit einer
stark typisierten Projektion ist
es so ziemlich dasselbe Wir wählen den Namen T, Namen
C als Trainername und haben diesen Namen
als Liganamen Beachten Sie also, dass ich
Name, Name gesagt habe, oder? Es musste diesem also
kein
Alias geben , weil das bereits
der Name der Spalte ist. Das SQL gab
ihr also keinen Alias, aber dann war der Alias für die anderen beiden
vorhanden, und dann ging es weiter
und machte die Verbindungen. Und wenn wir es dann ausgedruckt
haben, sehen wir Teamname, Trainer und Syrien, Syrien, und wir sehen alle
Ligadetails. Hier zielen wir also auf
die Kolumnen ab, die wir haben wollen. Es wird also eine
viel kleinere Abfrage sein, eine viel kleinere Nutzlast, als
jedes Team und jedes Detail jedes
Includes nur einmal
zurückzuholen Es wird nur sagen, welche Felder ich auswähle oder an denen ich interessiert bin Lassen Sie mich diese holen und sie dann als Liste
zurückbringen. Also noch einmal,
das ist zwar eine gute Einrichtung, in einem Projekt, insbesondere wenn
Sie mit anderen zusammenarbeiten, würde
ich empfehlen, dass Sie sich
an die stark typisierten Modelle halten an die stark typisierten Modelle Möglicherweise erstellen Sie für jeden Datentyp, den
Sie auf der Seite
anzeigen möchten, ein anderes
Modell Sie auf der Seite
anzeigen möchten ,
sodass Sie die Abfrage bei der Ausführung direkt
in das Modell extrahieren und diese Seite anhand dieser Daten
modelliert wird Und wenn Sie
es auf Sie erweitern müssen, erweitern Sie einfach Ihr Modell und erweitern Sie
Ihre Abfrage entsprechend
26. Filtern auf relevante Aufzeichnungen: Ordnung, Leute, wir sind zurück und schauen uns ein anderes Thema
an, und das wird eine
ziemlich kurze Lektion sein, in der
wir über das
Filtern mit verwandten Daten sprechen werden Was ist nun ein Szenario für das
Filtern mit verwandten Daten? Ich habe hier eine Abfrage und
mein Variablenname ist falsch Lassen Sie mich ihn auf Ligen korrigieren Und ich werde
die Ligentabelle abfragen,
aber ich frage die Tabelle der Liga nach etwas
ab, das
das Team Stellen Sie sich also ein Szenario vor, in dem
Sie die Ligen anzeigen, Sie zeigen dem Benutzer die Liste
der Ligen, aber dann erlauben Sie ihm, anhand des Teamnamens zu
filtern Ich kenne also den Teamnamen
oder einen Teil eines Teamnamens
und möchte sehen, in welcher
Liga dieses Team spielt Das heißt, wenn
ich auf Senden klicke, musst
du mir die
Liste der Ligen besorgen, in denen es
möglicherweise ein Team gibt , dessen
Name einen
beliebigen Suchbegriff enthält Stellen Sie sich vor, das wäre ein Suchbegriff,
der vom Benutzer kommt, kurz für Barn Munich, vielleicht Und dann sagen wir hier. Lassen Sie mich einfach die Zeit nehmen, diese Abfrage
neu zu schreiben, damit sie nicht so einschüchternd
aussieht, wie
sie es wahrscheinlich Jetzt sagen wir es
Kontext-Punkt-Beine wo. Damit sind wir alle vertraut. Wir wissen, dass wir
den Lambda-Ausdruck haben. Und dann werde ich sagen, wo Immobilie
ein bestimmtes Kriterium
erfüllt In diesem Fall widerspricht das
Kriterium der Navigationseigenschaft
, also Teams. Also sage ich
Q-Punkt-Teams und dann ist es eine Liste. Also ich kann nicht einfach
Teams diesen Namen sagen . Es ist
eine Liste von Teams. Also werde ich any verwenden, weil
any einen booleschen Wert zurückgibt, der auf einer bestimmten Bedingung
basiert Ich werde also sagen, dass
ich
dasselbe Lambda-Token nicht erneut verwenden kann, weil ich mich bereits in
einem Lambda-Ausdruck befinde Q steht hier also bereits
gleichauf und steht für einen Ligarekord Also kann ich Q nicht wieder verwenden. Deshalb habe ich das X. Es könnte S sein. Noch einmal, der Lambda-Ausdruck, das
Token ist nicht wirklich wichtig, aber ich zeige Ihnen nur, warum ich X in einem und Q in dem anderen
habe weil dieser eine Teilmenge
des größeren Lambda-Ausdrucks ist des größeren Lambda-Ausdrucks Also x Punkt und dann nein, ich kann auf die
Eigenschaften der Teamtabelle zugreifen Also werde ich sagen,
wo der Name ist, und dann wissen wir, dass der
Punkt bereits enthält, und dann den Suchbegriff, und dann haben wir unsere
ausführende Anweisung. Das ist also wirklich alles, was
es gibt, um nach
verwandten Datensätzen abzufragen , oder? Also noch einmal, Teams ist nicht die Haupttabelle.
Das ist die Haupttabelle. Für den Betrieb müssen wir jedoch
in die untergeordnete Tabelle gehen , um eine
bestimmte Bedingung zu erfüllen. Wenn wir uns das ansehen, gibt uns
unsere
generierte SQL-Anweisung lediglich die Liga, in
der existiert, und sie wird
einfach versuchen,
das Team anhand
des Suchbegriffs
oder des von uns angegebenen Kriteriums
auszuwählen das Team anhand
des Suchbegriffs . Und dann würde
uns das eine Liga zurückgeben,
die, wenn ich mich nicht irre, Bundes Llega
wäre
27. Ansichten und: Willkommen
zurück in dieser Lektion.
Wir werden uns ansehen, wie wir
durch Migrationen SQL-Objekte, die
keine Tabellen sind, zu unserer Datenbank hinzufügen
können durch Migrationen SQL-Objekte, die
keine Tabellen sind, zu unserer Datenbank Nun, eine Fallstudie dazu:
Wir haben
bis zu diesem Zeitpunkt Migrationen verwendet, um das meiste zu
kontrollieren, was in unserer Datenbank vor
sich geht Wir würden nicht unbedingt zwei separate Operationen
haben wollen ,
einen, bei dem wir
die Testberichte manuell schreiben, und einen anderen,
bei dem wir Skripte
in
den Tabellen schreiben Es wäre also gut, wenn
wir nur eine zentrale Anlaufstelle für
unsere Datenbank
hätten, Anlaufstelle für
unsere Datenbank
hätten sodass wir
jederzeit ein Rollback durchführen können und wissen , dass alles, was bei
der vorherigen Migration gemacht wurde, durch dieses
spezielle
Verfahren rückgängig gemacht werden kann durch dieses
spezielle
Verfahren rückgängig Denken Sie daran, dass
Migrationen quasi
wie eine Quellcodeverwaltung
für Ihre Datenbank wirken wie eine Quellcodeverwaltung
für In dieser speziellen
Lektion werden wir uns also damit befassen, wie wir eine Funktion hinzufügen
können, wie wir eine hinzufügen können. Und
dann würde dieselbe Technik, die wir für all das
verwenden werden die wir für all das
verwenden Funktion gelten gespeicherte Prozeduren und
jede
Art von Ich werde nicht näher darauf eingehen was
die Skripte sind. An dieser Stelle
gehe ich davon aus, dass Sie bereits wissen,
was eine Funktion ist, die Skalarfunktion
im Vergleich zur Tabellenwertfunktion, und auch, wie unsere
Ansichten aufgebaut sind Also werde ich mich nur darauf
konzentrieren, wie wir
diese Qule in die Migration
und damit diese Qule in die Migration in unsere Datenbank integrieren Nun, wie bei jeder Reise zu
irgendwas mit der Datenbank, beginnt
es damit, dass wir eine Migration
hinzufügen Also kommen wir zu unserer
Paketmanager-Konsole, fügen eine Migration hinzu, und dann nenne ich das einfach Hinzufügen von Teamdetails und Funktion für
frühe Spiele. Wie ich immer sage, möchten
Sie Ihre
Migrationsnachrichten klar formulieren. Seien Sie überhaupt nicht vage. Also füge ich einfach diese Migration
hinzu. Nein, ich habe an
keinem der
datenbankbezogenen Elemente
Änderungen vorgenommen . Ich habe den Kontext nicht geändert. Ich habe
keine der Klassen geändert. Sie stellen also fest, dass diese leer sein
werden,
weil ich eine Migration vorgenommen habe. Ich habe nichts gesagt, was ich
tun sollte, und es wurde
nichts gesagt, was rückgängig gemacht werden könnte. Also müssen wir
den Code manuell eingeben , damit er weiß, was dem Up und was mit dem Dom
zu tun ist. Schauen wir uns also das
Hinzufügen der Funktion an. Also werde ich mir
diese Funktionen SQL besorgen. Und ich werde
Migration Builder sagen. Was also wirklich und
wahrhaftig
passiert wäre , ist, dass ich
zu SQL gegangen bin und das gemacht habe. Ich bin ins
Management Studio gegangen und habe die Funktion
manuell erstellt. Das ist in Ordnung. Aber wie gesagt, ich möchte
es dort
nicht hinzufügen , weil ich in
Zukunft einen Zugangspunkt für alle
datenbankbasierten Änderungen haben
möchte alle
datenbankbasierten , oder? Also werde ich
Migration Builder Dot sagen und dann kann ich SQL sagen. Welches wird einen
Parameter vom Typ Zeichenfolge annehmen. Es erwartet also genau dort
den Befehl cual als Typstring Also werde ich mein A-Zeichen
verwenden, um
diese Zeichenfolge
in eine wörtliche Zeichenfolge umzuwandeln, und dann füge ich diese
Qual-Anweisung einfach genau So wird das
also aussehen. Also Migration Builder Q und
dann übergibst du ein beliebiges Q. Also obwohl es Q ist, eine Funktion zu
erstellen Es ist Q, um eine Ansicht zu erstellen, wie wir es gerade tun werden, oder
eine gespeicherte Prozedur, was auch immer es ist, das ist alles, was
Sie wirklich tun müssen Also werde ich das einfach kopieren und diesen Schritt mit der
Ansicht wiederholen. also davon aus, dass
ich bei dieser speziellen Migration diese
Funktion und diese Ansicht erstellen werde. Nun, ich habe das gesagt, und
ich habe das schon einmal gesagt, also sollten wir uns
mit der Tatsache vertraut machen, dass der Aufwärtstrend die Änderung bedeutet, die
ich vornehmen werde. „unten“ sind die
Änderungen gemeint, die ich rückgängig mache, oder die Dinge, die ich mache wenn diese Migration rückgängig gemacht
wird. Wenn ich also die
Create-Anweisungen innerhalb der Up-Anweisungen habe, bedeutet
das, dass ich die
Drop-Anweisungen innerhalb der Down-Anweisungen platzieren muss . Also mache ich einfach den Punkt SQL Drop View im Migration
Builder und gebe ihm dann
den Namen und dann Drop-Funktion mit diesem Namen. Das ist also das erste
Mal,
dass wir hier in
den Migrationsdateien Dreck in die Finger bekommen . Lassen Sie uns weitermachen
und Datenbank aktualisieren und
zusehen, wie die Magie passiert. Und meine Erfahrung war nicht sehr magisch, weil ich einen Fehler habe. Und wenn ich es mir ansehe, sehe
ich, dass ich
in dieser Zeile einen Fehler habe . Also lass es
mich einfach korrigieren. Ich war übereifrig geworden und
wiederholte die Wortkombinationen. Also lass uns das nochmal versuchen. Sie haben es wahrscheinlich entdeckt und nicht den Fehler bekommen
, der perfekt ist. Und an diesem Punkt ist
alles erledigt. Und wenn wir ganz schnell in unserer Datenbank nachschauen
und uns unsere Ansichten ansehen, dann werden Sie sehen, dass die Ansicht dort
erscheint, ebenso wie die Programmierbarkeit
und die Funktionen und die Skalarfunktionen da haben wir unsere
Funktion Diese Migration war also ein Erfolg. Wenn wir jetzt zurückkommen, werden
wir uns ansehen, wie wir mit einer Ansicht interagieren können. Später werden wir uns ansehen, wie wir mit Funktionen und
anderen skalaren Operationen
interagieren, bei denen wir einen Aufruf tätigen und
Daten erwarten, aber bei einer Ansicht ist
es nicht wirklich ein
Befehl, wir fragen und es wird sich
geringfügig von der Art und Weise unterscheiden ab
und es wird sich
geringfügig von der Art und Weise unterscheiden, wie wir unsere Tabellen abfragen, und es gibt bestimmte Regeln,
die wir kennen müssen Wenn wir also
zurückkommen, werden wir uns
die dafür
erforderlichen Änderungen ansehen die dafür
erforderlichen Änderungen
28. Abfragen Keyless (wie die Views): Hey, Leute, willkommen
zurück. In dieser Lektion werden
wir auf dem
aufbauen, was wir in
unserer vorherigen Episode
getan haben, in der wir
zwei Objekte erstellt haben ,
die nicht tabellengleich sind, in Form einer
Funktion und einer Ansicht Wir werden also mit der
Interaktion mit der
Ansicht fortfahren , da eine Ansicht in der Praxis wirklich wie
eine schreibgeschützte Tabelle
von der Qual-Seite aus
ist eine schreibgeschützte Tabelle
von der Qual-Seite aus Das heißt, wir möchten, dass unsere Anwendung
diese Ansichten abfragen
kann , ähnlich wie
wir normale Tabellen abfragen können Wir
müssen also
eine neue Datenklasse erstellen , die der
Ansicht
entspricht, und
sie dem Datenbanksatz hinzufügen. Also ich habe das schon irgendwie
gemacht , wo ich
eine neue Klasse erstellt habe. Ich habe es in das Domain-Projekt aufgenommen. Ich nenne es Teams,
Trainer, Ligen, und ich habe nur das
Wort Ansicht angehängt, damit Sie wissen, dass wir auf den ersten
Blick erkennen können, eine Ansicht
im Vergleich zu den anderen
handelt Welches Präfix/Postfix auch immer,
das liegt ganz bei Ihnen. Ich mache keine Vorschriften. Ich sage nur, dass es meine Konvention
ist, die Tabellen
anders als die Ansichten zu kennen. Alles klar? Sie könnten auch
einen ganz neuen Ordner erstellen und einen Call it View
eingeben,
tut mir leid, und alle Modelle, die sich
auf die Ansicht beziehen, dort ablegen. Sie
möchten sie jedoch trennen, das liegt ganz bei
Ihnen, solange es sauber und
leicht identifizierbar ist. Nachdem wir nun
diese Klasse zur
Darstellung der Ansicht und der
Daten, die aus der Ansicht
zurückgehen, erstellt Darstellung der Ansicht und der
Daten, die aus der Ansicht
zurückgehen, haben, möchten wir den DB-Kontext
über diese Ansicht informieren. Also werde ich
diesem DB-Kontext eine neue Zeile
hinzufügen, in der
ich DB set sage, ihr den Datentyp gebe und sie einfach den gleichen Namen wie
die
Ansicht in der Datenbank nenne . In unserem Programm Punkt CS werden
wir dem folgen, werden
wir dem folgen was wir bisher
gemacht haben,
und ich habe gerade eine
Methodenabfrage überprüft, die nur den Zweck
haben wird, den Kontext,
die Teams, Trainer, Ligen aufzurufen die Teams, Trainer, Ligen und aufzulisten. Wir werden jedoch sehen,
ob wir wirklich
Ergebnisse zurückbekommen und ob wir dabei
irgendwelche Fehler bekommen Lassen Sie uns das also ausprobieren. Sobald
es auf den Code trifft, werde
ich mit dieser Ausnahme begrüßt,
und sie besagt, dass der Entitätstyp die Definition eines
Primärschlüssels
erfordert Wenn Sie beabsichtigen,
einen Entitätstyp ohne Schlüssel zu verwenden, müssen
Sie ihn explizit wissen
lassen,
tut mir leid, dass er
keinen Schlüssel hat, oder Das ist also zu erwarten, und das ist ein Fehler, den
wir gemeinsam sehen sollten, weil man manchmal von diesem Fehler
überrumpelt wird
und sich nicht ganz
sicher ist, und sich nicht ganz warum man diesen Fehler
bekommt FCR gedeiht
also, wie wir gesehen haben, von relationaler Integrität. Primärschlüssel werden als Primärschlüssel
definiert,
Fremdschlüssel werden als Fremdschlüssel
definiert Und damit weiß es
genau, wie man die Abfragen effizient stellt,
wie man nachverfolgt, ob etwas geändert wird, und wie man einfach alles
überwacht während unserer Anfrage im Kontext
passiert. Nach diesem Standard also eher
unsere neue Tabelle oder unsere
neue Entität. Sie weiß nicht, ob es eine Tabelle ist. Es weiß nicht, ob es sich
um eine Ansicht handelt,
weil wir sie dem DB-Kontext hinzugefügt haben, ähnlich wie wir
jede andere Tabelle hinzugefügt haben. Was das Entity
Framework angeht, wird
es also so behandelt,
als wäre es eine Tabelle. Ausnahme besagte jedoch, dass ich in dieser Tabelle keinen Schlüssel sehe. Wir können keinen Schlüssel
darauf legen. Es ist kein Tisch. Es ist eine Ansicht, und ja,
sie hat keinen Primärschlüssel. Die Ausnahme ist also, dass
wir es
im Model Builder wissen lassen müssen
, dass es keinen Schlüssel hat. Ich muss also sagen, dass Model
Builder die Entität
mit dem Datentyp punktet , und dann
geben wir einfach an, hat keinen Schlüssel. Wenn es also erstellt, weiß
es,
okay, ich bin mir bewusst, dass ich nicht versuchen
sollte, das nachzuverfolgen. Wenn ich eine Tabelle oder
etwas finde, das dazu passt, dann weiß ich genau, was zu tun ist. Eine weitere Sache, die
wir an
dieser Stelle tun möchten, ist, dass wir mit
zwei Ansichten und zwei Ansichten grundsätzlich den Namen der Ansicht in
der Datenbank
angeben können den Namen der Ansicht in
der Datenbank
angeben , nach der gesucht werden soll. Das ist quasi eine
zusätzliche Vorsichtsmaßnahme um sicherzustellen, dass das Ganze
nicht als irgendwelche neuen Elemente,
Autothemen oder neue Arbeiten betrachtet wird.
Das muss
es tun, wenn wir das nächste Mal eine Migration durchführen Ich werde einfach wissen, okay, nun, dieser Datentyp, dieser Klassentyp oder dieses Modell wird direkt
der Ansicht in unserer
Datenbank mit diesem Namen zugeordnet Und es hat keinen Schlüssel, also führe kein Tracking durch. Also werde ich diesen Code
erneut
ausführen und diesen Breakpoint
belassen, damit wir uns ansehen
können, was
im Change Tracker passiert. Diesmal erreicht es also
den Breakpoint. Wenn wir uns die Details ansehen, würden
wir feststellen, dass wir Details
zurückbekommen weil die Ansicht korrekt
ausgeführt wird, und wir bekommen den Trainer zurück, wir bekommen die
Liga und wir
bekommen den Namen so, wie wir es erwarten Und dann weiß der Kontext
wirklich
nichts darüber, was
man verfolgen könnte, oder? Soweit es das betrifft, hat
es seinen Job gemacht und es ist getan, und es macht weiter mit dem Leben. So gehen wir also mit
Situationen um , in denen
kein Primärschlüssel
vorhanden ist , weil Sie am Ende möglicherweise eine Tabelle ohne Primärschlüssel
oder ein solches ID-Element haben könnten. Vielleicht sind Sie
gezwungen, sich mit
einer veralteten Datenbank auseinanderzusetzen , in diese Dinge nicht
durchgesetzt werden, wie wir Sie
ermutigen, sie durchzusetzen,
wenn Sie den
Entity
Framework-Kern von Grund auf neu verwenden , weil diese
Situationen existieren können Aber wenn Sie dann keinen Schlüssel
haben, um zu
kämpfen, dann ist
das das Heilmittel Sie fügen es in den Modellgenerator sobald ich einen Kontext finde, Sie fügen es in den Modellgenerator ein, teilen ihm mit, dass es keinen Schlüssel hat, und dann können Sie es direkt der Ansicht zuordnen , oder wenn es sich
um eine Tabelle handelt, könnten
Sie tatsächlich Punkt zu
Tabelle sagen und den Namen angeben. Es kann also vorkommen, dass
Sie eine Diskrepanz zwischen
dem im
DB-Kontext angegebenen Tabellennamen und
der tatsächlichen Tabelle haben dem im
DB-Kontext angegebenen Tabellennamen und
der tatsächlichen Tabelle Sie können immer zu Tabelle sagen
und ihr dann diesen Namen geben,
so wie wir es bei View getan haben. Okay.
29. Abfragen mit Raw SQL: Hallo Leute, willkommen
zurück in dieser Lektion. Wir werden uns ansehen, wie wir Abfragen mit Roh-SQL
ausführen können. Bisher haben
wir
alles mit unserem Link, unserer
Syntax und unserem C-Sharp geschrieben , und
das war alles perfekt. Aber es könnte
einfach eine Situation Sie etwas Roh-QL
schreiben müssen,
besonders jetzt
,
wo wir es
mit Objekten zu tun haben, die nichts mit Tabellen zu tun haben, und wir sehen
, dass es
etwas komplizierter wird . Wissen Sie, wie führt man
diese gespeicherte Prozedur
oder diese Funktion aus? Wie genau machen wir das, aber wir behalten die gesamte Nutzung
des Entity Framework-Kerns bei. Hier werden wir uns also zwei Beispiele
ansehen, während wir uns durch diese
verschiedenen Szenarien
arbeiten. Jetzt haben wir zwei
Funktionen, mit denen wir rohe Dual-Befehle ausführen können, und zwar von Q R und
von Q interpoliert Beachten Sie nun die Syntax, Kontext für
Teams Also müssen wir immer noch unsere Tabelle
spezifizieren, und dann sagen wir von QL R aus, dann können wir
unsere rohe Anweisung eingeben und dann auflisten Nun muss ich auf einige
der Einschränkungen hinweisen
und auf die Gefahren hinweisen, die
mit dieser Roh-QL verbunden sind Sobald Sie
diese Funktion verwenden, eröffnen
Sie sich tatsächlich
dem Potenzial der SQL-Injection wenn Sie nicht
sehr vorsichtig sind. Deshalb
haben sie dir aus QL Raw
und aus SQL
interpoliert gegeben , oder Also werden wir den Unterschied
in ein paar Augenblicken sehen. Schauen wir uns also an, was
wir von
Q R zurückbekommen . Ich kommentiere
nur die, die wir noch
nicht verwenden. Und aus SQL Raw müssen
wir
so etwas wie Select Star
aus Teams sagen , das ist irgendwie
kontraintuitiv, oder? Wir haben nur gesagt, dass Teams im Kontext
stehen, und dann muss ich wieder sagen,
Sterne aus Teams auswählen. Aber mal sehen, was wir
zurückbekommen, wenn wir das testen. Wenn wir jetzt unsere Ergebnisse überprüfen, stellen wir fest, dass wir
die Liste der Teams
zurückbekommen und wir bekommen alles zurück. Wir haben Sterne auswählen gesagt, also bekommen wir sie zurück
und alles ist gut. Die Sache mit dem
Roh-SQL ist, dass es
Spalten zurückgeben muss , die genau
dem DB-Set oder der Entität
hinter dem DB-Set entsprechen . Mit anderen Worten, wenn ich nur die Namen
der Teams
wollte und ich sage, wähle einen Namen aus den Teams,
lass es mich einfach halten. Es ist nicht einfach. Lassen Sie mich den allgemeinen Namen ID verwenden. Ich möchte nur zwei Spalten
aus der Teamtabelle. Wenn ich das versuche,
erhalten wir am Ende diese Ausnahme,
die besagt, dass
bestimmte Spalten nicht
im
Abfragesatz enthalten sind bestimmte Spalten nicht
im
Abfragesatz , weil versucht wurde nur zwei Spalten
abzufragen,
aber es erwartet. Das ist also eine der Einschränkungen bei diesem rohen SQL-Befehl. Erstens muss die
Abfrage oder die
Ergebnismenge also alle
Eigenschaften des Entitätstyps zurückgeben. Eine andere Sache ist, dass die
Spaltennamen übereinstimmen müssen. Selbst wenn ich
alle Spaltennamen auflisten würde, kann
ich ihnen keine Aliase geben
, die nicht dem ursprünglichen Entitätstyp
in unserer Klasse namens Team entsprechen Und eine weitere Sache ist
, dass wir nicht miteinander verknüpft werden
können, dass wir nicht direkt miteinander verknüpfte Daten
haben Ich kann jedoch an dieser
Stelle sagen, Okay. Also, nachdem ich das Roh-SQL geschrieben
habe, kann ich immer noch meine
Include-Anweisungen machen, und es würde
genauso funktionieren, wie wir wissen dass es
trotzdem funktionieren wird, oder? Also, wenn ich das mache und den Trainer mit
einbeziehe, dann schauen wir nach unseren Teams, und ich denke, Team
Nummer drei hat einen Trainer und los geht's,
wir werden sehen, dass die Trainer-Entität in
Form von Joseph Moreno aufgenommen
wird Also gut. Also das ist eines
der Dinge, die du tun kannst. Wenn Sie dies jemals von
EQ Raw aus ausführen
müssen und zugehörige Daten benötigen, sollten Sie
wissen, dass Sie das auch auf
die gleiche Weise tun können Zu diesem Zeitpunkt sind Sie bereits
mit SQL vertraut. Sie wissen also, wenn wir zum Beispiel einen Filter
hinzufügen wollten , wenn ich
den Fußballverein finden wollte bei dem der Name dieser Variablen
entspricht, und wir haben das in der Vergangenheit gemacht,
wo wir
Benutzereingaben akzeptiert haben und dann
diese Benutzereingabe für
den Filter verwendet haben, oder? Sagen wir einfach
, dass wir
diese Variable für unsere Filterung verwenden wollen . Wir können immer einfach sagen, wo Name gleich ist, und dann übergeben
wir unsere Variable. Interpolation würden
wir also dieses Dollarzeichen
vor die Zeichenfolge setzen, und dann können wir einfach unsere geschweiften Klammern
setzen und dann den
Namen in diesen Bereich setzen Wenn wir uns nun
das QL ansehen, das dafür
generiert wird, werden wir sehen, dass wir uns die letzten beiden Male
nicht unbedingt angesehen haben letzten beiden Male dass es
unsere SQL-Anweisung generiert
und dass es den Links-Join aufgrund
der Includes automatisch durchführt Aber dann nimm das jetzt zur Kenntnis. Was wir
hier tun, ist,
ausgewählte Sterne von Teams weiterzugeben , deren Name gleich ist. Und beachten Sie, dass es
den Wert zwar weitergibt, ihn
aber nicht mit Anführungszeichen weitergibt, denn in SQL
hätten wir angeben müssen, wo
Name gleich ist. einer Zeichenfolge zu tun haben, öffnen Sie vielleicht den Wert Wenn
wir es mit einer Zeichenfolge zu tun haben, öffnen Sie vielleicht den Wert einzeln
und schließen Sie ein einfaches Anführungszeichen. Infolgedessen beschwert es sich, dass es
das Schlüsselwort as nicht finden kann weil A S roma in Ques als AS-Befehl
angesehen wird. Um dem abzuhelfen, müssen wir
in unserer interpolierten
Zeichenfolge die Werte in einfache
Anführungszeichen
setzen einfache
Anführungszeichen Also lass uns das noch einmal versuchen. Und dieses Mal
erreichen wir unsere Breakpoints. Unsere Anfrage war erfolgreich. Aber noch einmal, wenn Sie sich
diese Abfrage im Vergleich zu
früheren Abfragen ansehen, bei diese Abfrage im Vergleich zu denen
wir gefiltert haben, stellen
Sie fest, dass es keine Parameter
gibt. Es wird der Literalwert
direkt an die Abfrage übergeben, A K ist eine schlechte Praxis, QL-Injection. Alles klar? Also, wenn Sie am Ende irgendeinen Parameter
nehmen und einen unformatierten QL-Befehl
verwenden müssen ,
um ihn auszuführen,
dann ist das, was passieren
wird, und Sie müssen sehr
vorsichtig sein, denn wenn jemand bösartigen
Befehl als Eingabe
weitergibt,
dann wären Sie vor den Tagen, an denen das
Entity Framework
entwickelt wurde, um
Ihnen zu helfen, Qual Injection zu verhindern, wieder an denen das
Entity Framework
entwickelt wurde, um
Ihnen zu helfen, Qual Injection zu verhindern In einer solchen Situation nehmen wir die
Dienste
seines engen Verwandten von Qual Interpolated Wenn Sie sich diesen ansehen, werden Sie nach einer
formatierbaren Zeichenfolge gefragt From qual
fragt nur nach einer Zeichenfolge, aber dann fragt from sc interpolated
nach einer formatierbaren Zeichenfolge,
was bedeutet, dass nur
eine interpolierte Zeichenfolge akzeptiert wird aber dann fragt from sc
interpolated
nach einer formatierbaren Zeichenfolge,
was bedeutet, dass nur
eine interpolierte Zeichenfolge akzeptiert wird. Und zweitens müssen wir
diese Autoaussage nicht so wörtlich nehmen,
wie wir es gerade getan haben diese Autoaussage nicht so wörtlich nehmen,
wie , weil Es kümmert sich also automatisch
um die Parametrisierung
des Befehls,
sodass wir den interpolierten oder
den injizierten Wert nicht in Einzelschichten in die Zeichenfolge einfügen müssen interpolierten oder
den injizierten Wert nicht in Einzelschichten in die Zeichenfolge Schauen wir uns
diese Gleichung an und vergleichen sie. Sie sehen also, wir haben
uns das gerade angesehen, wo es
den Literalwert übergeben hat Bei der zweiten Variante
wird es eigentlich darum gehen
, einen Stern aus Teams auszuwählen bei denen der Name gleich
dem Parameter Null ist, und
der Parameter oben definiert wurde Und das ist der
Unterschied zwischen From
Raw von Scale Raw und
From Escule Ich würde also immer empfehlen
, wenn Sie Variablen
mischen und abgleichen müssen, um Variablen
mischen und abgleichen eine rohe Cual-Anweisung
zu übergeben, zu Ihrem Seelenfrieden die interpolierte
Qua zu
verwenden eine rohe Cual-Anweisung
zu übergeben, zu Ihrem eigenen Schutz und zu Ihrem eigenen Seelenfrieden die interpolierte
Qua zu
verwenden.
30. Hinzufügen und Abrufen mit gespeicherten Prozeduren: Hey, Leute, willkommen
zurück. In dieser Lektion werden
wir uns die Interaktion
mit gespeicherten Prozeduren mithilfe des
Entity Framework-Kerns
ansehen . Die Fallstudie
, warum Sie mit einer
gespeicherten Prozedur interagieren
müssten , beruht der Tatsache, dass Sie es
vielleicht
mit älteren Systemen zu tun haben , bei denen ein Großteil der Logik in gespeicherten
Prozeduren in der Datenbank enthalten ist. Bei der Neuerstellung
möchten Sie also nicht den Aufwand verdoppeln, neu schreiben,
sondern sie einfach wiederverwenden. In dieser Situation müssen
Sie wahrscheinlich nur wissen, wie Sie gespeicherte
Prozeduren von FCR
aufrufen Ich habe also einen sehr einfachen Code, ich für
den Kontext oder die
Datenbank erstellt habe, in der ich nur
den SPG-Teamcoach habe, eine Team-ID erhält und dann
alles aus
der Trainertabelle zurückgibt alles aus
der Trainertabelle Denken Sie jetzt daran, dass wir, wenn wir
es mit rwQul zu tun haben , alles zurückgeben müssen, was dem
passenden
Entitätstyp entspricht In Ordnung, du
kannst also nicht einfach einen Namen sagen. Wenn du sie auflisten
willst, musst
du sie in der Reihenfolge der Spaltennamen
auflisten , mit
den gleichen Spaltennamen, ohne Ss und so. Wie bei unseren
Ansichten und Funktionen werden
wir als Erstes eine neue Migration
erstellen. Ich habe eine Migration hinzugefügt und gesagt, dass der Name des SPG-Coaches
hinzugefügt wurde. Ich habe den Namen
der Migration durcheinander gebracht ,
aber wir machen weiter Und dann habe ich den
Migration Builder installiert, um
die Prozedur zu erstellen und sie anschließend
auf ähnliche Weise zu löschen Sie können also weitermachen und die Migration
durchführen und diese Schritte ausführen, und dann können wir einfach unsere Datenbank
aktualisieren. Und dann können wir mit der
Interaktion mit unserer
gespeicherten Prozedur beginnen . Jetzt, in unserer Programm-CS-Datei. Ich habe bereits einen Beispielcode
geschrieben, und die neue Methode
,
mit der wir arbeiten , ist gespeicherte Prozedur. In der Store-Prozedur habe ich einfach eine Team-ID hartcodiert, und dann übergebe ich sie
an
die rohe SQL-Anweisung
und warte auf das Ergebnis. Schauen wir uns nun die Syntax an. Ich sage, warte auf den Kontext
, die Trainer machen FC R, dann rufe ich meine Exekution
an, um mir einen SPG-Teamtrainer zu besorgen, und dann habe ich einen Platzhalter Beachten Sie, dass ich von
squlRW aus verwende . In der vorherigen Lektion
habe ich aufgehört, es zu verurteilen und gesagt, dass es
schlecht ist, weil es Ihnen
die Möglichkeit bietet, eine doppelte Injektion zu erhalten Die Realität ist, dass es davon abhängt,
wie Sie es verwenden. Also habe ich dir gezeigt,
wie man es anfangs schlecht benutzt wo ich eine
interpolierte Zeichenfolge verwendet
und die gültige Zeichenfolge direkt übergeben Also wurde das alles in wörtliches QL
übersetzt, was das
Schlimmste ist,
was man
zwischen Benutzereingaben und dem Aufrufen der Datenbank haben kann was man
zwischen Benutzereingaben und Parametrisierung ist immer am besten, daher bevorzugen wir das
Interpolierte Aber dann sollten wir einen
Schritt zurücktreten und SQL Raw nicht zu sehr verdammen SQL Raw nicht zu sehr denn wenn wir uns die Überlastung
ansehen, heißt
es wirklich,
gib mir die Zeichenfolge
SQL und dann gib mir
eine heißt
es wirklich,
gib mir die Zeichenfolge
SQL und dann gib mir SQL und dann gib mir Das ist also genau das,
was wir hier getan haben. Ich sage DBO dot SP get Team Coach, und dann verwende ich einen Platzhalter Und dann, nach dem
Platzhalter nach dieser Zeichenfolge, habe ich jetzt den Parameter eingefügt. Wenn Sie es also auf diese
Weise tun, wird
es
die Parametrisierung für
Sie genauso übernehmen ,
wie wir es
von Equal Interpolateed gesehen haben von Equal Interpolateed Es ist also nicht die schlechteste
Methode und sie ist auch nicht völlig nutzlos, weil Sie wahrscheinlich Also warum haben sie es eingesetzt,
wenn es so gefährlich ist? Es gibt eine gute Art,
es zu benutzen , und es gibt eine
schlechte Art, es zu benutzen. Also habe ich dir den schlechten Weg gezeigt. Hier ist die bessere oder
empfehlenswertere Art, es zu benutzen. Schauen wir uns das also an. Wenn wir uns nun
ansehen, was wir zurückbekommen,
stellen wir fest, dass unsere Abfrage generiert
und parametrisiert
wird, wie wir es gesagt haben oder
erwartet Da nimmt sie also
diesen Parameter von drei eine dritte
Prozedur aus. Und dann ist unser Ergebnis Information von
Joseph Marina als Teamtrainer
der
Mannschaft mit der Kennung Drei So können Sie also eine gespeicherte Prozedur
ausführen. Und so ziemlich führen wir Befehle eine Datenbank aus
, die ja, Abfragebefehle
sind. Wir fragen die Datenbank nach etwas und wir
sehen, dass es zurückgegeben wird. In dieser Situation müssen wir also
diese rohen QL-Befehle für
eine Tabelle ausführen . In jeder Situation. Was nun passiert, wenn
wir
eine gespeicherte Prozedur ausführen müssen , die keiner Tabelle oder Abfrage
zugeordnet ist ,
ist etwas, das keinem Entitätstyp
direkt zugeordnet
ist. Wir benötigen also Roh-QL für ein Objekt, das keinem Entitätstyp
zugeordnet ist. Damit
werden wir uns
in unserer nächsten Lektion befassen. Okay.
31. Non-Query: Ihr werdet in dieser Lektion
zurückkommen.
Wir werden uns
ansehen, wie wir Befehle
ohne Abfrage in der Datenbank
ausführen können Befehle
ohne Abfrage in der Datenbank
ausführen Ein Beispiel dafür
wäre, wenn wir etwas löschen
oder aktualisieren möchten , das die Daten
manipuliert oder
erweitert, aber nicht
unbedingt
etwas zurückgibt uns
aber nicht
unbedingt
etwas zurückgibt, weil
wir Bis jetzt haben wir also
ausgewählt und ausgewählt und ausgewählt Schauen wir uns an, was wir tun,
wenn wir nicht auswählen, aber
diese Art von Befehl ausführen müssen. Ich habe auf dem Bildschirm ein neues
Migrationslöschteam von IDP,
SP, die Abkürzung für gespeicherte Prozedur, und ich habe
den Code zum Erstellen der gespeicherten Prozedur
namens Delete Team by ID, die eine
Team-ID als Parameter die eine
Team-ID als Parameter verwendet
und dann
das Team entsprechend löscht Wir haben die Aufwärts- und
Abwärtsmethoden, die ich pausieren,
replizieren und dann
weitermachen und die Daten aktualisieren kann replizieren und dann
weitermachen und die Daten aktualisieren Nachdem Sie
das erfolgreich abgeschlossen haben, können
Sie zum
Programm Punkt CS wechseln und sehen der Befehl method
execute non query
bereits erstellt wurde Wenn wir nun den Non-Query-Befehl
ausführen, gibt es ein paar Dinge,
die sich von dem
unterscheiden werden , wenn wir wissen , dass wir eine
Ergebnismenge erwarten und ich versuche beide Codesätze auf dem Bildschirm damit wir eine
vergleichende Analyse durchführen können. Erstens wird uns nur
mitgeteilt, wie viele Rollen betroffen
sind. Im Gegensatz zu der Zeit, als
wir nach den Teams
gesucht haben, wussten wir, dass wir eine Reihe von Teams
zurückerhielten. In dieser Situation
erhalten
wir nur eine
Variable zurück, die die Anzahl der betroffenen Zeilen angibt. Ordnung. Also das ist alles, was
wir bekommen. Das ist einer. Zweitens, als wir
die anderen Spiele gemacht haben, bei denen wir wussten, dass
wir Daten zurückbekamen, wussten
wir, gegen welchen Entitätstyp oder welches Datenbankset wir das ausführen sollten, weil man nicht erwarten
würde, dass man
ausgewählte Stars von Trainern abfragt ,
sondern das Team in einen Kontext stellt Wir wissen, dass Sie
einfach eine Fehlermeldung erhalten würden, wenn
versucht wird , diese
Methode vollständig auszuführen in dieser Situation jedoch nicht wissen, Da wir in dieser Situation jedoch nicht wissen,
was die gespeicherte Prozedur tun wird, wissen
wir nicht, mit welcher Tabelle sie
direkt interagiert. Wir sagen
Kontext-Punkt-Datenbank statt
Kontext-Punkt-DB-Setname. Also Kontext-Punkt-Datenbank, und dann werden die Methoden, die wir bekommen,
etwas anders sein. Im Fall des DB-Sets werden
wir von CLR und
von Q interpoliert In dieser Situation
erhalten wir eine Datenbank, die
SQL raw ausführt , und sie hat eine
asynchrone Version. Wir haben also Raw und
wir haben R A Sync. Daher der Witz, wo
ist der Asynchrone. Und dann haben wir auf ähnliche Weise unser
gleichwertiges interpoliertes Async ausgeführt. Wir haben also die
interpolierte Version und wir haben die Rohversion . Nun haben wir bereits die schlechte Verwendung der Rohmethode und
die akzeptabelere,
die sicherere Anwendung der Rohmethode
untersucht Rohmethode und
die akzeptabelere,
die sicherere Anwendung der Rohmethode Das Gleiche gilt auch hier. Wir wissen nicht, welche gespeicherte
Prozedur wir verwenden werden, aber wir wissen, dass wir einen Wert übergeben
müssen
, der
höchstwahrscheinlich von unserem Benutzer übernommen wird . Wir wollen
uns also schützen und eine formatierte Zeichenfolge
mit einem Platzhalter
verwenden,
nicht die interpolierte
Zeichenfolge, wenn wir die Q R A ausführen“
verwenden Und
wenn Sie dann nicht die zusätzliche
Verantwortung haben wollen, so viel
nachzudenken, ist
das natürlich zusätzliche
Verantwortung haben wollen, so viel
nachzudenken, ist
das so viel
nachzudenken Deshalb haben sie
dir die Alternative gegeben du einfach die
interpolierte Zeichenfolge übergibst und das Gleiche für dich tut Schauen wir uns also an, was wir
bekommen, wenn wir diese
Methoden ausführen. In Ordnung. Also ich sehe mir den Kill an, der generiert wurde,
und ich sehe hier,
dass er mit Team-ID zwei
parametrisiert wurde und alles
so aussieht, wie ich Es sagt mir jedoch, dass
es gescheitert ist. Warum ist es gescheitert? Das liegt an der
Fremdschlüsseleinschränkung , die ich aktenkundig gemacht habe. Ich habe also ähnliche Spiele wie
die Mannschaft mit ID zwei. Also kann ich den benutzen.
Das sind meine schlechten Daten. Lass es mich nochmal versuchen. In Ordnung, also passe ich meine Werte an,
weil ich nur nach Teams
suchen möchte , von denen ich
weiß, dass sie keine Spiele haben. Also sollten wir nicht wieder Fehler bei der Einschränkung von
Fremdschlüsseln haben . Lass mich das noch einmal versuchen. Und diesmal haben wir den
Breakpoint erreicht, was bedeutet, dass alles ordnungsgemäß ausgeführt
wurde. Wenn ich mir nun die
betroffenen Rollen ansehe, LC, eins. Wenn ich hier nach unten schaue, sehe ich einen. Es sagt Ihnen also nur, dass wir
das erfolgreich ausgeführt haben, und das ist die Anzahl der
Zeilen, die betroffen waren. Wenn Sie also wollen,
dass ein Flag sagt, es erfolgreich
war oder nicht,
dann könnten Sie immer sagen, ist die Anzahl der betroffenen
Zeilen größer als eins, dann können wir sagen, dass es
erfolgreich war. Alles klar? Also das ist
es wirklich für die Ausführung QL-Befehlsanweisungen, die keine Abfragen sind, mit Roh-QL. Okay.
32. Seeding: Hey, Leute, wir kommen in dieser Lektion
wieder. Wir werfen
einen kurzen Blick auf
eine der weniger befahrenen Straßen, über die man
aber unbedingt Bescheid wissen sollte,
nämlich, wie man Daten einspeist. Falls Sie mit dem,
wovon ich spreche,
noch nicht so gut vertraut sind,
ist Daten-Seeding der Vorgang, bei dem zu Beginn Daten in die Datenbank
eingegeben Sobald Ihre
Anwendung installiert ist, dort möglicherweise Standarddaten,
die Sie benötigen, z. B. eine Liste von Ländern oder bestimmten Rollen oder
wie ein Standardbenutzer, haben möchten solche
Dinge, die Sie
wahrscheinlich nur zum Zeitpunkt
der Erstellung im System Sobald die
Datenbank erstellt ist, müssen
diese Dinge da drin sein. COR ermöglicht es uns, das fest zu codieren ,
sodass wir, wann immer
unsere Datenbank mit diesem
Skript
generiert wird oder wenn wir
die Update-Datenbank ausführen , um die Datenbank mit
allen Migrationen auf den neuesten Stand zu bringen
, tatsächlich Code eingeben können, der als Migration
angesehen wird. Wenn diese Migration
ausgeführt wird,
werden als Migration
angesehen wird. Wenn diese Migration diese Daten automatisch aus dem Abruf-Code
in die Datenbank übernommen. Darauf wollen wir uns in dieser Lektion kurz konzentrieren. Der einfachste Weg, das Seeding zu
erledigen, besteht darin,
es mit der Methode zur Modellerstellung durchzuführen Unter all dem können wir Model Builder Dot
sagen
und dann eine Entität spezifizieren Nehmen wir an, wir haben Teams, wir haben Ligen, wir haben
Spiele, wir haben Trainer Nehmen wir an, ich wollte
einige Trainer in das System aufnehmen. Ich sage Entitätscoach und dieser Entitätscoach hat Daten, und dann kann ich mit diesen
Daten so viele
Coaches
angeben, wie ich benötige. Das ist kein Ci Brass
, das sind Klammern. Und in diesen Klammern würde
ich jetzt anfangen, ihm neue Coach-Objekte
zu geben Ich kann also sagen, neuer Trainer. Ich kann die
ID von Anfang an angeben. Ich werde einige IDs verwenden, von denen ich
weiß, dass sie nicht mit
den vorhandenen kollidieren. Der Name ID 20
entspricht Ich werde in dieser Situation meinen
Namen verwenden. Und die Team-ID. die kann ich auch lassen,
weil ich in der Kutsche Platz nehme. Nun, das bringt einen weiteren
wichtigen Punkt. Wenn Sie über hierarchische Daten verfügen, müssen Sie
sicherstellen, dass Sie
entsprechend der Reihenfolge oder dem Grad
der Abhängigkeit angeordnet sind, genauso wie wir die Tabellen mit
den Abhängigkeiten erstellen
möchten ,
genauso wie wir die Daten mit
diesen Abhängigkeiten ausstatten
müssen die Daten mit
diesen Abhängigkeiten ausstatten
müssen Weil ich nicht erwarten kann, Trevor Williams,
den Trainer von Team ID Five,
hinzuzuziehen , aber dann definiere ich das Team mit ID Five nach all dem Alles klar? Also lass mich
genau zeigen, was ich meine. Wenn ich Team sage,
will ich ein neues Team, ich werde ein neues Team gründen und dieses Team wird, sagen wir, ID 20
haben Der Name des Teams ist Trevor Williams Sample
Team. In Ordnung. Ich kann
diesem Trainer nicht sagen, dass seine Team-ID 20 ist,
weil die Reihenfolge, in ich diese
Startbefehle definiert habe,
die Reihenfolge ist , in
der die Autoabrechnung generiert wird. Ich kann also keinen
Trainer erstellen und den
Trainer mit der Team-ID 20 einfügen , wenn die
Team-ID 20 noch nicht existiert Also muss ich
sicherstellen, dass ich meine Reihenfolge entsprechend dem Grad
der Abhängigkeit beibehalte Nein, wie ich schon sagte, du kannst so viele
eingeben, wie du willst. Also habe ich hier einen neuen Coach, und dann kann ich einfach
so viele Objekte vom
neuen Coach trennen , wie ich brauche. Wenn ich also zunächst drei Trainer
im System haben wollte, können die IDs
natürlich kollidieren. Dann behalten wir einfach diesen Namen, Probe eins und Probe zwei. Und dann für die Teams, naja, ich kann nicht immer
und immer wieder Trainer derselben Mannschaft sein. Weil wir die Einschränkungen kennen. Welche Einschränkungen auch immer in der Datenbank existieren
, sie
werden natürlich auch die
Beschränkungen bestimmen, die Sie haben, wenn Sie Ihre
Sitzplätze einrichten, oder? All das sollten Sie sich nur
bewusst sein. Natürlich ist
dies auch hier wahrscheinlich der Zeitpunkt, an dem das
System gerade installiert wurde Ich verwende also die IDs 2021
und 22, weil ich bereits Teams und Trainer im System habe.
Ich möchte nicht aneinandergeraten. In einem brandneuen System
und einem brandneuen Paradigma würden
Sie jedoch wahrscheinlich mit eins, zwei, drei,
vier als Ihren IDs
beginnen, weil das
die IDs sind, die Sie definitiv
vor allem anderen haben möchten Nun, wenn Sie
Seeding für mehrere Tabellen durchführen würden, können
Sie sehen, dass das
ziemlich umständlich werden kann, und ehrlich gesagt mag
ich es nicht, all
das bei der Modellerstellung zu sehen Das ist zu viel Code. Ich möchte es etwas sauberer halten. Was ich also tue oder ich würde Ihnen empfehlen, in dieser Situation zu
tun, ist, diese in
Seed-Konfigurationsklassen zu extrahieren. Ich tendiere also dazu,
einen Ordner zu erstellen und das im Datenprojekt in
der
Nähe der Migrationen zu tun Datenprojekt in
der
Nähe der Migrationen Also nenne ich es Konfigurationen, und dann habe ich dort einen weiteren Ordner,
weil es vielleicht
mehrere Konfigurationstypen gibt , die wir vielleicht verwenden möchten Ich nenne
das mal Entitäten. Und dann werde
ich darin die verschiedenen
Konfigurationsklassen
pro Entitätstyp haben . Ich möchte zum Beispiel eine
Coach-CD-Konfiguration. Nun, in dieser Klasse, die ich veröffentlichen werde, werde
ich von der
Entitätstypkonfiguration erben Also werde ich einfach weitermachen
und mir die Referenz schnappen
und ihr sagen, dass
sie für den Typ Coach ist Und füge dann alles hinzu
, was fehlt. Also für den Typ
Coach will ich das. Jetzt muss ich diese Schnittstelle
implementieren,
die mir diese Methode
konfiguriert und einen lokalen Builder gibt. Jetzt, wo ich diesen Builder habe, ähnelt
dieser Builder im Grunde demselben Zweck wie dieses
Model Builder-Objekt, oder? Ich kann also einfach sagen, dass es Daten hat. Ich nehme einfach
diesen Teil, was das Team angeht, lassen Sie mich einfach den
Teil mit den Daten übernehmen. Ich werde schneiden, ich werde das alles
aus dem DV-Kontext
löschen Und dann
möchte ich sagen Builder,
Punkt und dann drüben auf hat Daten Also alles, was ich hatte, hat Daten und mehr, passt
perfekt zu dieser Methode. Builder Dot hat also Daten, und dann können Sie beliebig viele
See-Datensätze in diese spezielle Klasse
einfügen . Wenn ich jetzt zu einer speziellen Klasse
übergehe, brauche
ich natürlich eine Möglichkeit, sie referenzieren oder im DB-Kontext darauf verweisen
zu lassen. Also zurück im DB-Kontext sage
ich Model Builder
Punkt, Konfiguration anwenden
und dann neu und übergebe
einfach den Namen dieser
Methode oder, und dann neu und übergebe
einfach tut mir leid,
diese neue Klasse, die wir erstellt haben, sich um eine neue
Konfigurationsklasse handelt. Also übergebe ich einfach eine
neue Instanz davon und das war's. So viele
Konfigurationsklassen Sie erstellen, Sie müssen nur diese Zeilen
übergeben. Nochmals,
diese Reihenfolge beibehalten. Also habe ich das für die Sitze im Bus
oder in der Kutsche gemacht. Lass uns dasselbe
für die Teams tun, oder? Also werde ich hier einfach faul
spielen und
einfach
die bestehende Datei kopieren und einfügen und
den Namen einfach in
Teamsitz, Konfiguration ändern . Und dann werde ich
die Referenzen in der Datei aktualisieren. Das ist also ein
Vierer-Team. Das ist für das Team. Und dann wird unser Datenbereich direkt daraus
entstehen. Ich werde es einfach ausschneiden und in die entsprechende
Konfigurationsdatei
einfügen. Und zurück im DV-Kontext kann
ich
das einfach duplizieren und
Team-Seed-Konfiguration sagen ,
und los geht's Das sieht für mich viel
übersichtlicher aus
und ist genauso
effektiv, als ob
alles in der Datei Aber natürlich bleibt diese
Methode ein bisschen
koscher und sieht ein bisschen besser aus,
wenn wir es so machen Schauen wir uns also
an, was wir bekommen, wenn wir versuchen, eine Migration hinzuzufügen Und wenn ich das mache, nenne ich es zusätzliche
Standardteams und Trainer. Ich sehe jetzt, dass der Migration Builder
etwas anderes macht. Wir haben
ihn das noch nie zuvor tun sehen. Es heißt also immer
Tabelle erstellen oder Tabelle ändern. Jetzt fügt es Daten in die Tabellenteams mit diesen
Spalten mit diesen Werten ein, und das macht es
für alles. Und wieder einmal ist
diese Reihenfolge wichtig. Ich sehe, es hat sich um alle Teams gekümmert
. Und dann wird es sich um all die Trainer
kümmern, die von den Teams abhängig
sind, richtig? Stellen Sie sich also vor,
wir
würden versuchen, einen Trainer mit
einer Team-ID 21
einzufügen , bevor
das Team mit der ID 21 überhaupt
erstellt wurde, das Rezept für eine Katastrophe. Denken Sie also daran, dass
Ordnung wichtig ist. Und in D machen die
Löschdaten einfach all diese Einfügungen
mit dieser Löschanweisung
rückgängig mit dieser Löschanweisung Wenn ich also eine Datenbank aktualisiere, erhalte
ich diesen
Fehler, okay Ich erhalte die Fehlermeldung,
dass ich
einen Konflikt mit der Team
- und der Liga-ID-Spalte habe. Ordnung. Das ist in Ordnung. In dieser Situation muss
ich ändern, was
mit dem Team passiert , weil ich die Daten
nicht vervollständigt habe, also müssen Sie sich dessen bewusst sein. Sie müssen sich
der Tatsache bewusst sein, dass Ihre Einschränkungen bestimmen,
ob die Daten eingegeben werden können oder nicht Die Liga-ID kann also nicht Null sein. Das ist eine Einschränkung
, die sich auf der Datenbank befindet. Eine Mannschaft muss in einer Liga spielen. Ich kann also keine
Mannschaften ohne Ligen einsetzen. Also werde ich schnell
eine Beispielliga erstellen. Also folge den gleichen Schritten, und ich werde
dich ermutigen, eine Pause einzulegen und es selbst
auszuprobieren. Aber was ich getan habe, ist, eine neue Klasse zu
erstellen, die ich League
Seed Configuration nenne. Dabei
folge ich den gleichen
Schritten, die ich von der
Entitätstyp-Konfiguration vom Typ League übernommen von der
Entitätstyp-Konfiguration vom Typ League Und dann bauen wir einfach wieder
eine Liga mit der
ID 20
auf, um Konflikte
in der Datenbank zu vermeiden,
und der Name ist Sample Dann aktualisiere ich rückwirkend meine
Teamstartkonfiguration
, um
jedem dieser Teams diese Liga-ID hinzuzufügen , und damit auch den
DB-Kontext, in dem ich jetzt die
League-Startkonfiguration vor
allem
anderen habe vor
allem
anderen Jetzt habe ich einen
Fehler gemacht, okay? Ich habe diese Migration generiert
, als die Daten unvollständig waren. Jetzt sehen wir, dass
diese Migration fehlschlägt. Wie machen wir einen Rollback? Nun, der erste Schritt besteht
darin, die Migration zu entfernen. Dadurch wird also immer
die letzte Migration entfernt. Und dann kann ich es einfach erneut generieren. Und wenn wir uns dieses Mal ansehen, sehen
wir, dass es zuerst
die Liga schafft, dann die
Teams und dann die Trainer. Schauen wir uns also noch
einmal die Update-Datenbank an. Und nach eingehender Protokollierung
und sehr verbalen Äußerungen sehen
wir, dass wir fertig sind, und wir wissen
jetzt, dass wir diese Daten haben Also wieder einmal, das
ist jetzt eine Migration. Es wird also erwartet, dass sie
entlang der Kette von der
ersten Migration bis zur
allerletzten Migration
, die Sie möglicherweise
für Ihre Datenbank durchführen, stattfindet ersten Migration bis zur
allerletzten Migration . Es kann also vorkommen, dass Sie im Laufe der Zeit
verschiedene Suchvorgänge und
Tabellen einführen müssen ,
und Sie benötigen diese Werte vom ersten Tag an
als Standardwerte Nun, das ist perfekt dafür. Sie fügen
einfach die Konfigurationen hinzu
und dann können Sie
sie einfach in den DB-Kontext stellen. Der Modellbauer
weiß also, dass ich bei der
Erstellung
meines Modells diese
Sitzkonfigurationen berücksichtigen muss.
33. Back: Hallo Leute, willkommen
zurück in dieser Lektion Wir werden uns mit dem
Rollback und der Verwaltung von
Migrationen im Allgemeinen befassen Rollback und der Verwaltung von
Migrationen Wir haben also
einige Aktivitäten durchgeführt bei denen wir einige
Änderungen an unserer Datenbank vorgenommen haben, und bei jeder Änderung haben wir
eine Migration vorgenommen und dann die Datenbank
aktualisiert Aber was passiert, wenn Sie
eine Migration durchführen, die Sie nicht wirklich wollen,
oder wenn
Sie sie rückblickend möchten nicht wirklich wollen,
oder wenn
Sie sie rückblickend rückgängig machen,
eine Anpassung vornehmen und sie wiederholen In diesem Beispiel habe
ich bereits eine Migration durchgeführt Ich zeige
Ihnen die Änderungen, die ich
vorgenommen habe , um diese Migration auszulösen. Ich habe das Basisdomänenobjekt so geändert , dass es diese vier Felder enthält. Und diese Felder werden normalerweise zu Prüfungszwecken
verwendet. Wissen Sie, wenn Sie Leute
haben, die
Daten in eine Datenbank eingeben , möchten
Sie wissen, wann sie
erstellt wurde, wann sie zuletzt
geändert wurde und von
wem erstellt und von wem geändert. Normalerweise möchten Sie, dass
diese Informationen klar und deutlich sind. Also habe ich sie
bewusst falsch benannt, nur um Ihnen einen
Fehler zu zeigen, der wahrscheinlich eine Korrektur oder
einen Rollback oder
etwas Ähnliches
rechtfertigen würde eine Korrektur oder
einen Rollback oder
etwas Ähnliches
rechtfertigen einen Rollback oder
etwas Ähnliches Wenn
Sie sich also in dieser Situation nur
die Spaltennamen ansehen, sind
sie nicht wirklich
sehr zusammenhängend, oder? Erstellungsdatum, letzte Änderung. Wenn ich mir nur diesen Namen
ansehe, weiß
ich nicht, ob das das Datum der letzten Änderung
ist
oder ob es das letzte
Änderungsdatum ist, von wem. Ich weiß nicht, ob mit
dieser Änderung das
Änderungsdatum oder
die Person gemeint ist, die es geändert hat. Ich weiß es nicht. Du
verstehst, was ich meine. Also das sind die Dinge
, wenn, du weißt schon, wenn du von diesen Details
besessen bist, dann werden diese Dinge für dich
irgendwie hässlich aussehen Der Punkt ist jedoch, dass ich diese Anpassungen am Basisdomänenobjekt
vorgenommen habe , das natürlich
von jedem anderen Domänenobjekt vererbt
wird von jedem anderen Domänenobjekt Als ich also
die Migration generiert habe, die ich gerade als
zusätzliche Prüffelder bezeichnet habe, können
Sie weitermachen und das tun, wissen
Sie, Sie können mit mir
zusammenarbeiten. Aber als ich das gemacht habe, ist Ihnen
aufgefallen, dass
diese Spalten einfach zu jeder
einzelnen Tabelle hinzugefügt wurden , die es gibt. Aber rauf und runter. Und dann habe ich die Datenbank
aktualisiert, was ein
erfolgreicher Vorgang war. Ab sofort hat jedes Feld in der Datenbank
diese Auditspalten. Was passiert nun, wenn ich damit nicht mehr zufrieden
bin? Wir haben also
bereits gesehen, dass wir die Migration jederzeit entfernen
können, wenn wir eine Migration
generieren und feststellen,
dass
möglicherweise ein Fehler vorliegt. Aber schauen Sie sich an, was passiert,
wenn ich versuche,
das zu entfernen . Und wenn ich
zum Befehl gehe und sage, Migration
entfernen, wird alles
erstellt und ist erfolgreich. Aber dann erhalte ich die
Fehlermeldung, dass
die Migration mit diesem Namen bereits
auf die Datenbank angewendet wurde. es rückgängig und versuchen Sie es erneut Wenn es auf andere Datenbanken angewendet wurde,
sollten Sie erwägen, die Änderungen rückgängig
zu sollten Sie erwägen, die Änderungen rückgängig Sie sehen all das.
Mit anderen Worten, diese Migration wurde
bereits angewendet. Es kann also nicht einfach die
Migration entfernen , da beim Entfernen der
Migration tatsächlich die Referenz oder
der Datensatz dieser
Migrationsdatei aus dem Ordner
gelöscht der Datensatz dieser
Migrationsdatei aus dem Ordner Es ist also
ausfallsicher, heißt es, ich habe
diese Änderung an der Datenbank bereits zur Kenntnis Ich kann das also nicht einfach
aus
der Historie löschen , ohne dass Sie die Datenbank
ändern. Deshalb sind
wir hier, um zu verstehen, wie wir
mit diesem Rollback umgehen Und es ist ein ziemlich
einfaches Verfahren. Ich weiß nicht, vielleicht
hätte uns
diese Nachricht
einen größeren oder
besseren Hinweis geben können, wie wir die Datenbank wiederherstellen
könnten, aber lassen Sie uns das gemeinsam tun Wiederherstellen der
Datenbank ist also wirklich eine
Aktivität zum Aktualisieren der Datenbank, oder? Klingt irgendwie widersprüchlich, aber arbeite einfach mit mir zusammen Um die Datenbank auf
einen früheren Zeitpunkt zurückzusetzen, müssen wir
unseren
Befehl zum Aktualisieren der Datenbank ausführen und ihr mitteilen
, auf welche Migration
wir aktualisieren möchten, und zu
welcher, wenn sie in der Vergangenheit liegt,
sie wirklich Ich möchte also zu
der Migration zurückkehren , bei der
ich die Standardteams
und Trainer hinzugefügt
habe , kurz bevor ich die Prüfungsfelder hinzugefügt habe Also werde ich die Datei einfach sehr langsam
verdoppeln, oder Sie können mit Recht
Umbenennen sagen, und ich
kopiere einfach den Dateinamen Ich brauche das CS nicht. Ich brauche nur den Namen
, weil das der Name
der Migration ist , die tatsächlich gespeichert
ist
, dieser Zeitstempel-Unterstrich und was auch immer
Sie dahinter stecken Also sage
ich in der Package Manager Console nochmal Datenbank Und dann
gebe ich einfach den Namen der Migration in Anführungszeichen ein und drücke
die Eingabetaste,
und dann sehen Sie, dass
tatsächlich das getan wurde , was in der Erledigten enthalten
war. Alles klar? Also das ist alles, worüber wir reden, wenn du es
drauf hast und du es geschafft hast. Die Befehle, die gerade
ausgeführt
wurden, sollten also von
allem dort entfernt werden. Es ändert und
löscht die modifizierte Spalte. Wenn Sie in den Do-Teil schauen, nun ja, die Migrationsdatei, tut mir leid, wenn Sie in den fertigen
Teil dieser Migrationsdatei schauen, ist
das alles, was sie tut, sie sagt ihr, dass
sie die Spalten löschen soll Das ist also ein praktisches
Beispiel dafür, was passiert.
Wir machen einen rückgängig und zweitens , wenn dieser Down-Vorgang tatsächlich
aufgerufen wird, macht
er tatsächlich
alles rückgängig, was der Up-Vorgang bewirkt hat Jetzt, wo wir die Datenbank
auf eine frühere Version zurückgesetzt
oder aktualisiert haben , kann
ich jetzt tatsächlich weitermachen
und mit Sicherheit sagen, kann
ich jetzt tatsächlich weitermachen und mit Sicherheit sagen Sie wird es
bereitwillig und
ohne Rückfragen oder
Bedenken tun , und los geht's Die
vorherige Migration wurde entfernt. Ich werde nur
Anpassungen an meinem Hauptobjekt vornehmen.
Da haben wir's. Ich habe diese
Spaltennamen aktualisiert, damit sie
etwas besser beschreiben, was
in ihnen stehen wird Erstelle ein Datum, Änderungsdatum, erstellt von, geändert von Nachdem wir all das getan
haben, fügen wir einfach unsere Migration
wieder hinzu und
fügen das Datum hinzu, an dem sich das
Audit anfühlt. Okay. Und wenn das erledigt ist, möchte
ich nur, dass wir uns ansehen, was
mit unserer Datumsspalte passiert. Das sind also Spalten mit Datum
und Uhrzeit, für die keine NULL-Werte zulässig sind. Das passiert, wenn Sie
ein Datums- und
Uhrzeitfeld in der Datenbank haben , für das ein Wert eingegeben werden kann, oder wenn ein Wert eingegeben werden muss Deshalb erhalten wir diesen
Standardwert überall dort, wo diese Datums- und Uhrzeitspalte hinzugefügt
wird, oder Wir können also kein Datum
in einem Datumsfeld haben, für das NULL-Werte zulässig sind. Es wird also
das Standarddatum eingegeben, das
Sie in der Datenbank wahrscheinlich 01010001 sehen würden
. Ich schätze, es ist nur ein
Standarddatum
seit Anbeginn der Zeit. In Ordnung. Nachdem all das erledigt ist, können
wir weitermachen und unsere Datenbank
aktualisieren. Und ich werde diesen Befehl ausführen , ohne eine Migration
anzugeben, und es wird ein
erfolgreicher Vorgang sein. Da haben wir's. So, jetzt ist
unsere Datenbank auf sehr grundlegender
Ebene mit
einigen Prüfungsfeldern ausgestattet . Wenn also Leute reinkommen, wollen wir
natürlich wissen, wann sie diesen Datensatz
erstellt haben? Wann wurde er zuletzt geändert, und wer hat ihn dann erstellt
und wer hat ihn zuletzt geändert.
34. Einträge zu bearbeiten, vor dem Einsparung von Änderungen: Hey, Leute, willkommen
zurück in dieser Lektion. Wir werden uns ansehen, wie wir Einträge
bearbeiten können ,
bevor wir Änderungen speichern. Nun, ein kleiner Hintergrund dafür, warum Sie so
etwas tun möchten, würde vielleicht
von der Tatsache herrühren dass wir gerade
Prüffelder für alle Tabellen hinzugefügt haben, oder? Also haben wir gerade alle
Überwachungsfelder
im Basisdomänenobjekt hinzugefügt . Und offensichtlich ist das
ein bisschen aufwändiger, weil
wir gesehen haben, dass
wir beim Hinzufügen von Daten die Objekte formulieren und sie dann
hinzufügen und zum Kontext hinzufügen und
dann
die Änderungen speichern müssen sie dann
hinzufügen und zum Kontext hinzufügen und dann
die Änderungen speichern Das bedeutet, dass wir jedes Mal jemand ein
Team, eine Liga,
ein Spiel, einen Trainer
oder etwas anderes zur
Datenbank hinzufügt ein Spiel, einen Trainer
oder etwas anderes zur oder es ändert, zusätzliche
Verantwortung
auf uns oder unsere
Entwickler übertragen, indem
wir sagen, immer das Erstellungsdatum eingeben, immer ein geändertes Datum angeben, zumindest wenn Sie möchten, dass die
Daten Standard sind. Nun, das in
einem größeren System
zu tun, kann sehr umständlich werden, weil wir nur
mit vier Tabellen arbeiten, und ich ärgere mich schon, wenn ich
nur darüber nachdenke. Stellen Sie sich vor, Sie haben 2030
und mehr Tabellen damit zu tun. An dieser Stelle ist
es also gut zu verstehen, wie der Kontext
Ihnen tatsächlich Zugriff auf alles gibt
, was gespeichert werden soll, und Sie können tatsächlich
manipulieren, was Sie bearbeiten
müssen, bevor
Sie die Änderungen speichern. Ich werde hier zu
unserem Datenkontext übergehen, und das wird jetzt
eine ziemlich interessante
Erfahrung, weil wir die
gespeicherten Änderungen überschreiben können, oder? Wir sehen also eine ganze Reihe
von Optionen zum Überschreiben von Änderungen. Wir haben die Standardoption,
bei der wir
Context Dot Save Changes aufrufen Wir können es überschreiben. Und dann können wir
hier einige Operationen
ausführen , bevor wir sagen, dass wir die Änderungen
tatsächlich speichern. Sie werden hier feststellen
, dass das Speichern von Änderungen wirklich eine Ganzzahl zurückgibt, die normalerweise mehr
als eins ist
, wenn Speichern erfolgreich ist, und weniger als eins oder Null, wenn
es nicht erfolgreich war. Falls nötig, können
Sie dies wahrscheinlich in Ihre Prüfungen einbeziehen
, um festzustellen, ob der
Speichervorgang erfolgreich war oder nicht. Aber im Moment
werden wir uns nicht darauf konzentrieren, sondern
wir wollen wissen, wie wir alles, was wir wollen wissen, wie wir gespeichert werden soll
, abfangen
und diese Werte manipulieren
können ,
bevor sie in der Datenbank gespeichert
werden Es gibt
einige Dinge, auf die Sie
achten sollten, wenn Sie sich
in diesem Bereich aufhalten Erstens wird uns ein Objekt namens
Change Tracker
gegeben. Ich glaube, wir haben uns das schon früher angesehen
, aber schauen wir uns an,
was wir damit tun können. Also haben wir den Tracker geändert und dann können wir Punkteinträge sagen. Dies gibt uns tatsächlich
die Liste der Einträge in den Speicher eingehen. Änderungen
werden durch den
Kontext im Speicher verfolgt. Ich kann sagen, dass VR-Einträge den Punkteinträgen im Change
Tracker entsprechen. Okay. Eine weitere coole Funktion
bei der Möglichkeit, die Einträge zu sehen, besteht darin
, den sogenannten
Entitätsstatus Das ist also eine Aufzählung, die uns gegeben wurde. Eine Aufzählung ist nur eine Konstante, und diese Konstante hat verschiedene
Zustände, die im Allgemeinen in welchem Zustand sich Ihr Eintrag zu dem Zeitpunkt befinden
würde, zu dem
er die Speicheränderungen erreicht Wir haben also unverändert. heißt, Sie haben vielleicht eine Anfrage gestellt, das Tracking war aktiviert,
also verfolgt es es, aber dann haben Sie es nicht aktualisiert, Sie haben nichts daran geändert, also ist es in einem unveränderten Zustand. Hinzugefügt, ich denke, das ist
selbsterklärend. Sie sind dabei, der Datenbank
etwas hinzuzufügen. Jedes Mal, wenn Sie
ein Objekt erstellen und den
Kontextpunkt hinzufügen sagen und das Objekt
dann einfügen, befindet es sich jetzt in einem hinzugefügten Zustand. Abgetrennt bedeutet, dass es nicht vom
Kontext
verfolgt wird. Alles klar? Modifiziert heißt,
naja, du hast es genommen, du hast etwas daran geändert und dann hast du gesagt, hier ist es. Also wurde es entweder
nachverfolgt, als es geändert wurde. Jetzt sieht es also,
dass es sich
von dem unterscheidet , was es ursprünglich
verfolgt hat, oder dass es nicht verfolgt wurde, und Sie haben explizit
Context Dot Update aufgerufen und es weitergegeben. Und dann gibt es
noch eine andere Möglichkeit, ein Update durchzuführen, bei dem Sie es
einfach als geändert markieren, oder? Sie können es also
einfach in
den Entitätsstatus modifiziert versetzen den Entitätsstatus modifiziert ,
sodass der Tracker
weiß, dass ich es
als modifiziertes Objekt verfolgen sollte. Gelöscht, selbsterklärend. Jedes Mal, wenn wir „Kontext“ sagen,
löschen und ihm das Objekt geben, befindet
es sich jetzt in einem gelöschten Zustand sind also wirklich
die Entitätszustände uns
zur Verfügung stehen, oder? Aber in bestimmten Situationen müssen
wir vielleicht
einige verfolgen und manche nicht. Bei den Einträgen möchte
ich also nicht
jeden einzelnen Eintrag sehen. Ich benötige
nichts, was nicht geändert oder
hinzugefügt wurde,
zumindest nicht für meine
Prüfungszwecke. Nun, noch einmal,
ich gebe Ihnen nur ein pauschales Konzept, das Sie wahrscheinlich aus
verschiedenen Gründen übernehmen
können, oder? Möglicherweise haben Sie also eine
komplexe Auditprotokollierung oder eine zweite Datenbank
, in die Sie Protokolle
schreiben müssen . Möglicherweise müssen Sie nachverfolgen, wann dies hinzugefügt wurde. Wann wurde das geändert? Sollen diese gelöscht
und in
einen separaten Datenspeicher geschrieben werden ,
was auch immer es ist, der Change-Tracker ermöglicht es Ihnen
, diese Einträge abzufangen und alles zu
tun, was Sie tun müssen bevor die
Änderungen gespeichert werden Schauen wir uns das also an. Wir wollen alle Einträge
abrufen
, die bald
geändert oder hinzugefügt werden , und dann die entsprechenden Spalten
aktualisieren Im Moment konzentrieren wir uns nur auf die Daten. Okay. Richtig? Und dann können wir weitermachen und die
Änderungen danach speichern. Also kann ich diese Aufzählung erweitern weil diese Funktion nur eine Aufzählung
zurückgibt, also kann ich
das einfach erweitern und sagen wo, und wir können unseren
Lambda-Ausdruck genau hier verwenden Also kann ich sagen, wo Q oder
mein Lambda-Ausdruck ist, und dann suche ich nach
dem Zustand, der gleich ist, und dann kann ich diese Zahl verwenden
, um nach
hinzugefügt zu filtern, oder Q state
entspricht dem hinzugefügt zu filtern, oder Q state
entspricht Entitätsstatus
, den ich gerade hinzugefügt habe, also würde das jetzt geändert werden. Genau hier
filtern wir
alle Einträge heraus und rufen sie ab, die entweder hinzugefügt oder geändert werden sollen Okay. Als Nächstes lasse ich jeweils
vier Lobe diese Einträge
durchgehen und ich werde sie
in die Basisdomänenobjekte umwandeln in die Basisdomänenobjekte Schauen Sie sich also an
, was hier passiert. Eintrag in Einträgen. Wenn wir uns nun den Eintrag ansehen, Einträge vom Typ
Entitätseintrag. Alles klar? Also, wenn ich es konvertiere, kann
ich einfach den Eintrag konvertieren, aber ich muss die
Eintragspunkt-Entität konvertieren. Der Eintrag hat also ein paar
Objekte, ein paar Eigenschaften, Sie können die aktuellen
Werte im Objekt sehen, Sie können die ursprünglichen Werte sehen. Selbst für die
Protokollierung von Prüfungen können
Sie also sehen, wo die
Eigenschaften vorher oder die Werte auf den
Eigenschaften eher davor waren und was jetzt
die Werte sind. Sie können sich den Kontext ansehen, und die Entität
verkörpert natürlich den tatsächlichen Entitätstyp
, verkörpert natürlich den tatsächlichen Entitätstyp über den der Kontext Bescheid weiß Da wir nun
das Basisdomänenobjekt verwenden und jeder andere
Entitätstyp davon erbt, kann
ich es auf
diese Ebene herabsetzen, sodass ich die Objektfelder
ändern kann , denn zu diesem
Zeitpunkt weiß ich nicht, ob ich eine Fußballmannschaft rette Ich weiß nicht, ob ich ein Spiel
speichere. Ich weiß nicht, welcher Entitätstyp im
Eintrag wirklich auftaucht. Ich übertrage es einfach in das Basisdomänenobjekt, damit ich anfangen kann,
mit den Feldern zu interagieren. Für jedes Objekt werde ich sagen, dass überprüfbare Objekte
ein Datum erzeugen, nett und einfach entspricht Datum und Uhrzeit, weil ich gerade dabei bin, die Änderungen
zu speichern.
Es muss wissen, dass die
Änderung leider vorgenommen wurde Änderungsdatum, es ist
dieselbe Uhrzeit. Aber dann denk darüber nach. Ich suche nach
Hinzufügungen und Änderungen, aber jedes Mal, wenn
etwas hinzugefügt wird. Natürlich möchte ich das Erstellungsdatum
haben, aber ich möchte nicht jedes Mal, wenn
etwas geändert wird,
das Erstellungsdatum haben . Sie sehen, wie sensibel das ist. Ich betrachte also sowohl das
hinzugefügte als auch das geänderte Datum, aber ich gebe
jedes Mal, wenn etwas geändert wird, das Änderungsdatum ein. Oder, tut mir leid, ich gebe jedes
Mal
das Erstellungsdatum ein, wenn etwas
geändert wird, was falsch ist. Ordnung. Den nehme
ich raus. Also jedes Mal, wenn wir
auf Änderungen speichern klicken, möchte
ich sagen, dass es
geändert wurde, weil es wahr ist. , ob es erstellt
oder geändert wurde, das Änderungsdatum ist nein. Ich möchte das Erstellungsdatum jedoch nur
festlegen, wenn der Eintragspunktstatus Entitätsstatuspunkt
entspricht erstellten oder hinzugefügten Entitätsstatuspunkt
entspricht, oder? Wenn es also fertig ist, wird es sagen, dass
ich für diesen Eintrag das Änderungsdatum festlegen werde. Egal, ob es erstellt
oder tatsächlich geändert wird, wir legen das Änderungsdatum fest. Wenn es jedoch hinzugefügt wird, legen
Sie das Erstellungsdatum fest. Andernfalls wird dies einfach übersprungen
. Es wird nichts bewirken. Wir gehen einfach zum nächsten Eintrag und machen das alles,
bis es fertig ist. Wenn die gesamte
Prüfung abgeschlossen ist, wollen wir als letztes die Änderungen speichern. Das ist wie ein letztes Hurra. Welche Daten auch immer
herübergekommen sind, wir wissen nicht, wir wissen nicht, um welchen
Entity-DB-Set-Typ es sich handelt Wir wissen nur, dass all diese Objekte ein gemeinsames
Basisdomänenobjekt haben . Und sobald das eingerichtet ist, können
wir zu
den Prüfungsfeldern gehen, unabhängig vom Typ der
höheren Ebene, würde
ich sagen, und dann die Anpassungen vornehmen und
dann die Änderungen speichern. Bevor ich weitergemacht habe, habe ich festgestellt, dass es keine Verweise
auf diese Methode
gibt. In meinem CS-Programm
habe ich einige der alten Methoden, habe ich einige der die
wir verwendet hätten, entfernt, und jede dieser Methoden
ruft „Änderungen speichern“ auf, aber dann sehen Sie sich das an, Änderungen
speichern und synchronisieren Allerdings haben wir
lediglich das Speichern der Änderungen außer Kraft gesetzt. Das ist mein schlechter Ausrutscher von
mir, oder? Die Override-Methode, wir wirklich
suchen, ist Änderungen speichern. Also werde ich diese Überschreibung
neu schreiben, weil ich denke, dass es mehrere gibt Ich möchte nur sichergehen, dass
wir den richtigen bekommen. Also haben wir „
Änderungen speichern“, „Änderungen speichern und „Änderungen speichern“ eine Synchronisation,
die zwei Parameter verwendet, und dann diese, die
einen Parameter mit einem Standardwert verwendet. Also ich denke,
das ist der, den wir wollen, denn wenn wir den anderen
verwenden, müssen wir ein Edelmetall
angeben, und nun ja, das
Storno-Token ist standardmäßig da, aber dann wollen wir das
mit dem Standard, bei dem wir wissen, dass wir keine Parameter
angeben müssen Ich werde diesen verwenden und meinen Code
einfach
hier organisieren, richtig? Da haben wir's. Wir haben also eine öffentliche Überschreibungsaufgabe
in Save Change ist ein Sync, und das ist der Parameter. Sie können
weitermachen und diese Anpassung vornehmen, und dann
müssen wir zusätzlich diese
Sync machen, weil nun ja, es ist eine Syn, also müssen wir
daraus eine asynchrone Methode machen Und wenn es dann eine synchrone Methode
aufruft, ist
es eine asynchrone Methode,
was bedeutet, dass wir die
asynchrone Methode auch hier unten verwenden
wollen asynchrone Ich kann das einfach ändern, um Änderungen
als Sünde zu speichern und es erfordert
eine Ich kann das einfach als
Gewicht weitergeben und das sollte es sein. Also habe ich Konstanz. Ich werde
genau dort
dasselbe
Stornierungstoken im Parameter verwenden . In Ordnung. Also, mit dieser Anpassung, nein,
ich sehe, dass alle 12 Verweise auf die gespeicherten Änderungen vorgenommen wurden. Also das ist jetzt ein bisschen
besser. In Ordnung. Das heißt, wenn wir aus unserer program.cs heraus den Kontext
aufrufen, wird
er wirklich auf unseren neuen benutzerdefinierten Kontext
klicken, und dann wird er all
das tun, bevor er die Basis aufruft. Alles klar? Also das ist die Macht, das alles
außer Kraft zu setzen. Also lass uns weitermachen und
das mal ausprobieren. In Ordnung. Und was ich nicht gesagt habe , welche Methoden ich abgewischt habe
, entschuldigen Wir verwenden also einfache Methoden zum
Einfügen bei denen wir neue Ligen
und Teams mit Liga hinzufügen,
und ich mache die einfache
Aktualisierung des Ligarekords,
wir aktualisieren den
Ligarekord und den Teamrekord Schauen wir uns also die Konsole und die generierten
SQL-Anweisungen an. Sie werden hier sehen, dass
ich P drei habe, und ich erhalte genau dort den
Wert für Datum und Uhrzeit, richtig? Und wenn es
eingefügt wird, kommen Erstellungsdatum, Änderungsdatum,
P zwei und P drei rein. Dementsprechend ist hier P eins. Da ist P eins, das
ist unser Erstellungsdatum. Und dann ist P zwei Null, weil das von erstellt oder
geändert
würde . Wir sehen also
, dass unsere Daten
korrekt
in unsere SQL-Anweisung aufgenommen werden , oder? Also noch einmal,
diese SQL-Anweisung wird zu dem Zeitpunkt generiert, zu dem
Sie die Speicheränderungen vornehmen. Jetzt haben wir es überschrieben, um
vor dieser Q-Anweisung
einige zusätzliche Dinge zu tun vor dieser Q-Anweisung
einige zusätzliche Dinge Das ist also eine nette kleine Möglichkeit Ihre eigene kleine Logik
und ein wenig Konsistenz oder
Bereinigung oder ähnliches
einzufügen , was Sie tun müssen bevor die Daten tatsächlich in die Datenbank
übernommen werden.
Dann können Sie die Kontextmethoden immer so
überschreiben Nun gibt es eine Möglichkeit
,
den DB-Kontext noch weiter
zu erweitern , um bestimmte Dinge zu vereinfachen Im Kontext wollen wir also angeben, vielleicht modifiziert von, zum Beispiel einen Benutzernamen oder etwas anderes,
um zu sagen, wer ihn geändert hat. Offensichtlich können wir das hier nicht tun, weil es für mich keine
Möglichkeit gibt, hier
eine Zeichenfolge zu übergeben ,
die den Benutzernamen als
oder als irgendeinen Wert darstellt ,
die den Benutzernamen als
oder als irgendeinen Wert weil Safe Changes
nur danach sucht. Wir können also unseren Kontext so
erweitern dass er zusätzliche Daten
akzeptiert, die der Standardkontext nicht akzeptiert, und dann können wir
die Daten massieren , bevor wir den Basiskontext
aufrufen. Wir können uns das später ansehen, und ich denke, das wird
eine lustige Aktivität. Okay.
35. DbContext erweitern: Hey, Leute, willkommen zurück. Als wir das letzte Mal hier waren, haben wir den RDB-Kontext erweitert, um ein bisschen Auditarbeit zu
erledigen Mit anderen Worten, wir haben
die Speicheränderungen erweitert oder sie
sogar überschrieben , um
unsere Daten ein wenig massieren zu können , bevor wir sie in der Datenbank speichern Jetzt haben wir die Vorteile erkannt, weil wir jetzt sehen, dass
wir die Prüfdaten für das Änderungs - und
das Erstellungsdatum erhalten - und
das Erstellungsdatum Eine Einschränkung
besteht jedoch darin, dass wir zu keinem
Zeitpunkt
die Person kennen , die den Datensatz erstellt
oder geändert hat . Das ist also eine der Einschränkungen,
die wir einfach außer Kraft setzen,
weil wir immer noch irgendwie auf das beschränkt sind, was die standardmäßigen sicheren Änderungen für uns
bereithalten Ich kann
diesen Parameter nicht überschreiben .
Bitte um einen Benutzernamen Was den Kontext oder
das Programm angeht, würde Dot Says die Anwendung
stehen, die der Benutzer verwendet, oder? Wenn jemand die
Anwendung Web oder Desktop verwendet, fügt
er einen neuen Lead hinzu. Ich
möchte protokollieren, wer das getan hat. Ich möchte ihren
Benutzernamen vom System haben. Ich möchte nicht, dass sie
dafür verantwortlich sind, der Benutzer
mir sagt, wer sie sind. Ich möchte wissen, wer angemeldet
war, als diese Aktion
gegen diesen Datensatz ausgeführt wurde. Es wäre also schön, wenn
ich
einen Benutzernamen in die
Änderungen übernehmen könnte, damit wir vor dem Speichern bei der
Prüfung verwenden
könnten. Angesichts all
dieser Einschränkungen, die wir kennen und wissen,
was wir erreichen wollen, werde
ich gleich darauf eingehen. Was wir tun werden,
ist den DB-Kontext so
zu erweitern ,
dass eine andere Version
zitiert und zitiert wird ,
die die Rolle beim Speichern von Änderungen übernimmt, oder das Überschreiben
der Änderungen beim Speichern übernimmt und sie
dann übergeben Das klingt also etwas
komplizierter als es wirklich ist, und
die Arbeit hat eigentlich schon begonnen Also habe ich eine
brandneue Klasse erstellt, die ich direkt im
selben Datenprojekt wie
der ursprüngliche DB-Kontext erstellt habe. Ich nenne es einfach einen überprüfbaren,
sorry, Football-League-DB-Kontext Nun, diese
Audit-Football-League-DB-Kontextdatei ist abstrakt,
also würde sie,
du weißt schon, nicht von
alleine instanziiert werden Und sie erbt vom DB-Kontext
. Wir werden
den ursprünglichen DB-Kontext
oder den Football-League-DB-Kontext
von unserem
Football-League-DB-Kontext erben lassen den ursprünglichen DB-Kontext
oder den Football-League-DB-Kontext von unserem
Football-League-DB-Kontext erben lassen von unserem
Football-League-DB-Kontext Der Vorteil dabei ist,
dass
wir allein durch die Verwendung dieser Version alle Funktionen erhalten, die in der überprüfbaren Version
verfügbar sind, aber die überprüfbare Version
bietet uns dann etwas mehr
Flexibilität, da wir
nicht auf den
eigentlichen DB-Kontext beschränkt sind nicht auf den
eigentlichen DB-Kontext beschränkt und ihn
in dieser Hinsicht überschreiben Nachdem all das
gesagt und getan ist, werde
ich einfach
diese
AC-Methode zum Speichern von Änderungen aus unserem Football
League DB-Kontext herausschneiden diese
AC-Methode zum Speichern von Änderungen aus unserem Football
League DB-Kontext und sie
in der abstrakten Version platzieren, und ich werde an dieser Stelle einige
Änderungen vornehmen. Erstens werde ich
dieses Stornierungstoken herausnehmen , weil ich es nicht wirklich brauche, ich
werde es ganz
herausnehmen,
und ich werde
zulassen, dass es
die Basisspeicherungsänderungen aufruft , weil das der DB-Kontext ist, oder? Aber ich werde
diese Methode auch erweitern, um einen
Zeichenkettenparameter namens Benutzername zu verwenden. Damit wird
nun jeder aufrufenden Methode mitgeteilt , dass sie
einen Benutzernamen übergeben muss , um diese Methode ordnungsgemäß
aufzurufen. Und ich werde diese
Überschreibung entfernen,
weil wir sie
nicht mehr überschreiben Wir haben nur eine Methode
namens Save Changes, die nur die Basis
aufruft Es ist also wie eine Erweiterung oder eine Methode vor
der eigentlichen Methode. Jetzt, wo dieser
Benutzernamenparameter eingegeben wurde, kann
ich sagen, dass der Punkt für das
überprüfbare Objekt an dieser Stelle geändert
werden würde, und dann
wäre das modifizierte von der Benutzername Und in ähnlicher Weise wäre „Erstellt
von“ dieser Benutzername. Jetzt keine Verweise.
Warum ist das so? Das liegt
daran, dass in unserem Programm immer noch die
standardmäßigen Speicheränderungen aufgerufen werden. Lassen Sie mich eine dieser
Methoden finden. Da ist sie. Es ruft immer noch
save changes async auf, das ist die Standardeinstellung
für den Kontext Wenn ich mir jedoch die verfügbaren
Überladungen ansehe, werde
ich feststellen, dass es eine neue Überladung
gibt, die es mir ermöglicht, diese Zeichenfolge als Benutzernamen zu übergeben Da haben wir's. Damit ich einen Benutzernamen eingeben kann
. Sagen wir einfach
Testteam-Management-Benutzer. Es tut mir leid. Ich versuche nur, explizit
genug zu sein , damit wir in
der Datenbankabfrage sehen können , wo die gespeicherten Änderungen
gespeichert werden. Das ist ein einfaches Update. So können wir nach diesem Benutzer suchen
oder einen aktuellen Benutzer testen. Lass es mich einfach halten.
Benutzer testen und aktualisieren. Dieser Rekord. Das brauchen wir nicht. Ich werde diesen
ohne Benutzernamen lassen. Das verändert die Liga. Dieser wird
keinen Benutzernamen haben. Dieser ist Audit. Damit ich
meinen Liganamen ändern kann . Also
musst du das nicht tun. Sie können Ihre
alten Daten verwenden oder
Ihre eigenen Daten eingeben, aber das ist in Ordnung. Aber ich werde einfach
ein paar Überschreibungen eingeben , testen,
Audit Create User, und dann lasse ich diesen ohne Benutzernamen, oder? Also werde ich das an
dieser Stelle einfach ausführen und schauen, was
genau passiert Wenn ich mir also
einige der Anweisungen ansehe, sehe
ich hier in
den Änderungen speichern , dass ich den Benutzer test audit
create habe. Da haben wir's. das Testaudit erstellt hat, war also Benutzer, der das Testaudit erstellt hat, war also derjenige, der
diese Audit Testing League erstellt hat. Ordnung. Da haben wir's. Also diese Person, dieser Benutzer geht als P Null und P Zwei rein. Und wenn wir schauen, ist P
Null das Erstellte von und P Zwei das Geänderte von. So können wir
diese Benutzer in das System bringen. Ich stelle fest, obwohl ich es hier vielleicht hart
zitiert habe, in einer echten Anwendung
, in der
sich Leute anmelden usw., gibt es Möglichkeiten, die Benutzernamen abzurufen und sie einfach
in das Speichern der Änderungen einzufügen. In.NET Core-Webanwendungen können
Sie sogar
den CTP-Kontext nebenbei einfügen und auf das ganze Abrufen
und Senden verzichten ,
aber
das ist nicht zum Diskurs gedacht aber Ich versuche Ihnen nur zu
zeigen, wie Sie Ihren DB-Kontext
erweitern
und Ihre Daten auf immer kreativere Weise manipulieren können Ihren DB-Kontext
erweitern
und Ihre Daten auf immer kreativere Weise manipulieren ,
um
sicherzustellen, dass Sie diese Datenintegrität haben
, wenn sie
in um
sicherzustellen, dass Sie diese Datenintegrität haben der Datenbank ankommen .
Okay.
36. Volle Database: In Ordnung, Jungs. Als wir das letzte Mal hier waren, haben wir nur konkretisiert, wie wir unsere Prüfung durchführen. In Ordnung. Also auf zu wissen, Auditing ist nur ein geändertes Datum und geändert durch die Erstellung der Teilnahme erstellt von. Aber dann haben Sie möglicherweise eine andere Notwendigkeit, bei der Sie möglicherweise die gesamte Rolle prüfen müssen. So könnten Sie sich in einer separaten Datenbank befinden oder es ist eine separate Tabelle, oder zumindest ist das immer traditionell getan. Manchmal, was Leute tun, ist, dass sie Trigger
in die Tabelle setzen , so dass jedes Mal, wenn etwas gespeichert, bearbeitet oder gelöscht wird, es automatisch Schreibvorgänge in eine andere Tabelle erforderlich sind, die Trucking ist. Welche Aktivität auf einer bestimmten Tabelle passiert ist, nehmen Sie eine Kopie der Tabelle. Also werden wir eine Kopie der ursprünglichen Werte vor der Operation nehmen,
die neuen Werte nach der Operation, und serialisieren sie in eine Zeichenfolge und speichern diese innerhalb der Datenbank. Wie es gelesen werden kann. Das liegt an der Anwendung und dem Entwickler zu einem Zeitpunkt. Aber ich zeige Ihnen nur, wie flexibel EF Core beim Zugriff auf
Daten vor und nach der Tatsache ist und wie wir sie während manipulieren können. Also lassen Sie uns beginnen, indem Sie eine neue Klasse erstellen und ich werde es in die Domäne setzen. Sie könnten es wahrscheinlich gemeinsam machen, aber es wird wirklich eine Domain-Klasse sein. Erstellt eine neue Klasse. Ich möchte es nicht IT-Audit nennen. Also Audit wird ein paar Felder haben, wird die Standard-ID haben, eine Zeichenfolge für den Tabellennamen. Also machen wir es öffentlich. Und dann setzen wir auf die Felder. Es wird also ID-Tabellenname, datetime haben, was bedeutet, dass die Zeit, natürlich eingegeben wurde, der Schlüsselwert. Was auch immer Primärschlüssel aus dem zu überwachenden Datensatz ist, die alten Werte des Datensatzes und die neuen Werte des Datensatzes. Nachdem Sie diese Audit-Klasse repliziert
haben, können Sie zu unserem überwachbaren DB-Kontext wechseln. Und wir werden diesen DB-Satz hinzufügen, richtig? Es wird also im überwachbaren DB-Kontext sein. Benötigen Sie ein Audit? Und ich nenne es nur Audits. Dann werden wir in Täuschung Veränderungen gehen. Und ich möchte tatsächlich einige Dinge tun, bevor Sie Änderungen speichern, denn bevor wir die Änderungen speichern, müssen
wir eine Kopie der Daten, die eingehen, oder? Also genau oben, wo wir unsere LKW-Änderungen bekommen und wissen, was passiert ist und so weiter. Ich werde auf sehen, bevor Änderungen speichern, richtig? Diese Methode existiert nicht, also kontrolliere ich einfach den Punkt und generiere diesen Methodenstub. Und da gehen wir. Dies wird also
eine Liste einer anderen Klasse zurückgeben , die ich im Begriff bin, den sogenannten Audit-Eintrag zu erstellen. Also, wenn ich Steuerpunkt mache, Mal sehen, was Visual Studio für uns tun kann. Es sagt, dass es einen Typ namens Audit-Eintrag in seiner eigenen Datei generieren kann. Also gehen wir einfach weiter und erstellen es in einer eigenen Datei. Kein Schaden, kein Foul. Springen Sie zum Audit-Eintrag. Ein Prüfungseintrag wird also im Grunde ein Hindernis dessen sein, was genau wir brauchen, oder? Also lassen Sie uns diese Klasse für ein bisschen begleichen. Also werde ich sagen, öffentlicher Prüfungseintrag. Das ist also im Grunde der Konstruktor. Und ich möchte Entitätseintrag. Also wissen wir, was Entitätseintrag ist. Das kommt von EF Core. Und wir werden es einfach Entitätseintrag nennen und sicher. Und dann werden wir diesen Konstruktor verwenden, um unsere Eigenschaft zu initialisieren. So kann ich das steuern und sagen, Create verstehen Eigenschaft namens Entitätseintrag. Und das macht es für mich automatisch, oder? Dann werde ich noch andere Bereiche haben, so viel, was wir in der Prüfung hatten, richtig? Also werde ich String-Tabellennamen haben. Ich werde auch gut haben, alte Täler und neue Werte und gut Key Vault
dreht sich alles um ist nicht beinhaltet, was ich die Datentypen von denen ändern werde. Also haben wir den Tabellennamen, wir haben den Schlüsselwert, der wirklich wie ein Wörterbuch sein wird. Jemand, der den Datentyp in Wörterbuch von String und Objekt ändern kann. Also, wenn Sie noch nie mit Wörterbüchern gearbeitet haben, ist genau wie ein Schlüsselwertpaar, damit ich JSON lösen kann. Und das ist es, was ein Wörterbuch ist. Eine Zeichenfolge wäre der Schlüssel und die Objekte wären die Daten, die neben dem Schlüssel eingehen. Also Kontrollpunkt schließen das ein. Und ich werde es einfach initialisieren, damit es nie weiß. Also nehmen Sie einfach das und c ist gleich einem neuen Wörterbuch der Zeichenfolge, einem Objekt. Und so ziemlich das ist alles, was wir für alte Werte und neue Werte tun werden. Und wir machen die gleichen Initialisierungen und Sie sehen all diese Art von sieht konsistent und wenig gruseliger Kugel bald werden Sie sehen, was wir erreichen wollen. Die nächste Zeile wird für temporäre Eigenschaften sein. Also werde ich eine öffentliche Liste von Immobilieneinträgen sagen. Was kommt auch von Entitätseinträgen Bibliothek von Freeware-Trends Änderungsverfolgung, richtig? So sehen Sie eine Liste von Eigenschaftseintrag, temporäre Eigenschaften sind gleich einer neuen Liste. Ich werde eine schnelle Methode haben, die nur unsere Eigenschaft zurückgibt, anstatt dass ein boolescher Wert zurückgibt, um zu sehen, hat temporäre Eigenschaften. So bald erklären, was Tempereigenschaften wirklich bedeutet oder für verwendet werden. Aber dann werden wir eine andere Methode haben, die tatsächlich aufbauen
oder Audit erforderlich ist . Ich werde es zum Audit nennen. In Ordnung. Ich müsste nur einen Namespace dort einschließen. Dort gehen wir zum Audit. Und dann können wir anfangen, alle Funktionalitäten zu bauen. Wenn wir also über Audit reden, reden
wir davon, die eigentliche Entität aufzubauen, ihre Akte. So var Audits ist gleich neuen Audits. Initialisieren Sie ein neues Objekt vom Typ Audits. Und dann füllen wir alle Felder des Audits aus. So kann ich diesen Objektinitialisierer verwenden. Und dann kann ich sagen, okay, Wussten wir, dass Sie Datetime dot nl no brainer sind, richtig? Das sind also die Zeitpunkte. Nein. Richtig? Dann Tabellenname, das ist einfach genug und es sollte kein Semikolon verwenden, entschuldigen Sie sich. Der Tabellenname ist gleich dem Tabellennamen aus dem lokalen. Ordnung? Dann haben wir die Schlüsselwerte, die eine Serialisierung der Schlüsselwerte sein würden, richtig? Also sehe ich nur Schlüsselwerte sind gleich JSON-Konvertierung, siehe Serialisieren oder Objekt- und Schlüsselwerte, richtig? So ziemlich denken Sie daran, dass dies ein Wörterbuch ist. Also werden wir den Schlüssel haben
, der wie ID sein wird. Wir werden den Wert als Objekt gespeichert haben,
also ist es eine String-ID, oder in unserem Fall verwenden wir int IDs. Was auch immer es ist, wird nur
dieses Schlüsselwertpaar haben und wir werden es nur als JSON speichern. Und offen gesagt, das wird dasselbe für die alten Werte und die neuen Werte sein. Aber dann gibt es eine Art Wendung mit denen. Also werden wir so etwas sehen, wie alle Werte sind gleich allen Werten Punktkegel 0. Wenn es 0 ist, dann können wir null speichern. Andernfalls wollen wir das Volume umwandeln, das vom Schlüsselwert angezeigt wird. Kennen Sie die Relevanz davon. Wenn wir bestimmte Operationen wie das Einfügen unseres Datensatzes durchführen, dann gibt es keinen alten Wert für diesen Datensatz, da es sich um einen brandneuen Datensatz handelt. Es gibt also keine Möglichkeit, die alten Werte zu erhalten. Es wird also protokolliert, um zu sehen, ob alte Werte in diesem Datensatz gespeichert werden, wenn nicht dann null, weil wir vermuten können, dass es eine Add-Operation war. Und dann können wir weitermachen und
die Werte serialisieren , falls ich es nicht gegessen habe oder ein Update war. So wie wir alle gleich gemacht haben, werden
wir neue Werte tun. Also werde ich diese Zeile einfach duplizieren und so zwei neue Werte ändern. Und wo immer es eine Spaltung gab, neue Freunde. Wenn also keine neuen Werte vorhanden sind, speichern Sie null, obwohl Augen in den neuen Werten gespeichert sind. Ich glaube, ich werde noch ein Feld hinzufügen und das ist das Axon. Also werde ich in der Audit-Tabelle
Aktionen hinzufügen , damit wir wissen, welche Art von Operation durchgeführt wurde, was richtig ist. Also Aktion, und ich werde das gleiche hier tun, nannte dich Aktion. Und dann, um zu prüfen, werde
ich sagen, Aktion ist gleich unserer lokalen Aktion. Ich habe es gehört. Also wissen wir, was jetzt passiert ist, nachdem wir das ganze Audit-Objekt erstellt haben, soll
diese Methode dieses Audit-Objekt zurückgeben. Also geben wir nur Audit zurück. Das war's für unsere Prüfung. Geben Sie mindestens für null ein, während wir entlang gehen, wir könnten alle Anpassungen sehen, die benötigt werden. Nein, wir springen zurück zu unserem überwachbaren DB-Kontext. Und für mich ist es einfacher, ich werde das alles rausnehmen. Ich werde es schneiden und ich werde es in unsere neue Methode setzen. Also, bevor Änderungen speichern, sind Dinge, die wir sowieso tun wollten, oder? Okay, also werde ich das ein bisschen umgestalten,
anstatt nur diese Einträge am Mittwoch zu bekommen, stattdessen gehen Sie durch einen Prozess der Beseitigung. Also ging ich zu sehen, ob sie die Einträge vom Lehrer bekommen, wo der Staat nicht
gleich losgelöst ist und es ist nicht gleich auf Betrüger Weise würde mehr Szenarien dazwischen erfassen, oder? Also holen Sie mir die Einträge, die nicht getrennt oder
unverändert waren und dann sind das die Interessen, die wir durchlaufen. Sie sehen hier, dass es sich über Benutzername beschwert. Mal sehen, was controller.js für uns, können
wir eine Eigenschaft generieren, die in Ordnung ist. Okay, das fügen Sie einfach den Parameter hinzu. Generierter Perimeter-Benutzername. Es gab alle Arten, nach denen ich gesucht habe. Also jetzt haben wir den Benutzernamen i, wir können Boston diesen Benutzernamen vor,
sehen, ob Änderungen und alle glücklich sind. Alles klar, nirgends werden alle Interessen nicht berührt, nicht unverändert auf unsere Einstellung dieser Audits Spalten für sie. Bevor wir jetzt für jeden eingehen, möchte
ich eine neue Liste von Prüfungseinträgen und wir werden diese Liste zusammenstellen, während wir durchgehen. Also für jeden Eintrag, nachdem er diese ersten Tests durchlaufen hat, werde
ich versuchen und sehen, dass ich eine neue Instanz der
Audit-Eintrittsrichtlinie in diesem Eintrag von unserem THE Trucker kommen möchte . Richtig. Also denken Sie daran, das ist, als wir den Konstruktor und
Audit hatten , um sicherzustellen, dass Tolkien-Eintrag als Parameter. Dann werde ich den Tabellennamen erhalten, indem ich sehe der
Rechnungspunkt-Tabellenname gleich
ist und dann beeilen Sie sich einfach und setzen Sie sich, dass es Entry.metadata gleich ist. Also zeige ich nur eine ganze Menge Daten. Sie können tatsächlich ein Boot bekommen,
etwas, das ein Bolzen in der Datenbank gespeichert werden. Ich kann die Metadaten bekommen, nicht die Beziehung. Lassen Sie mich sehen, dass Ihr relationales Ereignis fehlende Referenz
enthalten muss oder es einfach richtig buchstabieren muss. Also dot relationalen oder eigentlich denke ich, das ist ein dotnet Core Drei-Punkt-eins. Wenn Kern 3.1, hier ist es, erhalten Sie Tabellennamen. Da gehen wir. In Gericht dotnet Core 5 ist
es also noch einfacher, einen Tabellennamen zu erhalten. Ich sehe nur den GET-Tabellennamen. In Ordnung. Und dann werden wir diesen neuen Prüfeintrag zu unserer Liste hinzufügen. Also werde ich nur sagen Add and Audit Eintrag als Ensemble Tatsache. Es gibt noch ein Feld, auf dem ich von diesem Punkt an sitzen möchte, und das wäre die Aktion. Okay, also müssen wir wissen, welche Maßnahmen durchgeführt werden. Und dann konnte ich nur den Eintrag Punkt,
Staat, Punkt zu String sehen , das ist die Auktion. Wissen Sie, dass wir diesen Teil des Weges haben und lassen Sie uns auf die Eigenschaften konzentrieren. Also müssen wir bestimmte Eigenschaften bewerten, eins, um ihre Werte zu kopieren, ob es alte Täler oder neue Väter oder der Primärschlüssel gleich und entfernt sind. Das ist unser Audit-Datensatz, hat ein bestimmtes Feld für den Primärschlüssel. Was wir also leicht tun können, ist mit einem foreach zu beginnen und wir können
var Eigenschaft im Eintrag sagen , Gedankeneigenschaften. Also dies verwendet, was wir Reflexionen nennen werden und alles, was eine
dieser großen Zulagen ist, wird uns durch neuere Versionen von C scharf gegeben. So können wir sehen, ob Eigentum, sorry, wenn Eigentum vorübergehend ist. Dies würde uns erlauben zu bewerten ob es schönste Wertsteigerung innerhalb der Immobilie gibt. Also zurück, wenn Sie neuer, mit dem Hinzufügen von Datensätzen
experimentieren und so weiter, würden
Sie sehen, dass der ID-Wert ein Minus hat, denke
ich, das ist int Min minus 2 Milliarden und etwas Wert darin. Das ist tatsächlich ein temporärer Wert, bis der Wert gespeichert ist. Richtig. Wir wollen also sehen, ob Eigenschaft temporär ist als Prüfpunkte. Überwachungseinträge sind temporäre Eigenschaften für diese Eigenschaft. Ordnung. Das ist alles, was wir wissen können, ob dies hinzugefügt wird oder nicht. Sie werden später sehen, warum das so wichtig ist. Danach können wir weitermachen. Wir müssen es keine andere Operation auf dieser Eigenschaft machen. Wenn es sich um eine temporäre Eigenschaft handelt, fügen
wir sie einfach zum Datensatz hinzu und dann gehen wir einfach weiter. Sie brauchen sich keine Sorgen darüber zu machen. Keine anderen Dinge, die wir tun müssen, wenn es nicht in diese Kategorie
fällt, ist der Name der Eigenschaft. Was noch einmal, ich muss property.metadata ergreifen und wir verwenden
nur meine Zwischenablage Eigenschaft Punktdaten Punktnamen. Also bekomme ich Entzündungen und das sind Metadaten. Wenn der Property.me Primärschlüssel ist. Und das ist eine Methode. Wir sehen also, ob wir es mit einem Primärschlüssel zu tun haben, dann wollen wir die Schlüsselfreunde speichern. Es wird also ähnlich aussehen wie wir hier gemacht haben. Wir sehen immer, dass IS-Audit Schlüsselwerte eingeführt hat und dann erhalten wir den Eigenschaftsnamen als Schlüssel oder tiefgestellt aus der IRI. Und wir speichern den Wert. Also gehen wir einfach voran und speichern das. Also das ist alles, was wir bekommen, dass Schlüsselwert erscheinen, oder? Das ist also eine Zeichenfolge im Wörterbuch, das ist als Eigenschaftsname. Und dann wäre der Wert oder das Objekt der aktuelle Wert des Primärschlüssels. Dann gehen wir zu einem Schalter, wo wir sehen, Holen Sie mir die Einträge Zustand. Also wechseln Sie den Eintrittszustand. Und dann machen wir ein paar Fälle. Wir werden überprüfen, ob es hinzugefügt wird, dann müssen wir die neuen Werte mit dem Eigenschaftsnamen auf dem aktuellen Wert speichern. Ordnung? Obwohl es war, wenn es gelöscht wird, müssen
wir die alten Werte mit dem Eigenschaftsnamen
und dem Ursprung von uns ECF aktuellen Wert und der Ursprung des Wertes speichern . Aktueller Wert ist, was immer bekannt ist und die ursprünglichen Werte, was auch immer es vorher war. Das kommt also praktisch wissen, wenn wir überprüfen, ob der NTT-Zustand in
einem geänderten Zustand an diesem Punkt ist , wo wir sehen, ob es
ändert es auf einer Eigenschaft wurde geändert, richtig. Wir sehen also, ob Sie diese besondere Eigenschaft ändern, die wir betrachten, dann wollen wir wissen, was die ursprüngliche Eigenschaft von Ardi war und was der neue Eigenschaftswert ist. In Ordnung. Das ist also, wofür diese switch-Anweisung ist. Und richtig, nein, das ist alles, wofür ich da mache. Also noch einmal möchten wir speichern, wenn es angebracht
ist, wenn es sich um eine temporäre Eigenschaft handelt. Wenn dies der Fall ist, bedeutet dies, dass es ein Datensatz ist, der eine Schraube hinzugefügt werden soll, und es gibt keinen Primärschlüssel, da dies vor dem Speichern der Änderungen aktiviert ist. Also passiert noch nichts wirklich. Primärschlüssel-Wege. Wenn es jedoch Primärschlüssel macht, der nur
vorhanden wäre , wenn es beim Löschen oder einer Änderung war, dann machen wir eine Notiz von dem, was der Schlüsselwert ist. Andernfalls für den Rest der Werte, wo Protokollierung, was die neuen Werte sind, was die alten Werte sind, fair gelöscht, und beides, wenn es geändert wird. Also weiter, nein, wir müssen diese Audit-Einträge tatsächlich speichern oder zumindest eine Liste von Audits erstellen, die später gesiebt werden sollen, richtig. Also werde ich wieder ein für jedes Auge tun, ich möchte nicht für
jeden Audit-Eintrag in speichern und ich werde diese Liste Audit-Einträge angedockt bekommen. Und ich will von ihnen, wo wir unseren Lambda-Ausdruck haben, q-dot hat temporäre Eigenschaften. Wir können sehen, dass es gleich fällt als bedeutet, dass es keine hat oder ich verwenden kann. Ich sage nicht, dass ich das für Lesbarkeitszwecke getan habe. Also, wir sind es gibt null temporäre Eigenschaften und ich kann den Überwachungseintrag hier nicht wieder verwenden.
Lassen Sie mich sehen, wie Audit ausstehende Audit überprüft, um sicherzustellen, dass ich diesen ausstehenden Auditeintrag verwenden kann. In Ordnung. Also für jeden ausstehenden Audit-Eintrag in der Liste, die wir zu diesem Punkt kompiliert haben, wo es null temporäre Eigenschaften, dann wollen wir es zu den Audits DB sitzen für führen zu Verletzungen hinzufügen. Also ausstehende Audit Eintrag Punkt und dann hier ist, warum wir die Methode zu prüfen hatten. Also denken Sie daran, dass die beiden Audit Lärm, wenn zu nehmen, was auch immer Wert war Boston und was war hier sitzen und tatsächlich auf Audits Rekord für die Rückkehr erstellen. Richtig? Also sehen wir nur alles, was wir gerade kompiliert haben, alle Schlüsselwertpaare auf. So weiter, konvertiert es in einen tatsächlichen Audit-Datensatz und Editier-Tool oder DB sitzen. Nach all dem möchte
ich die Überwachungseinträge zurückgeben, die nicht haben oder bedauern, dass dual ausstehende Eigenschaften, temporäre Eigenschaften haben. Also möchte ich zurückkehren, wo sie ausstehende Eigenschaften haben. Und natürlich sind wir das, um eine Liste zu sein, weil ich Zellen brauche, die eine Liste zurückgeben. Da gehen wir. Das ist also, was passiert, bevor Änderungen gespeichert werden. Das verstehe ich immer noch, Aaron. Ich denke, es ist, weil ich getan habe, es ist drin für jeden und das ist seine Karte. Das sollte also außerhalb von diesem für jeden passieren, den ich entschuldige. Also lassen Sie mich einfach schnell anrufen. Und am Ende der Methode durchlaufen
wir kompilierte Audits und geben diejenigen zurück, die vorübergehend sind. Da gehen wir. Jeder ist damit zufrieden. Nein, das haben wir schon mal gemacht. Speichern von Änderungen. In Ordnung. Und dann gehen wir weiter und speichern Änderungen. Was nun passieren wird, nachdem wir die Änderungen oft an
diesem Punkt gespeichert haben, ist, dass wir alle Audit-Interessen
haben, die die Werte haben
, die es will hinzugefügt werden, wo sie noch keine ID hatten . Sie sind alle noch innerhalb dieser Null gespeichert. Ich möchte zurück durch gehen und aktualisieren Sie die ID gültig wissen, dass sie gespeichert wurden. Anstatt an diesen Punkten zurückzukehren, werde
ich dies in eine Variable setzen. Ich werde es nur anrufen. Ergebnis oder Ergebnis. Also speichern wir nur, was das sein würde, oder? Und dann werden wir eine andere Methode haben, die ich nach dem Speichern von Änderungen an der Richtlinie in den Überwachungseinträgen
aufrufen werde. Richtig. So erhalten wir die Audit-Einträge, die sich in einem temporären ID-Zustand befanden. Wir sehen, dass g und g ist und alles, was sie aktualisiert wurden. Jetzt müssen wir nach den Speicheränderungen etwas tun. Also werde ich das On vorher zusammenbrechen und ich werde nur diese Methode generieren. Und wenn das erledigt ist, werden wir die Prüfungseinträge durchlaufen und prüfen, was auch immer es passieren muss, richtig? In der Tat muss
dies möglicherweise nicht einmal geschehen. Also werde ich sagen, ob die Audit-Einträge nicht gleich null sind, welchem
Grund auch immer, es könnte null sein. Oder Audit Verletzungen Dot Kegel ist eigentlich größer als 0,
was bedeutet, dass wir tatsächlich Zeug haben, um danach zu verarbeiten. Dann können Sie diese Methode aufrufen. Ordnung? Also innerhalb der Methode, was wir tun müssen, ist durchzugehen, weil wir an diesem Punkt annehmen, dass etwas innerhalb der Audit-Einträge ist, würden
Sie nur hier bekommen. Wenn etwas war, dann werden wir jeden Auditeintrag
bewerten und diese Liste aufstellen. Und dann bekommen wir die Eigenschaften in jedem von ihnen, also zwei für jeden aufgelistet. Also werde ich sagen, besorge mir jede Requisite in Audit-Eintrag Punkt temporäre Eigenschaften. Denken Sie also daran, dass wir eine Liste aller temporären Eigenschaften zusammengestellt haben. Dann ging ich zu einer if-Anweisung, um zu sehen, ob die Eigenschaft unser Primärschlüssel ist, dann fügen wir den Schlüsselwert hinzu, um den aktuellen Wert zu sein. In Ordnung. Wir machen also nur eine schnelle Aktualisierung dieses Audit-Eintragswerts, um der aktuelle Wert zu sein. Andernfalls ist der neue Wert unser aktueller Wert. Also sehen wir nur, ob es ein Primärschlüssel ist, was mehr als wahrscheinlich ist, warum es am Ende vorübergehend sein würde. Wenn etwas hinzugefügt wurde, aktualisiert auf das aktuelle Volume,
wissen Sie, dass alles gespeichert wurde. Andernfalls, wenn es nicht unser Primärschlüssel wäre
, der, wenn ich dort sitze, mir ein Szenario vorstellen kann, in dem Sie einen Holzwert für XOM hätten. Das ist nicht der Primärschlüssel. Aber in diesem Fall aktualisieren
wir es immer noch. Kein Problem. Alles klar, danach machen
wir das für jeden, für jeden, den wir sparen, dass wir es definitiv zur Prüfung hinzufügen werden. Nur ich rufe wir das Audit interessiert an der vor dem Speichern Änderungen hinzugefügt. Also wir nur Audits Punkt hinzufügen unter den beiden Audit, so dass es umgewandelt werden kann. Dann geben wir eine Speicheränderungen zurück. Also müssen wir zu diesem Zeitpunkt ein Meer von Veränderungen nennen. In Ordnung. Nachdem wir diese Änderungen gespeichert haben, können
wir das Ergebnis hier zurückgeben oder die Ergebnisse speichern. Das ist wirklich das, was ich für das Auditing in mehreren Anwendungen implementiert habe. Und es funktioniert ziemlich gut, weil, wie ich sagte, es wirklich nur String-Repräsentationen davon speichert, wie der gesamte Datensatz aussehen würde. Und wir haben die alten Werte und die neuen Werte für einen Side-by-Side-Vergleich. Auf einer Benutzeroberfläche könnten Sie das Ergebnis leicht drucken, da es sich um JSON
handelt, es möglicherweise nicht leicht lesbar ist. Also möchten Sie es vielleicht ein wenig optimieren, so dass die Details ein B präsentiert, es ist lesbarer, aber zumindest können Sie alles sehen, was passiert. Halten Sie ein Protokoll über alles, was gelöscht wird, geändert oder hinzugefügt Hals Anwendung, was auch immer sie Täler sind, wo zu dieser Zeit. Also kann er voran gehen und einige Tests machen, einige Protisten machen, und schauen Sie in diesem Audit stabil, natürlich, wissen Sie, mit all diesen Änderungen, müssen
wir Auto neue Tabelle abgekratzt. Also, wenn die Anzeigenmigration und wir sagen, hinzugefügt Audit-Tabelle. Und dann, nachdem wir diese Migration bekommen haben, müssen wir die Daten sehen. Und wenn all das erledigt ist, kannst
du es testen und mich wissen lassen, wie es für dich funktioniert.
37. UPDATE: Volles Database -: Hey Jungs, Dies ist eine schnelle Lösung für unser vorheriges Video. Sie hätten Ihr Auditing und die vollständige Datenbanküberwachung eingerichtet. Und wir werden sehen, wie es alles in JSON serialisiert, speichert es in der Datenbank. Wenn Sie jedoch versuchen, mehrere Operationen durchzuführen, aber zu buck, könnten
Sie in eine schwierige Situation geraten, in der es sich über eine Typisierung
für ein Auditfeld oder einen Audit-Datensatz beschwert , wenn das wirklich nicht passieren sollte. Und ich bin nur hier, um Ihnen die Fixed dafür zu zeigen. Also in unserem auf vor dem Speichern von Änderungen oder Speichern von Änderungen, was passieren sollte, ist, dass dies alles herausfiltern sollte, was unverändert bereits
berührt ist , um zu wissen, dass wir wissen, dass der Entitätszustand, Ich wette, alles, was eingefügt wird, wird die hinzugefügt. Und dann wissen wir, dass wir den Entitätsstatus für gelöscht und geändert haben oder so. Aber dann
ist der Grund, warum wir diese beiden ausschließen , dass wir nichts überprüfen müssen, was losgelöst ist, was
bedeutet, dass es nicht gefahren wird, unsere sollten nicht verfolgt oder unverändert werden,
was bedeutet, dass nichts passiert ist. Lesen Sie also im Wesentlichen, was passiert, ist, dass, sobald die Änderungen speichern wirklich aufgerufen werden,
alles, was verfolgt wurde, automatisch in einen onchange-Zustand übergeht. Wenn Sie also mehrere Operationen ausführen, dann werden Sie mit Überwachungseinträgen enden, die gespeichert werden. Und dann versuchen Sie, etwas anderes in das Framework zu sagen,
verfolgt immer noch die alten Objekte, die zuletzt gespeichert wurden, einschließlich des Überwachungsdatensatzes. Deshalb müsste es an dieser Stelle
herausgefiltert werden , weil es einen onchange-Zustand kennt. Aber aus welchem Grund auch immer dieser Filter eigentlich nicht funktioniert, wie ich es gerne hätte für Sie arbeiten, Amy anatta dieses Programms, das ist gut. Aber ich habe gesehen, dass dieses Problem mehr als einmal passiert ist. Also werde ich dir nur diese Lösung dafür zeigen. Und es ist weniger eine ausgeklügelte Lösung. Alles, was ich tun werde, ist, den Zustand zu invertieren und das funktioniert besser für einige. Also, was wir tun werden, ist zu sagen, geben Sie mir die Einträge, wo wir wissen, dass wir sie versuchen wollen,
was bedeutet, dass der Zustand ist äquivalent zu tot, oder es ist äquivalentes Werkzeug modifiziert. Und dann noch eins. Oder es ist äquivalent zu den gelöschten BreakLine. Richtig? Weil wir wissen, dass wir diese verfolgen wollen. Wir wollen die anderen beiden nicht aufspüren. Aber wenn wir versuchen, sie aus irgendeinem Grund auszuschließen, funktioniert
der Ausschluss möglicherweise nicht so, wie er sollte. Also, das ist in Ordnung. Wir werden nur unsere eigenen arbeiten, die immer noch die Qualität und die Integrität unseres Codes
beibehalten. Wir sind nirgends zu sehen, geben uns diejenigen, von denen wir wissen, dass wir auf jeden Fall prüfen wollen. Also bekommen wir diese Einträge und dann würde alles andere in Linie
fallen, weil es sie oder
Fallaussage gibt , basierend auf welchem Zustand es ist, der zum Audit-Eintrag hinzugefügt werden muss. Also, das ist eine schnelle Lösung. Wenn du diese Schwierigkeiten hättest, können
wir das tun und ich bin sicher, dass du eine bessere Erfahrung hast. Und wenn nicht, werden
wir natürlich weiter untersuchen und schauen, weil wir alle rot lernen. Dies ist eine sehr komplexe Bibliothek und wir tun nur unser Bestes, um das Beste aus ihr herauszuholen.
38. Daten-Validierung mit Data: Hey, Leute, willkommen
zurück. In dieser Lektion werden
wir uns damit befassen,
Einschränkungen und allgemeine Regeln für
die Eigenschaften
und die Werte, die
sie haben dürfen, festzulegen. Jetzt hätte ich das
Wort Beschränkung öfter als einmal verwendet. Und das wäre
spezifischer für die Migrationen gewesen ,
bei denen wir gesehen haben, dass Einschränkungen für
Fremdschlüsselbeziehungen oder
für Einzigartigkeit und ähnliches hinzugefügt wurden Fremdschlüsselbeziehungen oder . Aber das sind
alles Migrationen auf einigen der Regeln
basieren
, die wir in unserem Modell erstellen, und auf
den Datentypen
und dem, was wir
als Fremdschlüsselreferenz und dergleichen festlegen als Fremdschlüsselreferenz und dergleichen Abgesehen von diesen
spezifischen Situationen
gibt es Zeiten, in denen
Sie etwas
kalkulierter vorgehen und
einen besseren Überblick darüber haben möchten kalkulierter vorgehen und
einen besseren Überblick darüber haben einen besseren Überblick darüber was gespeichert wird und
wie es gespeichert wird Also ein praktisches Beispiel. Wenn wir uns Team ansehen, sehen
wir, dass wir
eine Zeichenfolge für den Namen haben, die in der Datenbank in
eine RCR übersetzt wird, aber dann ist es VRTR Wollen wir wirklich vrtrMx als Teamnamen,
oder? Also genau hier, wir öffnen die Datenbank für die
Möglichkeit, dass jemand einen ganzen Aufsatz
in diesem Bereich schreiben und
das einen Teamnamen nennen
könnte in diesem Bereich schreiben und
das einen Teamnamen nennen Das wollen wir nicht unbedingt. Andere Einschränkungen können Standardwerte
beinhalten. Also hatten wir diese
Basisdomänenobjekte hinzugefügt. Und ich verwende
nur ein Beispiel in dem wir die Datetime haben Aber dann kann es auch Situationen
geben, in denen Sie Standardwerte
in diesen Eigenschaften haben
möchten Wenn also ein Wert nicht
von der Benutzeroberfläche
oder vom Benutzer bereitgestellt wird , möchten
Sie trotzdem, dass er
einen Wert hat. Lassen Sie uns einen
Blick darauf werfen, wie wir zum Beispiel etwas
einschränken können, was unsere Zeichenkettenspalten aufnehmen können. Also aus dem DV-Kontext, und hier wird eine Fluent-API verwendet Wir hätten uns also früher mit
Fluent API befasst, als wir bestimmte Regeln
dafür spezifiziert
haben was jede
Entität All diese Codezeilen
oder Codeblöcke basieren auf
der Fluent-API wirklich fließend Was wir jetzt tun, ist die
Fluent-API für eine gewisse Validierung zu verwenden Fluent-API für Also ich möchte
Model Builder Dot sagen, und dann wird es dieses Mal im Team
sein Also werde ich Punkteigenschaft
sagen, was sich dann für
einen weiteren Lambda-Ausdruck öffnet Ich werde P als meine Tokens verwenden. Ich werde P Punkt sagen
und dann kann ich die
Immobilie auswählen, an der ich interessiert bin. Also habe ich Name gesagt. Und danach kann ich
sagen, welche Einschränkungen es hat. So kann ich der Datenbank sagen
, dass sie erforderlich ist oder dass sie einen bestimmten
Spaltentyp hat. Was wäre, wenn ich nicht unbedingt
wollte, dass es VT ist? Was wäre, wenn ich möchte, dass es VT ist. Zum Beispiel. Was ist, wenn ich eine maximale Länge festlegen
möchte, was wir gleich tun werden. Also sage ich maximale Länge, und dann braucht
es nur noch einen ganzzahligen Wert. Ich werde sagen, dass kein Team einen Namen haben
sollte, der mehr als 25 Zeichen lang ist.
Ich denke, das ist vernünftig. Da drüben
in der Bundesliga gibt es einige Mannschaften mit
langen Namen wie Barca, Munch und Gladbach Aber ich denke, 25 sind
ausreichend oder wir erhöhen es einfach auf 50, um auf
Nummer sicher zu Also sollte kein Team jemals
einen Namen haben, der 50 überschreitet. Nun, wenn wir die Regeln
leicht nehmen, legt
das wirklich die Beschränkung
für eine Eigenschaft fest, und das ist so ziemlich
eine Eigenschaft nach der anderen. Aber ich kann das für
mehrere Entitäten tun. Also möchte ich dieselbe
Einschränkung für eine Liga. Ich möchte nicht, dass der Name
einer Liga ein Aufsatz ist, und ich möchte nicht, dass der Name
eines Trainers zu
lang ist. In Ordnung? Andere Dinge, die ich tun könnte, ich könnte diese
Eigenschaft als Index einrichten. Wenn wir über Indizes sprechen,
handelt es sich dabei in Wirklichkeit um
Hochgeschwindigkeits-Suchpunkte Ich werde diese Zeile entfernen, ich habe nur diese Zeile dupliziert, und statt
Punkteigenschaft zu sagen, werde
ich sagen, Punkt hat Index Und dann wird mich das
jetzt
nach einem Lambda-Ausdruck fragen nach einem Lambda-Ausdruck Also werde ich einfach H
verwenden, als würden wir
Index machen und ich werde sagen, dass
der Index auf dem Namen steht Das heißt, wenn wir
nach dem Namen suchen, sollte
es eine hohe Geschwindigkeit sein. Punkt für die Daten, damit die Abfrage
relativ schnell ausgeführt werden sollte. Ich kann eigentlich einfach
dasselbe für unsere Liga und
für unseren Trainer tun. Beachten Sie, dass ich
die Namen einfach kopiere und einfüge und entsprechend ersetze
, weil sie alle
ähnliche Strukturen haben Sie möchten wahrscheinlich
nur angeben, dass diese Spalten eindeutig sein sollen diese Spalten eindeutig sein sollen oder welcher Wert auch immer in
ihnen steht, eindeutig sein sollte Also eine Fallstudie dafür, nun, Sie würden nicht zwei
Teams mit demselben Namen wollen, obwohl es sehr wahrscheinlich ist Du würdest nicht zwei
Ligen mit demselben Namen wollen,
obwohl das, glaube ich, weniger wahrscheinlich ist Aber in einer praktischeren
Umgebung, wenn Sie
eine Datenbank für ein
Schulverwaltungssystem oder ein Buch erstellen,
Storage . Sie haben die ISBN, die eine eindeutige
Nummer für jedes Buch ist, oder Sie haben die ID-Nummer eines
Schülers, die sich von der
standardmäßigen inkrementellen ID unterscheidet, aber nur die ID, die
sie in der Schule verwenden, Sie haben diese ID-Nummer, dann möchten Sie angeben,
dass sie eindeutig ist Also könnte ich
den HAS-Index tatsächlich dahingehend erweitern, dass dieser Index
auch eindeutig sein sollte Alles klar? Und es
gibt noch andere Dinge , die Sie anwenden könnten. Einige davon habe ich
ehrlich gesagt noch nie benutzt. Ich hatte noch nie eine
Situation, in der ich sie benutzen musste, aber das ist nur ich, du kannst sie
erforschen und nutzen. Also hier sage ich der
Datenbank, dass es sich einen Hochgeschwindigkeits-Suchbereich
im Tabellenteam
handelt, der einzigartig ist. Wenn Sie einen
Index für mehrere Spalten haben
möchten, können Sie ihn
einfach verketten. So kann ich einen
anonymen Objekttyp erstellen. Wir haben uns das schon früher angesehen, also kann ich im
Lambda einfach sagen, lass uns den Coach benutzen Ich würde sagen, dass der
Index in der Trainertabelle
ein kombinierter Index ist oder dass sowohl der Name die Team-ID Indizes
sein sollten, Also kann ich meinen
Lambda-Ausdruck starten, sagen wir neue offene geschweifte Klammern,
damit er weiß, dass
es sich um einen Objekttyp handelt Und dann geben Sie innerhalb dieses Objekts
einfach mehrere Spalten an, H-Punktname, H-Punkt Team-ID, Komma,
Trennen usw. usw.,
und dann kann
ich all das einzigartig machen Das bedeutet also, dass diese Kombination immer einzigartig
sein sollte. Das ist also eher so, als würde man zu diesem Zeitpunkt einen
zusammengesetzten Schlüssel erstellen. Alles klar? Also
zeige ich dir nur ein paar kleine Leckerbissen Ich weiß nicht, wie
praktisch sie in dieser
speziellen Situation
unbedingt sind , aber vielleicht stehen Sie vor
diesen Herausforderungen beim
Entwerfen Ihrer Datenbank,
und wenn Sie einen
strengen Datenbankhintergrund haben vor
diesen Herausforderungen beim
Entwerfen Ihrer Datenbank, ,
dann wissen Sie, wie einfach das ist Oder es ist relativ
einfach, dies in SQL Server
Management Studio zu tun. Wenn Sie
es jedoch mit einer Datenbank zu tun haben, bei der der Code an
erster Stelle steht, möchten
Sie, wie gesagt, alle
Änderungen aus
unserem Entitätsframework verwalten und sie in die Datenbank sickern lassen , anstatt
sie zu mischen und
abzugleichen Wenn ich also
all diese Änderungen vorgenommen habe, gehe ich zur
Paketmanager-Konsole und füge eine neue Migration hinzu, dann sage ich
zusätzliche Validierungen und denke immer daran, das richtige Projekt
auszuwählen Also wechsle ich einfach von der Konsole
zu den Daten, Entschuldigung. Aber jetzt, wenn wir uns
unsere späteren Aussagen ansehen. Sie sehen hier für
den Namen in Teams, es ist jetzt VRCR 50, und der alte Typ ist
NVCR Max. Alles klar? Es gibt also eine
Menge Leistungseinschränkungen, die entstehen können
, wenn Sie Ihre
Datentypen einfach bei VRTA Max
belassen Wenn Sie also anfangen, diese Einschränkungen einzuführen, machen
Sie Ihre
Datenbank
in Wirklichkeit kompakter, effizienter und besser, Sie wissen
schon, sparen sich den
Stress, Sie wissen schon, zukünftige
Designüberlegungen Wir haben also die
Alter-Spalte für die Namen. Also ist jeder gut generiert, dann haben wir den Create-Index. Wir sehen hier also, einen
Index für den Namen des Teams zu erstellen, und er sollte eindeutig sein. Und dann haben wir einen Index für
den Namen der Ligen erstellt , den wir nicht eindeutig
angegeben und einen Index für
die Trainertabelle erstellt, und die Spalten sind
Name und Team-ID, und wir haben uns den
Filtercode zuvor angesehen Also werde ich einfach weitermachen
und die Datenbank aktualisieren, und ich erwarte
keine Probleme bei der Ausführung dieses Befehls
. Und da haben wir's. Wir haben eine rote Linie, oder? Mal sehen, was diese rote Linie ist. Es heißt also, dass die
Anweisung create unique index beendet , weil ein doppelter
Schlüssel gefunden wurde. Wir sehen also
, dass wir bereits Daten
in der Teamtabelle haben , und wir versuchen
zu sagen, dass dieser eindeutige Index in
der Spalte mit dem Teamnamen einzigartig sein
sollte. Sie können also sehen, dass mein
Team hier stabil Ich habe viele Dinge, die sich wiederholen und wiederholen
und wiederholen. Aber es ist auch klar
, dass ich nicht sagen kann, dass die Namensspalte eindeutig
sein sollte, wenn ich eine CMLN so
oft in der Datenbank
habe Ordnung? Wir sehen also, dass
die Einschränkung funktioniert. Ich werde einfach
alles löschen , was
nicht unter den ersten drei ist. Mal sehen, ob ich
noch andere Fehler bekomme. Ja, ich hatte erwartet, dass ich einen Fremdschlüssel bekommen
würde. Lass mich das aufräumen. In Ordnung. Also, um das zu bereinigen, musste
ich rüber zu den Trainern gehen und
sichergehen, dass
niemand irgendeinen der Aufzeichnungen trainierte, die
ich löschen sollte. Gehen Sie auch zu den Spielen und
stellen Sie sicher, dass keiner
der Datensätze, die ich
löschen sollte, Übereinstimmungen enthält. Das ist also ein
praktisches Beispiel für unsere
Betriebsbeschränkungen, oder? Weil wir die
referenzielle Integrität nicht so festgelegt haben , dass sie kaskadiert,
sondern eingeschränkt wird Diese Dinge können also einfach nicht passieren, wenn diese
Einschränkungen erst einmal eingeführt sind, und wir lernen,
wie wir
sie mithilfe von EF Core durchsetzen können. In Ordnung. Also, nachdem das alles geklärt ist, gehen
wir zurück und versuchen es noch einmal mit unserer Update-Datenbank. Und dieses Mal glaube ich, dass
wir erfolgreich sein werden, und los geht's.
Erledigt. In Ordnung. So können Sie die Validierung
für Ihre Tabellen mit FCR einrichten .
Okay.
39. Vollständig mit Konfigurationsdateien: Hey Leute, in dieser Lektion werden wir nur ein bisschen Refactoring machen
und die volle Leistung unserer Konfigurationsdateien ein bisschen mehr verstehen. Als wir also unsere Konfigurationsdateien gemacht haben, wurden wir wirklich mit der Absicht entwickelt, unsere Seed-Konfigurationen zu erleichtern. Also nannten wir sie Liga-Seed-Konfiguration. Nun, die Realität der Sache ist, dass diese gesamte Klasse für
alle Konfigurationen relativ zu den Zieldomänenobjekten verwendet werden kann . Mit anderen Worten, nur dass ich im DB-Kontext rufe, haben
wir tatsächlich Liga-bezogene Konfigurationen. Wir haben bereits diese Liga-Konfigurationsklasse. Wir können diesen ganzen Code tatsächlich innerhalb dieser Klasse platzieren, um unseren gesamten DB-Kontext sauber zu halten. Alles klar, es geht, dann werden wir mit einer Menge von Konfigurationen und der Schleife enden. So viele Tabellen können Sie viele Konfigurationen haben. Sie wollen irgendwie alles in Stämmen halten, so dass Sie sie
sehen können oder sie sehr leicht finden können, wenn Sie es brauchen. Dann beginnen Sie einfach mit der Refactoring unseres Teams. Also plötzlich erste, Lassen Sie uns mit Teams beginnen. So sehen wir hier, dass wir diese Konfiguration für Team haben, diese Konfiguration, wir haben zwei andere hier. Und dann haben wir diese ganze Konfiguration mit dem Seeding. Also, erste Ordnung des Geschäfts, werde
ich dies von der Team-Seed-Konfiguration in nur Teamkonfiguration umbenennen. Und ich lasse das einfach alle Referenzen umgestalten, den Code werfen. Als Nächstes drauf. Was ich tun werde, ist, alle diese Konfigurationen aus dem DB-Kontext zu bringen. Also habe ich ModelBuilder dot n TTT-Karte, all das. Ich wollte das abschneiden. Und ich werde zu dieser Seed-Konfiguration kommen, was wir die Datei und den Neffen umbenennen werden, mach dir keine Sorgen darüber, aber richtig, nein, ich wollte nur die Konfiguration übergehen. Das ist also der Builder hat Datenkonfiguration. Ich werde unter das gehen, was immer noch in der Konfigurationsmethode ist. Alles klar, und dann werde ich all diese Konfigurationen einfügen, die ich gerade gesetzt habe. Dann wird ein Fehler mit ModelBuilder angezeigt. Und das liegt daran, dass wir in dieser Datei nichts namens ModelBuilder haben. Wenn Sie jedoch genau hinsehen, ist
ModelBuilder wie eine generische Version unserer Implementierung Das erlaubt mir,
ModelBuilder Punkt-Entität zu sagen und dann die Entität implizieren. Unser Builder-Objekt auf diesem Typ ist spezifisch. Es ist Entitätstyp Builder für die bestimmte Entität. Diese ganze Implementierung verkörpert also diese gesamte Linie. Alles klar, also alle diese Sätze als ModelBuilder-Punkt-Entität, dieses Team, kann ich das durch Builder ersetzen. Und Baumeister weiß, dass es relativ zum Team ist. Also alles, was wir hier tun, ist relativ zum Team. In Ordnung, also kann ich einfach Builder Dot Tasmania sagen und dann einfach alle Regeln auflisten. Ersetzen Sie das auch durch Builder, bewegen
Sie es einfach nach oben, so dass wir sehen können, wo es beginnt und stoppt. Und dann werde ich mit den anderen Bits der Konfiguration für das Team fortfahren,
jemand, um das zu schneiden und dann ging ich, um es direkt dort zu platzieren. Und noch einmal werde ich einfach den Builder verwenden, um diese
model.py in ModelBuilder Dot Entity, dieses Team Zeug zu ersetzen . Und da gehen wir hin. In Ordnung, und dann ist das unsere Konfiguration. Also haben wir bereits, dass diese Konfiguration hier aufgerufen wird. Also, sobald es diese Linie trifft, wird Boards oder
die Konfigurationsdatei springen und alles sehen, was für ein Team getan werden muss. Also kann ich diese Konfigurationen nicht wirklich über die hat die eta verschieben. Also lassen Sie mich diese Datei einfach schnell umbenennen, bevor ich es vergesse. Und dann werden wir das Gleiche für die anderen Konfigurationsdateien tun. Also Liga-Seed-Konfiguration, es ist nicht mehr spezifisch für Seeding. Also werde ich einfach weitermachen und das umbenennen. Ihre Freunde gehen weiter und benennen die Datei um, und dann kann ich über Liga-bezogene Konfigurationen direkt in unseren Baumeister bringen. Gehen Sie weiter und ersetzen Sie, was ich ersetzen muss. Und dann ging ich weiter und tat es auch für den Trainer. Also können Sie das tun, wissen Sie, dass Sie das Wesentliche haben. Und am Ende des Tages sehen wir RDB-Kontexte viel sauberer aussehen. Und dann all das chaotische Konfigurationsmaterial gibt es an bestimmten Orten, entweder im Besitz oder im Projekt.