Transcription
1. Introduction: Bienvenue dans ce nouveau cours Entity Framework
Core, une visite complète. m'appelle Trevor Williams, je suis
ingénieur logiciel et professeur avec plus de dix ans d'expérience
dans le développement d'applications, ainsi que dans l'enseignement aux
gens comment le faire Dans ce cours,
vous allez
découvrir Entity Framework Core,
le framework phare d'accès aux
données ou
ORM de Microsoft .
Dans ce cours,
nous allons passer en revue
quelques points qui vous permettront de
vous démarquer de
vos pairs et de vos collègues en termes d'interaction avec
vos bases
de données lors de la création d'
applications .net Nous allons explorer le framework d'
entités et la façon dont il vous
aide à créer des
applications plus rapidement dans .net, ainsi que la façon dont il vous
aide à gérer création et les modifications
de bases en utilisant simplement une syntaxe C sharp C'est exact. Utilisation de l'
entité Framework Core. Vous n'
avez pas nécessairement besoin d'utiliser SQL
ou de vous rendre dans un studio de
gestion pour manipuler votre base la fin de ce cours, vous aurez une
bonne compréhension façon dont tout cela est géré
par le biais des migrations, du contexte de base de données
et des modèles de base de données. Vous allez comprendre
comment écrire des requêtes de lien pour interagir avec les
objets et les tables de votre base de données,
et explorer de nombreuses
autres fonctionnalités avancées noyau
d'Entity Framework. À la fin de ce cours, vous êtes censé
être à l'aise avec framework d'
entités et la façon dont il vous permet d'
écrire des requêtes de lien et d'interagir avec vos données. Un petit historique du framework
d'entités. Il est en développement
depuis 2008 dans DottFramework, mais il a évolué et
évolué et nous en sommes
actuellement à D
cinq ou Dt COR cinq Ainsi, la bibliothèque, qui est actuellement utilisée dans un état stable, est EF Core five, c'est
ce que nous
allons explorer. Cependant, il y
aura bientôt l'EFC six, et la plupart des connaissances que
nous apprendrons ici seront des connaissances
transférables Maintenant, un peu plus d'
informations sur ce qu'est EF COR. C'est un mappeur
relationnel d'objets. J'ai utilisé l'acronyme ORM tout à l'heure. C'est ce qu'il représente. Mappeur relationnel d'objets. Il s'agit donc d'une bibliothèque open
source avec des API qui vous permettent
d'interagir facilement avec la base de données. Bien que nous utilisions SQL
Server dans ce cours, de nombreuses fonctionnalités de FCR
peuvent être étendues à d'autres bases de données telles que post
resca et cuaide and my ca. donc de nombreux
avantages apprentissage du C présente
donc de nombreux
avantages, car cela Cela vous aide à réduire la
répétition du code et vous permet de vous concentrer sur d'autres éléments de
votre application tout en préservant la
cohérence et la cohérence du code . Il est également
prêt à être utilisé en entreprise. C'est exact. Si vous créez une
application volumineuse et que vous craignez d'avoir
trop de requêtes et
d'avoir du code mésique, FCR est parfait pour vous car
il est agréable et compact Il vous permet de conserver
la syntaxe en C sharp et il est suffisamment stable pour
fonctionner dans des conditions extrêmes. Je sais que vous regardez
ce cours et que vous vous demandez s'
il est vraiment pour moi. Eh bien, si vous voulez en savoir plus sur FCR, vous êtes au bon endroit Si vous connaissez le langage C sharp et que vous avez une certaine connaissance des
bases de données, vous êtes au bon endroit. Si vous souhaitez apprendre des méthodes
modernes d'interaction avec votre base de données
à l'aide de la technologie, vous êtes certainement
au bon endroit. À la fin de ce
cours, vous
n'aurez aucune faiblesse ni aucune menace. Tu ne peux que t'
améliorer de plus en plus. Alors, qu'est-ce que tu attends ? Je suis heureuse de
vous accueillir dans ce cours, et je vous verrai lors de
la prochaine conférence.
2. Régler un environnement de développement: Salut, les gars, bon retour.
Dans cette leçon, je vais simplement vous expliquer ce dont
vous avez besoin pour configurer votre environnement
pour ce cours. Je suis donc déjà sur le site Web de
Visual Studio, vous pouvez y accéder en disant
sutudo.microsoft.com Et ce que nous allons
utiliser, c'est l'édition
communautaire de Visual Studio IDE. Non, il s'agit de l'IDE
phare que nous a offert Microsoft
pour le développement .net C'est donc parfait
pour ce cours. Toutefois, si vous n'êtes pas en
mesure d'utiliser cette édition communautaire sur un ordinateur Windows
et que vous utilisez un MAC, la version MAC est disponible. Si vous n'utilisez pas de MAC, vous pouvez utiliser le code
Visual Studio, qui est également open source
totalement gratuit et disponible sur tous les systèmes d'exploitation. Maintenant, les choses que je vais
faire dans ce cours seront différentes si vous utilisez du code
Visual Studio, mais je ferai de mon mieux pour prendre des
notes en cours de route pour essayer assurer que vous êtes capable d'
effectuer les opérations. Maintenant, après avoir téléchargé
Visual Studio, vous recevrez, au
moins en téléchargeant
le programme d'installation, après le lancement de ce programme d'installation, un
écran similaire à celui-ci s'affichera. Maintenant, je l'
ai déjà sur ma machine, et vous voyez
les différentes charges de travail que
j'ai déjà installées Vous n'en avez pas besoin
pour ce cours en particulier. Si vous avez déjà ceux
que je vais vous montrer, vous pouvez sauter cette étape. Mais si vous êtes ici et que vous devez
savoir quoi acheter. Vous avez besoin de cette charge de travail de développement
multiplateforme .net, qui nous donne
les bibliothèques de base
pour
le développement de base du .net Et nous allons faire une
petite activité sur le Web. Ce serait donc une bonne
idée de se contenter réseau AP et de
la charge de travail de
développement Web. Donc, au strict minimum,
vous avez besoin de ces deux. Plus vous cliquez, bien sûr, plus cela sera installé Vous n'avez
donc pas
à en cliquer autant que vous le verrez après avoir coché Donc, le développement réseau et Web AP ainsi que le développement
multiplateforme .net Vous pouvez donc
les installer. Maintenant, vous devez effectuer cette étape, surtout si vous n'utilisez
pas Visual Studio et
une machine Windows, car si vous voulez
utiliser le code Visual Studio, vous
devez installer
le SDK en arrière-plan Cela est fourni avec
Visual Studio, non ? Mais si vous n'utilisez pas
Visual Studio une fois de plus, vous pouvez
télécharger ce SDK Vous pouvez
donc simplement vous y
rendre en accédant à Microsoft co. Et
à partir de cette page de destination, vous pourrez naviguer sur page de téléchargement
.t5 où vous allez
obtenir ce SDK Vous pouvez également obtenir
les durées d'exécution, car nous en avons
besoin pour l'hébergement, mais
vous avez au moins besoin de ce SDK OK. Maintenant, une fois que tout a été installé et configuré, vous voulez simplement vous assurer
que tout est installé. Vous pouvez donc accéder à
votre invite de commande, quel que soit le système d'exploitation
activé, puis vous pouvez simplement
taper .net H. D'accord ? Ainsi, lorsque vous le ferez,
vous
indiquerez que si vous voyez une impression à l'écran
ressemblant à ceci, vous êtes sur la bonne voie Il vous indiquera donc la version du
SDK dont vous disposez et vous montrera simplement toutes
les différentes commandes
que vous pouvez utiliser Vous pouvez donc réellement utiliser
ces commandes lors création d'une nouvelle application
principale .net, et encore une fois, si vous utilisez du code
Visual Studio, vous
utiliserez certainement un peu plus les commandes
.net C'est bon. C'est donc vraiment tout pour configurer
l'environnement. s'agit d'une vidéo de cinq minutes, mais elle prendra
probablement quelques heures ou quelques minutes de plus si vous la
configurez à partir de zéro, mais cela ne prendra pas trop de temps. Donc, dès que
vous avez terminé et que vous pouvez vérifier que
tout est installé, vous pouvez passer à
la leçon suivante. OK.
3. Configurer la solution: Salut, les gars,
bienvenue dans cette leçon, nous allons commencer à configurer notre solution pour le
projet ou pour ce cours. Et ce que nous allons faire, c'est partir d'une solution vierge. Je vais donc
cliquer sur Créer un nouveau projet, et je vais simplement rechercher le modèle de solution vide. Et c'est celui que
nous allons sélectionner. Alors allez-y, cliquez sur Suivant. Et je vais
appeler la solution Entity Framework net five, vrai, ce qui indique le
cours que nous suivons. Et après avoir défini ma position, je
vais cliquer sur Créer. Et juste comme ça,
nous avons Visual Studio avec notre fichier de solution vierge. Ce que nous allons
faire, c'est
commencer par ajouter un nouveau
projet à la solution. Je vais donc ajouter un nouveau projet, puis je vais ajouter application console, car
nous allons utiliser
une application console pour passer une principes fondamentaux
du noyau d'
Entity Framework. Hein ? Avant d'entrer dans l'effervescence du Web
,
je veux que nous comprenions
ce que le FCR peut faire, car si nous le comprenons
à partir d'une application console, les
possibilités
sont illimitées lorsque nous devons créer des applications plus
complexes Nous allons donc continuer,
cliquer sur
Application console, sur Suivant, et nous allons
appeler cette application console One Entity Framework net Five. Alors allez-y, appuyez à nouveau sur Suivant. Nous ciblons cinq
comme cadre cible,
puis nous allons de l'avant et créons. OK. À l'heure actuelle, notre application
console est créée. Nous allons créer
deux autres projets, seront en fait
des bibliothèques de classes. Aujourd'hui, en matière de développement d'entreprise, l'
un des
principes fondamentaux est la séparation des préoccupations, ce
qui signifie que nous avons l'application, qui
va probablement tirer les ficelles,
parler à l'utilisateur. Mais nous avons ensuite besoin d'autres projets dans lesquels nous allons stocker des objets liés à la
base de données et configurations liées à la
base de données sont séparées. C'est pourquoi nous ajoutons deux autres projets sous
forme de bibliothèque de classes. J'ai donc une bibliothèque
de classe sur la gauche ici. Vous pouvez toujours faire défiler la page, mais vous pouvez effectuer une recherche si
nécessaire et
n'oubliez jamais qu'il s'agit
d'un do dièse. D'accord ? Donc, pour la bibliothèque de classes, nous allons appeler
ce premier framework d'
entités
net five dot data. Et puis il reste que le
framework cible est toujours à cinq, puis nous appuyons sur Créer. Enfin, et ce n'est pas le moindre, nous allons
ajouter une autre bibliothèque de classes, et celle-ci sera un domaine
à points. Donc, la même
convention de dénomination que nous avons Entity Framework Net
Five Dot Domain, n'est-ce pas ? Et il s'agit toujours d'un framework
cible .t5, puis nous allons de l'avant et ajoutons C'est donc tout
pour la configuration de notre solution. Donc, une fois de plus, nous
allons fonctionner
avec trois projets, au
moins pour le moment, trois projets
différents. Celui-ci, l'application console le
listant comme interface utilisateur,
vous pouvez le voir ici comme un type de
sortie d'exécutable. Il sait donc qu'il doit exécuter ou qu'il doit
faire quelque chose. Il en va de même pour la
configuration de base ou
les fichiers de projet , car
si vous considérez celui-ci différemment de
la bibliothèque de classes, vous verrez que celle-ci ne
contient que le framework cible. Celui-ci connaît son framework
cible
et le fait qu'
il s'agit d'un exécutable. C'est la seule différence importante
entre les deux, non ? Celui-ci représentera donc l' endroit où nous allons
écrire notre code pratique, puis nous allons configurer notre domaine et nos
objets de données ici. Eh bien, le domaine aura nos modèles de
données pour les classes, puis les données auront nos configurations de données
et nos fichiers. Donc, quand nous serons arrivés, nous
commencerons à nous amuser et à modéliser
certaines des tables que nous utiliserons
pour ce cours.
4. Créer les modèles de données avec EF Core: Bon retour, les gars.
Dans cette leçon, nous allons donc commencer à modéliser
nos tables de base de données. Maintenant, ce que j'ai à l'écran est un diagramme de base de données ou un diagramme de relations entre
entités ERD. Il porte plusieurs noms, et il en existe quelques
représentations. Mais le concept fondamental est qu'il s'agit d'un diagramme montrant les différentes entités
ou tables d' une base de données,
ainsi que la colonne de clé
primaire les autres champs, et les autres champs, puis illustrant l'
existence de ce que nous appelons une relation de clé étrangère
entre deux tables. Ici, cela montre que nous
avons des équipes et des ligues. Ce sont deux tables. La ligue a un identifiant, que nous allons transformer en
un
entier à incrémentation automatique, et elle a un nom Ensuite, une équipe possède également un identifiant, également sous forme de nom, mais
elle a également un identifiant de ligue. Cet identifiant de ligue est ce que nous appelons une clé étrangère
de la ligue. Une équipe appartient à une ligue. C'est la relation. Si vous connaissez la base
de données, vous savez déjà
ce qui se passe. Si vous n'êtes pas si familier,
alors ce n'est pas un problème. J'espère que vous comprenez
au moins le concept qui sous-tend ce schéma. C'est bon. Ce que nous voulons faire, c'est installer des tables comme
celle-ci à l'intérieur de l'EFC Nous voulons utiliser FCO pour modéliser une base de données qui
générera ces tables Vous avez donc différentes
conventions lorsqu' il s'agit de développer
à partir d'une base de données. Nous pouvons donc commencer par la base de données, c'
est-à-dire que quelqu'un a
conçu la base de données et tout le reste, puis nous commençons à
créer l'
application par la suite ,
ou vous avez abord le code,
ce
qui implique
que le code passe en premier, cela signifie vraiment
que nous allons écrire le code qui est ensuite
transformé en base de données. De cette façon, si nous devons changer
quelque chose par la suite, nous
changeons simplement le code, puis nous pouvons le laisser apporter des modifications incrémentielles
pour définir la base Et l'EFC soutient l'un ou l'autre.
C'est ce qui fait toute la beauté de la chose. Donc, pendant la majeure partie
de ce cours, nous allons d'
abord
examiner le code et la manière dont nous pouvons apporter modifications
marginales ou
incrémentielles fur et à mesure que nous
modifierons le code Mais nous verrons comment rétroconcevoir
une base
de données existante pour en faire
un ensemble de fichiers EFC, n'est-ce pas ? Donc, assez de discussions,
allons-y. Mes modèles de données ou modèles de
domaine
finiront donc par être intégrés au
projet de domaine, n'est-ce pas ? Je vais donc me débarrasser de cette classe par défaut
que nous avons
obtenue, et je vais ajouter
une nouvelle classe, que je vais appeler
ligue de classes. Maintenant, d'une manière générale, je conseille
toujours à mes étudiants, chaque fois que vous
créez une base de données, essayer de
commencer par celles qui ont
le moins de dépendances,
puis de continuer car vous ne voulez pas
créer une table contenant
deux ou trois
clés étrangères liées
à d'autres tables alors que deux ou trois
clés étrangères liées ces
tables n'existent pas encore Puisque dans cette situation,
League est une table autonome, ce qui signifie que la ligue existe Il y aura au moins une ligue en ce moment
sans aucune équipe, mais l'équipe
dépend de la ligue. Je veux d'abord que la ligue existe. Créez cette classe,
je vais la rendre publique afin que d'autres
projets puissent y accéder. Et puis, à l'intérieur, je vais avoir les deux
propriétés, l'ID et le nom. Nous allons donc dire public
int ID, nom de chaîne public. Vous voyez ici,
surtout si vous connaissez les types de
données en SQL, vous verrez que nous ne voyons pas caractère
Var ici. Nous
disons chaîne. FCR sera capable de traduire le C sharp natif
de quels types de données Dans les types de données
SQL équivalents. Nous verrons cela plus tard. C'est l'un des avantages. Nous pouvons utiliser notre langage C sharp natif dans notre application FCO, et la traduction vers
la base de données
se fera de manière anonyme pour nous Il est
également important de souligner les conventions de dénomination et le soutien que vous obtenez du FCO lorsque vous respectez
certaines conventions une manière générale,
une colonne ID sera appelée ID. Parfois, vous pouvez vous qualifier et
indiquer l'identifiant de la ligue ou
l'identifiant du nom de la table. Maintenant, COR va identifier
l'une ou l'autre de ces conventions, et il en
déduira automatiquement qu'il s'
agit de votre clé primaire et de
votre colonne d'
identité QL à
incrémentation automatique, n'est-ce pas clé primaire et de
votre colonne d'
identité QL à
incrémentation automatique colonne d'
identité QL à
incrémentation Il verra donc automatiquement cette convention de dénomination et indiquera à SQL qu'il s'agit
de la colonne clé primaire. Donc, si vous vous
écartez de cette convention de dénomination
générale, vous
devrez effectuer des
configurations supplémentaires pour
que cela fonctionne. Pour moi, il est donc plus facile de simplement
travailler avec le FCR que de forcer le cordon F
lors d'un autre passage Ce n'est pas la
chose la plus difficile à faire, mais pourquoi se donner plus de
travail alors que cela peut être aussi simple. Juste en disant « ID », vous
saurez qu'il s'
agit de la clé primaire et vous pourrez
régler tout le reste pour moi. Maintenant, je vais créer
la table suivante ou la classe suivante pour représenter la table
suivante, qui est l'équipe. Je l'ajoute simplement
au projet de domaine. L'équipe est le nom,
puis encore une fois l'équipe, public
aura également un identifiant et un nom. Comme nous l'avons vu, il y
a ensuite une troisième colonne, qui est l'identifiant de la ligue. Cela représente une clé étrangère. Maintenant, ce que nous allons faire
lorsque nous avons une clé étrangère, nous devons ajouter deux propriétés. premier étant le nom de la table ou le nom de la
table pour laquelle il s'agit d'une clé étrangère et d'un identifiant. Encore une fois, convention de dénomination. La deuxième serait une propriété
de navigation et la plupart du temps, vous
les verrez la rendre virtuelle. Ajoutons simplement cela.
La ligue virtuelle publique est type de
données de la classe que nous venons de créer avec le même nom. C'est très bien Mais
la combinaison de ces éléments permettra à F de déduire que cette correspondance entre le nom de la
table et le mot ID signifie qu'il s'agit d'une clé
étrangère pour cette table C'est bon. Donc, si
vous avez dû configurer une clé étrangère dans SQL Server, vous savez que vous
devez entrer et choisir les colonnes, et vous devez faire
ceci, et vous devez le
faire . Et il
y a quelques étapes. C'est tout ce qu'il faut. Respectez
la convention de dénomination et détenez cette propriété
de navigation. Et le FCO se contentera de dire :
OK, je sais qu'
il s'agit d'une clé étrangère, et je sais que je
peux automatiquement inclure ou
présenter automatiquement les détails associés à cet enregistrement via
cette propriété Plus tard, nous le verrons à une heure pour afficher trop d'informations. Mais j'essaie simplement de
vous montrer que dès le départ, une fois que vous aurez suivi ces conventions de dénomination
fondamentales, FCR fera une grande partie
du travail à votre place OK. C'est donc
tout pour le moment. Nous avons créé les classes censées représenter les tables
de la base de données. Bien entendu, les noms de colonnes
correspondant aux types de données sont conceptuellement les mêmes que ceux auxquels nous nous
attendrions dans la base de Et plus tard, à notre retour, nous verrons comment
nous avons configuré le contexte de base de données, le fournisseur et
la connexion
réelle à
la base de données, car rien
de tout cela n'existe pour le moment. Il n'y a pas de base de données. Nous sommes juste le
modéliser et de dire :
Eh bien, ils représentent
ce que je veux stocker. Donc, à notre retour,
nous verrons comment nous avons réellement configuré le
lien vers la base de données. OK.
5. Spécifier le fournisseur de données et la chaîne de connexion: Nos gars étaient de retour et l'objectif de cette
leçon est de configurer notre classe de données afin
qu'elle sache qu' elle doit se connecter à
notre base de données. C'est bon. donc devoir ajouter
quelques bibliothèques à notre classe de données Nous allons donc devoir ajouter
quelques bibliothèques à notre classe de données pour
lui permettre d'interagir réellement
avec ce framework réseau. Désolé, avec Entity Framework. Parce que pour le moment,
personne ne sait rien. Nous
parlons simplement d'un cadre d'entité. Il s'appelle Entity Framework, mais il ne sait rien
sur Entity Framework. Permettez-moi donc de commencer par
supprimer cette classe par défaut, et je vais passer
aux nouveaux packages Gate
et passer à Bros. Nous allons rechercher le serveur SQL de
base
d' Entity Framework Donc, avant de procéder à l' installation au saut,
permettez-moi de vous expliquer. Vous avez Microsoft
Entity Framework Core. Il s'agit de la
bibliothèque de base pour tout le monde. Je pense que chaque variation
dépend de celle-ci. Si vous le regardez, il s'agit
d'un
mappeur moderne basé sur des objets . Il prend en charge les
requêtes de liens, le suivi des modifications et fonctionne avec un
certain nombre de bases de données, le serveur
CQL, Azure, CQight postres
, Ce que vous savez,
c'est qu'à partir d'UGT, vous pouvez obtenir
différentes bibliothèques pour prendre en charge les
différentes bases Dans notre cas, nous utilisons le serveur
Microsoft K. Mais si je devais rechercher noyau d'
Entity Framework et simplement regarder les
différentes variantes que nous voyons pour notre serveur k, nous voyons en mémoire, nous voyons CQight Vous voyez Postgres, vous
allez voir MCL. Je ne vais pas les
passer toutes en revue, mais le fait est que,
quelle que soit la base que vous avez sous le capot, il existe très
probablement une bibliothèque pour la prendre en charge et vous pouvez l'
obtenir auprès de New gt. C'est bon. Comme je l'ai dit, aujourd'hui, nous ne travaillons qu'
avec SQL Server, alors allons-y
et installons celui-ci Je vais
donc simplement le
télécharger. Et ce faisant, il
va vous montrer toutes
les autres dépendances qu' il possède, n'est-ce pas ? Mais c'est bon. Nous pouvons simplement cliquer sur OK, accepter tous les
contrats de licence et vous
laisser l'
installer dans notre projet. Maintenant qu'il est
installé dans notre projet. Si je regarde en arrière dans le fichier CSP, il suffit de cliquer sur
le fichier de projet pour les données
du projet de données Vous verrez ici que cette
référence de package
est maintenant installée. Sinon, vous auriez également
pu aller l'avant et inscrire cette
ligne de la même manière. Il peut indiquer la référence
du package du nœud, inclure le nom de
la bibliothèque, la version qui
vous intéresse, puis juste pour
créer et il récupérera automatiquement
les dépendances pour vous. Il aurait donc pu le faire également, mais continuons en utilisant NewG Je peux donc fermer tout ça. Et la prochaine étape à l'ordre du jour serait de créer ce que
nous appelons le contexte de base de données. Je veux donc créer
une autre classe ,
puis je vais appeler
cette classe « contexte de ligue
de football ou « contexte de base de données de ligue de
football ». Nous avons tendance à le dire, le contexte de la
base de données signifie simplement qu'il s'agit du contexte ou de la connexion. Disons simplement que le contexte
est égal à la connexion. Le contexte de base de données signifie pour ainsi dire le fichier de
connexion à la base de données. Et puis cela vous
permet simplement de savoir quelle base de données il s'agit. Il ne s'agit pas d'une
convention de dénomination en soi. C'est comme ça que je le
fais. Je t'explique
juste pourquoi je le
nomme comme ça. Je vais donc rendre ce contexte de base de données de classe
public, puis chaque contexte
de base de données héritera du contexte de base
de données par défaut
provenant du noyau EF Vous avez donc différents contextes de
base de données, vous avez un contexte de base de données, vous avez un contexte de base de données d'identité si vous souhaitez vous authentifier. Mais pour l'instant, nous allons simplement nous en tenir
au contexte de base de données, contrôle et au point,
puis cela me fera
savoir que j'ai besoin d'une
instruction d'utilisation pour le framework d'entités. Noyau. Maintenant, c'est satisfait. Je peux le dire à propos des tables. N'oubliez pas que cela va
représenter la connexion
à la base de données. Donc, tout ce qui se trouve dans la base de données doit
être représenté ici. Nous avons les modèles qui représentent les tables de
la base de données. Maintenant que nous avons le lien
vers la base de données, nous devons indiquer à ce lien
les tables. Je veux donc dire ensemble de bases de données public. Et cet ensemble de bases de données signifie
simplement que l'ensemble de lignes ou d'enregistrements est réellement
une table dans la base de données. Vous êtes un modèle d'
équipe. D'accord. Et tu t'appelles Teams. Vous pouvez donc le lire comme
ça en disant simplement comprendre exactement ce que vous
tapez au fur et à mesure. Non, j'ai besoin d'une dépendance. Je dois ajouter une référence
au projet de domaine ici. Vous pouvez donc cliquer dessus, mais j'ai déjà eu des problèmes
avec cela Je vais
donc le faire
manuellement en cliquant sur les dépendances, ajoutant une référence au projet,
puis en ajoutant le projet de domaine, cliquant, puis nous pouvons simplement utiliser nos instructions d'
utilisation. Ensuite, je vais simplement
dupliquer cette ligne et faire la même chose pour une ligue que
la base de données a définie pour ligue, nous l'appelons ligues
dans la base de données. J'ai un ensemble de bases de données
pour les objets d'équipe, ce que
nous appelons des équipes. Encore une fois, cela
générera ou interagira avec
une table appelée équipes, et tout ce qui se trouve
dans la table des équipes sera sérialisé ou converti en
classe d'équipe native que nous avons définie La prochaine chose que je veux faire est lui faire
connaître l'existence d'une base de données, et nous devons faire ce que nous appelons une
chaîne de connexion pour cela. Ainsi, les chaînes de connexion
sont généralement ,
comme dans une application Web transmises,
comme dans une application Web. Vous
avez donc la chaîne de connexion
dans l'application Web et elle est transmise au contexte via les paramètres
de
configuration. Nous n'avons pas ce
luxe pour le moment, nous allons
donc le faire manuellement Je vais
donc écrire override Et puis le fait est
que le contexte de base de données, qui est notre classe
EFC, contient un certain nombre de fonctions que nous pouvons réellement remplacer et utiliser à
notre guise. Mais celui qui m'intéresse
, c'est la configuration. Cela signifie que chaque fois que vous
configurez le contexte de base de données, que voulez-vous que je fasse ? Je vais l'annuler. Je n'ai pas besoin de remplacer quoi que ce soit sur la base ou d'
interagir avec la base, mais je vais
lui dire que c'est le serveur UCL du générateur
d'options Vous voyez que c'est une gracieuseté
de notre serveur point, bibliothèque
FCR, n'est-ce pas ? Donc, serveur uEQL. Et nous allons saisir notre chaîne de connexion ici. Comme il s'agit d'une application de démonstration
qui n'en est qu'à ses débuts, nous
faisons tout cela. Mais bien sûr, je vais
vous le montrer pour que vous compreniez pourquoi nous
procédons de cette façon. Une chaîne de connexion
comprend donc quelques parties. Nous allons dire que la
source de données est égale à, puis nous allons
spécifier le serveur. Je vais donc utiliser la base de données locale, qui est un serveur local
intégré à Visual Studio, et vous pouvez accéder aux
bases de données locales via l'explorateur d'objets SQL
Server, que vous pouvez consulter, et le tour est joué. C'est bon. DB local, barre oblique inverse, barre oblique inverse, puis nous allons dire SQL local D B.
Corrigez Corrigez Prenez le temps trouver tel
que vous le voyez ici, même avec les parenthèses
et tout le reste, la double barre oblique inverse
et tout Ensuite, nous avons
le catalogue initial et il s'agit essentiellement du
nom de la base de données. Comment appelle-t-on
la base de données ? Je vais l'appeler Football
League Underscore FCR. C'est notre
chaîne de connexion. C'est bon. Nous avons
ainsi terminé de configurer le fournisseur de données et configurer le lien
vers la base de données. Bien sûr, cette base de données
n'existe pas encore, n'est-ce pas ? J'ai donc créé un lien vers quelque chose qui n'
existe pas vraiment. Et j'ai dit que ces tables
devaient exister dans une base de données définie, qui, comme nous venons de le
dire, n'existe pas. Je vais donc regarder
très rapidement dans
l'explorateur de serveurs SGO juste pour vous montrer qu'il
n'existe pas vraiment dedans J'ai quelques bases de données de test, et comme vous pouvez le
constater, elles n'existent pas. Donc, à notre retour, ce que nous allons
faire en utilisant FCO pour générer cette base de données
afin de pouvoir commencer à
interagir avec elle
6. Migrations et création de bases de données: Salut, les gars, bon retour.
Dans la dernière leçon, nous avions donc configuré notre contexte DV,
qui, comme je l'ai dit, est notre
connexion à la base Dans cette leçon, nous allons
commencer à examiner les migrations, qui sont nos instructions
pour la base de données. Notre première migration sera de
créer la base de données, car
une migration indiquera toujours ce qui existait, qu'est-ce qui existe maintenant Qu'est-ce qui est différent ? Permettez-moi de vous donner des
instructions pour
effectuer ces modifications. À ce stade, il n'y a rien. Donc, ce qui est là maintenant n'est rien, puis les instructions
généreront ce qui devrait s'y trouver. Hein ? Donc, pour
effectuer nos migrations, nous avons besoin d'un autre outil issu de
nos nouveaux packages de portail, et cette bibliothèque est
littéralement composée d'outils, n'est-ce pas ? Nous avons besoin du FC Two.
Passez à New Gate, je vais cliquer sur
Outils et télécharger
celui-ci est
automatiquement fourni avec Design
et d'autres bibliothèques, mais je vais juste continuer et
laisser cela s'installer. Après l'avoir installé, je vais
devoir définir une
référence de projet entre la console et notre projet de données car lorsque nous exécutons une commande
pour mettre à jour la base de données, nous devons l'exécuter le projet de démarrage
ou le projet principal, et le projet principal doit
connaître les autres
projets avec, vous savez, la connexion et
le contexte de base de données, etc. Je vais
donc simplement
ajouter une référence de projet
pour
configurer les deux, car nous devrons être en mesure d'
accéder aux objets du domaine. Nous devons également
pouvoir accéder au domaine, au contexte
de la base de données, n'est-ce pas ? Je vais donc simplement ajouter cela Et puis sachez que
tout cela est fait, nous pouvons effectuer une migration. Pour exécuter des migrations à
l'aide de Visual Studio, nous voulons accéder à la console
du gestionnaire de packages. Vous pouvez donc accéder aux outils, obtenir le gestionnaire de packages et
voir la console du gestionnaire de packages. J'ai déjà le mien à
ma disposition ici dans ce panneau, et bien sûr, vous pouvez tous les
déplacer vers le haut. Laisse-moi juste refaire celui-ci. Maintenant, avant de commencer
les migrations,
je veux juste que nous examinions l'étendue des options qui s'offrent à nous. Dans cette console de gestionnaire de packages, je peux dire get hip and help, puis taper
Entity Framework, puis lui donner
quelques secondes, et cela
générera un beau document nous
montrant tout ce qui est
possible grâce au framework d' entités. Cela commence par une licorne et il nous
parle de la bibliothèque, il nous donne tous les leviers de
commande et à quoi ils servent La même liste que celle que je
viens de mentionner dans GT est disponible ici
avec la documentation. Donc, comme je l'ai dit, nous
allons ajouter une migration, puis nous devrons mettre à jour la base de données après
chaque migration. J'ai mentionné plus tôt
que vous devez d' abord
utiliser le code plutôt que la
base de données. Donc, si vous commencez par coder,
eh bien, il s'agit de la base de données d'ajout de mises à jour de
migration. Si vous créez d'abord une base de données, vous
devez analyser
le contexte FO DB,
ce qui signifie essentiellement que je regarde la base de données et que je
génère les modèles de classe fonction de ce que je vois
dans la base Vous voyez donc qu'ils
ont plusieurs options disponibles. Vous pouvez scripter le contexte DV,
Scripto les migrations. Si vous êtes toujours démodé
pour générer la migration, vous avez besoin d'un script SQL. Vous pouvez faire tout cela à
l'aide de ces outils. Alors allons-y. Je vais juste
effacer ce CLS, effacer cette console,
puis je vais
savoir ajouter une migration Le
projet par défaut
doit donc, encore une fois , être le
projet d'exécution de la solution. Et je vais
dire ajouter la migration. Ensuite, je vais lui
donner un nom. Donc, le nom, généralement, vous voulez utiliser un nom
suffisamment
judicieux pour vous ou pour quelqu'un d'autre. Eh bien, commençons par quelqu'
un d'autre. Quelqu'un d'autre
peut venir et dire : OK, c'est l'
idée générale de cette migration. Vous devez également
utiliser un nom sensé car après votre départ en
vacances et votre retour,
vous voudrez revenir sur cette migration
et comprendre pourquoi elle a été
effectuée et
à quoi elle servait. Ne nommez donc pas la migration X ou simplement quelque chose de stupide,
donnez-lui un sens Comme s'il n'y avait rien ici. Je n'ai aucune migration,
aucune base de données. Pourtant. Je veux appeler cela
une migration initiale. J'aime aussi écrire mes noms à dos
de chameau. Lorsque vous utilisez des espaces, vous devez prendre des
précautions supplémentaires lorsque vous devez, vous savez, réutiliser les
noms, etc. J'utilise donc simplement une coque en chameau. Vous pouvez utiliser des traits de
soulignement, peu importe, mais je n'aime tout simplement pas les espaces
à l'intérieur de ces noms Je vais donc
ajouter cette migration. Il va générer le projet, et la construction est réussie, mais j'ai une erreur. Lisons donc cette erreur.
Et dans ce cours, je n'ai pas peur
de faire des erreurs, car je sais que beaucoup de gens détestent les erreurs qu'
ils commettent dans EFC Parfois, elles
ne sont pas très claires et il est difficile de résoudre
certaines de ces erreurs Je ne vais donc pas
avoir peur des erreurs. Au contraire, je vais
délibérément évoquer certaines erreurs afin que nous puissions
les corriger ensemble. Mais celui-ci dit
simplement que le projet de démarrage,
qui est
l'application console, qui est
l'application console, ne fait pas référence au projet de
conception, n'est-ce pas ? En d'autres termes, je dois
installer un package
dans l'application console. C'est donc un moyen facile de le faire. Bien sûr, vous pouvez
accéder à New gate, mais je vais essayer de le
faire via le fichier de projet. Je vais créer un nouveau groupe d'
éléments et lui donner une référence de package pour inclure design de base du
framework
Microsoft Dot Entity Framework. Et je suis juste en train
de définir la version que je sais utiliser dans
le reste du projet. Cette version peut varier en fonction du moment où vous
suivez le cours. Donc, si vous empruntez cette
voie, c'est bon. Sinon, vous pouvez toujours
accéder à New gate et ajouter le package de
conception du framework d'entité comme nous l'avons fait pour tous
les autres packages. La prochaine
étape très importante consiste à nous
assurer que notre projet de
données est sélectionné. Je viens de voir une liste
pour éliminer le bruit et les erreurs dans la section, mais je tiens simplement
à souligner que
nous avons besoin que le projet par défaut soit le projet dans lequel vous
avez le contexte de base de données, pour nous, ce sont des données. Je vais
sélectionner les données, puis je vais
simplement appuyer sur arch ce qui me permet de lancer la commande de
migration initiale add migration. Allez-y,
réessayez et cette fois, nous avons créé notre migration. Maintenant, voyons ce que nous avons ici. Nous avons obtenu notre dossier
appelé migrations, qui contient au moins un fichier portant le nom de la
migration que nous lui avons donné. Notez qu'il y a un
horodatage dessus. Nous avons également cet autre
qui est l'instantané du contexte. Donc, en gros, pour le moment,
voici à quoi ressemblera la
base de données, et nous avons notre fichier de migration. Prenons le temps de
comprendre exactement
le contenu d'un fichier de migration. Donc, généralement, en SQL, vous devez écrire des instructions
SQL, créer une table, créer, eh bien,
désolé, créer une base de données,
puis créer une table. Ensuite, vous saisissez tous les
champs et les contraintes. Si tu étais en train d'écrire un script. Si vous utilisiez le studio de
gestion, vous auriez cliqué et tout cela aurait été
généré en arrière-plan. Eh bien, un fichier
de migration sera
à peu près une représentation
de toutes ces actions, mais avec un contexte précis en C et construit sur ce que nous avons appelé
le modèle de générateur, n'est-ce pas ? Donc, si vous y
jetez un œil,
cela semble compliqué, mais que vous vous asseyez, respirez profondément et considérez-le en tant que développeur, vous remarquerez que
tout ce qu'il vous
dit a du
sens, n' est-ce pas ? Le générateur de migration, c'est-à-dire un objet transmis
ici, crée une table. Nom oublié,
fuites, non ? Et puis il
va automatiquement s'assurer
qu'il crée. Donc, même si dans
le contexte de la DV, j'avais suggéré, désolé, j'essaie juste d'en
dire beaucoup ici J'avais initialement suggéré
que lorsque nous
créons les modèles de classe, nous commencions par ceux qui sont
le moins dépendants. Parce que si nous avions commencé avec l'équipe et
que l'équipe dépendrait cette propriété de navigation la ligue
n'existait pas à l'époque, cela aurait été
une petite erreur Il aurait donc été prudent
de notre part de créer une ligue. Alors la ligue existe déjà au moment où nous créons des
choses qui ont besoin d'une ligue. OK. Maintenant, dans le contexte de la base de données, je n'ai pas nécessairement
suivi cet ordre. Je les ai juste listés
au hasard. Je ne
les ai donc pas nécessairement listés dans l'ordre dans lequel je
voulais qu' ils soient créés,
car
j'aurais évidemment voulu que les ligues
soient créées avant les équipes. Cependant, si vous regardez
la migration, elle
a déjà été effectuée
et vous avez constaté que les ligues ne possédaient pas de clés étrangères, c'est le cas de Teams. Les ligues doivent donc être
créées avant les équipes. C'est à peu près
ce que vient de faire FCR. Il s'agit donc de créer
le classement. Il lui donne l'ID et le nom de la
colonne. Et si vous regardez de plus près, conformément aux conventions de
nom, ID
sera automatiquement un entier,
non nullable, et il s'agit automatique de l'identité
d'un serveur CQL Tout cela a été généré parce que nous avons utilisé le mot ou
le nom ID pour cette colonne. FOR en a déduit que
c'est ce que nous voulions
comme clé primaire Et puis vous verrez
ici où il est indiqué que le type de colonne est une chaîne. C'est un type C sharp, mais dans la base de données, nous le transformons en NTR accord ?
Laisse-le juste pénétrer un peu. Ensuite, nous
ajoutons les contraintes qui en
font réellement la clé primaire, qui se trouve dans la colonne ID. Il répète ensuite ces actions. Générateur de migration, créez une table, créez des équipes, créez les
colonnes, encore une fois, déduisant quelle est la clé
primaire, puis en ajoutant l'ID de
ligue sous forme d'entier, mais cela va
encore plus loin avec les
contraintes créant la clé primaire et
en créant la clé étrangère, qui lie l'ID de ligue de
colonnes aux ligues de table principales
et à l'ID de colonne principale Vous voyez donc que tout cela est déduit lorsque nous utilisons nos conventions de dénomination
appropriées Il peut
arriver que vous deviez, vous savez, dévier de votre trajectoire,
et c'est compréhensible, mais ne faites pas en sorte que vous
deviez toujours
faire votre propre truc et lutter contre le QR, finir
par faire deux fois plus de travail alors que QoR est plus qu'heureuse de
faire tout le travail à votre Donc, après avoir créé tout cela, il continue et crée un index sur cette colonne de clé
étrangère. Maintenant, vous
remarquerez également qu'il
existe deux. Désolé, il existe deux méthodes dans ce fichier
de migration. Nous l'avons fait et nous l'avons
fait à peu près cela signifie que lorsque je mets à jour la base de données ou que je la mets à
niveau, c'est
ce que je veux qu'on fasse. D signifie que si je
dois annuler cette migration
depuis la base de données, c'est
ce qu'il faut faire. D tout comme up est le contraire de D, le code qui
se trouve dans up va faire
quelque chose de totalement contraire au
code qui est dans do parce que parfois
vous modifiez une base de données, puis vous dites, Oh, ce n'est pas
vraiment ce que je voulais faire,
puis vous apportez une modification. Mais lorsque vous souhaitez
apporter ce changement, c'est
parfois plus facile à
dire qu'à faire. Donc, au moins, la FCR dit, eh bien, je dis à la base de données ce qu'elle doit faire une fois la
migration effectuée, et je vais également vous
dire ce qu'il ne faut pas faire ou ce qu'il faut faire lorsque cette
migration est annulée Tout cela est donc automatisé
dans ce fichier. OK. Très bien, maintenant
que nous avons la migration. Nous allons terminer cette
leçon en exécutant la
commande la plus magique et probablement la magique et probablement la
plus importante de toutes, qui consiste à mettre à jour la base de données. Donc, jusqu'à présent, nous
n'avons toujours pas notre base de données. Nous allons de l'avant et saisissons la base de données de tirets de
mise à jour. Appuyez sur Entrée, laissez-le construire. Et cette commande
examine
les migrations qu'
elle connaît probablement puis examine les migrations
dont elle
ne connaît pas
l'existence, puis
reprend à partir de ce point et exécute les
migrations à l'avenir Ici, il est dit
d'appliquer la migration, puis il
m'indique quelle migration elle s'
appliquait s'il y en avait eu cinq, mais il n'y en a qu'une,
donc cela me fait savoir qu'il l'a fait
avec succès. Ainsi, lorsque je regarde
en arrière dans ma liste de bases de données, je vois maintenant la base de données le nom que j'avais défini
dans cette chaîne de connexion, football league EF core. Lorsque je développe les tables, je vais voir l'historique de
migration EF, qui est essentiellement une
table dans la base de données, permettant de suivre la migration. Vous pouvez ainsi savoir jusqu'à quelle
version se trouve votre base de données. Hein ? Ensuite, il y a les
ligues et nous avons les équipes. Et si vous regardez, vous voyez des clés, OK, donc c'est
la clé primaire. Et vous voyez ici que le
League ID est une clé étrangère. Tout cela a été configuré dans la base de données pour nous
grâce à cette migration. Dans la
leçon suivante, nous allons
voir comment nous aurions
pu scripter voir comment nous aurions
pu scripter cette migration, car vous souhaitez pas
nécessairement exécuter la mise à jour de la base de données et
laisser FCR avoir le contrôle total sur
tout le contenu de la Mais il existe un moyen de générer
un script SCO basé sur
ces instructions,
et vous pourriez un script SCO basé sur
ces instructions, ensuite l'
exécuter vous-même. Donc, à notre retour,
nous examinerons cela.
7. Générer des scripts de migration: Bon retour, les gars.
Dans cette leçon, nous allons donc parler de la
création de scripts pour notre migration Donc, l'étude
de cas expliquant pourquoi vous voudriez créer un script plutôt
que, vous savez, générer un
fichier de migration et le faire à partir du gestionnaire de packages serait peut-être simplement
la séparation des contrôles. Peut-être qu'un administrateur de
base de données est
chargé des modifications de
base de données. Vous, en tant que développeur, apporteriez donc pas
ces modifications à la base de données, mais vous avez effectué la migration par
rapport à votre version locale. Vous devez le lui remettre pour qu'il
puisse le faire dans
l'environnement. Vous savez,
différentes situations peuvent déterminer si vous pouvez ou non
le faire comme nous venons de le
faire dans la vidéo précédente. Sinon, vous devrez écrire
le script de migration et le transférer. Néanmoins, nous allons
apprendre à scripter
la migration, et c'est une procédure très
simple. Nous n'avons donc qu'une seule migration, donc le script ne sera pas
le plus compliqué. Au fur et à mesure que
le script grandit, des comportements
particuliers sont ajoutés en conséquence, et le script grandit avec les différentes migrations, n'est-ce pas ? Nous pourrons donc y revenir
plus tard, mais pour le moment, nous voulons simplement voir comment nous allons
scripter cette migration Donc, dans la
console du gestionnaire de packages, c'est assez simple. Vous dites simplement migration par
tiret de script. Ce qu'il va faire,
c'est la version normale, puis il va générer le fichier SQL qui correspond
à toutes ces commandes. Nous y voilà. Vous
verrez ici qu' il vérifie si la table d'
historique des migrations est nulle, puis
créez cette table. Ensuite, nous lançons la transaction, nous créons les
tables en conséquence. Nous obtenons l'index, nous l'insérons dans l'historique des
migrations, la migration qui
vient d'être exécutée, n'est-ce pas ? C'est ça. Donc, encore une fois, cela se fera
probablement lorsque vous souhaiterez transférer la responsabilité des modifications
ou de la création de la base de données,
quelle qu'elle soit, à un autre votre équipe
au sein de
l'organisation, et c'est ce que le FCO autorise
8. Base de données d'ingénieur inversée: Salut, les gars, bon retour.
Dans cette leçon, nous allons donc
voir comment
rétroconcevoir une
base de données existante. Encore une fois, nous avons d'abord
du code dans lequel nous pouvons écrire le code qui
génère la base de données. Mais dans certaines situations, vous
avez peut-être déjà une base de données que vous souhaitez intégrer à vos modèles de classe comme nous l'avons
fait jusqu'à présent Donc, dans cette leçon, nous
allons examiner cela, et vous aurez remarqué que j'ai déjà
créé un nouveau projet. Vous pouvez donc le faire si vous
voulez suivre,
mais ce n'est pas absolument
obligatoire, car nous allons simplement
examiner la commande et voir exactement ce qu'elle fait. J'ai donc créé ce
nouveau projet de console, uniquement dans le
but d'échafauder la base de données,
afin que vous puissiez voir
exactement ce
qui afin que vous puissiez voir
exactement ce Je vais donc en faire
mon projet de démarrage, et nous allons passer
au gestionnaire de packages. Et pour rappel, je vais vous dire « demandez de l'aide », et nous allons
examiner
la commande permettant de structurer la base
de données. Voici donc la liste
des commandes, et nous voyons ici que nous pouvons
parler de contexte de base de données d'échafaudage C'est donc à cela que
nous allons prêter attention dans cette leçon. Donc, lorsque nous voulons échafauder, je vais simplement le
copier-coller comme prochaine
commande que je vais exécuter,
et nous allons utiliser la
même base de données sur
laquelle nous
travaillons dans l'
ensemble de ce cours, à savoir la base sur
laquelle nous
travaillons dans l'
ensemble de ce cours, de données de notre
ligue de football Je vais l'
intégrer aux modèles, non ? Je dois donc spécifier
le fournisseur. Donc, fournisseur d'hyfène. Il s'agit donc d'un paramètre. Fournisseur, et notre
fournisseur sera Microsoft point tit Framework
Core Dot SQL. D'accord ? C'est donc le nom
de notre package, et c'est notre fournisseur. montre donc que
cette
commande de contexte Scaffold DB peut être utilisée pour d'autres bases de données qui
ne sont pas nécessairement SQL Server C'est bon. Nous
spécifiez donc le fournisseur, puis nous allons devoir lui
donner la connexion, toutes les connexions,
voici la même connexion
que celle que nous utilisons à peu
près dans notre contexte B. Il suffit donc de formuler
une chaîne de connexion. Comme j'en ai déjà un, je ne vais pas le taper
à partir de zéro. Je vais juste le copier parce
que, comme je l'ai dit, nous utilisons la même base de données. Mais quelle que soit la base de données, vous écrivez une chaîne de connexion. source de données est égale
au serveur, sa présence dans le catalogue initial est égale au nom
de la base de données, car elle peut se trouver sur un autre
serveur. Il se peut qu'il ne
se trouve pas nécessairement sur le même serveur. Vous voulez donc simplement prendre note
du fait que vous écrivez chaîne de connexion en fonction emplacement de cette base de données. Je vais donc ouvrir les
guillemets, mettre ma chaîne de connexion. Fermez les guillemets. Donc, encore une chose
que nous voulons faire avant d'essayer d'
exécuter cette commande. Nous voulons nous assurer
que notre projet fait référence aux mêmes
bibliothèques que celles que nous avons dû configurer lors de notre échafaudage initial ou de
nos migrations
initiales, n'est-ce pas ? échafaudage initial ou de
nos migrations
initiales, n'est-ce Donc, si nous examinons
les données, nous constatons que nous avons dû faire
référence au serveur de neutralisation, ainsi qu'à la conception des outils et des
références d'outils. Tous ces éléments sont
nécessaires. Je vais juste prendre
tout ce groupe d'objets. Copiez puis passez à notre nouveau projet, collez-le,
puis effectuez une construction rapide. Ensuite, une fois que cela aura
été un succès, nous reviendrons à
la console du gestionnaire de packages. Je vais juste
vérifier que le fournisseur est correct et que
la connexion est correcte. Je vais m'assurer
que le projet par défaut
ou le projet cible est
le projet sur lequel nous voulons
réaliser l'échafaudage Ensuite, je vais
appuyer sur Entrée. C'est bon. Et après avoir appuyé sur Entrée, le bâtiment
m'
a-t-il donné un avertissement
, puis une exception très meurtrière ? Maintenant, comme je l'ai dit,
je ne vais
pas éviter les erreurs
dans ce cours. Je pense qu'il est très important
de voir
les erreurs et de les corriger. Cette erreur indique donc qu'
une erreur liée au réseau s'est produite lors de la
tentative de connexion au serveur. Cela signifie donc que quelque chose
ne va pas avec ma chaîne de connexion. Et je pense que je sais ce que c'est. C'est la double barre oblique car nous devons utiliser
la double barre oblique écrire la chaîne de connexion dans
le contexte littéral ici Mais au lieu du gestionnaire
de packages, je n'ai pas besoin de cette double barre oblique Je vais le supprimer, puis je vais réessayer. Et cette fois, je n'ai aucune erreur. J'ai reçu le même avertissement,
mais je n'ai aucune erreur. Et si vous jetez un œil derrière
ma console de surveillance des packages, et à l'intérieur du projet,
vous verrez apparaître
un tas de fichiers. D'accord ? Voyons donc ce que
chacun d'eux représente. Je vais donc simplement
réduire tout ce qui n'est pas absolument nécessaire. Ensuite,
examinons le contexte. Il a donc généré un fichier de contexte. Le même fichier de contexte
que nous avons créé manuellement, c'est juste pour le générer. Il lui a donné le nom
basé sur la base de données. Je lui ai donné l'héritage
du contexte de base de données, il a deux constructeurs,
un paramètre s, un avec le paramètre acceptant options provenant autre application,
c'est bon Nos ensembles de bases de données sont tous deux
créés en tant que virtuels, puis nous avons la même méthode de
déconfiguration, n'est-ce Donc, si je faisais une comparaison
côte à côte, vous verrez que même si mienne est beaucoup plus ou toujours
beaucoup plus simplifiée. C'est vraiment la
même chose, non ? Nous avons la déconfiguration,
puis il est dit que si aucune
option n'est configurée, il
insère cette
chaîne de connexion comme nous l'avons fait Cependant, il
nous donne cet avertissement, qui est le même
que celui que nous avons vu dans la console du gestionnaire de packages. Cela signifie simplement que vous
voulez éviter de placer votre chaîne de connexion directement dans le contexte de cette façon. Et comme je l'ai dit,
nous le faisons de
manière provisoire car
il ne s'agit que d'une application console Nous la mettons
donc juste là pour qu'elle fonctionne C'est bon. Mais dans le cas d'une application
plus importante, il résiderait dans un autre fichier
et serait transmis à la demande. Vous allez également prendre note
d'une autre méthode, que nous n'avons pas encore tout
à fait examinée, mais comme je l'ai dit, vous pouvez remplacer la
plupart, sinon toutes les méthodes standard de la classe de contexte
de base de données, et cette autre méthode
concerne la création de modèles Donc, celui-ci dit simplement
que nous avons l'anation
, le classement relationnel, qui définit
les jeux de caractères que
nous allons utiliser
pour cette base de données,
puis il poursuit en disant que nous avons l'anation
, le classement relationnel définit
les jeux de caractères que nous allons utiliser
pour cette base de données, que l'équipe d'
entités à points du constructeur de
modèles a un index, qu'elle possède une ligue
avec de nombreuses équipes
et qu'elle a un étranger, souvenez-vous de cela simplement en suivant la convention de
dénomination lorsque nous avons créé
la base de données, cela impliquait en quelque sorte tout cela pour nous ou
cela s'est produit lors de la migration. Dans ce cas, il
examine une base de données existante, puis il essaie de
formuler les règles à respecter lors de la création cette base de données existante
ou de
son interaction avec
elle C'est bon.
De même, si nous changions le nom de cette base et que nous vous demandions ensuite de procéder
à une migration, seraient prises en toutes ces règles seraient prises en compte
pour savoir comment effectuer une migration pour une toute
nouvelle base de données qui ressemble à celle sur laquelle elle est échafaudée Donc, je vous le dis, FCR est très, très intelligent
et il fait beaucoup de Cela vous permet de tirer beaucoup de ficelles
en arrière-plan. Très bien, voici à quoi ressemble
vraiment
le contexte de base de données. Et puis, si
nous examinons les classes qui ont été générées, vous voyez que nous obtenons
une classe partielle, ensemble de hachages qui représente
la collection de l'équipe J'y reviendrai donc dans une minute. Mais nous obtenons cette construction et
nous obtenons les mêmes propriétés. Et si nous cherchons une équipe, cela ressemble pratiquement à ce
que nous avons fait nous-mêmes. Cela signifie que nous sommes sur
la bonne voie, non ? Nous avons toujours cette clé
étrangère et la propriété de navigation
vers la ligue, qui est également virtuelle Maintenant, pour en revenir à
ce que possède la classe de ligue, nous voyons ici que nous avons
une propriété supplémentaire que nous n'avons pas installée dans la nôtre Je vais donc juste
évoquer la ligue originale. C'est celui que nous avons
créé, non ? Et puis celui qui a été échafaudé possède cette propriété
supplémentaire, qui est un ensemble d'équipes Maintenant, le concept ici est que c'en est un de trop. Nous le savons. Nous l'avons créé, et nous y
reviendrons plus tard, mais je tiens simplement à
souligner que ce qu' il fait ici, c'est dire qu'une ligue
aura accès à de nombreuses équipes. Une équipe appartient à une ligue. Mais une ligue compte de nombreuses équipes.
C'est le seul de trop. Donc, avec cette
propriété de navigation définie comme une collection ou comme elle
aurait pu être une liste ou bien, elle a utilisé la collection par défaut Lors de la création,
nous aurions pu dire liste, nous aurions pu dire I numérable Mais le fait est qu'il s'agit la collection d'
objets liés à cette entité. Donc, en choisissant une seule ligue, je pourrais inclure
toutes les équipes, ce qui m'éviterait le chagrin d'avoir à
faire deux requêtes distinctes, désolée, pour obtenir les équipes et la ligue auxquelles
elles sont liées accord, donc c'est un
truc très puissant de le faire comme ça. Nous pourrons donc ajouter ultérieurement cette
propriété de navigation à la nôtre, mais je
voulais simplement souligner ce qui était
exactement échafaudé et ce qui est fait exactement Et c'est à peu près tout pour
échafauder la base de données. Il y a d'autres petites choses
que vous pouvez probablement faire, mais au niveau le plus élémentaire, s'il existe une base de données,
si commencé à
créer un serveur sc, ou si elle fait partie d'un
ancien projet ou d'un ancien système et que
vous souhaitez la retravailler, vous voulez simplement commencer à travailler dessus sans
repartir de zéro Ensuite, vous pouvez utiliser cette commande, importer ou importer cette base de données sous
la forme de ces modèles. Ensuite, à travers le contexte, vous pouvez simplement commencer à l'utiliser dès le départ. OK. OK.
9. Afficher le diagramme avec les outils de base d'Entity Framework: Salut, les gars,
bienvenue dans cette leçon, nous allons examiner outils électriques FCO
et
la façon dont ils peuvent nous
aider à visualiser notre
base de données via Visual Studio Cela fait suite
au fait que j'ai montré
un schéma de base de données
plus tôt alors que nous étions dans SQL Server Management
Studio et
que j'ai généré ce diagramme zéro juste pour décrire la base de données que nous
essayions de créer à l'époque Vous n'
avez peut-être pas nécessairement ce luxe,
et je ne dis pas que vous devez
vous procurer le studio de
gestion, mais en utilisant les
outils EFC fournis par Visual Studio, vous pouvez générer un diagramme
similaire et voir comment FCO visualise votre base de données
ou la base de données à laquelle
il se connecte Commençons donc. Si vous avez Visual
Studio, c'est bien. Il suffit d'accéder aux extensions, de gérer les extensions. Et lorsque cette boîte de dialogue apparaît, il
vous suffit de rechercher les outils électriques
FCO, et lorsque vous voyez apparaître dans
les résultats de recherche, il
vous suffit de cliquer sur
Télécharger OK. Ensuite, nous devrons
redémarrer Visual Studio que vous puissiez
le faire rapidement. Maintenant, après avoir fermé
Visual Studio, le gestionnaire d'extensions
va démarrer et
terminer l'installation. Si vous n'avez pas encore installé
cette fonctionnalité de l'
éditeur DG ML, qui a probablement été installée
avec Visual Studio, vous n'aurez peut-être pas à
passer par cette étape. Mais si vous passez
par l'étape, n'est pas un problème. Allez-y et
appuyez sur Modifier pour autoriser l'introduction des dépendances. Et une fois cette procédure terminée, vous pouvez rouvrir Visual
Studio, puis ce que nous allons remarquer, c'est que lorsque
nous cliquons avec le bouton droit sur un projet, nous allons voir
un nouvel élément de menu sous la forme de FQ Power Tools Vous verrez donc un
certain nombre d'options, certaines ressemblent à celles
dont nous avons discuté
jusqu'à présent
avec les dont nous avons discuté
jusqu'à présent différentes
migrations, les
échafaudages et l' ingénierie
avancée .
Toutes ces choses sont
réellement possibles grâce ces outils électriques FQ sans qu'il soit nécessaire d'écrire
les commandes Cependant, pour cette leçon
en particulier
, je veux me concentrer sur l'
ajout du diagramme de contexte. Donc, bien sûr, encore une fois, nous voulons nous assurer que nous sommes dans un projet qui possède
le contexte de base de données. Nous allons cliquer avec le bouton droit de la souris,
accéder à FC Power Tools, puis nous allons dire Ajouter un diagramme de contexte
de base de données. Ensuite, il va
générer un nouveau fichier avec un point d'extension DGml et nous
allons obtenir notre schéma J'ai donc pensé que je
serais capable de sélectionner, mais en fait, il suffit de
faire glisser le pointeur Vous voyez ici, cela nous donne
ce contexte de base de données
sous forme de diagramme, nous
donne l'équipe, les
différentes propriétés, et nous pouvons cliquer ou survoler la propriété pour obtenir un peu
plus d'informations à ce sujet C'est la clé primaire, et elle n'est pas remarquable. Vous pouvez voir toutes ces
annotations ou toutes
les métadonnées sont disponibles
ici même en survolant Et si nous survolons le tableau, c'est à peu près la même chose Ainsi, à partir de Visual Studio, nous pouvons utiliser cet
outil pour visualiser exactement ce qui se passe dans notre base de données à un moment donné. Maintenant, étant donné que nous n'
avons que deux tables correctes. Maintenant, ce diagramme
peut ne pas sembler aussi intéressant qu'il pourrait
probablement l'être. Mais tu peux juste prendre le
temps d'y jeter un œil. Vous pouvez maintenir le
contrôle et faire défiler l'écran pour zoomer un peu ou vous pouvez simplement modifier le
zoom vers le haut ici, et vous pouvez regarder la légende où
elle indique quels sont
les différents symboles ou
les différentes couleurs Vous le voyez ici, le rouge représente
une propriété de navigation. Qu'est-ce que c'est
violet ou bleuté, je suis désolée, je suis
légèrement daltonien,
mais cette couleur violacée
représente les clés étrangères,
puis les
clés primaires sont surlignées,
puis les différentes
propriétés le Vous pouvez donc
prendre le temps de simplement
prendre en compte, vous pouvez voir les différents types
de relations. Mais au fur et à mesure que notre base de données s'agrandira, nous y
reviendrons et examinerons comment le FCR déduit, quels types de relations et annotations
différentes
sur les différentes propriétés au
fur
et à mesure, puis nous pourrons voir ce diagramme
évoluer avec et à mesure, puis nous pourrons voir ce diagramme notre base de données. OK.
10. Ajouter de la loging à la charge de travail d'EF Core: Salut, les gars, bon
retour. Dans ce billet, nous allons donc
configurer le FCR avec quelques options supplémentaires pour fournir plus
de détails
sur ce qu'il fait COR fonctionne donc
très bien par défaut, mais nous voulions faire du bruit car lorsque nous
exécutons nos commandes, je veux que nous ayons une représentation
visuelle du Q qui est orchestré et des
différentes opérations effectuées
en arrière-plan pendant que nous faisons notre travail. Donc, ce que nous allons faire ici c'est étendre le
générateur d'options pour qu'il sache qu'il doit se connecter à et je vais le laisser se connecter
à la console sur la bonne ligne. Donc, comme nous utilisons une
console, elle se trouve sur la droite. Nous nous connectons donc pour consoler
la bonne ligne. Et je vais ajouter à la
configuration ou, disons, au pipeline de ce qu'
il devrait enregistrer. Je veux qu'il enregistre le nom de la
commande de la catégorie de l'enregistreur de base de données afin que nous puissions voir une
représentation visuelle de ce qui est fait exactement Et je vais
étendre cela pour lui faire
savoir que nous voulons un niveau de journalisation. J'allais dire un niveau de log. Informations sur les points. Et je pense que je vais devoir
inclure
une bibliothèque pour la journalisation par points des
extensions Microsoft. Je pense que j'ai pris
de l'avance sur moi-même tout à l'heure. Il s'agit donc d'une nouvelle catégorie d'enregistreurs de base de données, puis nous fermons une entretoise
bouclée ici Ensuite, nous avons les informations relatives au niveau du
journal, puis nous fermons les
parenthèses. Alors jetez un œil à cette
ligne. Excuse-toi pour ça. Nous nous connectons donc à la ligne
droite de la console, à la nouvelle matrice, puis nous passons simplement la
ligne de nom de commande, le nom de commande de la
base de données de la catégorie
DV logger, et nous
lui faisons savoir que nous voulons un niveau d'enregistrement des informations Cela signifie donc que nous voulons voir cracher
sur la console tout
ce qu'
il fait voir cracher
sur la console tout
ce qu'
il Une autre chose que je
vais inclure est d'activer l'enregistrement
des données sensibles. Cela nous permet de voir
ou indique à FCR que
tout ce qui se passe en arrière-plan et
que vous ne voudriez probablement pas votre utilisateur
frontal voie, nous voulons le voir C'est notre application que nous sommes en train d'apprendre Nous pouvons
donc au moins le
faire sans aucun risque, mais vous ne voudriez pas nécessairement faire sur un serveur de
production, mais cela facilite le débogage
dans certaines situations Maintenant que
tout est connecté, je vais simplement
passer à la console. Vous n'êtes pas nécessairement
obligé de suivre cette étape. J'ai juste
écrit du code pour
que nous puissions commencer à
interagir avec F course, afin que vous puissiez voir exactement à quoi
tout cela reviendrait. Mais dans les prochaines vidéos, nous allons passer en revue l'
ensemble de ce code. Mais pour l'instant, je
veux juste que vous voyiez un échantillon de la journalisation
supplémentaire. Ainsi, à l'écran, vous verrez
l'application console. Et si vous regardez de plus près, vous verrez les bûches
crachées. Nous avons donc des informations à
cet horodatage. Nous avons fait cette commande, puis cela vous
montre que nous exécutons une commande de base de données,
le paramètre était. Donc, ce qui se passerait
naturellement si nous n'activions pas la journalisation
sensible ,
c'est que ces paramètres vous verraient pas les valeurs. Donc, comme je l'ai dit, l'activation de la
journalisation sensible affichera certains détails qui
auraient été omis pour raisons de sécurité, où le titre de
journalisation sensible, n'est-ce pas ? Nous pouvons donc voir exactement quelles
valeurs sont transmises, leur taille, leur type,
le délai d' expiration de la commande, puis nous voyons le
code SQL
généré s' insérer dans cette table, les valeurs, puis il prend
simplement ce paramètre. Il ne s'agit donc pas d'intégrer directement
cette valeur. montre donc que FCR effectue activement le
paramétrage, élément clé lutte contre l'injection de
SQL en tant que faille de sécurité que de
nombreuses personnes tentent
d'exploiter, n' nombreuses personnes tentent Il configure donc
la requête simple, puis il sélectionne l'ID à partir de
là et met à jour
l'identité de la portée Mais pour le moment, je
ne vais pas
trop entrer dans les détails de
ce que fait le script. Je tiens simplement à souligner
que nous sommes maintenant dans une position où, lorsque
nous allons
écrire nos commandes FC, nous pouvons voir activement le code SQL
généré en arrière-plan. Nous constatons également que la durée d'exécution
est de 61 millisecondes. Mais il peut arriver qu'une requête soit trop
longue et que vous vous demandiez pourquoi vous
devez probablement la modifier Toutes ces choses que vous pouvez
faire lorsque vous avez ce type de journalisation à votre
disposition. D'accord.
11. Opérations simples: OK. Salut, les gars, bon retour. Dans cette leçon,
nous allons voir comment
effectuer une simple insertion et une
sélection de résolutions à l'aide d'EF COR. Maintenant, nous revenons à notre
leçon précédente où nous avons examiné la journalisation détaillée et l' ajout d'
informations supplémentaires à la console Vous auriez vu que j'avais
ce bout de code que
nous devons explorer et
essayer de comprendre. Donc, la première ligne que je
tiens à vous signaler, et c'est encore une fois,
le fichier point CS du programme dans notre application console. C'est bon. Donc, la première ligne que je veux vous
signaler est celle où j'instancie
notre contexte de base J'ai donc un contexte de base de données
de ligue de football statique privé. Et juste au cas vous vous demanderiez d'où vient
ce nom, c'est le nom de
notre contexte de base de données ici. N'oubliez pas que j'ai
dit que ce fichier représente la connexion
à la base de données. Il possède la
chaîne de connexion, et bien, il connaît plutôt les éléments ou les entités de
la base de données. Donc, cette classe entière, à mesure que notre
base de données développe nos contrats, nous donne
cette passerelle d'accès à la base de données et nous permet d' interagir avec les
différentes entités. Nous devons donc en avoir un
objet instancié. Maintenant, dans un noyau point nic normal, eh bien, ne disons pas un noyau point nic
normal. Dans une application de
base plus importante, telle qu'une application Web ou même
une application Blazer, vous ne verriez pas cela
se faire de cette façon Vous le verriez
être injecté. Mais encore une fois, nous sommes ici pour en savoir plus sur la
syntaxe du noyau F. J'essaie donc de ne pas me concentrer sur ces autres aspects du développement dans ce cours
en particulier. C'est bon. Nous instancions donc le contexte de base de données de la ligue
de football. J'appelle l'objet contexte. Différentes
suggestions vous auraient été données. Vous pouvez
donc choisir
celle qui vous semble la plus révélatrice de ce que cet
objet doit représenter. Mais le contexte est presque un
mot universel désignant le fichier qui
me connecte à la base de données, n'est-ce pas ? C'est pourquoi il est utilisé dans le nom de la classe et même dans
le nom de l'objet. Encore une fois, le nommage
est plus subjectif. Donc c'est bien si vous
avez d'autres idées. Nous l'instancions donc ici. Ensuite, nous passons au principal. Donc, comme nous l'avons fait
dans la classe, cela est global à toute
autre fonction que nous allons utiliser
dans ce fichier de classe. Maintenant, pour ajouter quelque chose
à une table, la syntaxe serait le contexte. Encore une fois, cet objet qui représente une connexion
à la base de données. Nous disons donc contexte, point. La table avec laquelle nous espérons
interagir, et ce mot ligues, est vraiment liée au nom que
nous avons donné aux tables ici. accord ? Ce sont donc les ligues. Donc, si je le
retape à partir de zéro, je vais dire contexte, point, je veux voir
un tas d'options Je peux ajouter, je peux ajouter une synchronisation. Je peux faire un certain nombre de choses, mais vous verrez ensuite les
différentes propriétés, et certaines d'entre elles
incluront les noms des tables. Il y a des ligues, et si je fais défiler un peu
plus l'écran vers le bas, il y a des équipes. Ainsi, à autant d'ensembles de bases de données que nous avons définis dans le fichier de contexte, nous pouvons y accéder
directement ici chaque fois que nous avons besoin
d'interagir avec ces tables. Contextualisez donc les ligues, et ensuite qu'est-ce que je veux faire
avec le classement Dans cette situation,
je tiens à ajouter. Maintenant, si nous
examinons la fonction publicitaire, vous verrez ici que c'est
la surcharge qui
s'attend au puits, et
non la surcharge. Le paramètre attendu par la fonction publicitaire
est plutôt de type ligue, et il indique simplement qu'elle
attend une entité de ligue. En d'autres termes, il s'attend à un objet du type league. C'est la beauté de F
court qui nous permet de rester en do aigu, car dans la syntaxe Q, nous aurions
dû écrire quelque chose comme insérer dans les ligues, puis les valeurs, puis les lister , et ce, si nous n'allions pas spécifier les colonnes puis les valeurs. Et oui, cette syntaxe
serait intentionnelle, mais devoir la mettre en do
dièse, puis la convertir et faire tout ça
,
FC dit simplement de
rester en do dièse, j'ai le contexte de l'objet Je reçois le tableau que vous souhaitez ajouter, puis vous me donnez les
données que vous souhaitez ajouter. J'ai donc ajouté une
ligue de football jamaïcaine ici, mais ensuite nous pouvons changer
cela et essayer la
Premier League anglaise. C'est bon. Donc, une nouvelle ligue
instancie un objet, et nous lui transmettons
les propriétés, et League
n'avait vraiment que des noms d'identification Ainsi, étant donné que l'ID est déjà principalement
une incrémentation, nous n'avons pas à fournir
de valeur pour l' Nous pouvons certainement y accéder, mais nous n'avons pas besoin de fournir de valeur lors de l'
ajout. C'est bon. Alors allons-y, exécutons cette commande et
voyons ce qui se passe. Les journaux ici
nous montrent qu'il a correctement exécuté
cette commande, il a fallu 112 millisecondes et qu'il a saisi les
paramètres et tout le reste Et puis voici la
syntaxe CQL qui a été générée. Insérez donc dans les ligues, puis les noms des colonnes,
puis les valeurs, puis la valeur,
puis il a simplement mis à jour cet objet en conséquence. Maintenant, une autre ligne que je tiens
à souligner est la ligne 14, qui est la dernière ligne
que vous devez appeler. Quoi que vous fassiez, vous
pensez interagir
avec la base de données. Une fois que vous manipulez des données, c'est-à-dire que vous ajoutez mettez à jour ou supprimez des données, vous devez appeler safe changes car toutes ces méthodes fonctionnent ainsi que les méthodes similaires pour
la mise à jour et la suppression Tout
ce qu'ils font réellement, c'est suivre les changements qui doivent se produire, mais ils
les suivent en mémoire. Hein ? Donc,
tant que l'application traite cette opération
en particulier, elle la suit simplement
en mémoire et, d'accord,
je sais que je dois l'ajouter.
Je dois le mettre à jour. Je dois le supprimer.
Mais tant que vous n'aurez pas enregistré les modifications,
enregistrer les modifications
dit réellement, générer le code SQL, envoyer à la base de données
et essayer, puis nous reviendrons en
arrière en cas d'
échec et informerons l'utilisateur
de ce qui s'est passé. accord ? C'est donc vraiment à cela
que servent les modifications de sauvegarde. Ensuite, nous avons appelé «
sauvegarde des modifications » « synchronisation », mais il y a aussi la sauvegarde des modifications sans
l'AC, c'est bien. Je vais l'utiliser sans l'AC
car il ne s'agit pas d'une
fonction asynchrone. Je vais juste rester simple. Mais une fois que vous utilisez la programmation
asynchrone, vous pouvez toujours utiliser la
version A sync de ces méthodes Qui, bien sûr, doivent être placés dans une méthode
asynchrone. J'ai donc simplement remplacé toutes
mes méthodes par les versions de synchronisation
A, et j'ai transformé la
fonction principale en tâche de synchronisation A. Et puis à cause de cela, maintenant je peux dire qu'
un poids, ajouter une synchronisation, un
poids, enregistrer une modification, c'est une synchronisation. Maintenant, autre chose, je
voudrais juste en dire un peu plus. Parce qu'ici j'ajoute l'objet directement
dans le paramètre. Ce n'est peut-être pas
toujours le cas, car en particulier dans les applications
plus volumineuses, car en particulier dans les applications
plus volumineuses,
comme lorsqu'un utilisateur
soumet le formulaire, puis dans une application Web,
il envoie le formulaire, vous pouvez obtenir toutes les
données du formulaire dans un objet que vous devez
transmettre à la base de données. Vous ne voudriez pas nécessairement
l'obtenir à partir du formulaire pour
ensuite écrire nouvelle ligue, puis essayer de replacer chaque propriété
avec chaque valeur. Vous pouvez donc toujours simplement initialiser Subq Sevar
League is equal to, puis je peux initialiser
une nouvelle Permettez-moi de le faire pour
réduire les longues saisies. Allons-y. Et ensuite je
pourrai lui donner une Liga. On voit bien que je suis fan
de football, non ? Donc, La Liga. Ce
serait donc le championnat espagnol. Maintenant que j'ai mon objet qui représente la ligue que je
souhaite ajouter à la base de données, je peux maintenant dire « ajouter AC » et
transmettre cet objet. C'est donc aussi simple que cela. Vous pouvez créer votre objet
ailleurs, puis l'ajouter,
puis, lorsque vous enregistrez les modifications, vous le validez dans la base de données. Maintenant, ce que je veux
également vous faire
remarquer , c'est
qu'une fois les modifications enregistrées, cet objet sera automatiquement mis à jour
avec sa nouvelle valeur. Permettez-moi donc d'ajouter un
point d'arrêt et de lancer. Ce que je vais faire ici,
c'est ouvrir une fenêtre de surveillance, et j'y place l'
objet de la ligue afin que nous puissions suivre ses valeurs au fur et à mesure que nous
progressons ligne par ligne. accord ? Laissez-moi juste l'épingler, l'agrandir un peu
pour que nous puissions le voir. Donc, première ligne, rien ne s'
est encore passé. La ligue est nulle. Ensuite, je vais passer à l'étape.
Et puis vous verrez que g a un ID de zéro
et la valeur Liga. Ensuite, il va
enregistrer les modifications, puis nous allons intervenir une fois de plus. Et si vous regardez l'objet, vous verrez qu'il
possède désormais la valeur ID. C'est donc
pratique lorsque vous avez des opérations
enchaînées, n'est-ce pas ? Parce que vous pouvez avoir
une opération où vous devez ajouter quelque chose
à la base de données, puis vous avez besoin de
cette valeur, de cette nouvelle valeur d'identifiant
afin d'afficher les détails de cet
enregistrement sur la page suivante. Je soumets donc un formulaire, vous le modifiez dans la base de données, puis vous m'amenez
sur la page pour voir les données. Je viens de soumettre ce qu'il
lit dans la base de données. Eh bien, c'est là
que cela s'avère pratique ,
car je peux alors
interroger la base de données directement sur cet identifiant d'enregistrement juste après la fin de l'
opération. Je vais juste appuyer sur la touche F5 pour continuer l'exécution. Et encore une fois, nous voyons ici notre message
très amical indiquant que l'entreprise a ajouté
ces données à la base de données. Non, juste pour des
raisons de description, comme je l'ai dit, nous voulons voir certaines des
erreurs que nous pourrions avoir Ce que je vais
faire, c'est essayer d'ajouter une valeur d'identifiant à cet objet avant qu'il ne soit
ajouté à la base de données. Je sais donc que la carte d'identité était de sept personnes à l'
instant. Je vais donc mettre une pièce d'identité. Peu
importe la valeur, car si
elle est autre que zéro, lors de
l'opération d'ajout, elle produira une erreur. Je voulais donc simplement
connaître le type de commentaires que nous allons recevoir
de l'EFC, n'est-ce pas ? Il suffit donc de l'exécuter et lui permettre de faire
ce qu'il doit faire. Et puis vous voyez
ici que cela échoue, et nous avons
cette erreur ici. Il indique qu'une erreur s'est produite. L'exception CQ ne peut pas
insérer de valeur explicite
pour la colonne d'
identité lorsque l'insertion d'identité est activée. Vous voyez donc que nous
recevons littéralement l'une de ces erreurs que nous aurions constatées si nous avions essayé de le faire directement
en SQL. S'il ne s'agit pas de la même erreur, le libellé est très
similaire à celui-ci. C'est bon. C'est donc le genre
de feedback qu' EF COR nous donnera
chaque fois que nous essaierons de le faire. Et nous verrons ici dans le journal de
notre console que
cela a simplement échoué. Il indique simplement que vous avez échoué
et insérez là-dedans que vous avez simplement échoué. D'accord ? Donc, si je continue, l'exécution se terminera
en conséquence. C'est bon. Nous sommes donc en train de le faire,
et je voudrais juste donner un autre exemple de la façon dont le fonctionnement du cadre d'entité
peut vous faciliter la vie. Dans cette situation, je voudrais ajouter une nouvelle ligue, et nous l'appelons
Syria, c'est la ligue italienne, et nous ajoutons la ligue comme
nous savons devoir le faire, puis nous enregistrons les modifications. Mais ensuite, j'ai besoin d'informations de cette ligue pour
mener une autre opération. Dans ce cas, je
souhaite ajouter des équipes. Donc, évidemment, une équipe
doit exister dans une ligue, non ? J'ai donc besoin des informations
de la ligue qui
vient d'être créée pour créer ces équipes. Donc, ce que je vais faire, c'est passer cet objet
de ligue à cette méthode. Notez ensuite que nous
devrons enregistrer les modifications
car chaque fois que nous effectuons une opération dans le contexte, nous devons enregistrer les modifications pour qu'elles prennent
effet dans la base de données. Donc, j'ai déjà
créé cette méthode J'ai créé une tâche AC statique, et je l'appelle ajouter des
équipes avec un identifiant de ligue. Eh bien, je l'appelle avec un identifiant de ligue. Permettez-moi de supprimer la ligue Permettez-moi de supprimer l'identifiant car je montre deux
opérations différentes dans cet exemple, et vous verrez pourquoi, et il prend un paramètre
de type ligue, qui est la ligue. C'est bon. Vous pouvez donc simplement
continuer et reproduire cela Et puis dans cette méthode, j'essaie quelque chose de différent. Au lieu d'un
objet à ajouter ensuite, je fais une liste d'objets, puis je vais ajouter une plage. Cela va donc maintenant tirer parti
de la capacité
de la FCR à
effectuer des opérations en masse Maintenant, avec des opérations un
peu groupées, c'est une fonctionnalité
qui permet à
FC de regrouper plusieurs opérations, par exemple ajoutant des opérations, etc.,
en une seule instruction Q
et en tirer. Mais ensuite, l'équipe a en quelque sorte
décidé qu'
il serait plus efficace
, pour un plus petit nombre d' enregistrements, de simplement exécuter
des instructions SQL individuelles. Cependant, à partir d'un certain seuil, vous commencerez à voir une
instruction SQL contenant toutes
les informations. Cela ne représente qu'un
petit aperçu de la façon dont ces opérations en masse
fonctionnent en arrière-plan. Mais dans cette méthode, je
définis une liste d'équipes, et à chacune d'elles, je
donne son nom. Voici donc Vents, et cet identifiant de ligue est celui qui provient de
notre objet de ligue. Hein ? Et puis l'équipe
suivante serait une simulation suivant le même format. Mais pour ce qui est du troisième
, Aroma, je vais faire quelque chose de différent. Au lieu d'utiliser
la clé étrangère, j'utilise maintenant l'objet de navigation
réel et je réutilise l'objet
qui a été transmis Nous allons donc voir
exactement comment cela fonctionne. Ce serait donc
la méthode traditionnelle. Vous avez la clé étrangère, vous avez saisi la valeur de la clé étrangère, et c'est satisfait, n'est-ce pas ? Mais dans cette équipe, au lieu d'utiliser
la clé étrangère, j'utilise l'
objet réel pour le transmettre. Voyons donc ce que cela pourrait faire. Je vais donc mettre un point d'arrêt lors de la
première sauvegarde des modifications, puis nous pourrons simplement
passer en revue et voir le fonctionnement étape par étape. J'ai donc également ajouté la montre
pour les équipes, non ? Permettez-moi donc de vous dire la ligue n'a pas encore
été créée. Donc, étape par étape, utilisez F dix, ne pas avoir à
passer au contexte. Je sais que nous avons une carte d'identité de huit. Si nous regardons dans l'objet de notre ligue, nous voyons qu'il est mis à jour en conséquence. Ensuite, je vais
utiliser F 11 pour aborder
cette méthode dans laquelle
les équipes sont désormais définies. Je vais juste passer en
revue sa création. Et puis, si je regarde
la liste des équipes, je vois qu'elles
ont toutes leurs identifiants respectifs, puis Roma est là avec l'objet de navigation
actuel au lieu de l'identifiant de la ligue. D'accord ? identifiant de ligue pour la Roma est donc zéro, mais l'identifiant de ligue pour tous les autres est de huit, comme prévu. Cependant, la propriété de navigation pour tous les autres est nulle, et pour Soma, elle possède sa propre propriété
de navigation Voyons maintenant ce qui se passe une
fois les modifications enregistrées. Je vais juste
appuyer sur cinq pour que nous
puissions voir les bûches
crachées. Et vous voyez la première opération d'
insertion se dérouler ici même
dans la ligue. Oh, non, ça. Celui-ci appartient à
la ligue. Désolée, non ? Ensuite, nous en voyons un autre
se produire pour l'équipe première, et nous voyons que l'identifiant, l'identifiant de ligue de huit
et le nom qui est transmis dans le nom
d'
identification de la ligue, n'est-ce pas ? Et puis pour la dernière, vous remarquerez qu'il s'agit de
la même instruction SQL. Il obtient le huit,
il sait que c'est Aroma et il fait le même
type d'insert. Cela va simplement
vous montrer que vous pouvez valeur réelle de
la clé étrangère
et qu'elle fera, bien sûr, ce qu'elle doit
faire avec l'insertion, ou
que vous pouvez saisir l'objet entier
et il en déduira toujours que l'objet a sa clé primaire donc évident qu'
il s'agit d'un objet connexe, donc la clé étrangère serait l'objet de décalage de la clé primaire
et toutes les autres données. Donc, FCR le fait pour
vous en arrière-plan. Je voulais simplement souligner les différentes manières d'
insérer un enregistrement dépendant d'
une clé étrangère. Maintenant, il y a quelques autres
choses que vous pouvez faire, mais parfois elles ne sont possibles qu'avec
de l'expérience, mais au moins si vous
comprenez les bases de la
façon d' ajouter quelque chose
à la base de données. Et remarquez que j'ai dû ajouter ici, enregistrer les modifications, puis les
ajouter à nouveau et enregistrer les
modifications, car j'avais besoin que cela soit ajouté pour que la clé
soit générée afin que je puisse effectuer cette
opération. D'accord ? autre côté, si j'avais fait quelque chose comme ça et que j'avais
pris le temps de le regarder. Je l'ai juste retravaillé pour
ne pas avoir à m' asseoir
à me regarder taper Mais je suis en train d'
initialiser une nouvelle ligue, puis j'ai une équipe Cette nouvelle équipe s'
appelle Bern Munich, puis je
transmets cet objet de ligue Maintenant, notez que je ne suis pas
en train de faire un, je
n'enregistre pas les modifications entre
ces deux lignes, n'est-ce pas ? Donc, première ligue, nouvelle équipe, et il s'agit d'obtenir ce
nouvel objectif de ligue. Ensuite, je ne fais qu'ajouter l'équipe et enregistrer les modifications. Et remarquez la différence
entre cette annonce et les lignes ACC précédentes Vous avez bien entendu la possibilité de mettre en évidence le tableau avec lequel
vous souhaitez interagir. Donc, si je disais que les ligues à
points contextuels ajoutent une synchronisation, puis que je
transmets un objet d'équipe, ce sera une erreur
automatique. Pourquoi ? Parce qu'une fois de plus,
l'opération publicitaire nécessite un type
de ligue, non ? Je ne peux donc pas transmettre
un objet d'équipe. J'aurais bien sûr pu dire que les équipes et tout
irait bien. Mais si je ne
spécifiais pas le tableau, Entity Framework saurait
automatiquement que, d'accord, il
s'agit d'un objet d'équipe ou d'une liste d'objets d'équipe,
comme nous l'avons fait ici, où je disais simplement que
le point contextuel ajoute une plage passée dans la liste de l'équipe. Il sait donc clairement qu'
il va rechercher la table correspondante
pour ce type de données. Vous n'êtes donc pas obligé faire, du moins lorsqu'il s'agit
du contexte, vous n'avez pas à spécifier le tableau en
permanence. C'est bon. Mais ce que je tiens à
souligner, c'est que lorsque je fais cela puis
que je sauvegarde les modifications, cela crée en fait
la propriété dépendante ,
puis crée automatiquement l'équipe avec cette clé étrangère. Jetons donc un coup d'
œil à cette opération. Ainsi, si vous regardez
ce qu'il a généré, vous verrez qu'il a d'abord exécuté la commande pour créer
la ligue. Là, il crée
la Bundesliga, puis il obtient cet identifiant, puis il
exécute celui qui permet de créer l' équipe en transmettant
la nouvelle clé
étrangère à cette nouvelle SCEF CR tire toutes
ces ficelles pour vous. Tout cela parce que je l'
ai dit, je veux une nouvelle équipe, et cette équipe fait partie d' une ligue dont je ne
connais pas l'identité. C'est ce qu'il a dit, pas de
problème. J'ai ceci Il continue, crée
la ligue, obtient l'identifiant, crée l'équipe, puis vous
indique simplement que
tout est fait. Donc, si vous
examinez cet objet d'équipe, vous verrez toutes les données relatives à l'équipe et à la ligue. notre retour, nous commencerons à envisager faire des requêtes de sélection,
car jusqu'à présent, nous n'avons fait que saisir des
données, des données
, des données. Voyons maintenant
comment lire les données de la base de données et
les afficher
dans notre application. OK.
12. Sélectionnez des opérations simples: Dans cette leçon, les gars,
nous allons
parler d'opérations de sélection simples. Maintenant, avant de passer à autre chose, je tiens simplement à
souligner que nous avons
fait une bonne partie des
simples insertions,
et que je les ai extraites
dans des méthodes individuelles. Je me suis donc débarrassé du code, et je les ai en quelque sorte
commentés afin que, lorsque
vous y repensiez, vous puissiez voir ce
qui se passe et où. D'accord ? Je les ai donc simplement
commentés parce que nous ne voulons pas
continuer à ajouter et à
ajouter les mêmes anciennes données. Il est donc temps pour nous de réfléchir
à la sélection Je vais
donc simplement
les séparer, les mettre de côté, puis nous pourrons continuer à les
contourner. C'est bon. Donc, lorsque nous parlons de sélection, ce serait le R dans CRD. Je ne sais donc pas si j'utilise cet acronyme avant de
parler de ce sujet, mais CRD create read
update delete, n'est-ce pas ? C'est un acronyme largement utilisé dans le développement de
bases Il représente essentiellement
les quatre opérations que vous effectuerez toujours sur une
base de données dans n'importe quelle application. Vous créez des données, et c'est
ce que nous venons examiner lorsque nous avons
examiné l'insertion, c'
est-à-dire que vous
allez lire des données, ce qui signifie que vous souhaitez récupérer les données qui
se trouvent dans la base C'est ce que nous allons faire maintenant, puis nous
examinerons le U et le D,
qui signifient mise à jour et suppression. Maintenant, lorsque nous voulons récupérer
des données de notre base de données, nous commençons à penser à
formuler ce que nous appelons des requêtes de liens
ou des déclarations de lien Link, abréviation de
Language Integrated Query. C'est essentiellement un dialecte. Je l'appelle un dialecte du do dièse. C'est une méthode qui vous permet d'écrire une requête en C sharp, puis, bien sûr, FC
va la traduire en QL. Commençons. La première et la plus simple
chose que vous puissiez faire. La requête de lien la plus simple
pour récupérer
des données de
la base de données serait de
définir une variable. Je veux donc que toutes les
ligues reviennent, et je dois dire que Regus
est égal au contexte,
c'est-à-dire à la connexion à la table de base de données qui m'
intéresse, à savoir les ligues Et cela en dit long sur
ce look dans l'ensemble des ligues de la
base de données. Mais ensuite je le veux dans une liste. Je vais donc dire point à liste. Ensuite, il va me demander d'
inclure une certaine bibliothèque. Je vais juste contrôler si vous
voyez que cela me
dit que j'ai besoin du
lien point-point du système de bibliothèque pour le faire. Je vais juste aller de
l'avant et inclure cela, cette erreur disparaîtra. Et juste comme ça,
je vous l'ai dit, sélectionnez une étoile dans le
tableau intitulé Leagues. C'est à peu près ça. Hein ? Ensuite, ce qui va se
passer, c'est que le contexte crée une connexion
à la base de données. Il passe au
classement, puis cette liste indique d'
extraire les données, de les ramener sous forme de tula, puis de les matérialiser dans
une liste d'objets de la ligue la même manière que nous avions
créé la liste des équipes, où se trouve-t-elle ?
Voici la mienne. la même manière que nous avons créé
la liste des équipes, elle sera intégrée à la
liste des ligues pour nous Donc, ce que je vais
faire, c'est faire un pour chacune, et je vais dire pour
chaque ligue par ligues. Je veux consoler
point right line. Je fais donc un trait d'union
en utilisant un trait d'union pour séparer l'identifiant du nom C'est bon. Jetons donc
un coup d'œil à cela. C'est bon. Et lorsque nous examinons le résultat, nous voyons ici la déclaration
qui a été exécutée, sélectionnez l'ID et le nom des
ligues en L, n'est-ce pas ? Il s'agit donc essentiellement de cette instruction SQL
,
que vous pouvez simplement
copier depuis la console, passer dans votre
studio de gestion et exécuter. Cela s'avère donc très pratique lorsque vous effectuez un
dépannage Peut-être que vous avez écrit une
requête et que vous n'obtenez pas les
résultats souhaités. Vous pouvez toujours obtenir
cette instruction SQL et essayer de déchiffrer pourquoi ce code
est mal formé Encore une fois, il s'agit d'un outil
très puissant. Cependant, lorsque nous
examinons les objets
imprimés,
nous voyons tout ce qui se trouve dans la base de données. Pendant les tests, nous avons probablement participé à la Earth strap
Premier League quelques fois, trop souvent, et aussi à
la Premier League, mais ensuite nous verrons toutes les
autres ligues également. C'est ce que nous obtenons lorsque
nous disons simplement le contexte, le nom de la
table, et que nous les donnons
sous forme de liste. Maintenant, quelques points importants à noter en ce qui
concerne la syntaxe, c'est
ce que nous appelons l'instruction d'
exécution. Donc, sans cela, cette
requête ne serait pas exécutée. Cela dirait simplement : Eh bien, les jambes sont maintenant juste le jeu de hachage ou
le jeu de base de données de la table
appelé jambes, n'est-ce pas ? Donc, lorsque nous l'inscrivons sur la liste, c'est là qu'il est écrit : «
Je vais exécuter
cette requête, Je vais exécuter
cette requête énumérer et
les renvoyer sous forme d'objets Donc, si nous étions censés
faire quelque chose comme laisser de côté la liste des tâches
et continuer à l'exécuter. Cette requête
ne sera pas exécutée tant qu'elle n'aura pas réellement démarré
les quatre boucles de chaque boucle. Ce serait donc comme
dans un état de stase ici. Et puis, quand nous commençons à quatre par étape,
on dirait :
OK, OK, laisse-moi aller les chercher pour que je puisse les
énumérer Maintenant, le danger de
procéder de cette façon est que la connexion restera ouverte pendant toute la durée
de ces quatre boucles. Maintenant, avec seulement 15 disques, cela ne semble pas
grand-chose. Je veux dire, OK, très bien.
Mais lorsque vous parcourez
une base de données plus importante, cette connexion est ouverte. Et imaginons simplement que chaque connexion à
la base
de données est une
opération coûteuse dans n'importe quel système, n'est-ce pas ? Vous voulez donc le réduire autant
que possible. Et vous ne
voulez pas non plus qu'
une connexion reste ouverte trop
longtemps ou plus longtemps que nécessaire. Donc, lorsque nous faisons cette
déclaration, nous pourrions même nous
débarrasser de cette
partie de la ligue et simplement dire « pour chaque ligue VR » dans les ligues
contextuelles. Le
fait est que cela créerait en quelque sorte un verrou très
inefficace En fait, plus
vous devez effectuer d'opérations pour atteindre
la portée, le temps entre chaque élément augmente,
puis, bien sûr, la connexion reste ouverte, ce qui devient encore
plus cher. Je fais donc simplement remarquer
que, oui, vous pouvez essayer cela et cela fonctionne, mais ce n'est pas le moyen le plus
efficace de le faire. Le moyen le plus efficace et le plus intelligent de le
faire, encore une fois,
serait de lancer cette opération d'
exécution, laisser itérer
et d'obtenir la liste, puis cette liste ne sera
pas stockée en mémoire Cette connexion n'est pas
proche de la base de données, et vous pouvez ensuite effectuer toutes
vos opérations et manipulations sur les
données par la suite. C'est bon. C'est donc vraiment tout pour effectuer
les requêtes de sélection simples. J'ai en quelque sorte extrait tout ce code et je l'
ai mis dans cette méthode, qui est une méthode d'annulation statique. Celui-ci n'utilise donc aucune opération
asynchrone. Nous n'avons donc pas besoin d'en
faire une tâche asynchrone, n'est-ce pas ? C'est donc un simple vide. Et ce que j'ai fait,
c'est mettre en évidence lequel est bon et
lequel est plutôt mauvais. Donc, tout ce qui
fonctionne, même si cela fonctionne,
n'a pas des
conséquences sous-jacentes dont vous n'êtes peut-être pas au courant, mais c'est pourquoi je suis ici pour
vous indiquer quelle est la meilleure façon d'
engloutir vos opérations. OK.
13. Filtrer les enregistrements: Salut, les gars,
bienvenue dans cette leçon, nous allons commencer à voir comment
filtrer nos requêtes. Maintenant, l'étude de cas sur le
filtrage est évidente, n'est-ce pas ? Ce que nous avons examiné dans
le cadre de la sélection simple, c'est que nous sélectionnons tout ,
puis que nous
répétons tout Dans certaines
situations, vous ne voulez pas tout, vous voulez des enregistrements spécifiques, et c'est ce que nous
allons examiner dans un premier temps. J'ai donc créé une
méthode de filtres de requêtes. Avant d'aller plus loin, je tiens à souligner que j'
ai dit que nous avions annulé cette
disposition parce que cette méthode n'avait rien de
synchrone Eh bien, grâce à l'entité
Framework Core, nous devons répertorier A sync. Et quand je contrôle cela, il me suffit de l'ajouter en utilisant instruction pour Entity
Framework Core. Et grâce à cela, je peux maintenant le rendre synchrone. En plus d'ajouter le poids
avant l'appel AC. Passons donc à
nos filtres de requêtes. Donc, lorsque nous voulons
ajouter un filtre de requête, et je vais dire que les ligues
sont égales ou contextuelles, point, au tableau qui nous
intéresse, qui est ligues, puis point, et j'ai accès à un certain nombre de méthodes de ce
côté. Donc, si je voulais dire, donnez-moi toutes les catégories où le nom est égal à une valeur, alors je pourrais dire point, où et puis cette fonction
où prend un paramètre qui
ressemble à un prédicat, à un prédicat ou à une expression Lambda Le format d'
une expression Lambda est donc que vous avez un jeton Je vais l'appeler
Q. La plupart des exemples sur Internet utilisent Q.
Cependant, il n'y a aucune stipulation à ce
que doit être ce jeton Bien entendu, vous le traitez
comme un nom de variable. Donc, si tu veux utiliser Q, si tu veux utiliser League,
tu sais, peu importe ce que c'est. Donc, si j'ai dit Q et qu'
il est suivi de
cette flèche Lambda, je peux maintenant utiliser Q pour représenter n'importe quel
enregistrement de la table C'est donc le format
de l'expression Lambda. Si j'ai utilisé x, c'est pareil. Si j'ai écrit la ligue des
mots, je souligne
simplement
que
peu importe le nom que vous lui donnez, elles
fonctionneront toutes de la même manière. Peut-être que celui-ci se lirait mieux parce que, encore une fois,
il est question
de base ligues par table donnez-moi les ligues par table
et donnez-moi
les records où une ligue a un nom équivalent
à une valeur. Si nous voulions trouver, disons, Siri, c'est à cela que cela
ressemblerait Encore une fois, ce jeton
aurait pu être Q, il aurait pu être x, il
aurait pu être y, il
aurait pu être Z. Donc, peu importe
ce que vous utilisez comme jeton Maintenant, si je le fais,
cela ne s'exécutera pas tant que, encore
une fois, nous n'en aurons pas terminé
avec notre liste de choses à faire. Puisque nous avons la
version synchronisée A de la liste de tâches, nous pouvons dire de synchroniser la liste A, puis je vais
attendre et, bien sûr, faire de la méthode une tâche de synchronisation A. Ensuite, après avoir fait tout cela, je vais répéter cette opération où
je vais simplement les imprimer tous sur
la console. J'attends cet
appel de fonction
et, bien sûr, j'attends avant
tout le reste. Je vais juste
régler ces problèmes avant d'aller de l'avant. Donc, lorsque nous l'appellerons,
cela ira de l'avant. Regardez dans le tableau où cette
condition est remplie. Cela
sera donc vrai ou faux,
donc cela remplira la condition ou non. S'il remplit la condition, il sera ajouté à la liste et éventuellement renvoyé ici. Laissons donc exécuter cette requête
et voir ce que nous obtenons, n'est-ce pas ? Et puis on voit qu'
il revient. Nous avons notre seul
record qui revient. Si nous
examinons bien le SQ, nous voyons qu'il s'agit simplement d'une
simple requête de sélection, mais elle ajoute cette clause were avec cette condition. C'est bon. Maintenant, j'ai codé en dur. Notez que, contrairement
aux autres fois où vous avez vu les paramètres, simplement mis la valeur réelle
dans la requête, et c'est parce qu'elle
était en quelque sorte codée en dur. J'ai donc mentionné que le
paramétrage constitue bonne protection
contre l'injection de CQL Donc, la raison pour laquelle le FCR n'a pas utilisé paramétrage dans
cette situation est qu'il voit que c'est moi
qui ai codé en dur la
valeur à partir du Je ne mettrais donc pas d'injection SQL directement
dans mon propre code. Donc, bien sûr, d'accord, c'est prudent parce que
c'est mon maître qui a fait ça, donc ça doit aller, non ? Mais la réalité est
que dans des situations normales, vous obtiendrez probablement
ce que vous
recherchez ailleurs, n'est-ce pas ? Faisons donc preuve d'un
peu de créativité. Je vais donc modifier un peu
cette fonction, et je vais dire console
le nom de interligue en ligne droite J'invite donc
l'utilisateur cette fois. Encore une fois,
il s'agit d'une application console , mais dans une
application Web ou autre. Habituellement, vous autorisez l'utilisateur à décrire ou à déterminer ce dont il a besoin,
n'est-ce pas Et vous effectuez le
filtrage en conséquence. J'invite donc l'utilisateur, puis nous allons stocker la réponse dans cette variable Et puis c'est la
variable que je vais utiliser pour exécuter la requête. Je vais donc dire où
l'expression Lambda, le nom du point
Q, est l'équivalent du nom
de la ligue. D'accord ? Nous pourrions même
dire que les points sont égaux, car nous pouvons simplement nous fier aux fonctions C sharp que nous utiliserions probablement
dans une instruction normale, mais vous remarquez que cela ressemble une déclaration,
n'est-ce pas ? Il s'agit du même type
d'opérateur logique que celui que vous utiliseriez
dans une condition. Parce qu'encore une fois, il s'agit simplement d'une condition qui
doit être vraie ou bonne, elle doit être vraie
pour être incluse dans la liste. Hein ? Alors maintenant, nous nous en vantons en
quelque sorte Maintenant, nous pouvons
interagir un peu plus avec elle. Je vais donc lancer ceci, et nous allons
voir les instructions. Je suis déjà entré
en Syrie. J'appuie sur Entrée. Et puis il a fallu 83 millisecondes pour le regarder,
maintenant il a paramétré Et puis il s'exécute
avec le paramètre. Donc, vous voyez, encore une fois,
c'est automatiquement une sorte de protection contre injection de
CQL grâce
au paramétrage, nous revenons à notre série Maintenant, nous n'avons qu'une seule
ligue portant ce nom, mais nous avons eu plusieurs ligues
Red Stripe Premier Leagues. Je vais donc
réessayer avec quelque chose qui, je le sais,
renverra plusieurs enregistrements. Nous essayons à nouveau avec
Red Stripe Premier League, et le filtrage va maintenant
ramener tous les records. Vous voyez que cela fonctionne. Cela ramène
tous ceux qui portent exactement ce nom. Et n'oubliez pas que cette fois, nous
n'avons pas utilisé le
double signe égal. Nous avons utilisé le C dièse
parce qu'il s'agit d'une chaîne Nous avons
donc dit que le point
est égal au nom de la ligue. Cela nous permet donc d'écrire
la syntaxe C sharp que
nous connaissons
dans d'autres parties de notre code directement dans la requête, et il se charge
du reste pour nous. Maintenant, faisons une
autre expérience ici. Dans certaines
situations, votre filtre peut ne pas être aussi exact que le
vrai ou le faux. Il peut s'agir d'une sorte de logique
floue où vous
voulez savoir si elle contient, surtout lorsqu'il
s'agit de mots, n'est-ce pas ? Ainsi, dans une recherche classique, vous pourriez
taper une partie
du mot ou une partie de l'
expression que vous recherchez, puis vous
verrez les résultats correspondants. J'ai donc étendu l'invite pour indiquer le
nom de l'interligue ou une partie de celui-ci, puis nous allons
faire deux requêtes Je vais donc prendre tout
cela et le dupliquer. Et ce que je vais faire,
c'est appeler l'un des correspondances exactes et l'autre des correspondances
partielles. Donc, pour les correspondances partielles, je ne vais pas dire que le point est égal, mais
que le point contient. Parce qu'en do dièse, si nous devions essayer de
déterminer si une chaîne contient une autre chaîne,
le point contient. C'est donc ce que je vais
passer sous silence dans
cette expression. Jetons donc un coup d'œil à cela. Je vais donc simplement
utiliser Je vais entrer un bit de chaîne à rechercher. Je vais entrer en
Premier, n'est-ce pas ? Je sais qu'aucune ligue
ne correspond exactement à la première place. Nous avons donc déjà vu les correspondances
exactes fonctionner. Mais je vais juste
taper en avant-première. Et puis ce que vous allez remarquer, c'est qu'il va
exécuter les deux requêtes. Donc, il va
dire qu'il a exécuté ceci, il cherche un premier ministre. Celui-ci contient donc une clause d'usure pour le nom de la ligue Premier.
Bien sûr, il n'y en a pas. Mais alors celui-ci
a le nom
de la ligue ou l'index du graphique. Le
nom du point L est supérieur à zéro. Donc, il suffit de tracer une
belle requête pour dire que je cherche quelque chose comme ce qu'il y a dans le
paramètre. D'accord ? C'est alors que nous voyons
toutes nos ligues le mot premier
revient. C'est bon. C'est donc une autre façon de filtrer
vos requêtes. Maintenant, en ce qui concerne le,
vous pouvez utiliser le contenu, désolé, ou vous pouvez
utiliser les fonctions EF. Je vais donc simplement
dupliquer ceci, et je vais recommander cette partie, donc c'est la première option Une autre option serait
d'utiliser la fonction. J'ai donc toujours besoin du jeton, dois
encore l'initialiser, mais je vais
parler des fonctions EF Point. Et puis vous voyez ici, je peux faire des contenus, je peux le faire et un tas d'
autres fonctions qui
seraient à ma disposition si je
faisais du SQL direct. Certains d'entre eux sont
là pour nous permettre d'y accéder. Je vais donc faire comme ça parce que c'est
plutôt ce que nous recherchons. Je vais dire « j'aime »
, puis je vais
dire le nom d'un point. La méthode prend donc, quelle est l'expression
ou quelle est la chaîne ? Quelle est la colonne de base de données sur
laquelle je compare ? Et puis le deuxième paramètre serait le modèle de chaîne. Si je voulais définir
un schéma précis, si vous connaissez
la colorité, vous
savez que lorsque
vous avez affaire à like, vous avez ce joker Je pourrais donc dire premier modulus, ce qui signifie que cela
commence par le mot première Si nous mettons le module devant, il se termine par le mot premier Donc, quoi que vous
ayez fait en SQL pour ce module ou
ce bit générique, vous pouvez le faire à l'intérieur
de la chaîne et cela l'
agrégera et
créera cette expression exactement
comme nous nous y attendrions Donc, dans notre situation, étant donné que nous avons affaire
à cette variable, je dois m'y prendre un peu plus. Je ne veux pas coder en dur
ce que nous recherchons. Je vais juste utiliser
une interpolation ici, et je vais juste saisir
la valeur qui provient de
l'entrée Donc nous disons, donnez-moi
toutes les ligues où le nom ressemble à ce modèle
de recherche. C'est bon. Alors laissez-moi le faire encore une
fois afin que nous puissions voir ce
que cela va cracher. Cette fois, je
vais taper La. Je ne sais pas Je
n'ai pas de Liga. Je ne sais pas quelle
autre ligue de la base de données peut contenir
les lettres LA,
mais nous voyons la
Liga revenir. Et si nous examinons à nouveau cette
requête, nous voyons qu'elle nous donne le format et qu'elle indique
ensuite où se trouve le nom. Ce paramètre. Vous voyez donc
que cela semble un peu plus
clair que ce que la requête
contient a généré, mais en fin de compte, elles vont toutes deux nous
donner des résultats très similaires, sinon les mêmes. Voilà pour une
petite expérience filtrage
de nos requêtes. À notre retour,
nous verrons comment nous
pouvons agréger les
données, peut-être une, la première et la liste,
la dernière et la liste, nous additionnons tous les éléments de la liste, ce genre de choses Donc, à notre retour,
nous y jetterons un œil.
14. Methods d'exécution supplémentaires: Salut, les gars, bon retour.
L'objectif de cette leçon est donc de
comprendre ou
d' apprécier certaines
des autres méthodes mises à
notre disposition via Lincoln FCR et leur
fonctionnement exact J'ai donc déjà créé
une nouvelle méthode, destinée aux méthodes
d'exécution supplémentaires. J'ai donc ici une déclaration qui ressemble à
une instruction sélective issue de nos activités
précédentes où nous avons un contexte
qui mène là où, et je dis simplement qu'il contient A. Maintenant, l'étude de cas pour une fonction d'
agrégation ou l'une de ces méthodes
d'exécution supplémentaires
serait que vous ne
voulez probablement pas la liste complète. Vous voulez probablement
faire quelque chose qui va à l'encontre de la liste ou vous voulez sélectionner la liste ? Ainsi, lorsque nous parlons de fonctions d'
agrégation en C, nous parlons de choses
comme Min max, count, certaines opérations de
ce
type, toutes disponibles via ces fonctions d'
agrégation supplémentaires. Maintenant, une autre chose que
vous voudriez probablement
faire est de trouver le premier ou
le dernier d'une liste, ce
genre de choses, n'est-ce pas ? Je vais donc m'en servir
comme exemple rapide. Et si je voulais la toute première ligue dont le nom
contient la lettre A ? Ensuite, après avoir vu toutes ces instructions et
ajouté le filtre, je le terminerais par
un premier ou par une valeur par défaut. Vous verrez ici que
nous avons, bien sûr, les méthodes asynchrones et pour chaque AC, il existe
une version non AC Mais ce n'est pas nécessairement
l'inverse. Toutes les méthodes n'ont donc pas
d'équivalent asynchrone, mais vous le verrez plus tard OK. Donc, ici, je peux dire que je veux un premier ou un par défaut ou
je peux dire le premier. La différence entre le
premier et le premier ou le premier par défaut est que nous nous attendrons toujours à voir d'abord une liste et elle
obtiendra la première. Donc, si rien n'est renvoyé, il lancera une exception. L'exécution se terminera
par une erreur. D'accord ? Le premier, ou par défaut, dira : je vais essayer d'obtenir le premier et s'il n'y a rien à obtenir, je renverrai null sans terminer l'
exécution à ce moment-là. D'accord, donc la première option ou la valeur par défaut
est probablement la solution la plus sûre. Et ensuite, cela
ne fera que récupérer la ligue qui se trouve
en tête de liste. C'est bon. Maintenant,
nous pourrions simplifier les choses parce que
ce que nous faisons ici, c'est dire de me donner
la clause de travail
, puis de mettre la condition
et de m'obtenir la première. J'aurais pu
juste le faire. J'aurais pu dire dans quel contexte les
ligues obtiennent la première étoile
par défaut, cette condition. Il s'agit d'une méthode d'exécution. N'oubliez pas de
revenir à notre sélection simple. Sing context point leg
ne fait rien vraiment, mais une fois que nous avons activé
cette méthode, elle s'exécute. Nous avons vu la même chose avec
le top list et le ware. Mais dans cette situation,
je peux simplement dire « première étoile par défaut »
, puis cette condition,
puis la requête sera exécutée en conséquence. Je vais donc simplement vous présenter
d' autres méthodes d'exécution couramment
utilisées. Je vais donc
remplacer cette ligne par
une simple instruction qui définit notre base
de données ici, n' est-ce pas ? Et bien sûr, à partir de
l'ensemble de bases de données, nous pouvons accéder aux méthodes
d'exécution. Passons-les donc en revue un peu dans l'ordre. Nous avons donc déjà
examiné le tost. Nous savons que les
péages
exécuteront l'instruction Selcti Nous avons également le premier
et le premier R par défaut, et nous venons de discuter de
la différence entre
les deux Nous pouvons
donc dire que les fuites indiquent d'abord une synchronisation ou que le premier R indique
une synchronisation par défaut et, encore une fois, il existe des
versions non asynchrones de ces méthodes Selon votre situation, vous utilisez peut-être la synchronisation A, vous n'utilisez peut-être pas la synchronisation A, mais je vais simplement
m'en tenir à la synchronisation A. Nous avons également le mode par défaut unique
ou unique. Single, il fait ce que le
premier ferait sauf qu'il voit d'abord une liste, et il va juste
choisir le premier, littéralement le premier de la liste. Single fonctionnera de la
même manière que le premier où s'il en cherche une, attend d'
abord une liste et il
prendra la première. Si aucune liste n'est renvoyée, cela génère une erreur. Single s'attend à ce qu'
un seul enregistrement soit renvoyé. Donc, quoi que vous attendez-vous à ce qu'un seul
enregistrement soit renvoyé. S'il en voit plusieurs, il lancera également une exception. Single ne lancera tout simplement pas l'exception mais renverra valeur par défaut dans des
circonstances similaires. Vous pouvez toujours
en savoir plus en passant simplement le
curseur sur la méthode, cela vous donnera
des informations sur son fonctionnement Maintenant, lorsqu'il s'agit de certaines
des fonctions d'agrégation traditionnelles
que nous connaissons probablement grâce au
SQL, vous voyez le nombre. Vous pouvez donc dire que le nombre de points des ligues diminue, vous exécuterez
la requête de décompte. Vous avez un compte long,
vous avez un minimum, maximum, vous avez un S, vous en avez un certain nombre d'autres. Comme je l'ai dit, vous pouvez
toujours simplement dire
point de ligue ou point de contexte point de table, puis vous pouvez faire
défiler la page et vous verrez la pléthore de méthodes à
votre disposition Vous pouvez choisir de les utiliser
lorsque vous en avez besoin. Mais s'asseoir et
essayer de
les parcourir tous en même temps peut
être épuisant, mais à tout moment,
vous pensez avoir une idée en tête Vous pouvez toujours utiliser l'
espace de contrôle
par points, regarder et voir laquelle de ces viandes vous avez besoin
à ce moment-là. Maintenant, une autre méthode d'exécution, qui n'est pas nécessairement une méthode de requête
comme celle-ci, mais qui s'exécutera sur
un ensemble de bases de données consiste à trouver une synchronisation. Celui-ci va en fait simplement
sortir et trouver en fonction d'une valeur, donc cette valeur
sera la valeur clé, n'est-ce pas ? Trouve donc une entité avec
une clé primaire donnée. Ainsi, lorsque vous dites « trouver une synchronisation », vous êtes censé identifiant
unique correspondant à cette table, saisir
l'identifiant
unique correspondant à cette table,
puis l'enregistrement sera renvoyé. Cela le ramènera
ou ramènera zéro, non ? Ou il renverra l'
enregistrement ou renverra null. C'est ainsi que fonctionne la
recherche d'une synchronisation. Essayons donc d'exécuter et voyons exactement comment cela
fonctionnerait pour nous. J'ai donc défini un point d'arrêt
au début de cette méthode, et je vais juste le
parcourir étape par étape afin que nous puissions voir le C
quel être généré. Je crois que lorsqu'il
s'agit du single et single ou du
moins du premier, il y aura probablement une
erreur sur l'un d'entre eux,
mais laissez-nous passer à autre chose et voir exactement
ce qui se passe. J'ai donc placé mes fenêtres
côte à côte pour que nous
puissions voir chaque étape du processus. Donc, lorsque nous disons de lister, nous allons
exécuter celle-ci, puis nous voyons ici
que nous obtenons cette requête de sélection que nous
connaissons déjà. Je vais donc y aller
et faire le premier. Donc, vous voyez qu'il
obtient le premier, il sélectionne le premier. De la ligue. C'est bon. C'est donc ce que fait le premier. Et le premier ou par défaut, si je ne me trompe pas, nous générons à peu près
le même SQL que le premier. Mais comme je l'ai dit, si d'abord il
ne voit rien, il créera une exception. Maintenant, le single
va certainement créer une exception car il n'
attend qu'un seul enregistrement, mais il s'agit d'obtenir la liste
et de dire un single. Donc, lorsque nous optons pour celui-ci, cela génère cette
exception. Nous y voilà. L'exception est donc que séquence contient
plus d'un élément car elle s'attendait à ce qu'un seul élément
soit renvoyé, n'est-ce pas ? Je vais donc simplement mettre
fin à cette exécution, et je vais
commenter cette ligne juste pour que
nous puissions poursuivre le
reste de l'exécution. J'ai donc poursuivi l'exécution contre toutes les autres méthodes, et vous verrez à droite certaines d'entre elles ont été
couronnées de succès, d'autres non. Donc, une seule valeur par défaut singulière et à peu près toutes ces erreurs
mathématiques, vraiment, parce que, eh bien, je ne fais rien de
mathématique ici. Je dois m'assurer trouver le
sens de quelque chose, de trouver le maximum de quelque chose. Évidemment, ce n'est pas vraiment cas
quand je parle simplement de
ligues, n'est-ce pas ? Mais le fait est qu'il
s'agit de méthodes supplémentaires que vous pouvez utiliser
lorsque
vous effectuez des opérations plus complexes. Et si vous regardez vers la droite, vous verrez que jusqu'
au lit bébé. Lorsque nous avons demandé quand nous avons
demandé le compte et nous avons
demandé un compte long, la différence entre
les deux était que nous avions sélectionné cont star pour
le lit bébé, puis cont big star
pour le La seule différence
importante est que count renvoie un entier et celui-ci
renvoie un grand entier. Donc, vous savez, en fonction de
la taille de la base de données, vous ne finirez peut-être jamais par utiliser
long count ou big en SQL, mais la méthode
existe malgré tout. C'est donc tout pour
les méthodes d'exécution. Au fur et à mesure, nous
trouverons peut-être une utilité pour eux. Et nous devrons peut-être interagir
avec eux dans le cas contraire. Mais pour le moment, nous ne le savons pas. Je vais commenter toutes celles qui ont
probablement donné des erreurs, et je veux juste que nous voyions le q généré
lorsque nous essayons de le trouver. Nous voyons donc ici que l'
exécution de la recherche est qu'elle trouve une première
où cette condition est remplie. Tout cela
est donc une fois de plus généré pour nous. Et il est fort probable que
nous n'allons pas coder cet identifiant en
dur de toute façon, cet identifiant
proviendrait de quelque part, vous savez, comme lorsque quelqu'un clique sur
Modifier dans votre interface utilisateur. Vous devez savoir quel
enregistrement ils ont l'intention de modifier. Vous devez aller
chercher cet enregistrement, renvoyer, puis le
présenter à l'utilisateur. Il s'agit donc d'une étude de cas pour savoir
quand vous utiliseriez cette découverte. C'est donc tout pour nous qui
étudions d'autres méthodes d'exécution. Comme vous l'avez vu, la liste est
beaucoup plus longue que celle que nous
avons examinée ici. Mais vous avez ces
quatre références, et je suis sûr que vous les trouverez
utiles à l'avenir.
15. Syntaxe LINQ alternative: Salut, les gars, bon
retour. Dans cette leçon, nous allons
examiner une syntaxe de lien alternative. Jusqu'à présent, nous avons étudié des
liens sous la forme de
ces méthodes d' exécution et différentes
expressions Lambda que nous pouvons placer dans certaines d'
entre elles pour adapter nos opérations
à nos besoins Maintenant, c'est bon, l'utilisation de la
méthode d'expression Lambda est parfaitement correcte, et comme vous pouvez le voir,
elle peut être écrite en une seule ligne, belle et propre Cependant, il existe une syntaxe
alternative que certains développeurs trouveront
peut-être un peu plus intuitive car elle ressemble un peu plus au SQL
traditionnel, mais elle est toujours en C sharp. C'est donc en fait
la première méthode que j'ai utilisée pour
écrire un lien avant de
découvrir ou de me familiariser suffisamment avec les expressions Lambda Et j'ai
préparé le code ici pour vous, donc je vais juste
vous le montrer. Donc cette fois, nous
examinons les équipes, n'est-ce pas ? Et puis notre syntaxe ici
est de dire « à partir d'un jeton ». Cela pourrait donc être, vous savez, que nous avons utilisé Q dans nos expressions
Lambda Cela représente quelque chose
comme ce Q. Nous pourrions dire équipe, nous pourrions dire Q. Je dis I. Très bien. Donc, à partir de moi, puis nous indiquons le tableau qui nous
intéresse. Contextez donc
ces équipes, puis sélectionnez. Donc, comme je l'ai dit, cela ressemble un
peu plus à Q parce qu'il contient certains de ces mots clés
SQL, n'est-ce pas ? C'est juste un peu en
arrière car il
aurait fallu sélectionner une étoile dans le tableau Et celui-ci provient d'un
enregistrement dans une table, sélectionnez un enregistrement, ou nous pourrions dire
sélectionner quelque chose de spécifique. Mais nous y reviendrons plus tard. Donc, quand je ferai cette requête, cela me donnera des informations sur les équipes, n'est-ce
pas Cela signifie donc que je dois le
convertir en liste. Mais exécutons
et voyons ce que nous obtiendrons, puis nous pourrons affiner au
fur et à mesure. Si vous regardez cela, il a
parfaitement exécuté cette requête, n'est-ce pas ? Cela nous a donné notre point de
départ, et cela nous
redonne nos équipes. Nous n'avons donc pas eu à
dire explicitement à la liste et à
essayer de la convertir. Maintenant, l'un des avantages de l' avoir sous forme de liste, c' est que lorsqu'elle est sous forme
de quarable, notre capacité à la manipuler une certaine mesure
est limitée, n'est-ce pas ? Donc, si je regardais les équipes, certaines
fonctions sont propres à
i quarable et certaines fonctions
sont propres aux
listes
que vous voudrez probablement
utiliser plus tard dans votre codage et que vous ne pouvez pas vraiment obtenir lorsque vous avez affaire
à un i quarable Donc, de temps en temps, je mets
tout cela entre parenthèses,
puis je dis « à la liste », puis cela me
renvoie simplement ma liste, qui est un peu plus
proche de ce que j'aurais envie de
faire dans mon code C sharp
à la fin de la journée Bien sûr, pour ce faire, je
dois changer ma méthode de void à AC task, n'est-ce pas ? Nous obtenons donc notre liste, et comme vous pouvez le voir, la liste les types de collections fonctionnent manière
assez similaire,
mais comme je l'ai dit, la liste
nous fournit certaines choses
qu' un énumérable interrogeable, et les autres types de collections de
listes ou
types de collections en C
sharp ne le font tout simplement pas Mais bien entendu, la
situation de chacun est différente. Utilisez celui qui
convient à votre contexte. Maintenant, étendons cela. Nous avons également envisagé de poser des
questions, ou de nous excuser. Nous avons également envisagé de
filtrer nos requêtes. Donc, pour le moment, il s'agit
simplement d'une étoile de sélection standard. Hein ? Mais que se passerait-il si nous
voulions une clause d'avertissement ? Eh bien, nous dirions
d'après moi dans le tableau, et je vais juste
dépasser les limites. Cela semble donc un peu plus lisible. Où, et vous
verrez que cela met en évidence ces
mots clés pour nous. Donc, où I représente une expression ou
un enregistrement quelconque dans la base de données. Je peux donc dire où mon
nom est équivalent, puis le mettre dans mes dossiers. Donc, de la même manière
que nous avons pu injecter
une variable ou un nom statique
ou n'importe quoi de ce genre, nous pouvons faire tout
cela ici. Laissez-moi voir si
cela peut même fonctionner. Je vais essayer de dire où je nomme ou laissez-moi dire
à quoi ressemblent les fonctions d'EF. Et alors ce
serait je ne le nommerais pas. Et puis nous avons
le nom de la ligue, pour
lequel je vais juste vous demander
rapidement cette
méthode.
Ce serait également le nom de l'équipe Entrez donc le nom de l'équipe. Permettez-moi de changer le
nom du verbe. Et nous y voilà. Nous vous demandons donc le nom de l'
équipe et une partie de. Et puis nous parlons de la table
d'équipe
où le point fonctionne
comme le nom du point, n'est-ce pas ? Notre expression,
puis nous voulons sélectionner, puis nous voulons mettre
tout cela dans une liste pour
retourner à nos équipes d'appels
variables. Cela va donc
fonctionner, bien sûr. Je souligne simplement
le fait que nous pouvons utiliser la syntaxe alternative la même manière que nous
utilisons notre expression Lambda Je suis donc en train de
le tester, et je tape
B A Y dans le nom de l'équipe. Nous voyons notre déclaration sélectionnée avec la déclaration
générée pour nous, et nous récupérons
Bar et Municx puisque c'est la seule équipe que nous
avons à contenir BAY Donc, encore une fois, c'est
notre syntaxe alternative. Tout ce que vous pouvez faire dans
l'expression Lambda, vous pouvez également le faire avec
ce type de syntaxe Personnellement, cependant, je trouve que les expressions
Lambda sont un peu plus simples Donc, depuis que je suis
à l'aise avec eux
, abandonne d'écrire
mes requêtes comme ça. je n'ai pas écrit de
questions comme celle-ci Pour être honnête, je n'ai pas écrit de
questions comme celle-ci
depuis
des années, mais il est bon de connaître toutes vos options
et alternatives, si nécessaire. OK.
16. Requis de mise à jour simple: Salut, les gars,
bienvenue dans cette leçon, nous allons voir comment
effectuer une opération de mise à jour. présent, le
flux de travail général pour une mise à jour récupérer l'enregistrement que vous avez l'intention de modifier, puis à effectuer la modification, puis à enregistrer les modifications. Il s'agit donc d'un flux de travail typique. Dans toutes les applications que vous utilisez, c'est ce qui se passe dans les
coulisses. Vous indiquez que vous
souhaitez modifier un enregistrement, il recherche cet enregistrement, vous le
présente, le modifie, puis lorsque vous
cliquez sur Enregistrer, eh bien,
vous avez apporté les
modifications à l'enregistrement, puis la sauvegarde
validera ces
modifications dans la base de données. C'est bon. Voyons donc d'abord comment récupérer les enregistrements Et si nous voulions modifier ? Et nous en avons quelques-uns, laissez-moi simplement
regarder nos ligues. Nous avons quelques
valeurs dupliquées ici. Je pense que nous avons trois records en Red
Stripe Football League. Et oui, nous le faisons. Nous avons donc des identifiants ,
deux, trois
et quatre identiques. Donc, ce que je vais
faire, c'est simplement changer les noms
de certains d'entre eux, n'est-ce pas ? Je vais donc changer
le nom de trois d'entre eux. C'est un double, mais
rétrospectivement, nous nous rendons compte que cela aurait
vraiment dû être le
poste de premier ministre écossais, Nous savons donc que nous voulons
modifier l'enregistrement avec l'ID trois. Donc, ce que je vais
faire pour récupérer le record, c'est SVR League, z égal au contexte, ligues trouvent, et
je vais simplement utiliser une synchronisation Bien sûr, si j'utilise une synchronisation, je dois transformer ma
méthode en une tâche de synchronisation A, puis je l'attends ici. Nous allons donc
dire de trouver une synchronisation, puis de nous rappeler
que tout ce que nous avons à transmettre est la clé primaire, donc nous savons que nous voulons
enregistrer avec l'ID trois. Maintenant, quand nous aurons cette ligue,
le changement que je veux
apporter est le nom à point de la ligue Je veux que ce nom
soit désormais celui de Premiereship écossais Ensuite, nous enregistrons nos modifications. Nous avons donc déjà examiné les modifications de
sauvegarde enregistrées lorsque nous insérons les mêmes modifications de sauvegarde Chaque fois que vous souhaitez
augmenter les données de la base de données, vous devez l'appeler
pour valider la commande Ensuite, je veux imprimer le résultat ou je veux réimprimer cet enregistrement
à l'écran. Je vais juste créer une
méthode appelée get record, qui sert spécifiquement
à rechercher cet enregistrement. Je l'ai défini en haut, ou je vais juste dire Varg, va chercher le même enregistrement Ainsi, une fois la sauvegarde modifiée, elle aurait fermé la
connexion à la base de données. Je vais juste
attendre get record, qui va simplement
récupérer l'enregistrement,
puis le réimprimer à l'écran juste pour montrer que
la procédure de mise à jour
a été réussie. Donnons-lui donc un objectif. Ainsi, lorsque j'exécute, nous voyons ici qu'il
effectue la sélection, c'est là
qu'il
fait la recherche, qu'il récupère l'enregistrement, puis qu'il
effectue cette mise à jour, de
sorte qu' il conserve la clé primaire et la nouvelle valeur
de cet enregistrement Ensuite, il exécute
cette instruction de mise à jour, définit le nom comme étant n'importe quelle
valeur de ce paramètre, où se trouve l'ID dans
ce paramètre, puis il procède à
la mise à jour. Et puis, bien sûr,
notre enregistrement get ne
fait
que rouvrir cette requête de sélection, c'est un selquy et
nous restituer cet enregistrement. C'est bon. Essayons donc encore une fois, et je ne changerai rien. Je vais laisser
le même record. Je vais faire
le même changement et tout restera pareil. Ensuite, nous verrons
ce qui s'est passé. Cette fois, nous n'avons pas de déclaration de
mise à jour. Prenez note de cela, non ? Nous n'avons pas de déclaration de
mise à jour car elle indique que
quel que soit le changement que j'apporte, il ne s'agit pas vraiment d'un changement. C'est déjà la valeur dans
la base de données. Il ne va donc pas se donner la peine
de perdre son temps à dire
: « Oh, je dois faire un changement ». CEFCO choisit intelligemment ne pas ouvrir de connexion à
la base de données et d' exécuter une commande dont il se rend compte qu'
il n'en a pas besoin Maintenant, qu'est-ce qui permet à ce
type de changement de se produire, c'
est-à-dire que le FCR constate que les données que nous présentons pour ce champ sont différentes, alors il sait qu'il doit
enregistrer les modifications C'est ce qu'on appelle le suivi, non ? Nous nous intéressons au suivi et à l'
absence de suivi par la suite. Mais à titre d'aperçu rapide, chaque fois que nous
modifions des objets, FCR suit en fait dans
la mémoire les objets qu'il possède si des
modifications
leur sont apportées , de sorte que lorsque nous
disons « enregistrer les modifications », il dira littéralement : « OK, je peux voir qu'une modification
a été apportée ici, je dois valider
cette modification , etc. » C'est donc ce que le suivi nous
permet de faire. Maintenant, il existe d'
autres moyens d'
effectuer une mise à jour, car
une mise à jour peut ne jamais être aussi
simple que de trouver cette valeur
exacte, de simplement modifier une propriété, puis
d'enregistrer les modifications. La plupart du temps, lorsque les utilisateurs
ont une interface utilisateur et interagissent
avec un formulaire, lorsque nous leur permettons de
modifier les données, nous ne savons pas ce qui a changé. Nous ne pouvons donc pas être
sûrs que, d'accord, nous allons simplement mettre à jour le nom, et nous allons simplement
mettre à jour ceci et cela. Nous ne savons pas si, lors
de la modification d'une équipe, elle change de
ligue et de nom. Nous ne le savons pas. Donc, pour cet autre exemple,
je vais utiliser team. J'ai donc renommé notre méthode de
mise à jour du record en simple
mise à jour du record de ligue. Il est donc clair que
nous avons affaire la ligue et qu'il s'
agissait d'une simple mise à jour, et maintenant nous avons une
simple mise à jour du record de l'équipe. Jetons donc un coup d'
œil à l'alternative. Maintenant, dans le cas
où quelqu'un utilisant une interface Web
aurait soumis le formulaire, cela signifie
que nous avons déjà toutes les informations sur
l' enregistrement dont nous avons besoin
à ce moment-là,
ce qui signifie que nous n'avons pas
à aller le chercher avant la mise à jour
car nous l'avons déjà trouvé avant de le montrer
à l'utilisateur. Maintenant que l'utilisateur a soumis, nous avons les nouvelles données. C'est bon. Je vais donc simuler cela en créant un tout nouveau puits, un objet de type équipe, non ? Ensuite, ce que je vais faire,
c'est spécifier un identifiant cette fois. Donc, jusqu'à présent, nous n'avons pas
vraiment attribué d'identifiant à aucun de nos objets car
ceux-ci s'incrémentent automatiquement Cependant, ce que nous devons comprendre, c'est que lorsqu'
un identifiant est présent, il faut bien
sûr
rechercher dans les tables de base de données
l'enregistrement portant cet identifiant. Je vais donc passer
à la table d'équipe. Et ce que je vais faire, c'est insérer
manuellement juste
pour que nous puissions passer par cette équipe d'activité locale. C'est dans la Red
Strip Premier League, mais je vais le mettre avec quelques fautes d'orthographe,
non ? C'est Tivoli C'est Tivoli, et je vais mettre avec
le mauvais identifiant de ligue, parce que ce n'est pas
en ligue huit, et sur la base des équipes
de la ligue huit, nous pouvons supposer Ce n'est pas en Syrie, donc nous
devons faire ce genre
de mise à jour, non ? Supposons donc que cela ait été saisi
par erreur
par un utilisateur, puis qu'un
autre utilisateur remarque cette erreur et s'apprête
à l'écrire On leur
aurait donc présenté le formulaire, puis ils
y auraient apporté les corrections, puis ils l'auraient
soumis. L'objet qu'ils
auraient soumis
ressemblerait donc ceci
où l'identifiant est sept, c'
est-à-dire l'identifiant de
cette équipe, oui. Et le nom ayant
été corrigé est Tivoli Gardens FC avec un O au lieu d'AW, c'est
une orthographe correcte Et puis l'identifiant de la ligue serait désormais le Red Stripe
Premier League, n'est-ce pas ? Utilisons donc le numéro 2 de League ID. Nous voyons que nous avons un autre
doublon, mais c'est bon. Utilisons simplement
la ligue avec l'identifiant deux. Il s'agit donc de la mise à jour que
cet utilisateur est en train de soumettre. Maintenant, comment faire entrer ce nouvel
enregistrement dans la base de données ? Eh bien, on peut dire que le contexte met les équipes de la ligue en
point. Nous avons affaire à
Teams Dot Update. Nous avons donc une méthode de mise à jour
qui, tout comme l'
annonce utilisera
un objet du type de données correspondant au tableau. Nous avons donc l'objectif de notre équipe. Je note qu'il n'y a pas d' asynchrone, il n'y a pas de version
asynchrone Nous avons le single et la version par lots, et nous avons déjà
examiné la gamme de lots signifie que si nous en avons un
tas à mettre à jour, nous avons simplement remis la liste et elle
les traitera tous pour nous. Pour le moment, nous sommes juste en train de
regarder le single. Ensuite,
nous devons appeler
notre point de contexte « enregistrer les modifications ». Et nous utiliserons la
synchronisation A pour celui-ci. Et bien sûr, je
dois en faire une synchronisation pour que tous nos
problèmes soient résolus. Voyons ce qui est fait lorsque nous publions
ce type de mise à jour. Vous verrez qu'il s'agit d'une opération
similaire. Personne, il ne se met pas à jour une
fois de plus car il voit l'identifiant. Elle sait donc qu'il y a
une équipe avec l'identifiant sept, puis elle partira pour le
trouver automatiquement. Eh bien, elle n'a pas à la trouver
parce que le communiqué de mise à jour indique un changement d'identifiant de ligue, changement de
nom où
l'identifiant est équivalent à l'identifiant qu'elle a vu
apparaître sur le compte rendu. Il fait donc tout cela
automatiquement une fois que cet identifiant d'
enregistrement est présent. Passons donc en revue
un certain nombre de permutations. Si nous ne spécifiions pas cet identifiant, que se passerait-il réellement ? Et je vais juste utiliser
une autre équipe de football, Ciba United, qui
joue également dans cette Premier League à rayures
rouges Essayons donc celui-ci
et notons la différence. Il n'y avait aucune pièce d'identité. Nous avons retiré la carte d'identité, et il l'a prise pour l'insérer. Prenez-en note. Donc, la commande mise à jour
ou la fonction de mise à jour
disait que, je ne vois pas de clé
primaire à
ce sujet, elle n'existe clairement pas encore
dans la base de données, donc je vais l'insérer. Maintenant, je ne le
présente pas comme une alternative
à l'encart J'aimerais qu'
ils soient bien séparés. Si j'insère quelque chose, j'utilise la fonction d'ajout. Si je fais une mise à jour, j'utilise
la fonction de mise à jour, ou je fais simplement le suivi en conséquence, mais le suivi n'est pas
toujours une option comme c'est le cas dans
nos applications. Mais une chose à noter, si cet identifiant n'est pas présent, il l'ajoutera. C'est pourquoi nous
veillons toujours à inclure les informations d'identification
sur un formulaire afin que lorsqu'il est soumis,
cet identifiant soit présent dans le dossier afin que nous puissions effectuer
correctement cette mise à jour. C'est donc un point très
important à noter. Et une autre expérience consiste à mettre un identifiant
qui n'existe pas. Donc, si cette valeur d'ID est
complètement incorrecte. J'en ai dix, et nous savons
que nous n'avons que de bonnes équipes, pas huit, n'est-ce pas, ou des équipes avec un identifiant huit. Donc, ID ten est complètement faux. Il essaiera de faire la mise à jour, mais il lancera ensuite une
exception lors de la sauvegarde des modifications, indiquant que l'
opération a échoué. Eh bien, elle devait affecter au moins une ligne,
mais n'en a affecté aucune. Certaines modifications ont peut-être été apportées aux données qu'il contient. Vous pouvez donc voir ici que cela ne vous dit pas vraiment
exactement ce qui ne va pas. Nous savons que c'
est faux car la valeur ID n'existe pas. Et il dit qu'
il pensait qu'il apporterait au
moins un changement,
mais rien ne s'est produit. On ne sait donc pas vraiment
ce qui a pu se passer. Vous devez aller
lire la documentation. Mais comme je l'ai dit, je
veux voir quelle peut être la cause ces erreurs afin que, lorsque nous recevons
des erreurs un peu vagues comme celle-ci, nous puissions supposer que, d'accord, il doit y avoir un
problème avec certaines des données que j'ai
fournies quelque part ici C'est donc
tout pour la mise à jour. Comme vous pouvez le constater, c'est une opération assez
simple. Encore une fois, deux options s'offrent à vous. Vous pouvez rechercher l'enregistrement, le modifier,
puis enregistrer modifications,
puis le suivi
permettra à COR de savoir que, d'
accord, cet enregistrement a été modifié Je dois
donc créer la déclaration de
mise à jour correspondante. Parce que même si nous en
avons une liste,
si nous n'apportons des modifications qu'à une seule, il saura qu'une seule
doit être mise à jour, n'est-ce pas ? Et l'alternative, connue ou autre, pourrait être celle où le suivi n'est pas
nécessairement une option. Et le dossier que nous devons mettre à jour n'est pas suivi
par la FCR à ce moment-là Nous pouvons
donc utiliser cette méthode de
mise à jour, qui recherchera l'enregistrement et générera
automatiquement
la déclaration de mise à jour Si aucun identifiant n'est présent, la méthode de mise à jour
se poursuit et ajoute le
nouvel enregistrement. OK.
17. Requis simple de suppression: Et nous sommes de retour. Donc, jusqu'à présent, nous avons examiné
toutes les lettres
du CRD sauf le
D, qui est supprimé Nous avons donc
examiné comment créer. Nous avons passé un certain temps à réfléchir à manière dont nous pouvions récupérer et
aux différentes méthodes. Nous avons simplement examiné la façon dont nous procédons aux
mises à jour et nous voulons maintenant savoir comment nous supprimons ou supprimons les
données de notre base de données. J'ai donc déjà mis
en place deux méthodes, l'une pour montrer un exemple de
suppression simple
, puis l'autre pour afficher une suppression lorsqu'il existe des données
associées. accord ? Donc, la simple suppression. Jetons un coup d'œil aux options qui s'offrent à nous. Et je vais passer un peu de temps avec le classement parce que
nous devons faire le ménage Premièrement, nous avons des doublons
ici et ici. Et puis nous
voulons probablement aussi supprimer la Bundesliga. C'est donc ce que nous allons
faire aujourd'hui. C'est bon. Donc, quand je dis
point de contexte et que je choisis un tableau. Donc dans ce cas,
c'est le point des ligues, puis commencez à taper Delete, ou plutôt remove my bad, nous verrons que nous
avons deux options. Nous avons retiré et nous
avons supprimé la portée. Supprimez donc comme si vous ajoutiez et mettez à jour des offres avec
un enregistrement à la fois, puis les
opérations de plage se feront en masse. accord ? Donc, lorsque je
dis supprimer et que jette un
coup d'œil à ce que cela
nécessite pour effectuer une suppression, nous verrons que l'entité
entière doit être supprimée. C'est bon. Donc, généralement lorsque vous écrivez
une instruction q, vous dites supprimer
de la table, notre identifiant est
peut-être égal
à un. C'est bon. Ensuite, il
ira simplement pour cela, optera pour importe quel enregistrement
correspondant à la condition qui
m'a été donnée et supprimez-le. Et sans cette condition, il ne fera
qu'essuyer la table. Il existe donc au moins
un filet de sécurité dans lequel
nous devons
fournir l'entité ou la liste
des entités à supprimer, ce qui signifie que nous devons faire un effort très délibéré pour savoir si c'est ce
que nous
voulons supprimer pendant l'exécution. Le risque d'effacement de
la base de données est donc considérablement réduit dans cette
situation. C'est bon. Donc, bien sûr, si
nous devons fournir l'
entité à supprimer. Et si vous
regardez simplement la documentation, elle indique que la suppression place l'entité dans un état
appelé supprimé. Il indique donc qu'il doit être supprimé, mais comme vous le savez, rien ne se passe tant que nous n'
appelons pas enregistrer les modifications. Donc, si je dois fournir
une entité à cet enregistrement, il est clair que je dois
rechercher ce que je dois supprimer. Je vais donc mettre
une ligne juste au-dessus où je
trouve la ligue avec l' identifiant quatre quatre parce
que c'est
l' un de mes
doublons, Et celui-ci n'a
aucun enregistrement connexe. Il s'agit donc d'une simple suppression. Il suffit de trouver celui
avec l'identifiant quatre, quand nous l'aurons, nous pourrons dire que c'est celui que je
veux supprimer. Et puis, comme nous le savons, nous disons « enregistrer les modifications ». Bien sûr, en utilisant l'
ASIC pour ajouter deux,
la déclaration de méthode,
OK, et c' est parti Donc, quand j'appellerai celui-ci, je vais juste
commenter ce deuxième appel pour le moment. Lorsque je lance cette opération, nous voyons où a été déchirée la requête de sélection pour
récupérer le record, puis elle est sortie et a dit de
supprimer des ligues la même
requête que nous connaissons et aimons Bien entendu, avec cette clause
were,
assurez-vous de ne pas effacer les
tables de la base de données. C'est bon. C'est ainsi que fonctionne réellement une
simple suppression. Maintenant, la raison pour laquelle je fais la
différence entre une simple suppression et une suppression avec des relations est que lorsque nous avons des enregistrements
connexes, une opération de suppression devient
un peu plus sensible signifie qu'il existe un
paramètre appelé suppression en cascade, qui signifie que si je supprime l'enregistrement
avec une clé primaire, tous les autres enregistrements contenant une clé étrangère
seront également supprimés. accord, ce serait presque comme vous supprimer d'une base de données. Ainsi, toutes les cartes que vous avez
possédées et toutes les
informations vous concernant seront également supprimées de différentes parties de la base
de données. Bien que cela puisse être une bonne chose
dans certaines situations, cela peut être très dangereux
dans d'autres. C'est bon. Donc, dans cette situation, si je dois supprimer la
Bundesliga avec l'identifiant neuf, je vais simplement répéter
le même code
que le symbole Supprimer Ce qui fait la différence, c'est
que je sais que j'ai au moins une équipe liée
à la Bundes Liga, n'est-ce pas ? Cela signifie donc que si je
supprimais Bonds Liga, cette équipe serait
également supprimée. la même manière,
si je retirais la Syrie, une, deux ou trois
équipes seraient supprimées. Maintenant, pour en revenir à notre fichier de migration, juste
pour comprendre les règles de contrainte lorsque
la table Four Teams a été
créée et que règles de contrainte lorsque
la table Four Teams a été la contrainte de
clé étrangère a été insérée,
par défaut, l'action
référentielle a été mise en cascade Il existe d'autres options
que nous pourrions définir ici. Il pourrait donc indiquer restreindre, ce qui signifie que vous ne pouvez pas
effectuer de suppression sur
un enregistrement contenant des enregistrements connexes
ou dépendants. Définir Null signifie qu'il
définira tous les autres enregistrements, tous les enregistrements associés. La valeur de la clé étrangère deviendra
désormais nulle, n'est-ce pas ? Supposons que nous supprimions
le parent et que nous
définissions simplement toutes les valeurs de la
clé étrangère sur null. Et puis vous n'avez aucune action, c'est-à-dire
ignorer la contrainte,
puis une autre
qui indique par défaut, qui définirait simplement une
valeur par défaut par la suite, n'est-ce pas ? Je vais donc le laisser
sur la cascade par défaut, mais encore une fois, ce n'est peut-être pas toujours la
meilleure situation. Et il arrive que le
cœur du framework d'
entités, lors de
la génération de la migration, vous indique que si j'y place une cascade, il peut certains types d'erreurs
car, vous savez, il peut y
avoir
certains types d'erreurs
car, vous savez,
cette table peut
dépendre de ceci ou de
cela et vous obtenez une
situation de référence circulaire ou différentes tables
basées sur les mêmes données. CO vous avertira donc en quelque sorte dans les situations où la conception
de votre base de données
n'est peut-être pas optimale pour ce type de règle de contrainte. C'est bon. Cela étant dit, essayons de supprimer la Bundesliga,
dont nous savons qu'elle possède une
équipe apparentée
, et voyons ce qui se passe Donc, lorsque nous examinons
le qua qui est généré. Cela ne semble pas
différent de ce que nous avons vu avec
le précédent. Vous vous
demandez donc probablement, d'accord, où est la deuxième suppression
pour l'enregistrement correspondant. Vérifions si c'est bien le cas. Donc, si je rafraîchis les équipes, la
Bundesliga a disparu,
désolée, les ligues, et ensuite si je rafraîchis les équipes, cela signifie
que Burn
Munich est également parti La cascade s'est donc produite, mais nos journaux n'
indiquent qu'une seule suppression. Cela est dû au fait qu'une règle de cascade appartient réellement à l'ingénieur
de base de données. Ce n'est pas nécessairement
une instruction ca qui sera
générée. C'est bon. Cette
règle de migration était donc réellement définie dans la base de données lorsque
nous avons effectué la migration. La base de données elle-même
sait que la règle est de supprimer tous les enregistrements associés. Cela n'a donc rien à voir
avec le FCR à ce stade. C'est donc l'une des situations
dangereuses potentiellement dangereuses
dont vous
devez être conscient lorsque vous
concevez une base de données, configurez vos migrations et effectuez vos opérations de
suppression. Sachez simplement que par défaut, sera indiqué en cascade, mais vous pouvez toujours remplacer
cela pour dire restreindre par
défaut ou quoi
que ce soit d'autre par le biais de configurations C'est donc tout pour
nos opérations de suppression, comme vous pouvez le constater, c'est
assez simple. Il suffit d'aller
récupérer le dossier. est fort probable que nous
ayons l'identifiant de l'enregistrement que nous
devons supprimer de toute façon.
Nous allons le récupérer, Il est fort probable que nous
ayons l'identifiant
de l'enregistrement que nous
devons supprimer de toute façon.
Nous allons le récupérer, puis nous
lui disons simplement que c'est celui que
nous voulons supprimer, enregistrons nos modifications,
et le tour est joué.
18. Suivi Vs. Pas de suivi: Salut, les gars, bon
retour. Dans cette leçon, nous allons examiner le
suivi par rapport à l'absence de
suivi afin de mieux comprendre ce qui se passe
en arrière-plan. J'ai déjà écrit
du code qui peut faire une pause ici, le
reproduire, mais
je vais
vous expliquer ce que fait
chaque ligne Nous commençons par la méthode appelée suivi
par opposition à l'absence de suivi. Dans cette méthode, j'ai
deux instructions, l'une où nous obtenons de la
valeur de la base de données, et je
l'appelle simplement avec suivi, et l'autre où je l'
obtiens sans suivi. Si vous
regardez attentivement les deux lignes,
la différence que vous
remarquerez est que j'ai un point guise de suivi dans la déclaration. La première concerne le contexte dans lequel nous sommes
habitués à mettre en contexte les équipes à points. Je veux le premier enregistrement
portant l'identifiant deux. Hein ? Cela
aurait presque facilement pu être une découverte sauf que le suivi An ne fonctionne pas lorsque
nous utilisons une trouvaille. accord ? Donc, si nous
devions essayer de trouver que nous aurions supprimé
et mis à jour, etc., nous pourrions mettre un suivi dans
ce type de déclaration. D'où mon écriture du premier ou de
la valeur par défaut. Et puis, par souci de cohérence, je l'ai
fait les deux fois, non ? Donc, sans suivi, je peux dire de me
donner l'équipe. Donc, ne faites pas de
suivi une fois que vous m'avez donné,
s'il vous plaît, ne la suivez pas en mémoire, mais je veux la première ou la
valeur par défaut avec l'identifiant huit. Maintenant, la façon dont cela est
écrit ne semble pas intuitive , car
vous allez probablement dire, pourquoi ne pas dire, donnez-moi la
première équipe avec comme suivi. La réalité est qu'après la
première instruction ou l'instruction par défaut, tout cela
devient à peu près l'objet que
nous recherchons. Donc, en d'autres termes, la
seule chose que je puisse faire après une première étoile par défaut, c'est utiliser le acing. Donc je vais juste mettre
ça entre parenthèses. Donc, une fois cette instruction
exécutée, non ? Et je dois le
faire uniquement parce que c'est acc si ce n'était pas le cas, je n'aurais pas
eu à le faire, mais à la fin d'une
première opération par défaut, nous allons commencer à
interagir avec les champs réels qui se
trouvent dans l'objet C'est pourquoi le
suivi d'Ano ne peut tout simplement pas venir
après cette déclaration. Nous devons donc indiquer
au contexte de base qui consulte le tableau des équipes, ne pas suivre les éléments, mais je veux le premier
qui répond à cette condition. C'est la déclaration.
Le véritable avantage absence de suivi est que
cela libère un peu
plus de mémoire et accélère les
performances, car
vous pouvez imaginer que si vous
récupérez 100 enregistrements avec suivi, le FCR
devra surveiller 100 enregistrements,
et ce, sur une seule demande Qu'arrive-t-il aux
centaines de dossiers que vous êtes peut-être en train de jongler dans
le système, n'est-ce pas ? Le moteur FCR doit donc fonctionner
au fil du temps pour
suivre tout cela en permanence Ainsi, dans le cadre d'une opération simple
, comme si vous faisiez simplement
une lecture de la liste, comme si vous listiez des éléments de
la base de données à l'intention de votre utilisateur. Vous pouvez toujours simplement
refuser le suivi car vous n'avez pas à le suivre. Des choses qui figurent dans une
simple liste, non ? Cependant, au moment
où vous êtes sur le point d'
apporter un changement et que vous faites
une déclaration comme celle-ci, alors oui, le suivi
sera là. Vous pouvez le supprimer
ou même lors de la mise à jour, le suivi serait disponible après la découverte, donc
nous pourrions être désolés Ce n'est pas une bonne méthode
. Nous avons pu, allons-y, apporter la modification, puis elle est suivie à ce
moment-là pour être enregistrée, n'est-ce pas ? Mais pour les opérations de
lecture volumineuses, vous pouvez toujours utiliser le
suivi Ano pour réduire
en quelque sorte l'attention que le FCR doit
accorder à l'attention que le FCR doit
accorder à chaque enregistrement récupéré Maintenant, ce que j'ai fait après
les avoir récupérés avec
et sans suivi, j'ai modifié
leurs noms respectifs Ensuite, je vais vous montrer que nous pouvons réellement
regarder les entrées. Nous avons donc ce qu'on appelle un outil
de suivi des modifications dans le contexte, qui
va simplement nous montrer des
informations sur l'entité
suivie,
son état juste
avant les modifications de sauvegarde, puis nous allons l'examiner à
nouveau après les modifications de sauvegarde. Je ne l'ai fait que par mesure de précaution, mais je suis sûr que cela sera toute façon mis à jour par la suite Mais nous verrons bien. Alors allons-y et exécutons. J'ai défini un point de rupture sur
la ligne de sauvegarde des modifications, et j'ai les
variables dans la montre. J'ai donc les entrées
avant la sauvegarde et après la sauvegarde. Donc, si je jette un œil
aux entrées avant de les enregistrer, cela me donnera une vue
des résultats, et cela me montrera
qu'un seul
des enregistrements qu'il suit est
modifié, n'est-ce pas ? Donc, si je développe, vous verrez que l'état de l'entité ici
est modifié. Nous avons en fait quelques
énumérations qui nous ont été fournies par le FCR, où nous pouvons dire
entity state point et où vous avez modifié,
ajouté Tout ce qui être fait
dans un contexte grossier, nous pouvons déterminer quel
changement est sur le point d'être enregistré ou
dans quel état il se trouve juste avant qu'il ne soit
sur le point d'être enregistré. Nous voyons ici que l'
enregistrement avec l'ID deux est dans un état modifié. dossier portant le numéro deux est celui que nous avons
récupéré avec le camionnage Nous avons effectué le changement,
puis juste avant de sauvegarder, il s'aperçoit que c'est le seul fichier dont
il a besoin parce que nous ne
suivions pas le
dossier avec l'identifiant huit. Donc, peu importe les
modifications que nous y avons apportées,
cela ne s'en soucie tout simplement pas. est donc
le scénario qui nous
a donné cette situation où
nous aurions le dossier, nous saurions tout
sur le dossier, mais nous devons ensuite
indiquer dans le contexte que cette équipe ou cet enregistrement
doit être mis
à jour, après quoi elle
commencera à le suivre. Donc, pendant qu'il était là, il n'
était pas suivi. Cet objet est dans le même
état que cet objet, mais il n'est pas suivi par l'EFC Cependant, si nous devions insérer la déclaration de mise à jour manuelle
pour « sans suivi », elle serait également répertoriée comme un enregistrement
modifié à enregistrer au moment de son arrivée . C'est bon. Je vais
donc simplement dépasser cette étape, puis faire deux étapes supplémentaires afin que
nous puissions
voir les entrées après la sauvegarde
et les entrées après la sauvegarde. Maintenant, il ne fait que
suivre le fait qu'il avait
cette entrée avant la sauvegarde. Non, il est dans un état inchangé. Ainsi, une fois que nous avons enregistré les modifications, elles passent de l'
état dans lequel elles ont été ajoutées, supprimées ou modifiées, et elles sont passées à
un état inchangé. Cela signifie donc qu'Entity Framework le suit toujours, n'est-ce pas ? Une fois qu'il est répertorié
ici dans les entrées, cela signifie qu'il est suivi. Il peut donc arriver
que vous
rencontriez des problèmes de simultanéité lorsque vous effectuez une opération, puis que vous enregistrez
les modifications apportées à l'enregistrement, puis que vous essayez probablement de le
manipuler à nouveau
juste après, puis vous pouvez
obtenir un message d'erreur indiquant que cela est déjà
suivi par le cours EF C'est donc l'une de
ces situations. Il faut donc parfois éviter
de le suivre, mais nous n'
aborderons pas ce niveau de complication, du
moins pas pour le moment. Pour le moment, nous
voulons simplement nous concentrer sur
ce que le suivi fait
différemment de l'absence de suivi. Donc, comme je l'ai dit, dans
un scénario où vous n'avez besoin de données qu'à des fins de
lecture seule, absence de suivi crée un
scénario très efficace pour vous. OK.
19. Réalisez des relations à l'adresse un, à de nombreuses: Salut, les gars,
bienvenue dans cette leçon. Nous voulons passer rapidement en
revue notre relation « un à plusieurs » et
voir comment le FCR nous
facilite la vie en définissant ce
type de relation et en nous permettant d'interagir
avec les dossiers connexes Donc, pour résumer, notre classement est
défini comme ce modèle de données, et notre tableau d'équipe est
défini à droite Nous savons donc qu'en suivant
notre convention de dénomination, le FCO a tout d'
abord pu déduire qu'une relation de
clé étrangère existait entre les deux Quelle est cette convention de dénomination ? Eh bien, tout d'abord, j'
aurais indiqué que le nom du champ est l'identifiant de
la ligue. C'est bon. Nous avons donc la table appelée
League et la clé étrangère. Juste en l'appelant League ID, il en a déduit qu' il existe une relation
clé étrangère Ainsi, à titre d'exemple, si je n'incluais pas cette propriété de navigation
virtuelle, cela permettrait de savoir qu' il existe une
clé étrangère simplement en raison de la convention de dénomination que j'ai utilisée
à ce stade. Maintenant, en raison du type de
données utilisé, j'utilise t et t ne peut pas être nul par
défaut. Vous vous rendriez donc compte
que cette migration
générée aurait une valeur NULLABLE. Ici, l'
ID de ligue était la colonne, et un ulle tombe, ce qui signifie qu'il ne peut pas être
nul dans la base de données Eh bien, C sharp prend en charge les types de données
nullables. Si je disais en point d'interrogation, cela serait
automatiquement nul. Je vais donc juste exécuter
une migration juste pour montrer. Voici donc notre migration et notre
migration a rendu l'identifiant de
ligue nullable. Et puis, dans ce
nouveau fichier de migration, il semble un peu
différent du précédent, et nous allons procéder
à d'autres migrations. Je ne me concentre donc pas encore sur ce que
nous examinons. Je tiens juste à souligner que la colonne alter
voit maintenant que nullable
est égal à vrai, tout cela parce que nous avons mis
ce point d'interrogation En C sharp, si vous rendez
le type de données nullable, c'est ainsi que
FCR saura que c'est nul ou devrait être vrai
en SQL, à
peu près, Cela signifie donc que l'
ancien type nouveau est TS, mais qu'il est maintenant nullable C'est donc l'une des manières de rendre
une clé étrangère nullable Alors pourquoi voudriez-vous
rendre une clé étrangère valide ? Dans une telle situation, vous pouvez
peut-être avoir une
équipe sans ligue. Plus tard, nous
ajouterons d'autres tables L'
une des tables que nous
allons ajouter est un entraîneur, un entraîneur peut être un entraîneur. Techniquement, un entraîneur
peut être un entraîneur sans équipe parce que mon
métier est que je suis entraîneur, mais je n'ai pas de
coach d'équipe pour le moment. Je suis donc dans le tableau des entraîneurs, mais je n'ai tout simplement pas d'équipe. À ce moment-là, cet identifiant d'
équipe devrait être nul si je ne suis pas employé dans une équipe à ce
moment-là. n'est donc qu'un exemple rapide que nous examinerons plus tard. Mais pour l'instant, je
veux juste me concentrer sur le fait que nous pouvons rendre cette clé
étrangère annulable. Pour en revenir à
notre équipe, le modèle de données, j'ai apporté un léger
ajustement en supprimant le nombre entier de la clé étrangère et en le remplaçant
uniquement par la propriété de navigation. Cela va également essayer de générer un champ de clé
étrangère lisible Le seul problème est que le champ de clé étrangère
sera généré dans la base de données sans que la propriété ne figure dans
la classe, c'est qu'il n'
y a aucun moyen d'obtenir cette valeur entière ou d'interagir
avec cette valeur d'identifiant, n'est-ce pas ? C'est pourquoi,
pour me faciliter la vie, il vaut mieux
interagir avec les deux. Maintenant, je l'ai fait savoir, mais je ne
veux pas nécessairement conserver cette chaîne Donc, ce que je vais faire dans la console du gestionnaire de packages,
c'est supprimer la migration. Nous l'avons donc probablement vu plus tôt lorsque nous
examinons toutes les options ou toutes les commandes
que nous pouvons exécuter. Donc, pour effectuer cette action, il est dit que c'est
ici, supprimez la migration. La migration de suppression
essaiera donc toujours de supprimer la dernière ou la plus
récente migration effectuée. Voici donc notre plus
récente migration. Je peux simplement dire de supprimer la migration, et cela tuera ce fichier. Veuillez noter, cependant, que
s'ils disent que le est revenu en arrière et qu'il fait
tout ce qu'il sait qu'il est nécessaire de faire Donc, la seule chose, est que si vous avez déjà effectué cette
migration
vers la base de données
et que je l'ai supprimée, la migration devient
un peu plus difficile Mais c'est quelque chose que
nous allons également examiner, alors ne vous inquiétez
pas pour l'instant. Maintenant, une dernière chose
que je tiens à souligner à propos ces relations clés étrangères est le fait que, du côté de
la ligue, je peux ajouter une propriété qui est une collection d'objets
dont je sais qu'ils sont liés. Donc, lorsque nous avons élaboré
la base de données, vous avez probablement
remarqué que
la ligue possédait une
collection, et une collection Il peut donc s'agir d'une collection. Cela peut être énumérable,
il peut s'agir d'une liste. Cela dépend vraiment de vous,
mais nous allons simplement en déduire qu'il s'agit d'un
ensemble d'équipes, c'est vrai Et je vais simplement l'appeler
équipes, ce qui signifie que la ligue peut accéder automatiquement à la liste des équipes qui lui sont associées.
Alors pensez-y. En général, si vous vouliez la ligue et ensuite toutes les équipes de la ligue, vous devriez trouver la ligue peut-être par
identifiant, puis organiser
le tableau des équipes pour dire, trouvez-moi toutes les équipes ayant
le numéro de ligue, n'est-ce pas ? Ou vous obtenez simplement le numéro de ligue de toutes les
équipes, mais vous devez ensuite les
rejoindre sur le classement pour obtenir les
détails de la ligue dans laquelle elles Nous sommes donc déjà en train de le faire parce
qu'une fois avec une équipe, je peux obtenir les détails de la ligue dans laquelle cette équipe
participe. Nous verrons cela plus tard. Hein ? Mais juste en mettant
ce type de collection ici, je peux dire : trouvez-moi
la ligue avec l'
identifiant 1 et incluez
toutes les équipes. Donc automatiquement, je reçois la ligue, le nom, et je reçois les
2030 équipes associées à la
ligue, le tout dans un seul objet. C'est donc un autre avantage. Je vais donc
ajouter cette propriété, et je vais la laisser là. Vous pouvez faire de même
pour votre modèle. Et la dernière chose que je
tiens à souligner, c'est que je tiens à réitérer l'importance de respecter les conventions de
dénomination. Lorsque vous ne respectez pas
les conventions de dénomination, vous vous battez en fait
contre un système conçu pour
vous aider à mieux faire les choses. Donc, dans cette situation particulière, je parle de
la clé étrangère. Création car vous avez peut-être d'autres idées quant au nom que vous souhaitez donner à cette colonne de clé
étrangère. Et je ne vais pas dire non. Vos règles de gestion
peuvent vous obliger à utiliser un autre nom de colonne. Mais ensuite, cela devient
difficile, car si je voulais nommer cette ligue FK, je sais
que cela briserait un autre code que j'
ai utilisé ailleurs. Mais si je le faisais, ce qui
se passerait ,
c'est que lorsque
j'exécuterai la migration, elle
générera toujours une colonne appelée League ID parce que FC
suit sa propre convention, puis ce sera une colonne aléatoire. Une colonne aléatoire appelée
league FK qui n'a absolument aucune affiliation
avec la clé étrangère. Donc, encore une fois, je
tiens à le répéter, suivez ces conventions de dénomination, et la vie vous sera
beaucoup plus facile. Maintenant, dans la leçon suivante,
nous allons
examiner la relation entre
plusieurs et plusieurs, et je vais approfondir
certaines des choses géniales
que FCR peut faire pour
20. Ajouter des relations de nombreux rapports: Salut, les gars, bon
retour. Dans cette leçon, nous voulons commencer à examiner
de nombreuses relations. Maintenant, il est préférable de
définir une relation entre
plusieurs lorsque vous
avez de très nombreux enregistrements relatifs
à de nombreux enregistrements. Dans le contexte de notre application de football,
ou de notre base de données sur le football, nous devons
tenir compte du fait
qu'il y aura de nombreux
matches entre de nombreuses équipes. De nombreuses équipes joueront contre de nombreuses autres équipes au
cours d'une saison. J'ai à l'écran une belle application
utile appelée raw point IO. Il s'agit d'une application Web dont l'utilisation est
totalement gratuite. Et ce que nous allons
faire, c'est visualiser notre structure de données Je vais donc simplement utiliser des
rectangles, c'est sympa
et simple, et je vais
appeler cette ligue et nous allons
appeler cette équipe Nous savons donc que nous avons des
ligues liées aux équipes. Génial et simple, il suffit
d'utiliser un r pour les connecter. accord ? Nous avons donc une
ligue et une équipe. Non, j'ai besoin d'une nouvelle
entité dans le mix, et je vais l'
appeler Mach Maintenant, une correspondance
va être comprise, et je vais juste écrire les champs et les entités. Nous savons déjà ce qu'il y a
dans la ligue et dans l'équipe, mais celle-ci
aura un identifiant. Bien sûr. Il y aura également une équipe locale et une équipe visiteuse. Nous pouvons dire non, je m'
éloigne un
peu de la
convention de dénomination, non ? Donc, équipe locale, équipe
visiteuse, et nous allons
probablement avoir le temps. Comme je l'ai dit, nous allons nous
retrouver avec la même équipe
locale, la même équipe à
domicile plusieurs fois et la même équipe
à l'extérieur plusieurs fois, mais elles s'
affronteront. Cette relation « beaucoup trop
nombreux » a donc vraiment besoin de ce que nous
appelons une table d'éditeur de liens, c'
est-à-dire une table située entre les deux tables
associées Dans cette
situation particulière, cependant, le trop de joueurs se situe en réalité entre de nombreuses équipes
et de nombreuses équipes. Cela signifie que notre équipe est liée deux fois
à cette table.
Donc, excusez-moi si vous débutez dans le développement de bases
de données, mais c'est exactement comme ça que ça se passe. Parfois, vous avez
deux clés étrangères d'
une autre table pour accéder à
la même table, n'est-ce pas ? Ainsi, une table contient deux clés
étrangères ici. Nous avons une clé étrangère
pour l'équipe locale, mais une
clé étrangère pour l'équipe visiteuse. Mais cela signifie
vraiment que de nombreuses équipes sont liées à de
nombreuses équipes, beaucoup trop nombreuses. C'est bon. C'est bon. Maintenant que j'ai
visualisé
à quoi doit ressembler
cette structure de base doit ressembler
cette structure de base de données et cette nouvelle table, nous pouvons passer en revue et créer
les modèles correspondants Je suis donc allée de l'avant et j'ai créé une toute nouvelle classe que
je vais appeler match. Et tout comme ses homologues, il aura
certaines conventions de nom. Maintenant, avant de poursuivre, je tiens
simplement à souligner que chaque table ou chaque
modèle possède essentiellement cet identifiant. Et puis il arrive
que vous ayez
plusieurs champs qui se répètent probablement dans toutes les tables, comme lorsque vous
effectuez un audit ou, vous savez, lorsque
vous avez une date de création, ces types de champs dont tout le monde a
peut-être besoin, car il est clair que dont tout le monde a
peut-être besoin, car il est clair tous nos champs suivent
la même convention, toutes nos tables, désolé, nous avons un champ appelé ID. Maintenant, je ne veux pas continuer à le répéter à
chaque fois parce que, vous savez, si nous avons 20 tables, cela représente 20 copies de
la même ligne de code. Donc, j'ai tendance à ajouter ce que j'appelle, laissez-moi l'appeler come on, puis je vais ajouter
une classe à l'intérieur de come on que j'appelle objet de
domaine de base. Il ne s'agit pas non plus d'une
convention de dénomination. Je l'appelle simplement objet de
domaine de base. Les gens l'appellent objet de données
basé, les gens l'appellent
objet de base, peu importe ce que c'est. Mais ce ne sera en fait
qu' un cours abstrait public. Je le rends simplement abstrait
parce que lorsqu'il est abstrait, je ne peux pas l'instancier
tout C'est vraiment une solution sûre pour moi, mais ce n'est pas
nécessairement Mais je vais prendre
cette propriété ID, placer dans l'objet de domaine de
base, puis toutes les autres entités pourront hériter de l'objet de domaine de
base Ainsi, je n'ai pas nécessairement à répéter les champs. Si le nom du champ change, du
moins les
champs communs à tous, je n'ai qu'à effectuer
la mise à jour à un seul endroit, mais tout le monde hérite
de cet endroit, donc tout le monde obtient le champ Très bien, donc je vais
juste faire ça pour longtemps. Donc, pas de match. Dispose par défaut d'une équipe de terrain dédiée aux identifiants. Et je ne vais pas le
supprimer de l'équipe, mais je vais
laisser l'équipe hériter Et puis ce que vous
allez remarquer maintenant est qu'il va
commencer à se plaindre du fait qu' il voit un identifiant à la fois ici
et dans la classe héritée. Cela signifie que je peux
supprimer l'identifiant de cette classe en toute sécurité. n'est donc qu'une petite astuce que vous
pouvez appliquer si vous ne vous
entraînez pas déjà pour vous
assurer de ne pas trop
répéter le code. D'accord ? Passons donc à autre chose. Nous
avons le Match ID. Maintenant, j'ai besoin d'une propriété qui
représente mon équipe locale. Je vais l'appeler
Home Team ID. Une fois de plus, cela
rompt avec la convention de dénomination. Dans la vidéo précédente,
j'aurais mentionné importance des
conventions de dénomination. Mais dans certaines
situations , vous
ne pouvez vraiment pas suivre la convention de dénomination,
car lorsque j'appelle l'équipe
locale et l'équipe visiteuse ID, CR ne sait pas ou ne veut
pas en déduire que cela signifie que je fais référence à l'équipe et que
je fais référence à l'équipe Nous verrons donc comment y
parvenir dans un instant. C'est bon. Donc, en ajoutant simplement le reste
des propriétés, j'ai ajouté les
propriétés de navigation qui
correspondront à
chaque clé étrangère. Nous avons donc la clé étrangère, nous avons la clé étrangère,
puis j'ai la date et l'heure. J'ai donc changé de date
plutôt que d'heure car la date peut
capturer la date et l'heure. Nous connaîtrons donc la date
et l'heure du match contrairement à mon
dessin initial, qui ne disait que l'heure. Maintenant que nous avons défini cette nouvelle
classe ou ce nouveau modèle. Nous savons que nous devons ajouter au contexte
de base de données. Nous
devons le lui faire savoir. Je vais juste le
dupliquer et ajouter le nouveau modèle à l'ensemble de bases de données
et je l'appelle matches. Mais je dois faire
quelque chose de plus. Donc, une fois de plus, j'ai
rompu avec les conventions de
dénomination recommandées. Je dois faire un peu plus
de travail pour qu'il sache que vous êtes censé
être une clé étrangère. Allons-y et
ajustons
le modèle d'équipe pour qu' le modèle d'équipe pour il sache qu'il
doit comporter deux listes, une liste appelée matchs à domicile et une liste appelée matchs à l'extérieur. Maintenant, souvenez-vous que nous avons fait
quelque chose de similaire pour une ligue. Nous avons une équipe qui fait référence
au classement. Nous savons donc qu'une équipe
appartient à une ligue. Cependant, une ligue
compte plusieurs équipes. De la même manière, un match peut avoir une équipe locale
et une équipe visiteuse. Donc, un, un à la fois
pour un enregistrement ou une ligne. Mais alors, une équipe peut disputer de nombreux
matches à l'extérieur et à domicile. C'est pourquoi nous devons nous
assurer mettre dans ces listes les propriétés
de navigation. Maintenant, sur cette base, nous devons faire
savoir à Entity Framework que tout ce câblage signifie qu'il existe une relation clé
étrangère entre l'équipe et le match. Jusqu'à présent, bien sûr, j'ai toujours oublié tout cela Donc, ce que je vais
commencer par faire c'est remplacer notre méthode de création de
modèles Nous avons donc la configuration. Cela signifie que chaque fois que
vous configurez le contexte, c'est
ce que vous devez faire. Eh bien, celui-ci dit que
chaque fois que vous allez
créer le modèle
ou effectuer une migration, la prochaine fois que vous
effectuerez une migration, assurez-vous que ces
règles sont en place. D'accord ? ne veut pas dire que chaque migration répétera le code correspondant, mais cela signifie simplement que chaque fois que
vous créez la base de données et que vous
manipulez la base de données, c'est
ce que je voulais faire. C'est donc pour cela que cette méthode
est vraiment là. Je vais donc supprimer
cette ligne par défaut, puis nous
devrons informer le constructeur
du modèle que notre entité est notre entité. Nous utilisons donc une API fluide à ce stade pour
définir certaines règles, et vous verrez pourquoi on l'
appelle API fluide. Donc notre entité s'est appelée team, et puis je suis juste train de franchir les limites pour
ne pas aller trop loin. Et nous allons dire point, puis vous verrez
un tas d'options ici. Maintenant, je me suis laissé
emporter et j'ai essayé
toutes les combinaisons, mais toutes ne
fonctionnent pas vraiment. Donc, tu dois juste
savoir ce que tu fais. Donc, dans cette situation, je
tiens à dire que mon équipe a beaucoup, d'accord. Ensuite, nous définissons simplement
une expression Lambda, point, et je vais dire matchs
à domicile Une équipe disputera
de nombreux matches à domicile. C'est vrai. Ensuite, nous passons
à la ligne suivante avec un. Ce que vous allez déduire
à ce stade, non, c'est que vous allez avoir de
nombreux matches à domicile avec un seul point, puis nous verrons des
propriétés provenant matches à domicile ou de
l'entité du match, vous voyez ça ? C'est pourquoi c'est
fluide, car chaque ligne est basée
sur la ligne précédente. Une équipe joue donc de nombreux matches à domicile, puis tous les matches ou un
match entier n'en compte qu'un seul, et je dois dire que si j'ai
affaire à des matches à domicile, elle n'a qu'une seule équipe locale. Hein ? Ensuite, je vais devoir le lui
dire et il contient à nouveau
une
expression Lambda à clé étrangère, M point, puis je pourrai spécifier quelle clé étrangère
facilite cela a plusieurs avec une seule relation
dont je parle Je vais dire que la
clé étrangère est l'identifiant de l'équipe locale. Et j'espère que vous
commencez à vous rendre compte que vous savez, nommer correctement vos colonnes. Si cela ne peut pas aider le FCR à
comprendre ce que vous voulez, cela vous aide à déterminer
ce que vous devez faire plus tard Je vais également
ajouter une contrainte pour indiquer que c'est obligatoire, et pour finaliser, je vais définir le comportement d'annulation. Nous avons déjà discuté
du comportement d'annulation lorsque nous savons qu'il s'agit d'une
configuration pour la base de données Je vais dire cascade. Cela signifie que si je supprime une équipe, je veux qu'elle soit suivie
de tous les matchs. C'est
peut-être ce que vous voulez
faire ou non , car
pour les archives,
vous voudrez peut-être conserver l'équipe et toutes les données du match à portée de main. Cela dépend de vous et de vos règles
commerciales, bien entendu. Je vais donc simplement répéter tout cela pour l'équipe visiteuse. Et vous verrez que
les deux sont identiques. La seule différence, c'est
que j'ai rangé les correspondances et mis de côté les colonnes où
elles étaient les colonnes d'accueil. Et c'est à
peu près tout pour définir les règles relatives
à ces trop nombreuses relations. Il y a donc plusieurs fois où vous devrez
peut-être vous salir
les mains comme ça. Dans cette situation,
il s'agit d'une situation tout à fait unique car d'une part, nous ne
suivons pas la convention de dénomination
avec nos clés étrangères, et deuxièmement, il s'agit de deux fois de la
même table associée à une autre table. Dans une autre situation,
disons, je vais juste vous donner
un scénario ouvert ici. Nous avions une table pour
ranger les produits. Nous avions une table pour
entreposer les clients, puis nous avons
une autre table pour stocker les produits que
les clients ont commandés. De nombreux clients peuvent
commander de nombreux produits. Cette
table intermédiaire doit donc contenir identifiant
du client et
l'identifiant du produit. accord ?
Réfléchissez à ce scénario. Maintenant, dans ce scénario, c'est
une belle relation propre. C'est une relation plus facile à définir que ce que
nous avons dû faire ici. Et puis dans cette
situation, vous suffit de placer la propriété de navigation par
liste
sur l' une ou l'autre table. Ensuite, le FCR
déduirait simplement qu' une
table des produits clients doit être générée Désolé, je viens de commencer, mais il devrait y avoir un tableau des commandes de
produits du client , par
exemple, à générer, car vous
venez de lui dire que le client aurait une liste de produits et que les produits auraient
une liste de clients. Il saura donc
automatiquement que je dois créer une
table intermédiaire pour un trop grand nombre,
et littéralement, ce serait
beaucoup si la liste était de trop. Il existe donc différents
scénarios et chaque scénario peut
avoir ses propres particularités. C'est une bizarrerie du scénario, et je pense qu'il est bon de choisir le scénario le plus difficile, car
au moins vous pouvez voir ce qui pourrait
être mis en place si vous rencontrez des difficultés et si votre scénario n'est pas
aussi simple qu'il pourrait l'être Maintenant que tout cela est
dit et fait, lançons notre
migration et voyons ce que nous allons obtenir. Voici donc notre fichier de migration. Il crée la
table appelée Matches. Nos colonnes
sont définies, puis les contraintes
imposées à l'équipe
indiquent nos relations
clés avec l' étranger, n'est-ce pas ? clé étrangère numéro
un se trouve donc entre les deux se trouve dans
la colonne AA
et elle se trouve entre les équipes.
Cet identifiant supprime en cascade, équipes.
Cet identifiant supprime en cascade,
et il en va de même
pour l'équipe locale C'est bon. Maintenant que
tout cela est fait, mettons à jour notre
base de données. C'est bon. Donc, si vous avez mis à jour votre base
de données comme je viens de le faire, vous auriez
obtenu cette erreur. Si tu ne l'as pas fait,
envoie-moi un message et dis-moi que
tu ne l'as pas fait. Mais ce message vient d'arriver, et comme je l'ai déjà dit, je ne vais pas éviter les
erreurs, car c'est le genre de choses qui font
peur aux gens face à ce type
de technologie Il nous dit donc qu'il n'a pas réussi à exécuter la
commande DB, à créer la table. Et si je fais défiler la page vers le
bas, cela signifie que
j'introduis une contrainte ou que j'introduis cette contrainte, cela peut provoquer plusieurs cycles ou
plusieurs chemins en cascade. En d'autres termes, cela
signifie que le fait d'avoir ce référentiel, la cascade d'actions de
suppression, sur ces deux clés étrangères peut poser problème à la structure de la
base de données Peut-être qu'en concevant
la base de données manuellement, vous pourriez
probablement contourner ce problème, car SQL Server ne m'
a jamais averti directement à
ce sujet, mais FCR
vous fait simplement savoir que cela peut
poser problème et qu' une erreur s' est produite en essayant de le
faire pour vous Donc, ce que nous pouvons faire et ce que nous allons faire, c'est simplement supprimer
cette migration pour le non, et suite à la suggestion de l'EFC selon
laquelle ce
comportement de suppression est problématique, je vais simplement créer une restriction En d'autres termes,
vous ne pouvez pas supprimer une équipe si vous
n'avez pas supprimé tous
les matchs auparavant. C'est bon. Et je vois où cela est
raisonnable, parce que lorsque
je disais tout à l'heure que vous supprimez une équipe
et que cela
efface automatiquement les matchs, cela
peut poser problème, n'est-ce pas ? Et surtout lorsqu'
une équipe peut figurer sur l'identifiant de l'équipe locale
ou sur l'identifiant de l'équipe A. Et puis, vous savez,
cela finira par supprimer les données des équipes qui
sont toujours dans le système. C'était donc un mauvais
choix de design de ma part. Pas de problème I R nous a prévenus,
mais encore une fois, je veux juste vous aider à comprendre ce que signifie réellement cette
erreur. Donc, si vous voyez ce genre
d'erreur survenir, c'est peut-être parce que nous devons modifier ce comportement de
suppression. N'oubliez pas que ce sera
en cascade par défaut. Donc, même si nous n'avions pas
défini la cascade ici, vous auriez probablement
toujours eu cette erreur. Il est donc important de
comprendre comment atténuer cette
erreur si vous la recevez. Essayons donc d'ajouter à nouveau
cette migration. Et cette fois, vous le voyez
dire que c'est restreint. C'est très bien Laissez-nous
mettre à jour la base de données. Et cette fois, j'ai
terminé et
en le regardant dans notre explorateur de
serveurs d'objets SQL, nous constatons que nous avons
notre identifiant et que
nos deux colonnes de clés étrangères ne sont pas lisibles C'est une façon d' établir une petite relation. Comme je l'ai dit, cela peut varier
en fonction de votre situation. Compte tenu de la structure
de la base de données, c'est
ce que nous avons
dû faire pour accomplir tout cela. Il s'agit bien entendu de
directives générales. Lorsque vous créez votre relation
beaucoup trop nombreuse, vous pouvez essentiellement suivre ces directives et
vous serez en mesure créer, aussi compliquée ou
simple que cela puisse être.
21. Ajouter des relations d'un à un de l'un, de l'un, de l'autre.: Salut, les gars, nous
reviendrons dans cette leçon, nous parlerons de mappages de tables
un à un ou de relations
un-à-un J'ai donc déjà
créé un nouveau modèle d'entité, et nous appelons un entraîneur,
et un entraîneur sera utilisé pour décrire le face-à-face avec une équipe,
car dans notre situation,
dans notre base de données, un entraîneur ne
peut appartenir qu'à une
seule équipe à la fois, et bien sûr, à une équipe Il a un entraîneur, non ? Mais si l'entraîneur
est renvoyé demain, disons simplement
que cette équipe n'a
peut-être pas d'entraîneur et que cet entraîneur n'en a
peut-être pas. Donc, vous savez, ce type de
règles ou de contraintes commerciales
uniques
peut influencer les règles que
nous introduisons ou la conception de notre
base de données. Alors allons-y. coach
hérite déjà de l'
objet de domaine de base. Comme nous l'avons dit, l'objet de domaine de
base fournit cette propriété ID par défaut . Nous pouvons
donc nous concentrer sur toutes les autres propriétés plus spécifiques
au coach Ainsi, la première propriété
d'un autocar, comme vous l'auriez probablement
deviné, serait son nom Maintenant, je ne vais pas trop me
compliquer la tâche avec la base de données, mais nous savons que nous avons
un entraîneur, un entraîneur aura un nom. Pour le moment, je
ne vais
pas inclure plus de détails
sur cet entraîneur. Mais je vais inclure le fait que cet entraîneur possède une
propriété appelée Team ID. Cet identifiant d'équipe, comme son nom
l'indique,
sera donc la
clé étrangère de la table d'équipe. Maintenant, notre
équipe ou la table de notre équipe doit comporter une représentation
d'un entraîneur. Et ce que je vais
faire ici, en restant
très simple, c' est simplement faire
référence à l'entraîneur. Donc, juste comme ça, l'entraîneur va faire partie
d'une équipe ou, vous savez, être
apparenté à une équipe, et l'entraîneur, et l'entraîneur la table des entraîneurs, sait également
que c'est lié à une équipe. Je vais le rendre nul. Quand je
parlais des règles, etc.,
j'ai évoqué le scénario selon lequel l'entraîneur peut figurer dans le tableau
sans avoir d'équipe. Donc, si je ne le
rends pas nullable, alors cela sera nécessaire. Ce n'est pas toujours obligatoire,
car s'il se fait virer, il
restera entraîneur sans équipe. Je le rends donc gérable afin que la migration sache
que dans la base de données, cela peut être nul même temps,
dans notre tableau d'équipe, rien qu'en faisant cela,
il sait que, accord, cela peut être annulé, il n'aura
donc pas à faire d'efforts
supplémentaires pour cela Maintenant, les
propriétés de navigation vous
aident à nouveau à obtenir les détails
des entités associées Ainsi, quand j'ai une équipe, je peux obtenir les détails
de la ligue dans laquelle elle se trouve. Je peux obtenir les coordonnées
de l'entraîneur. Et je peux obtenir toutes les
allumettes s'il le faut. Du point de vue des entraîneurs, si je regarde l'entraîneur, il me
suffit de
fournir un identifiant d'équipe. Donc, si je le voulais, je pourrais inclure une propriété de
navigation, je vais simplement copier-coller pour avancer plus rapidement Je pourrais simplement inclure cette propriété de navigation de l'équipe ici afin que,
si je trouve un entraîneur, je puisse également inclure les détails de
l'équipe, de tous les matchs
et tout le reste, n'est-ce pas ? Examinons donc
la migration que nous
pouvons générer à partir de cela. Très bien, ma migration
a donc ajouté l'équipe d'entraîneurs une à une. Notre migration est donc générée, et nous pouvons simplement y jeter un
coup d'œil et voir que
nous obtenons la nouvelle
table appelée coach. Et si vous l'avez remarqué, nous avons en fait sauté l'une
des étapes les plus vitales Je ne sais pas si vous l'avez remarqué, mais nous avons ignoré
ce que je
lui ai enseigné comme étape vitale
vers la création d'une table, à savoir l'inclure
dans notre contexte de base de données Nous n'avons pas inclus
notre nouveau tableau appelé coach ou coachs
dans notre contexte de base de données. Regardons donc cela maintenant. Le fait que j'aie indiqué à une table qui se trouve dans
le contexte de la base de données, qu'elle fait référence à cette
classe ou à une autre classe, la migration ou, bien sûr, à
la migration ou, bien sûr,
va simplement
permettre de créer une table qui représente le nom de cette table. Ce nom est donc généré en fonction du
nom de la propriété, qui est coach. Ce n'est donc peut-être pas la meilleure
approche si nous voulons standard convention de dénomination standard,
car jusqu'à présent, nous avons toujours pluralisé
chaque nom de table Je souligne donc simplement
qu'en ajoutant cette propriété de
navigation, EFCR
insérera ou créera automatiquement toute
cette migration autour création d'un tableau pour cette propriété de
navigation Je vais donc simplement supprimer
la migration,
car nous voulons en
quelque sorte rester standard. Et je vais l'ajouter
au contexte de la base de données. Nous avons donc une table appelée Coach. Refaites la migration,
et nous pourrons nous sentir un peu mieux avec
ce qui est généré Je ne fais donc que
souligner certaines choses que FCR fera en quelque sorte dans les
coulisses, même
si vous manquez une étape Vous devez donc être un
peu délibéré,
mais la FCR va faire
certaines suppositions pour vous en fonction de la façon dont elle
sait qu'elle doit fonctionner Allons-y, mettons à jour
le et c'est fait. Je tiens donc simplement à
souligner que l'index de création est un peu différent de ce que nous aurions pu voir
jusqu'à présent, et qu'il possède un filtre. L'identifiant de l'équipe n'est pas nul. Donc, rien qu'à y regarder, vous vous demandez probablement, d'
accord, ce que cela signifie, autant plus que nous avons indiqué au tableau que l'
identifiant de l'équipe est nullable Eh bien, si nous examinons
l'instruction qui a été générée pour
l'index de création, nous créons l'index unique sur cette colonne lorsqu'
il n'est pas nul. Donc, une fois qu'il y a une valeur, cela signifie
que vous ne pouvez pas répéter cette valeur à un autre entraîneur. C'est à peu près
ce qu'il dit, mais il est autorisé à
être nul malgré tout. OK. C'est donc vraiment tout pour
établir une relation individuelle. Encore une fois, le
scénario
serait que vous
sachiez que vous ne voulez qu' une entité soit associée
une seule fois à une autre entité. Et il existe différents
scénarios lorsque vous entretenez
des relations individuelles. Il se peut également que l'un
soit entièrement
dépendant d'un autre, ce qui signifie qu'il peut s'agir d'un scénario dans
lequel nous voulons avoir
un entraîneur dans le système uniquement lorsqu'
il est associé à une équipe. En plus d'être
associé à une équipe, il ne devrait pas figurer dans la base de données. Vous avez donc
également ce scénario, mais encore une fois, vos règles commerciales et
vos exigences détermineront les
décisions que vous prendrez lors de votre conception.
22. Générer un nouveau diagramme d'entité: Salut, les gars, bon retour.
Il s'agit d'une courte vidéo. Je veux juste vous montrer comment vous pouvez mettre à jour le schéma de votre
base de données. Nous avons donc apporté un
certain nombre de modifications. Nous avons ajouté de nouvelles tables,
ajouté de nouvelles relations, et je veux simplement
vous montrer comment vous pouvez mettre à jour la représentation visuelle de votre base de données. Et
c'est assez simple. Comme
la première fois, il vous suffit de répéter cette étape créer un nouveau
diagramme et le modifier pour vous. Il vous suffit donc de
cliquer avec le bouton droit sur votre projet. Vous allez de l'avant et
allez dans FCR Power Tools, ajoutez un diagramme de contexte de base Il va simplement
en générer un tout nouveau pour vous, et vous le verrez ici. Nous avons donc nos nouvelles entités
sous la forme d'entraîneur, et vous remarquerez que
les flèches
vous montrent la cardinalité de
ces relations Vous pouvez
donc voir dès
le départ que cela est considéré comme un contre
un par FCR C'est un de trop, et c'est aussi un de trop. Vous remarquerez également que les
propriétés de navigation ont été mises à jour lorsqu'un match oppose une équipe
visiteuse à une équipe locale. Cependant, l'équipe a
des listes de matchs à l'extérieur. Et bien entendu, si vous
survolez l'un de ces
blocs ou propriétés, ils vous indiqueront quelle catégorie est la collection de navigation, fonction de la correspondance, et
son type est la liste de correspondance Il s'agit donc d'un excellent diagramme de
référence à donner à quelqu'un qui ne
comprend pas nécessairement ou qui ne veut passer au
peigne fin chaque classe pour
voir exactement ce qui se passe. Ce joli diagramme d'ensemble est un excellent moyen de
se familiariser avec ce qu'est la référence et comment ces relations se
forment.
23. Inserter des données liées à l'insertion: Salut, les gars,
bienvenue dans cette leçon. Nous allons passer en revue
quelques exemples de situations dans lesquelles nous devrons ajouter des enregistrements
ayant des relations. Tout à l'heure, lorsque nous avons
examiné nos scénarios d'insertion, nous en avons examiné un,
et je l'ai répété ci-dessous, qui consiste à ajouter de nouvelles
équipes par ligue. Dans ce scénario, nous avions une
ligue qui n'existait pas encore, puis nous avions une équipe, qui n'existait pas encore non plus, où la création, n'est-ce pas ? Ensuite, nous avons ajouté cette équipe
en transmettant l'objet de la ligue. Ensuite, nous avons remarqué que lorsque nous avons appelé Ajouter et enregistrer les modifications, cela s'est
passé, c'est que cela a créé la ligue qui
n'existait pas encore, puis
qu'il a
automatiquement inséré cette
relation clé étrangère avec l'équipe. Vous pouvez donc revoir
cette vidéo d'insertion et
revoir ce qui s'est passé lorsque
nous avons effectué cette opération Maintenant, j'ai quelques
autres scénarios que nous
voudrions examiner. La première est lorsque nous ajoutons une nouvelle
équipe avec l'identifiant de la ligue. Et je pense que celui-ci est probablement scénario
plus révélateur de ce qui se passerait dans
une situation logicielle. Maintenant, lorsque nous
ajoutons une nouvelle équipe, ajoutons une nouvelle équipe avec un identifiant de ligue, c'est probablement ce qui va
se passer , peut-être depuis une interface
Web, n'est-ce pas ? Quelqu'un saisit
le nom d'une équipe, puis il indiquera
probablement quelle ligue
appartient cette équipe par le biais d'
une liste déroulante Vous auriez donc
ce scénario si
vous demandiez à l'utilisateur de
saisir les deux en même temps,
en saisissant le l'équipe
et le nom de la ligue. Alors oui, vous pouvez créer
manuellement
les objets, puis enregistrer les modifications et
les deux être validées. Un autre scénario plus pratique serait que
vous ayez la liste des ligues et que, lorsqu'ils
sélectionnent une ligue dans cette liste , ils vous parvenir
l'identifiant de la ligue
sélectionnée ainsi que sélectionnée ainsi le nom de l'équipe à
laquelle ils participent. Nous avons donc déjà quelques
ligues dans notre base de données. Laisse-moi juste aller les
chercher rapidement. Nous pouvons donc facilement
simuler quels identifiants
seraient les identifiants potentiels parmi lesquels
un utilisateur pourrait choisir. Supposons donc qu'ils souhaitent ajouter une nouvelle équipe de football de Serre. Notre code
ressemblerait alors davantage à ceci. Nous n'aurions pas à créer
cet objet de ligue, mais nous créerions l'équipe, puis nous transmettions
l'identifiant de ligue de huit. Dans ce scénario, la
ligue existe donc déjà. Nous savons que c'est une pièce d'identité. Nous l'
ajoutons à l'équipe. Nous ajoutons le nom
à cette toute nouvelle équipe, et cette équipe
ira à la Fiorentina, puis nous pourrons
l'ajouter, et cette relation
sera alors Maintenant, l'un des avantages d'
avoir des relations, eh bien, les bases
de données
relationnelles sont conçues pour renforcer cette
cohérence dans leurs données Nous réduisons
considérablement le risque, s'il
existe toujours , d'
associer une ligue qui n'existe pas à une équipe J'ai donc déjà examiné le fait que nous effectuions une suppression en cascade. Si nous supprimons la ligue, toutes les équipes seront
supprimées, n'est-ce pas ? Mais je ne peux pas ajouter une équipe liée à une ligue
avec un ID de 50 alors
que nous avons vu
que huit était le maximum. CO, eh bien, la base de données elle-même rejettera que le
COR essaie de
le faire, la base de données donnera une erreur, puis
elle la renverra C'est donc l'un des avantages
de l'application de ce type d' intégrité référentielle
forte
dans vos tables Il y a des gens
qui n'aiment pas ça, mais vous utilisez une base de données
relationnelle Utilisez-le à votre avantage. Très bien, donc ce premier scénario. Orwell deux, le
premier scénario était celui où nous pouvions simplement
mettre l'objet entier et ajouter les deux et la relation
aurait été créée ou les données correspondantes
auraient été créées
en arrière-plan Notre autre scénario,
plus pratique, serait celui
où nous obtiendrions l'identifiant de l'enregistrement associé,
puis que nous le transmettions à l'enregistrement que
nous avons l'intention de créer. Maintenant, notre prochain scénario
serait celui où nous voudrions ajouter une nouvelle ligue avec des équipes. Encore une fois, il peut s'agir d'un scénario dans lequel vous créez la ligue
et, vous savez, vous donnez à l'utilisateur la
possibilité d'ajouter une nouvelle ligue, d'ajouter toutes les équipes
, puis de les soumettre une seule fois. Cela signifie donc que dans cette situation, vous devez créer
l'objet pour la ligue et
informer les équipes qu'il l'a fait Tout comme le
contexte publicitaire aurait ajouté nouveaux objets aux
deux objets puis
configuré les valeurs relationnelles, scénario
serait le
même ici J'ai donc déjà
utilisé cette fonction
qui ajouter une nouvelle
ligue avec des équipes, puis une équipe R équivaut
à une nouvelle liste d'équipes. Disons donc que c'est
ce que l'utilisateur a soumis, ainsi que le nom
de cette nouvelle ligue. Vous pouvez donc voir que je le
copie et le colle, n'est-ce pas ? Cette nouvelle ligue est donc la CFA, abréviation de Man Island
Football Association Travaillons avec ça. Et voici quelques-unes des
équipes qui participeraient à la CFA. Ainsi, lorsque nous ajouterons cette nouvelle ligue, qui est un objet de
type ligue et qui
a son nom et
sa liste d'équipes, Entity Framework fera le
reste lorsque nous enregistrerons les modifications. Dans le scénario suivant,
nous cherchons à créer des enregistrements pour nos
nombreuses tables. N'oubliez donc pas que les
matchs représentent notre tableau principal où de nombreuses équipes joueront
contre de nombreuses équipes, n'est-ce pas ? Cette fonction
définit donc simplement une liste de types de matchs, et elle contient quelques matchs
avec l'identifiant de l'équipe visiteuse, l'identifiant de l'équipe
locale et la
date du match. accord ? Maintenant, je
fais un peu deux pour le prix d'un ici parce que nous cherchons
un moyen de créer un record pour
le plus grand nombre. Et n'oubliez pas que notre table match ou notre table many many aurait
généralement l'ID ainsi que la propriété
de navigation. Donc, de la même manière que nous
pourrions saisir l'objet pour la
propriété de navigation et ajouter à la base de données,
il en va de même ici. Mais dans un scénario plus
pratique, ces équipes
existeraient déjà au moment où
nous ajouterons un match. Nous devons donc nous assurer
que nous
référençons correctement les identifiants. Avec une
interface utilisateur, bien entendu, vous limitez les
valeurs que l'utilisateur peut saisir à des valeurs
qui sont plus que susceptibles d'être des valeurs
valides afin de réduire
les risques que la base de données
tente de saisir les enregistrements accord ? C'est donc la première partie des 241 de ce scénario. La partie suivante est le fait que
j'utilise cette plage d'ajout. Donc, Ponto, nous n'avons toujours fait
que de la publicité. Hein ? Ajouter représente un. Nous ne transmettons qu'
un seul objet lorsque nous disons «
ajouter » ou « ajouter une synchronisation ». Cependant, lorsque nous disons « ajouter
une plage » ou « synchroniser une plage », nous pouvons transmettre une
collection de valeurs, qui seront toutes
ajoutées une fois les modifications enregistrées. Ainsi, traditionnellement,
dans les anciennes versions, vous le
mettrez probablement dans une boucle pour chaque boucle et pour
chacune des boucles de la liste, vous ajoutez, ajoutez, ajoutez
puis enregistrez les modifications. Maintenant, dans notre scénario final, il ne se passe rien de vraiment
spécial ici. Nous savons déjà
comment ajouter un enregistrement. Et le fait que
nous ayons
une relation individuelle dans
ce scénario ne change rien au fait qu'
il s'agit du même bit de code pour simplement ajouter un enregistrement. Nous avons donc un entraîneur s'
appelle Joseph Marino, et il va
entraîner l'équipe ID 3. Maintenant, n'oubliez pas qu'il s'agit
en fait d'un champ viable. Supposons donc que nous avions deux entraîneurs et que l'un d'eux
n'ait pas d'équipe. Je vais donc
dire Antonio Conte, et cet entraîneur n'a pas d'équipe,
n'est-ce pas ? De la même manière que je peux ajouter Joseph Marino
avec l'identifiant de l'équipe, je peux ajouter Conte
sans l'équipe. La seule chose, c'est
qu'il sera un peu orphelin. Il
existera dans la table, mais il n'a aucun
lien avec une équipe Donc, dès qu'il sera embauché, nous mettons simplement à jour son dossier et il aura le
dossier correspondant pour l'équipe. En l'état actuel des choses, si je l'exécute nous verrons que les deux entraîneurs seront inscrits
sans
aucune erreur. Antonio sans son identifiant d'équipe, ainsi que Joseph
Marino avec le sien. J'avais donc commenté
les autres fonctions. Permettez-moi de décommenter, puis
nous allons simplement
les exécuter tous et voir exactement
ce qui se passe dans le code Essayons donc encore une fois. Très bien, donc tout s'
est passé sans Terre. Nous voyons donc que nous ajoutons la
Bundesliga au sommet. Nous ajoutons Barn Munich, nous ajoutons Florentina,
nous ajoutons CFA Vous pouvez donc voir que même
lorsque nous avons regroupé les objets,
le FCR, une fois de plus,
savait intelligemment lequel était la dépendance Insérer qui obtenait son identité de
portée, puis l'utilisait pour insérer
tout ce qui y Nous voyons donc que nous ajoutons
Rivoli United aux côtés de CFA. Le CFA a donc un identifiant de 11, et c'est pourquoi Rivoli et
Waterhouse Dans ce scénario, nous
ajoutions une ligue à
la liste des équipes. Pour celui avec les matchs
où nous avons ajouté de la portée, vous voyez qu'il suffit
de passer en revue et ajouter individuellement. Vous vous demandez probablement
pourquoi il n'a pas simplement créé une instruction d'insertion
et ne l'a pas fait ligne par ligne. Eh bien, cela revient
aux opérations en masse. La FCT a décidé qu'à moins avoir affaire à un
certain nombre d'enregistrements, regroupement de ces commandes
n'en valait probablement pas la peine C'est pourquoi, pour des commandes
plus petites
ou un plus petit nombre d'enregistrements, vous verrez des instructions
SQL individuelles exécutées pour celles-ci. C'est donc
tout pour ce qui est de la façon dont
nous pouvons insérer des données connexes Encore une fois, cela peut sembler
peu intuitif, car nous codons les données en dur et nous utilisons une application
console Mais dans un scénario d'
application Web, n'oubliez pas que vous
auriez fourni à votre utilisateur un formulaire, ce qui
vous aurait permis de le limiter ou de le restreindre pour qu'il n'
insère que les valeurs de données dont
vous savez avoir besoin pour effectuer
les opérations de sauvegarde. Ainsi, lorsqu'ils remplissent
ces formulaires et les soumettent, vous extrayez ces données. S'ils étaient en train de créer une nouvelle ligue avec une
liste d'équipes, eh bien, nous verrons comment nous pouvons y
parvenir assez facilement. Hein ? Ce ne sont que
des directives ce qui peut se passer
dans le back-end Une fois que vous avez
les données que le formulaire ou l'utilisateur aurait
préféré
soumettre via un formulaire, vous savez comment les créer, puis les envoyer à FCR et laisser FCR
faire le reste.
24. (Chargement à (Eager Inclut les données liées: Salut, les gars,
bienvenue dans cette leçon, nous allons voir
comment récupérer données de plusieurs tables
en utilisant une seule commande. Dans
ce cas, vous pourriez
avoir un rapport ou
un affichage de données à réaliser,
mais que les données
que vous devez
afficher soient ensuite réparties sur plusieurs tables. Tout d'abord, c'est
là que
l'intégrité référentielle entre en jeu, car vous savez que vous pouvez
toujours aller chercher
les données
associées dans une autre table Mais si vous connaissez
le qua traditionnel, vous saurez également
que vous devez effectuer ou l'autre forme de jointure. Cela peut être juste,
cela peut être gauche, cela peut être inerique, mais vous
devez effectuer une forme de jointure dans cette requête pour
récupérer les données associées Ce n'est pas très
différent de ce que nous
aurions vu avec nos
simples requêtes de sélection, sauf que nous allons
examiner quelques points supplémentaires. J'ai donc la simple
requête de sélection ici à titre de référence, et nous savons que nous l'
exécutons avec elle pour répertorier, et c'est ainsi que nous obtenons nos données. Jetons un coup d'œil à
certains scénarios que j'ai élaborés
pour voir comment nous pouvons contourner
le concept global
d'inclusion de
données connexes ou de chargement rapide. Donc, tout d'abord, nous
allons voir comment nous pouvons obtenir de nombreux enregistrements
connexes. Et le scénario
est le suivant : et si nous voulions obtenir toutes les
ligues et toutes les équipes ? Et pensez simplement à afficher ces données à un utilisateur, n'est-ce pas ? Vous avez la liste des ligues et peut-être que lorsque
vous cliquez sur la ligue, vous voyez les équipes. D'accord ? Vous voulez donc
récupérer toutes les ligues et toutes les équipes qui leur sont
associées, peut-être en un seul appel Pour une raison ou une autre,
votre scénario pourrait déterminer pourquoi vous auriez besoin d'écrire
ce type de noyau. Il n'y a aucun problème. Entity Framework Core nous
permet de tout faire. Donc, ce que nous ferions, c'est
comme une simple sélection, nous allons dire que les
ligues sont égales à, puis nous attendons notre contexte, qui
appellera nos ligues, puis nous allons simplement dire «
à la liste ». C'est donc ce que nous
ferions pour obtenir les ligues. Maintenant, nous voulons les équipes
associées aux ligues, n'est-ce pas ? Donc, avant notre liste de tâches, nous avons une autre fonction que
nous pouvons utiliser appelée include. Include nous permet d'insérer
une expression Lambda. Vous voyez donc comment fonctionnent les
expressions Lambda. Non, vous voyez qu'ils ne sont pas
propres aux filtres, etc. Certaines fonctions utilisent
des expressions Lambda. Et vous pouvez toujours savoir qu'une expression
Lambda va être utilisée en fonction du type de données, qui est Expression Funk, puis vous verrez la ligue ou l' objet de
la
table sur laquelle vous vous trouvez accord ? Nous disons donc
essentiellement : que voulez-vous que j'inclue ? C'est ce que cela
demande en ce moment, et je voudrais inclure un point Q, puis je dirais équipes. Donc, dès le départ, nous allons voir cette
carrière être exploitée pour nous
redonner, en gros, une étoile
sélectionnée parmi équipes dont
les jointures
intérieures l'identifiant de ligue ou à l'identifiant de ligue ou dans le tableau des équipes, correspondant à l'identifiant
de ligue indiqué dans le classement des ligues. Jetons donc rapidement un
coup d'œil à cette instruction SQL générée. Et là, nous voyons select, puis il répertorie toutes les
colonnes des deux tables. Donc, ligues est L, et équipes est T, donc il sélectionne toutes les
colonnes entre L et T, puis il va
rejoindre les équipes dont l'identifiant de ligue correspond à
l'identifiant de ligue par équipes. Ainsi, grâce à cette intégrité
référentielle que nous avons imposée, F C sait clairement comment formuler cette requête
pour savoir quelles colonnes doivent être mappées les unes aux autres
dans cette jointure gauche Notez qu'il utilise une jointure gauche. Cela signifie que s'il y a
une ligue dans la
base de données qui
ne compte aucune équipe parce que nous
interrogeons le classement, elle la
ramènera Cependant, l'
objectif de l'équipe sera. Permettez-moi donc de mettre un point de
rupture à la fin
de cette exécution. Vous pouvez donc voir à quoi
cela ressemblera. Voici donc les données
renvoyées dans cet objet de ligue. Et si je développe,
vous verrez l'ID 2, Red Star Premier League et
les équipes qui jouent dans cette
Reds Premier League, ainsi que tous les détails. Cette équipe n'a donc pas d'entraîneur. Il porte l'ID 7. Vous voyez qu'il est lié
à League avec l'identifiant deux, et vous pouvez obtenir le nom. Donc, juste là, vous pouvez écrire « point de
ligue » point « équipes et cela permet d'accéder à
tout ce que vous voulez depuis
l'objet de la ligue. C'est donc le pouvoir
de notre empressement à charger. Nous avons donc
d'autres exemples que nous voulons examiner
juste pour vous montrer comment
vous pouvez combiner
et les différentes choses que vous pouvez faire en
fonction de votre situation. Nous avons donc cherché à
obtenir de nombreux disques avec leurs nombreux
enregistrements connexes, n'est-ce pas ? Nous avons donc accès à toutes les ligues et la liste des équipes par ligue. Ce n'est peut-être pas le cas.
Peut-être que vous ne voulez obtenir un seul enregistrement et un enregistrement
connexe ou, vous savez, une liste d'enregistrements
connexes, mais un seul enregistrement. Dans cette situation, nous voulons obtenir les coordonnées d'une équipe
et de l'entraîneur. Donc, pour celui-ci, je
dois dire que notre équipe est à la hauteur, et nous attendons le contexte. Comme on appelle nos méthodes ici. Donc, si vous y regardez le contexte, les équipes incluent des
points. Mais comme nous l'avons établi, même lorsque nous parlons d'équipes à points
contextuels, cela ne fait rien tant que nous n'avons pas
activé cette commande d'exécution. Maintenant, j'ai dit que je
n'en voulais qu'un. Et si vous vous en souvenez, le
moyen d'en obtenir un serait soit unique, soit par défaut, soit par le premier
ou par défaut. Dans ce cas, je vais
mettre en premier ou par défaut. Je veux donc une équipe avec
un identifiant, disons, deux, et l'entraîneur de
l'équipe avec un identifiant deux. Ou disons trois. Je crois que j' ai fait venir le coach avec le numéro trois. Nous pouvons juste y retourner et vérifier. Alors faites équipe avec ID
Three. Nous y voilà. Je vais donc dire point include puis mettre ma commande d'
exécution,
qui est, dans ce cas, première étoile par défaut parce
que c'est l'exécution. Je n'en veux qu'une. La
première étoile par défaut prend donc l'expression Lambda dans laquelle
je vais spécifier que je veux que l'équipe dont l'ID soit
égal à. Trois. C'est bon. C'est ainsi que vous
enchaînez ces commandes. Je franchis juste les
limites pour que vous puissiez voir où commence réellement
chaque fonction, n'est-ce pas ? Donc, contextualisez les équipes Trouvez-moi toutes les équipes. Veuillez inclure le coach, mais je ne veux que
le premier ou
celui par défaut dont l'identifiant est
équivalent à trois. Voyons donc ce que nous obtenons lorsque nous
exécutons celui-ci. Très bien, donc Q qui est généré est assez
simple. Sélectionnez le haut, et nous voyons le même type de jointure
en cours. Donc, en raison de la première valeur par défaut, nous sélectionnons la clause supérieure, puis nous avons cette clause
were à
filtrer jusqu'à ce que l'
identifiant de l'équipe soit trois. J'espère donc que vous voyez le thème
commun passer en revue. Je suis donc de retour dans le code
ou dans la fenêtre de la montre. Et vous voyez ici cet autocar, la propriété de navigation contient
tous les détails de l'autocar. C'est donc le pouvoir
de notre inclusion. Et je
tiens à souligner une chose, qui peut être
frustrante si vous ne vous
rendez pas compte de ce qui se passe. L'endroit où vous placez la
première ou la valeur par défaut dépend en grande partie du
fait que l'instruction fonctionnera ou non. Cela ne fera que vous donner une erreur. Donc, si je place les
équipes de points contextuels en premier ou par défaut, je ne peux pas faire d'inclusion après une première ou une équipe
par défaut,
car une première ou une équipe par défaut
en fait un objet de type équipe, je ne peux pas faire d'inclusion après
une première ou une équipe
par défaut,
car une première ou une équipe par défaut
en fait un objet de type équipe,
et ensuite je ne peux accéder
qu'aux propriétés. Comme j'utilise la synchronisation A
qui n'apparaît pas
clairement, alors laissez-moi
retirer l'ASIC et vous le montrer Quand je dis point, je ne reçois en
fait que
les propriétés, l' identifiant des matchs à
domicile, n'est-ce pas ? Donc, si c'est ce qui arrive si c'est ce qui vient
après le premier ou par défaut, il
est clair que l'option include ne figure pas dans cette liste. Nous nous retrouvons donc avec cette erreur de
syntaxe à ce moment-là. À mes débuts,
je n'appréciais pas grand-chose, et j' avais l'habitude de penser que le framework d'
entités était bogué, mais c'est vraiment l'
ordre qui compte, n'est-ce pas ? Vous voulez donc effectuer toutes les tâches liées à la
base de données, puis vous devez laisser votre instruction d'
exécution pour la fin. C'est bon. Encore une fois, nous
allons sélectionner les équipes,
inclure l'entraîneur, puis d'abord ou par défaut, et ces lignes rouges
sont dues au fait que j'ai besoin de la synchronisation A,
et c'est parti. C'est bon, les gars. Donc, pour
notre prochain scénario, nous allons
examiner l'inclusion des petits-enfants. Donc, lorsque nous
parlons de petits-enfants, c'est juste une question
de hiérarchie. La première table que nous interrogeons, disons
que c'est le parent Ensuite, la première table
ou la table suivante que nous incluons est celle de l'enfant. Mais alors nous pouvons avoir
plusieurs inclusions. Tous les enfants
ont donc des relations clés étrangères
directes avec relations clés étrangères
directes la table principale interrogée Ce sont donc des enfants. Vous pouvez donc avoir plusieurs
inclusions uniquement pour les enfants. Cependant, il
se peut que vous ayez besoin de
données supplémentaires de la part de l'enfant, puis que vous
deviez consulter un autre tableau lié à cet enfant. Dans cette situation, il va donc falloir
avoir des matchs en équipe puis des matchs. Et puis, quand nous avons
les matches, vous savez, rentrons chez
nous,
soit nous jouons à l'extérieur. Mais ensuite, nous avons besoin
des informations sur l'équipe adverse. Donc, si je suis l'équipe locale, j'ai besoin
des informations sur l'équipe visiteuse. Si je suis l'équipe visiteuse, j'ai besoin des coordonnées
de l'équipe locale. Je vais donc devoir passer aux petits-enfants,
car
les matchs
auront les propriétés de navigation de l'équipe locale
et de l'équipe visiteuse. Donc, encore une fois, nous laissons notre méthode d'
exécution pour la fin, et nous faisons toutes nos inclusions avant d'en appeler la
dernière partie. Je vais donc
commencer par quatre ou quatre matches à l'extérieur.
C'est bon. Je suis donc l'équipe numéro un. Nous voulons voir tous
les matchs des AA. Et puis on peut le voir. Mais lorsque nous incluons
les matchs à
l'extérieur, nous ne voyons que
les détails de l'équipe que nous avons choisie, mais je ne sais
rien d'autre que l'identifiant de l'équipe locale. Je peux donc enchaîner et dire, puis inclure puis
inclure me donne accès aux propriétés
de l'enfant. Donc include m'a donné accès à la propriété de navigation de la table ou à l'objet
qui représente la table. Je m'ai donné accès à cette propriété
de navigation. Maintenant, je souhaite inclure une propriété de navigation
dans cet enfant. Je peux donc dire d'inclure et d'utiliser à
nouveau l'expression Lambda et de dire point Q, et je pourrai rechercher l'équipe
locale. Nous y voilà. J'ai donc des matchs
de jour et des matchs à l'extérieur, qui sont de type match. Je souhaite inclure des informations
sur l'équipe locale. OK. D'un autre côté, et je l'ai dit plus tôt tous les enfants peuvent être
inclus côte à côte. Donc j'ai cette inclusion, puis j'ai ceci
alors inclus, n'est-ce pas ? Donc, ce que je vais faire, ne pas
embrouiller les choses. Permettez-moi de vous montrer
plusieurs inclusions pour plusieurs
propriétés de navigation avant vous montrer les petits-enfants. Nous venons donc de voir un exemple
du petit-fils, n'est-ce pas ? Mais je prends
juste du recul et vous
montre que
vous pouvez dire « inclure autant de fois que nécessaire pour inclure des propriétés directement
liées. Je peux donc dire :
trouvez-moi les équipes et pour
chaque équipe, vous me
permettez d'obtenir ses matchs et
tous ses matches à domicile. Mais encore une fois, lorsqu' il s'agit d'un match à domicile
ou d'un match à l'extérieur, j'ai besoin
des informations sur l'équipe locale. Quand c'est un match à domicile, j'ai besoin des coordonnées
de l'équipe visiteuse. Je peux donc dire qu' fois que vous aurez inclus
les matchs à domicile, je veux que vous indiquiez les
détails de l'équipe locale. De même, lorsqu'
il s'agit d'un match à domicile, je veux que vous indiquiez ensuite
les détails de l'équipe visiteuse. Ensuite, nous pouvons
appeler notre exécution. Donc, que nous l'appelions en premier, par défaut
ou sur liste, le fait est que c'est notre question de trouver
nos petits-enfants. Et puis le fait
est que vous pouvez réellement enchaîner cela
parce que, vous savez, fonction de la configuration de votre base de données, vous pouvez avoir
plusieurs tables avec des enfants sur des enfants ou
des clés étrangères sur des clés étrangères. Tant que vous avez une clé
étrangère impliquée, vous pouvez dire « alors inclure », «
vous pouvez inclure ». Mais n'oubliez pas que l'
inclusion vous permet de
référencer directement les clés étrangères
liées à la table principale. Et puis pour chaque
inclusion, vous pouvez dire, puis inclure, puis vous pouvez continuer à
inclure et à inclure. Et remarquez qu'ils
incluent ensuite , cela ne
m'empêche pas de faire une
inclusion par la suite, car même si je faisais
tout cela en une seule ligne, c'est un peu moins lisible, c'est
pourquoi je l'
ai divisée en deux lignes. Mais vous voyez, je dis :
trouvez-moi les équipes. Incluez la façon dont les matchs se marient.
Incluez ensuite ceci. Ensuite, je vais revenir pour inclure. Mais évidemment, l'inclusion
ne peut que suivre l'inclusion
car je ne peux pas alors inclure après une
table qui ne
possède pas la propriété de navigation que je
recherche et que je m'attends
à trouver, n'est-ce pas ? J'inclus donc la façon dont les
matchs se font, puis je dis, lorsque vous obtenez les matchs, alors incluez l'équipe locale
pour la façon dont les objets font correspondre les objets. Ensuite, je dis :
incluez également à peu près
les matches à domicile. Et lorsque vous l'incluez, je veux
que vous
indiquiez les détails de l'équipe
Away. Une fois que vous aurez formulé
tout cela, je ne veux que celui qui
en a un identifiant. Alors allons-y faire un
tour et voyons ce que nous obtiendrons. Alors, tout d'abord, prêtons
attention au code SQL
généré. Nous avons toutes les tables
que nous avons. Donc, vous voyez, sélectionnez T zéro, T quatre, T deux, ils sont
tous là. Et puis nous avons from, mais
ensuite il utilise une sous-requête. Nous interrogeons donc les équipes dont
l'identifiant est égal à un, et nous appelons cela t zéro. Ensuite, nous sommes partis, nous l'avons rejoint,
puis nous avons fait une
sélection parmi les matchs, puis nous l'
avons réintégré aux équipes Hein ? La complexité
du SQL variera donc en fonction de la manière dont
les relations sont réellement établies. Dans cette situation,
c'est presque comme une référence circulaire parce que
je parle d'une équipe, puis je dis, vous savez, lorsque je regarde des matches, revenez en arrière et
ramenez l'équipe. C'est donc en quelque sorte un retour à la table d'équipe, qu'
elle vient de demander. Mais c'est juste une situation à
laquelle nous devons
travailler lorsque nous faisons ce
genre de choses. D'accord ? Mais encore une fois,
vous n'avez pas à vous blesser la tête en essayant de
trouver une solution, car le
FCO l'a créé pour vous Maintenant, ce qui revient, c'est l'équipe qui a des matchs
et des adversaires, et cela
aurait dû être des excuses de l'équipe Mais il y a aussi les
matchs AA, qui ne sont qu'un. Donc, cette équipe avec un identifiant, Juvento, n'a qu'
un seul match AA et un match à
domicile. OK, très bien. Lors du match à l'extérieur, nous
connaissons notre façon de faire équipe. C'est sous-entendu parce que nous avons
inclus les matchs Way. Nous savons donc que nous sommes l'équipe Away. Jovents est l'équipe idéale.
Nous n'avons pas besoin de celui-ci. Cependant, nous avions besoin des
coordonnées de l'équipe locale, et nous les avons obtenues. Nous voyons donc ici qu'
il s'agit d'InterMilan. Et je pense que Jvento a
de bonnes chances parce qu'ils n'
ont même pas d'entraîneur, Alors Javent pourrait bien
gagner ce match à l'extérieur. Si on regarde les matches à domicile, c'est la même situation. Nous sommes l'équipe locale. Ce sont les matchs à domicile. Javent
est donc évidemment l'équipe locale. Mais si nous examinons l'équipe visiteuse, nous constatons que l'équipe
visiteuse est Asma, et que l'entraîneur est nul, mais si nous avions
inclus l'entraîneur Et si nous voulions inclure
le coach à côté de cela ? Donc ça en est une autre,
faisons-le. Et si pour chaque équipe
que nous incluons, nous voulions voir qui est l'entraîneur ? Nous voulons connaître les coordonnées de l'entraîneur. Je peux donc dire, encore une fois, qu'il faut alors inclure. Donc, lorsque
vous incluez l'équipe locale, je veux que vous incluiez Q, puis vous voyez que cela
descend simplement dans la chaîne et que vous me donnez les
propriétés de navigation en fonction les
propriétés de navigation en fonction
de la prochaine étape. Je peux donc simplement dire d'
inclure le coach. Ensuite, cela nous permettra de connaître les coordonnées de l'entraîneur de
cette équipe. Alors laisse-moi le refaire. Et nous sommes en train de
regarder les matches à domicile, donc nous voyons que nous
sommes l'équipe locale. Une équipe A, c'est une Roma, et l'entraîneur de
Sarma est Joseph Moreno.
C'est donc un bon entraîneur. Nous allons devoir remporter notre match A pour gagner
ce match à domicile. C'est ainsi que vous pouvez
procéder et enchaîner vos inclusions pour assurer que vous obtenez toutes les données de toutes
les tables associées. Et c'est là un autre point
fort de la mise en œuvre
correcte de l'intégrité
relationnelle et de la collaboration avec FQ Bien sûr, il
essaie de vous simplifier la vie autant que possible. Cela vous permet donc de réduire tout un tas de jointures et de jointures
internes, car
si nous regardons ce code SQL, il s'est un peu agrandi
parce que nous devons maintenant joindre
le coach par
interne ou par jointure gauche sur la table. Je remarque que cela signifie « forme
intérieure » et « gauche pour somme ». Il sait donc automatiquement
que si elle est nullable,
il s' agit d'une jointure gauche,
car cela signifie qu' n'
y a peut-être rien de ce
côté de la table Cependant, lorsqu'il n'
est pas annulable, il fait juste un inner
car il sait qu'ils doivent correspondre pour que je puisse ramener quelque chose J'avais prévu ces deux autres
exemples,
mais je pense que nous les avons tous
épuisés avec
ces trois exemples, car sont assez
complets en termes de ce qu'ils décrivent que vous pouvez faire en
ce qui concerne les inclusions Celui-ci dit qu'avec des filtres, nous avons déjà filtré ici. Mais l'idée principale vous en
montrer un avec des
filtres serait dire que toutes les
équipes jouent à domicile. C'est donc une simple requête. Nous attendons les équipes à points contextuels, et je vais ajouter la clause
where à mon filtre, puis je
dis simplement les matchs à domicile, dont nous savons qu'un
nombre de points de liste est supérieur à zéro. Cela signifie qu'il faut
me désigner toutes les équipes qui ont au moins
un match à domicile, et je veux inclure leur
entraîneur. Et bien sûr, c'est A. C'est
donc l'instruction SQL
qui est générée pour nous. Vous pouvez vous asseoir et y
jeter un œil, bien sûr, si vous en avez besoin. Mais ensuite, nous constatons que nous avons
trois équipes
qui n' ont aucun
match prévu à domicile. Vous pourriez donc être tenté
quand vous regardez les données, vous pourriez être
tenté de dire : Eh bien, pourquoi n'avons-nous pas simplement vérifié
si les matchs à domicile sont nuls Et je veux dire, je comprendrais parce que nous disons que home matches.com est
supérieur Et si j'avais dit, combien est équivalent à null, puisque ce sont les
données que nous voyons, mais comment exactement FCO
serait-il capable de
traduire cet
objet de liste en null ? Parce que n'oubliez pas que SQL
ne sait
rien des listes et que
les listes sont nulles. Donc, si nous examinons
l'instruction
SQL générée pour cela,
eh bien, tout d'abord, aucune
donnée ne revient, n'est-ce pas ? Cette requête, quelle que soit
la requête générée, ne
renvoie donc pas
les données que nous attendions. Non, si nous examinons la
requête SQL qui a été générée, nous voyons qu'il s'agit d'une
requête de sélection normale avec la jointure gauche, mais que ce filtre ne fait que la
lancer complètement vers le haut. Donc, bien sûr, c'est une
façon de dire, je ne peux pas
comprendre ce que vous voulez que je compare
dans cette situation, n'est-ce pas ? Donc, même si nous n'avons pas reçu d'erreur de syntaxe
ou d'avertissement, nous voulons simplement être prudents lorsque nous ajoutons nos
filtres, et, vous savez, nous risquons d'être un
peu trop
zélés dans notre façon de procéder, et
c'est très bien C'est bien d'expérimenter,
mais soyez prudent. C'est donc vraiment pour
nous d'explorer
comment interroger les enregistrements connexes. Et comme d'habitude, je
vais simplement laisser cette méthode là afin que vous
puissiez y faire référence plus tard. Je vais simplement nettoyer ce que
nous n'avons pas vécu, et vous aurez ces exemples
à revoir par la suite.
25. Projections et types de données anonymes: Salut, les gars,
bienvenue dans cette leçon. Nous examinerons les
projections et les types de données
anonymes. Maintenant, vous êtes probablement en train de
regarder ce sujet et vous vous demandez, d'
accord, de quoi
parlons-nous exactement ici ? Une étude de cas à ce sujet serait que vous avez tous
vos modèles sûrs, mais que vous souhaitez ensuite obtenir des
données spécifiques à partir d'une requête, et plus encore, que ce sont les seules données que
vous souhaitez renvoyer. accord ? Vous voulez donc
avoir un objet personnalisé contenant uniquement des bits de données provenant de
l'ensemble de données renvoyés, et c'est tout ce que vous
voulez vraiment faire passer dans votre système. Passons donc en revue
quelques exemples de situations lesquelles vous auriez probablement besoin de faire
quelque chose comme ça. Très bien, je vais vous
montrer trois scénarios
dans lesquels vous devez savoir
comment gérer une sélection. La première est lorsque nous
voulons sélectionner une propriété. Comme nous l'avons dit, nous
interrogeons peut-être l'ensemble du tableau d'équipe. Disons des équipes. Et qu'il s'agisse d'une
ou de plusieurs équipes, le principe
resterait à peu près le même, à savoir le contexte, points et les équipes. Et ensuite, travaillons avec
une liste dans cette situation, d'
accord, que
nous devons bien sûr attendre. Non, je ne veux pas que tout
sorte de l'équipe, car nous savons que
nous allons obtenir une liste d'objets
avec un nom et un identifiant de ligue. Et puis si nous incluons, alors les autres choses, n'est-ce pas ? Je ne veux pas tout ça. Et si je ne voulais
que les noms ? Je voulais juste la liste des noms. Je ne voulais pas d'objets
complexes
ou quoi que ce soit d'autre, non ? Donc, dans
ce scénario, je
devrais ajouter une sélection. Je dirais donc que
le contexte permet aux équipes de
sélectionner des points . Ensuite, je peux utiliser mon
expression Lambda pour spécifier la propriété que
je souhaite sélectionner Donc, si je sélectionne le nom
puis que j'exécute les deux listes, il ne s'agit que d'une liste
de chaînes. C'est bon. Parce que le nom est une chaîne, et j'ai dit que je voulais la liste de
tous les noms de l'équipe. Je reçois donc la liste
des chaînes de caractères. Et cela vaut pour à
peu près tous ceux que vous fréquentez. Donc, si je voulais que tous les
identifiants de ligue figurent dans le tableau des équipes, j'
obtiendrais une liste d' entiers k en cas de disparition Nous y voilà. Une liste d' entiers car l'
identifiant de la ligue est un entier Et c'est exactement comme ça que ça se
passerait pour tout. Liste des entraîneurs. C'est bon. C'est ainsi que vous devez
sélectionner une propriété. Maintenant, le scénario pourrait être que vous ne
vouliez pas qu'une seule propriété. Vous voulez plusieurs propriétés, et plus encore, vous
voulez probablement plusieurs propriétés provenant de plusieurs tables. C'est bon. Examinons donc la projection
anonyme. Et si je voulais sélectionner toutes les équipes et inclure
tous les entraîneurs ? Mais tout ce que je
voulais vraiment retrouver, c'était la liste Well,
I list contenant le nom de l'équipe et le
nom de l'entraîneur. C'est tout ce que je veux vraiment. Nous savons donc, d'après notre expérience
précédente avec les inclusions, que cela
finirait par faire quelque chose comme ça, disons point include. Ensuite, je vais dire,
assurez-vous de me donner coordonnées de
l'entraîneur ou objet de
l'entraîneur
ainsi que de l'équipe. Mais ensuite, je veux
sélectionner plusieurs choses. Je ne peux pas séparer ça. Cela ne fonctionne pas.
Je ne peux pas dire un point. Nous savons donc en SQL quand vous
voulez des colonnes spécifiques. Tout ce que vous avez à faire est de
dire colonne, colonne
un, puis colonne deux, et cetera, tout avant le FM Ce n'est pas vraiment
une option ici. C'est pourquoi nous parlons projection dans
un autre type de données. Donc, à la volée, ce que vous êtes autorisé à
faire est quelque chose de nouveau, puis vous pouvez ouvrir un tout nouvel objet directement
dans cette instruction de sélection. C'est bon. Et puis si
vous le survolez ici, cela indique
qu'il s'agit d'un type anonyme Nous savons que le C aigu est
fortement typé, non ? Donc, dans C Sharp, tout
est fortement dactylographié. C'est soit une chaîne, soit
un int ou quelque chose comme ça. Mais dans cette situation,
je dis juste du nouveau, il n'y a rien après le nouveau pour dire que
l'on sait quoi, n'est-ce pas ? C'est donc juste un nouveau blanc. Mais remarquez qu'il n'
y a pas d'erreur et qu'il lui attribue
un type anonyme Il ne sait donc pas de
quel type de données il s'agit. Il sait juste que c'est un
type que je veux définir, et il a une propriété de
type chaîne appelée nom. Il hérite donc déjà
du nom donné. Sur le terrain. Donc, dans cette situation, Q représente l'équipe. Donc, si je voulais être précis, je dirais que le
nom de l'équipe est égal au nom du point Q. Et puis si je le survole à nouveau, vous verrez qu'il a évolué Il dit : « Ce type anonyme possède une propriété appelée nom de l'équipe ». C'est bon. Et si je
voulais aussi le nom de l'entraîneur ? Je peux donc venir ou me séparer
car non c'est un objet. Permettez-moi donc de le
diviser en une nouvelle ligne afin que vous
puissiez voir où tout
se passe, où tout commence
et où tout se termine. C'est bon. Voici donc notre nouvel objet en cours définition. Nous avons donc Lambda Ensuite, nous projetons dans
ce nouveau type anonyme, et nous définissons l'objectif, les noms de champs
qu'il possède
et les valeurs qu'il obtient Donc, le nom de l'équipe prend le nom que, puis le nom de l'entraîneur, et ne vous laissez pas intimider par le fait que
ce que vous tapez n'est pas une question d'intelligence car encore une fois, nous le
faisons à la volée Et ça va juste
fonctionner avec nous, point, et ensuite on pourra dire
point coach point name. Il y aura donc deux propriétés, l'équipe et le nom de l'entraîneur. Si je survole les équipes, vous verrez juste une liste de
ce
type de données anonymes, d'accord ? Ensuite, nous le
projetons simplement dans une liste. Ensuite,
je peux dire quatre pour chacune, et je vais juste en faire quatre
ici pour les imprimer, pour chaque élément de
la liste des équipes. Je peux consoler Dot Right Line. Et imprimez l'équipe et mettez le nom de l'équipe au
point de l'article, et je vais juste faire un gâteau comme entraîneur délimiteur et le nom de l'entraîneur par
point Ainsi, même après cette
projection et cette création très aléatoire et
spontanée de cet objet anonyme, nous pouvons facilement accéder aux
propriétés définies. Donc, si je modifie sa définition, l'objet perd de vue que
le nom de l'équipe était
une propriété, n'est-ce pas ? Je suppose donc que c'est aussi
flexible que peut l'être le do pointu, et cela peut parfois être très pratique
à faire. D'accord ? Maintenant, il existe une
étude de cas à ce sujet, peut être très utile, comme je viens de le dire,
mais personnellement, je préfère avoir une projection
fortement typée, ce qui signifie que je connais toujours
les types d'objets avec lesquels j'interagis
chaque fois
que je lance une requête Donc, comme je l'ai dit, il se peut
que vous ayez besoin d'un objet personnalisé, ce qui est bon pour un scénario à la
volée. Cependant, dans un projet de plus grande
envergure, vous voulez avoir un peu plus de
contrôle que d'avoir ces nouveaux objets anonymes un peu
partout. Donc, ce que vous voudriez faire, c'est avoir une classe fortement typée, et ce que je vais faire, c'est créer un nouveau
dossier à l'intérieur du domaine Cela ne devrait pas
entrer dans le domaine, mais travaillons simplement avec. J'appellerai ça des modèles. À vrai dire, vous souhaiteriez probablement
créer un nouveau projet, mais il s'agit d'un très
petit projet de démonstration. Je ne vais pas aller dans Far West avec un
certain nombre de projets. Mais dans un projet plus important, vous
ne voulez pas que cela se trouve dans un espace dédié qui ne soit pas
mélangé aux objets de votre domaine. Mais j'appelle les modèles parce que ce sont en fait des
modèles de données. Il s'agit donc d'un modèle
des données de base de données, mais ensuite, ce que je
vais créer, c'est un modèle contenant
probablement des données personnalisées
auxquelles je m'attends. Supposons donc qu'un modèle soit un accord appelé Team
detail. D'accord ? Les détails de l'équipe auront donc quelques propriétés. Supposons que le détail de l'équipe comporte
le nom de l'équipe. Il y aura le nom de
l'entraîneur, et il y
aura le nom de la ligue. Il s'agit de trois points de
données différents que nous ne
pourrions jamais obtenir en exécutant
simplement une requête normale. faudrait inclure
tout ce qui concerne l'entraîneur et tout ce qui concerne le nom de la ligue. Et puis ça peut devenir un peu ennuyeux à la
réception quand
on parle d'équipes d'entraîneurs d'équipes. Vous voulez donc
avoir un seul objet où
tout est là pour vous. C'est pourquoi je l'
appelle un modèle. D'accord ? Nous pouvons donc nous projeter dans
cette requête fortement typée. Je vais donc simplement
copier cette requête initiale. Permettez-moi
de tout dire. Et je vais ajouter et
inclure pour l'équipe. N'oubliez donc pas que c'est votre requête, quelles que soient les données
dont vous avez besoin, vous allez les obtenir. Donc, désolé, j'ai besoin de
l'équipe de la ligue. Nous examinons donc le tableau des
équipes et nous incluons les
détails de l'entraîneur, ainsi que les détails de la
ligue. Ensuite, je vais
sélectionner
une nouvelle instance de Team Detail. Nous étions donc anonymes au début, mais maintenant nous savons de quoi
nous parlons ci-dessous. Les détails de l'équipe ont un nom. Il a également le nom de l'entraîneur, puis le nom de la ligue. Je vais dire le nom du point Q
League. Au fait, lorsque nous
examinons ce qui est remboursé, nous sommes certains qu'il s'agit d'objets du
type « détails d'équipe ». Nous n'avons donc pas à
deviner, à épeler et à dire quel type de données
puis-je m'attendre cette fois-ci. Ou nous n'avons pas
nécessairement besoin d'aller à la définition pour voir
quels étaient tous les champs du type anonyme
au moment où le développeur l'a fait, car lorsque nous avons une classe
fortement typée, nous pouvons toujours simplement
regarder cette définition de classe Et une fois que nous savons que nous
obtenons ce type de données, nous savons
comment l' utiliser dès le départ. C'est bon. Je vais donc simplement les connecter puis
nous allons examiner les différentes
instructions QO exécutées pour
chacune d' entre elles et les données
qui reviennent C'est bon. Donc,
en regardant dans notre console, nous pouvons
simplement procéder lentement. Notre première commande, qui
consistait à sélectionner une propriété. Nous voyons qu'il est dit de
sélectionner le nom T de l'équipe. accord ? Simple. Vous voulez une propriété
ou une colonne. C'est ainsi que cela se
fait. Pas de problème Dans le suivant, nous avons
dit que nous voulions nom, le nom de l'équipe
et le nom de l'entraîneur. Tout ce que nous avons fait, c' est de
choisir ce type anonyme et de spécifier les
colonnes que nous voulions. FCR a généré exactement
la déclaration dont
elle avait besoin pour obtenir
exactement ces données Il a donc sélectionné le
nom comme nom d'équipe, quel est l'alias, n'est-ce pas ? Nous avons donc appelé le
nom du champ différemment dans notre type anonyme. Eh bien, il a donné l'alias à
la colonne à l'intérieur du SQL,
puis la jointure est laissée en conséquence. Nous connaissons déjà
l'inclusion. Je souligne donc vraiment le ciblage des
colonnes que nous voulons. Et puis ce sont les
équipes qui sont revenues. Nous voyons que Juventos a Conte, Roma a Joseph Marina, et tous les autres sont
vides. C'est très bien Maintenant, pour la prochaine avec une projection
fortement typée, c'est à peu près la même chose Nous sélectionnons le nom T, le nom
C comme nom de l'entraîneur, et nous avons sélectionné ce nom
comme nom de ligue. Alors remarquez que j'ai dit
nom, prénom, non ? Il n'était donc pas
nécessaire de donner
un alias à celui-ci car c'est déjà
le nom de la colonne. Le SQL ne lui a donc pas
donné d'alias, mais l'alias a été
mis en place pour les deux autres, puis il a fait les joints. Et puis, lorsque nous l'avons imprimé, nous voyons le nom de l'équipe, entraîneur et la Syrie, la Syrie, et nous voyons tous les détails de
la ligue. Nous ciblons donc ici
les colonnes que nous voulons. Ce sera donc une requête
beaucoup plus petite, une charge utile bien moindre que le
simple fait de
ramener chaque équipe et chaque détail de chaque et chaque détail de chaque
inclusion en une seule fois Il s'agit simplement de dire quels sont les domaines que je sélectionne ou
qui m'intéressent. Permettez-moi de les récupérer et de les
ramener sous forme de liste. Encore une fois, même
s'il s'agit d'une bonne installation, dans le cadre d'un projet, en particulier lorsque
vous travaillez avec d'autres personnes, je vous recommande de vous en tenir aux modèles fortement dactylographiés Vous pouvez créer un
modèle différent par type de données vous souhaitez
afficher sur la page sorte que lorsque vous exécutez la requête,
vous l' extrayez directement
dans ce modèle,
et cette page soit
modélisée à partir de ces données Et si vous avez besoin de l'étendre,
il vous suffit d'étendre votre modèle et d'étendre
votre requête en conséquence.
26. Filtrer sur les enregistrements: Très bien, les gars, nous sommes donc de retour, et nous
examinons un autre sujet, et ce sera une leçon
assez courte où nous
allons parler du
filtrage avec des données connexes Maintenant, qu'est-ce qu'un scénario de
filtrage avec des données connexes ? J'ai une requête ici, et le nom de
ma variable est incorrect, alors laissez-moi le corriger en ligues. Et je vais demander
le classement des ligues, mais je demande
le classement des sur quelque chose que
l'équipe pourrait avoir Imaginons donc un scénario dans lequel
vous affichez les ligues, vous montrez à l'utilisateur
la liste des ligues, puis vous l'autorisez à
filtrer en fonction du nom de l'équipe. Je connais donc le nom
ou une partie du nom de l'équipe, et je veux voir dans quelle
ligue appartient cette équipe. Cela signifie donc que lorsque
je clique sur Soumettre, vous devez me procurer la
liste des ligues où équipe
peut avoir un nom contenant un terme de recherche
quelconque . Imaginez donc qu'il s'agit d'un terme de recherche provenant
de l'utilisateur, peut-être
l'abréviation de Barn Munich. Et puis nous disons ici. Permettez-moi donc de prendre le temps de
réécrire cette requête pour
qu'elle ne
paraisse pas aussi intimidante qu'elle le fait
probablement correctement Maintenant, nous disons que c'est le
point de contexte, les jambes où. Nous le connaissons tous. Nous savons que nous avons
l'expression Lambda. Ensuite, je vais dire où une propriété répond à
certains critères. Dans ce cas, le
critère va à l'encontre de la propriété de navigation
, à savoir les équipes. Donc je vais dire Q point
teams, puis c'est une liste. Je ne peux donc pas très bien prononcer simplement ce nom d'
équipe. C'est
une liste d'équipes. Je vais donc utiliser any car
any renvoie un booléen
basé sur une condition Je vais donc dire que, comme
je suis déjà dans
une expression Lambda, je ne peux pas réutiliser le
même jeton Lambda Q est donc déjà à égalité ce qui
représente un record de championnat. Je ne peux donc pas réutiliser Q dans le. C'est pourquoi j'ai le X. Cela pourrait être S. Encore une fois, l'expression Lambda, le
jeton, n'a pas vraiment d'importance, mais je vous montre simplement pourquoi j'
ai X dans l'un et Q dans l'autre parce que celui-ci est un sous-ensemble de l'expression Lambda plus large Donc x point puis
non, je peux accéder aux
propriétés de la table d'équipe. Je vais donc dire
où se trouve le nom, puis nous savons que le
point contient déjà, puis le terme de recherche, puis nous avons notre instruction d'
exécution. C'est donc vraiment tout ce qu'
il y a à interroger rapport aux enregistrements connexes, n'est-ce pas ? Encore une fois, les équipes ne constituent pas le tableau principal.
Il s'agit de la table principale. Cependant, le fonctionnement
nécessite que nous nous
rendions dans la table pour enfants pour
répondre à certaines conditions. Donc, si nous examinons cela, notre instruction SQL qui est
générée ne fera
que nous indiquer où elle existe et elle essaiera
simplement de sélectionner l'équipe en fonction
du terme de recherche ou du critère
que nous avons spécifié. Et cela
nous redonnerait une ligue,
qui, si je ne me trompe pas, serait Bundes Llega
27. Ajouter des vues et d'autres objets de données: Bienvenue dans cette leçon, nous verrons comment ajouter des objets SQL qui
ne sont pas des tables à notre base de données par le
biais de migrations. À titre d'étude de cas, nous avons utilisé les migrations
jusqu'à présent pour
contrôler la plupart de ce qui
se passe dans notre base de données. Nous ne voudrions pas nécessairement
avoir deux opérations distinctes, l'une où nous scripterons manuellement
les révisions et l'autre où nous scripterons
les tableaux Il serait donc bon que
nous disposions d'un point focal central pour notre base de données afin de pouvoir
toujours revenir en arrière et de savoir que tout ce qui a été fait lors la migration précédente peut être
annulé par le biais de cette procédure
particulière N'oubliez pas que
les migrations agissent en quelque sorte comme un contrôle de source
pour votre base de données. Dans cette
leçon particulière, nous verrons comment ajouter une fonction,
comment ajouter un . Et
puis, par extension, la même technique
que nous allons
utiliser pour faire tout cela s'appliquerait en
quelque sorte aux procédures
stockées et à tous les types de fonctions. Je ne vais pas entrer dans les détails
des scripts. À ce stade, je
suppose que vous connaissez
déjà
ce qu'est la fonction,
la fonction scalaire par rapport à
la fonction à valeur tabulaire, ainsi que la façon dont nos
vues sont construites Je vais donc me
concentrer sur la façon dont nous intégrons ce Qule dans la migration et, par extension,
dans notre base de données Maintenant, comme pour tout voyage dans
la base de données, nous commençons par l'
ajout d'une migration. Nous allons donc accéder à notre
console de gestionnaire de packages, ajouter une migration, puis je vais simplement l'appeler
ajouter vue des détails de
l'équipe et la fonction de match
anticipé. Comme je le dis toujours, vous devez être clair dans vos messages de
migration. Ne soyez pas vague du tout. Je vais donc simplement
ajouter cette migration. Non, je n'ai apporté aucune
modification aux éléments
liés à la base de données. Je n'ai pas changé le contexte. Je n'ai changé
aucun cours. Vous remarquerez donc que ceux-ci vont être vides
parce que j'ai effectué une migration. Je n'ai rien dit à faire et il n'a
rien dit à annuler. Nous devons donc saisir manuellement
le code pour savoir quoi
faire pour le up et quoi
faire pour le dom. Regardons donc l'
ajout de la fonction. Je vais donc me procurer
cette fonction SQL. Et je vais dire générateur de
migration. Donc, ce qui se serait vraiment
passé c'est que je me suis lancé
dans SQL et que je l'ai créé. Je suis allé dans le studio
de gestion, créé la fonction
manuellement. C'est très bien. Mais comme je l'ai dit, je
ne veux pas l'ajouter ici parce que je
veux un point d' entrée unique pour toutes les modifications
basées sur les bases de données à l'
avenir, n'est-ce pas ? Je vais donc dire
migration Builder point, puis je peux dire SQL. Ce qui va prendre un
paramètre de type chaîne. Il attend donc
la commande cual sous forme de chaîne de caractères Donc, ce que je vais
faire, c'est utiliser mon signe a pour transformer cette chaîne
en chaîne littérale, puis je colle simplement cette déclaration
qual dedans Voilà donc à
quoi cela va ressembler. Donc, le générateur de migration Q
, puis vous transmettez n'importe quel Q. Donc, même si c'est Q pour
créer une fonction. C'est Q de créer une vue comme nous sommes sur le point de le faire ou
une procédure stockée, peu importe ce que c'est, c'est tout ce que
vous avez vraiment besoin de faire. Je vais donc simplement le copier, et je vais répéter
cette étape avec la vue. Donc, dans cette migration particulière, je compte créer cette
fonction et créer cette vue. Je l'ai déjà dit et
je l'ai déjà dit Nous devrions
donc être conscients du fait que la hausse signifie
le changement que
je suis sur le point d'apporter. Le down désigne les
modifications que j'annule ou les actions que je fais chaque fois que cette migration
est annulée. Donc, si j'ai les
instructions create à l'intérieur du up, cela signifie
que je dois mettre les instructions
drop à l'intérieur du down. Je vais donc simplement faire ce point SQL drop view du
générateur de migration, puis je lui donne
le nom, puis supprime la fonction portant ce nom. C'est donc la première
fois que nous
mettons la main sur les fichiers
de migration. Allons-y, mettons à jour la base de données
et voyons la magie opérer. Et mon expérience n'a pas été très magique car j'ai une erreur. Et en le regardant,
je vois que j'ai une erreur dans cette ligne.
Permettez-moi donc de le corriger. J'avais fait preuve d'un excès de zèle et j'avais
répété le mot correspondance. Essayons donc encore une fois. Vous l'avez probablement détecté et n'avez pas obtenu
cette erreur parfaite. Et à ce moment-là,
tout est fait. Et si nous examinons rapidement
notre base de données
et examinons nos vues, vous verrez
apparaître la vue qui y apparaît, ainsi que notre fonction sur la programmabilité, les fonctions
et les fonctions
scalaires notre Cette migration a donc été un succès. Maintenant, à notre retour,
nous allons voir
comment nous pouvons interagir avec une vue. Plus tard, nous verrons comment nous
interagissons avec les fonctions et autres opérations scalaires lorsque nous effectuons un appel et attendons
des données, mais dans le cas d'une vue, il ne s'agit pas vraiment d'une
commande, nous interrogeons, et cela va être
légèrement
différent de la façon dont nous interrogeons nos tables, et il y a certaines règles
que nous devons connaître Donc, à notre
retour, nous examinerons les modifications
nécessaires pour cela.
28. Requérir des entités sans clés (Comme des vue): Salut, les gars, bon
retour. Dans cette leçon, nous allons nous
appuyer sur ce que nous avons fait dans épisode précédent
où nous avons créé deux objets égaux non tabulaires sous la forme d'une
fonction et d'une vue Nous allons donc continuer à
interagir avec la
vue, car en termes pratiques, une vue ressemble
en
fait un tableau en lecture seule vu
du côté égal Cela signifie que nous aimerions notre application
puisse interroger
ces vues de la même manière
que nous pouvons interroger des tables ordinaires. Nous allons donc
devoir créer
une nouvelle classe
de données correspondant à une nouvelle classe
de données correspondant la
vue et l'ajouter à
l'ensemble de bases de données. Je l'ai donc déjà fait en quelque
sorte en créant
une nouvelle classe. Je l'ai mis dans le projet de domaine. Je l'appelle équipes,
entraîneurs, ligues, et j'ai simplement ajouté le
mot vue pour que vous sachiez, à première vue, que nous puissions celui-ci est un point de vue
par rapport aux autres Quel que soit le préfixe,
c'est à vous de décider. Je ne suis pas prescriptif. Je dis simplement que
c'est ma convention pour connaître les tables différentes
des vues. D'accord ? Vous pouvez également créer
un tout nouveau dossier et y placer une vue « call it », désolé, et y placer tous les modèles liés à la
vue. Cependant, vous
voulez les séparer, cela dépend entièrement
de vous tant que c'est propre et
facilement identifiable. Maintenant, après avoir créé
cette classe pour représenter la vue et les
données qui en découlent, nous voulons informer le contexte de base de données de cette vue. Je vais donc
ajouter une nouvelle ligne dans ce contexte de base de données où
je vais dire DB set, lui donner le type de données, et je vais simplement l'appeler
du même nom que la
vue dans la base de données. Dans notre programme point CS, nous allons suivre
ce que nous avons
fait jusqu'à présent, et je viens de créer une revue de requêtes de
méthode, dont le seul but est
d'appeler le contexte, les équipes, les entraîneurs, les ligues, et de les mettre sur la liste. Cependant, nous allons voir
si nous allons vraiment obtenir des
résultats et s'il y aura des
erreurs en cours de route. Alors allons-y faire un tour. Maintenant, dès qu'
il atteint le code, je suis accueilli par cette exception, indique que le type d'entité nécessite la définition d'une
clé primaire. Si vous aviez l'intention
d'utiliser un type d'entité sans clé, vous
devez explicitement lui faire savoir,
désolé, qu'il n'a pas de clé, n'est-ce C'est donc normal, et c'est une erreur que je
voulais que nous examinions ensemble, parce que parfois vous êtes pris au
dépourvu par cette erreur, et vous ne
savez pas exactement pourquoi vous l'
obtenez Donc, comme nous l'avons vu, le FCR prospère grâce à
l'intégrité relationnelle. Les clés primaires sont
définies comme des clés primaires, les clés
étrangères étant
définies comme des clés étrangères. Grâce à cela, il sait
exactement comment effectuer les requêtes efficacement,
comment suivre si quelque chose est modifié, et comment simplement
surveiller tout ce qui se passe dans le contexte
lors de notre demande. Donc, selon cette norme, notre nouvelle table ou plutôt notre
nouvelle entité. Il ne sait pas si c'est une table. Il ne sait pas s'il s'agit d'une vue car nous l'avons ajoutée
au contexte de base de données, peu comme nous l'avons fait pour
toutes les autres tables. Donc, en ce qui concerne
le cadre d'entité, il va le traiter
comme s'il s'agissait d'une table. Cependant, cette
exception disait que je ne vois pas de clé sur ce tableau. On ne peut pas y mettre de
clé. Ce n'est pas une table. C'est une vue, et oui,
elle n'a pas de clé primaire. Donc, sauf que
dans le modélisateur, nous devons lui faire savoir
qu'il n'a pas de clé. Je dois donc dire que l'entité point du
constructeur de modèles avec le type de données, puis nous
spécifions simplement qu'elle n'a pas de clé. Donc, quand il crée,
il sait que, accord, je suis conscient que je
ne devrais pas essayer de suivre cela. Si je trouve une table ou
quelque chose qui correspond à
cela, je sais exactement quoi faire. Maintenant, une autre chose que
nous voudrions faire à ce stade est de dire que deux vues et deux vues nous permettent essentiellement de spécifier le nom de la vue dans la base de données
qu'elle doit rechercher. s'agit donc d'une précaution
supplémentaire pour s'assurer qu'il
ne considère pas tout
cela comme de nouveaux éléments, de nouveaux
sujets ou de nouvelles œuvres, mais qu'il devra le faire
lors de la prochaine migration Je dois juste savoir que, d'accord, eh bien, ce type de données, ce type de classe ou ce modèle correspond directement à la vue de notre
base de données portant ce nom. Et il n'a pas de clé, alors ne faites aucun suivi. Donc, ce que je vais faire, c'est
exécuter ce bout de code,
encore une fois, et je vais
laisser ce point de rupture afin que nous
puissions voir ce qui se passe
dans le suivi des modifications. Donc, cette fois, il atteint
le point d'arrêt. Quand nous examinons les détails, nous constatons que nous
recevons des informations parce que la vue s'
exécute correctement, que nous revenons entraîneur, que
nous obtenons la
ligue et que nous
obtenons le nom comme prévu. Et puis le contexte ne sait
vraiment
rien de ce qu'
il faut suivre, n'est-ce pas ? En ce qui le concerne, il a fait son travail et c'est fait, et il poursuit sa vie. C'est ainsi que nous gérons situations où
aucune clé primaire n'est présente, car vous pourriez vous retrouver avec une table sans clé primaire
ou un élément d'identification comme celui-ci. Peut-être êtes-vous
obligé de gérer une ancienne base de données dans laquelle ces éléments ne
sont pas appliqués, comme nous vous encourageons
à les appliquer
lorsque vous utilisez Entity Framework
Core à partir de zéro, car ces
situations peuvent exister. Mais si vous
avez cette clé sans clé, pour vous battre, alors
c'est le remède. Vous le mettez dans le générateur de modèles dès que je trouve un contexte, vous le mettez dans le générateur de modèles, savoir qu'il n'a pas de clé, puis vous pouvez directement le
mapper à la vue, ou s'il s'agit d'un tableau, vous pouvez en fait dire point à
table et spécifier le nom. Il peut donc arriver qu'il y ait une incompatibilité entre le nom de table donné dans le contexte de base de données et
la table réelle Vous pouvez toujours dire à table
puis lui donner ce nom, peu comme nous l'avons fait pour view.
OK.
29. Requérir avec Raw SQL: Salut, les gars,
bienvenue dans cette leçon. Nous verrons comment
exécuter des requêtes en utilisant du SQL brut. Jusqu'à présent, nous avons
tout écrit en utilisant notre lien, syntaxe et notre C sharp, et
tout était parfait. Mais il
se peut
que vous deviez
écrire du QL brut,
surtout maintenant
que nous avons affaire à des surtout maintenant
que nous avons affaire objets non
liés à une table, et nous commençons à voir
que cela devient un peu plus compliqué. Vous savez, comment exécutez-vous cette procédure stockée
ou cette fonction ? Comment faisons-nous exactement cela, en
conservant l'utilisation complète
de Entity Framework Core. Nous allons donc
examiner deux exemples au fur et à mesure
que nous étudions ces
différents scénarios. Maintenant, nous avons deux
fonctions qui
nous permettent d'exécuter des commandes duales brutes, partir de Q R et
de Q interpolé Maintenant, notez la syntaxe, le contexte fait aux équipes. Nous devons donc toujours
spécifier notre table, puis nous disons à partir de QL R, puis nous pouvons mettre
notre instruction cual brute,
puis dans la liste Maintenant, je dois souligner certaines
des limites
et les dangers
associés à ce QL brut. Une fois que vous utilisez
cette fonction, vous vous exposez au potentiel de
l'injection de code SQL si vous ne faites pas
très attention. C'est pourquoi ils vous ont
donné du QL raw et du SQL
interpolé, n'est-ce pas Nous verrons donc la différence
dans quelques instants. Voyons donc ce que
nous obtenons de Q R. Je commente
simplement celui que nous
n'utilisons pas encore. Et à partir de SQL Raw, nous devons dire quelque chose
comme Select Star
from Teams, un peu
contre-intuitif, n'est-ce pas ? Nous avons simplement dit que le contexte influait sur les équipes, puis je dois redire « sélectionnez une
étoile parmi les équipes ». Mais voyons ce que nous obtiendrons en
retour lorsque nous le testerons. Maintenant, lorsque nous examinons nos résultats, nous constatons que
nous retrouvons la liste des équipes et que nous
récupérons tout. Nous avons dit sélectionner une étoile, donc nous allons les récupérer
et tout va bien. Maintenant, le problème avec le
SQL brut est qu'il doit renvoyer des
colonnes qui correspondent exactement à colonnes qui correspondent exactement l'ensemble de bases de données ou à l'entité
derrière l'ensemble de bases de données. En d'autres termes, si je ne voulais que les noms des
équipes et que je disais, sélectionnez le nom des équipes,
laissez-moi faire simple. L'identification n'est pas simple. Permettez-moi d'utiliser le nom commun de l'identifiant. Je ne veux que deux colonnes
du tableau des équipes. Si j'essaie
cela, nous nous retrouvons avec cette exception indiquant
que
certaines colonnes ne sont pas
représentées dans l'
ensemble de requêtes car il a essayé n'
interroger que deux colonnes,
mais il attend. C'est donc l'une des limites de cette commande SQL brute. Tout d'abord, la
requête ou le
jeu de résultats doit renvoyer toutes les
propriétés du type d'entité. Une autre chose est que les noms des
colonnes doivent correspondre. Donc, même si je devais répertorier
tous les noms de colonnes, je ne pourrais pas leur donner d'alias
qui ne correspondent pas
au type d'entité d'origine
dans notre classe appelée team Et puis une autre chose est
que nous ne pouvons pas effectuer d'interjointure, ne
pouvons pas
avoir directement des données connexes. Cependant, je peux, à ce
stade, dire « OK ». Donc, après avoir écrit
le code SQL brut, je peux toujours faire mes
instructions d'inclusion, et cela fonctionnerait
exactement comme nous savons que cela fonctionnera
malgré tout, n'est-ce pas ? Donc, si je le fais et que j'
inclus l'entraîneur, alors nous verrons pour nos équipes, et je pense que l'équipe
numéro trois a un entraîneur et voilà, nous verrons l'entité
d'entraîneurs être incluse sous la
forme de Joseph Moreno C'est bon. C'est donc l'une
des choses que vous pouvez faire. Si vous avez besoin de
l'exécuter à partir d' EQ Raw et que vous avez besoin de données connexes, sachez
simplement que vous pouvez le
faire de la même manière À ce stade, vous êtes déjà familiarisé
avec le langage SQL. Vous savez donc que si nous voulions ajouter un filtre, par exemple, si je voulais trouver
le club de football dont le nom est égal
à cette variable, et nous l'avons fait par le passé
en acceptant entrées
utilisateur pour ensuite
les utiliser pour
le filtre, n'est-ce pas ? Disons donc simplement
que nous voulons utiliser cette variable pour notre filtrage. Nous pouvons toujours simplement dire où le nom est égal à, puis nous transmettons
notre variable. Donc, pour l'interpolation,
nous devrions placer ce signe dollar
avant la chaîne, puis nous pouvons simplement
faire nos accolades et ensuite le
nom du lieu dans Maintenant, si nous examinons le QL
généré pour cela,
nous verrons celui que nous
n'avons pas nécessairement
examiné les deux dernières fois Il génère
notre instruction SQL et effectue
automatiquement la jointure gauche à cause
des inclusions. Mais prenez-en note maintenant. Ce que nous faisons
ici, c'est transmettre étoile
sélectionnée aux équipes
dont le nom est égal à. Et notez qu'il
transmet la valeur, mais il ne la transmet pas entre guillemets, car en SQL, nous aurions dû le mettre là où le
nom est égal à. Ouvrez peut-être la valeur unique et fermez les guillemets simples
lorsqu'il s'agit d'une chaîne. En conséquence, il se plaint ne pas trouver
le mot clé
car A S roma est
considéré comme une commande AS dans ques. Donc, pour y remédier, dans notre
chaîne interpolée, nous devons placer nos guillemets
simples
autour des valeurs Essayons donc encore une fois. Et cette fois, nous
atteignons nos points de rupture. Notre requête a été prise en compte. Mais encore une fois, si vous regardez cette requête par rapport aux requêtes
précédentes où
nous avons filtré, vous remarquerez qu'il n'
y a aucun paramètre. Il s'agit de transmettre la valeur littérale
directement dans la requête, A K est une mauvaise pratique, injection
QL. D'accord ? Donc, si jamais vous
deviez prendre un paramètre et utiliser une commande QL brute
pour l'exécuter,
c'est ce qui va se passer, et vous devez être très
prudent, car si quelqu'un transmet une
commande malveillante en entrée, vous serez revenu à la
case départ avant l'époque où le framework d'
entités a été
développé pour
vous aider à empêcher l'injection de Qual Dans une situation comme celle-ci, nous
utilisons les services de son proche cousin à partir de
Qual interpolated Si vous regardez celui-ci, il demande une chaîne formatable From qual ne
demande qu'une chaîne, mais ensuite from sc interpolated
demande une chaîne formatable,
ce qui signifie qu'il n'
acceptera qu'une seule chaîne ce qui signifie qu'il n'
acceptera qu'une seule acceptera qu'une Deuxièmement, nous n'avons pas à traiter cette déclaration de voiture aussi littérale que nous le faisions tout à l'heure, car elle
va l'interpoler. Il
va donc gérer automatiquement le paramétrage
de la commande, de sorte que nous n'avons pas à mettre des couches uniques autour de
la valeur
interpolée ou injectée dans la Jetons donc un coup d'œil à
cette équation et comparons-les. Donc, vous voyez, nous venons de
regarder celui-ci, où il a transmis
la valeur littérale Alors que le second
va en fait
dire sélectionner une étoile parmi les équipes
dont le nom est égal
au paramètre zéro, et il a défini
le paramètre en haut. Et c'est la
différence entre brute et une escule
interpolée Je recommande donc toujours
que si vous devez mélanger et associer des variables pour transmettre une instruction cual brute, utilisez le qua interpolé pour votre propre protection
et votre tranquillité d'esprit
30. Ajouter et requérir en utilisant les procédures mémorisées: Salut, les gars, bon
retour. Dans cette leçon, nous
examinerons l'interaction
avec les procédures stockées à l'aide de
Entity Framework Core. Maintenant, l'étude
de cas expliquant pourquoi vous
devriez interagir avec une procédure
stockée
provient du fait que vous avez
peut-être affaire systèmes existants
dont une grande partie de la logique se trouve dans les
procédures stockées de la base de données. Ainsi, lors de la reconstruction, vous ne
voulez pas doubler le travail, réécrire, vous devez
simplement les réutiliser. Donc, dans cette situation, vous devez probablement simplement
savoir comment effectuer des
appels de procédure stockée
à partir de FCR J'en ai donc un très simple que j'ai créé pour le contexte ou
la
base de données où j'
ai juste un entraîneur d'équipe SPG, obtient un identifiant d'équipe, puis il renvoie
tout ce qui se trouve dans le tableau des entraîneurs Rappelez-vous maintenant que lorsque nous avons
affaire à RwQul, nous devons renvoyer tout ce qui correspond au type d'entité
correspondant D'accord, donc tu ne
peux pas juste dire ton nom. Si vous
voulez les répertorier,
vous devez les répertorier dans l'ordre des noms de
colonnes avec
les mêmes noms de colonne, sans S ni rien d'autre. Comme nous l'avons fait avec nos
points de vue et nos fonctions, la première chose que
nous allons faire est créer une nouvelle migration. J'ai ajouté une migration disant d'
ajouter le nom du coach SPG. J'ai mal compris le nom de la migration,
mais nous allons continuer Ensuite, j'ai intégré le générateur de
migration pour créer la procédure et, de même, pour le
supprimer par la suite. Vous pouvez donc procéder à
la migration et
effectuer ces étapes, puis nous pourrons simplement
mettre à jour notre base de données. Cela nous permet ensuite de commencer à interagir avec notre procédure
stockée. Maintenant, dans notre programme, le fichier CS. J'ai déjà
écrit un exemple de code, et la nouvelle méthode
avec
laquelle nous travaillons est la procédure stockée. Donc, dans la procédure du magasin, j'ai juste codé en dur un identifiant d'équipe, puis je vais le
transmettre dans l'instruction SQL brute
et attendre le résultat. Maintenant,
examinons la syntaxe. Je dis « wait context
point coachs do fc R », puis j'appelle mon exécution
pour que je sois entraîneur de l'équipe SPG, puis j'ai un espace réservé Notez maintenant que j'utilise SqulRW. Dans la leçon précédente, je ne l'ai pas condamné en disant qu'
il était
mauvais parce qu'il vous
ouvre La réalité est que cela dépend
de la façon dont vous l'utilisez. Je vous ai donc montré la mauvaise
façon de l'utiliser au départ en utilisant une chaîne
interpolée et en passant directement une valeur valide Tout cela a donc été
traduit en QL littéral, qui est la pire
chose que vous puissiez avoir entre la saisie de l'utilisateur et l'accès à
la base paramétrage est toujours préférable, où notre préférence
pour l' Mais prenons du
recul et ne condamnons
pas trop le SQL raw car si nous
examinons sa surcharge, il indique vraiment :
donnez-moi la chaîne
SQL, puis donnez-moi
une liste de paramètres. C'est donc exactement
ce que nous avons fait ici. Je dis DBO point SP get team coach, puis j'utilise un espace réservé Et puis après cet
espace réservé après cette chaîne, j'ai maintenant inclus
le paramètre Ainsi, lorsque vous le faites de cette
manière, il gérera
le paramétrage pour vous, de la même
manière que nous l'avons vu Equal Interpolateed Ce n'est donc pas la pire
méthode et elle n'est pas
totalement utile , car vous êtes probablement reparti de la dernière
leçon en vous demandant Alors pourquoi l'ont-ils mis
si c'est si dangereux ? Il y a une bonne façon de l'utiliser et
il y a une
mauvaise façon de l'utiliser. Alors, je t'ai montré le mauvais chemin. Voici la meilleure ou la plus
recommandée façon de l'utiliser. Jetons donc un coup d'œil à cela. Maintenant, lorsque nous
examinons ce que nous obtenons,
nous constatons que notre requête est générée
et paramétrée, comme nous l'avons dit ou comme nous nous y
attendions Il prend donc
ce paramètre de trois et exécute une troisième procédure Et puis notre résultat est information de
Joseph Marina en tant qu' entraîneur de l'
équipe avec un numéro trois. C'est ainsi que vous pouvez
exécuter une procédure stockée. Et c'est à peu près
ainsi que nous exécutons des commandes sur une base de données qui
sont, en fait, des commandes de requête. Nous demandons quelque chose à la base
de données et nous
voyons qu'il sera renvoyé. Dans ce cas, c'est
pourquoi nous devons exécuter ces commandes QL brutes
sur une table. Dans chaque situation. Maintenant, ce qui se passe lorsque
nous devons exécuter une procédure stockée
qui n'est pas
associée à une table ou à une requête n'
est directement
associée à aucun type d'entité. Nous avons donc besoin de QL brut un objet qui n'est pas
associé à un type d'entité. C'est ce que nous
allons examiner dans notre prochaine leçon. OK.
31. Exécuter le SQL Non-Query: Vous
reviendrez dans cette leçon, nous verrons comment
exécuter des commandes
autres que des requêtes sur la base de données. Par exemple, lorsque nous voulons supprimer
ou mettre à jour quelque chose qui
manipule ou augmente les données, mais cela ne nous renvoie pas
nécessairement quoi que ce soit parce que nous ne les
sélectionnons pas Donc, jusqu'à présent, nous avons sélectionné, sélectionné
et sélectionné. Voyons ce que nous faisons
lorsque nous ne sélectionnons pas, mais que nous devons exécuter
ce type de commande. J'ai à l'écran une nouvelle équipe de suppression de
migration par IDP, SP, abréviation de procédure stockée, et j'ai
le code pour créer la procédure stockée
appelée delete team by ID, qui prend un
identifiant d'équipe comme paramètre, puis supprime
l'équipe Nous avons les
méthodes ascendantes et descendantes que je peux mettre en pause, les
reproduire, puis
mettre à jour les données Maintenant, une fois
que vous avez terminé cela avec succès, vous pouvez vous rendre dans le
programme point CS et vous verrez que la méthode
execute non query command est
déjà créée. Maintenant, lorsque nous allons
exécuter la commande sans requête, certaines choses
vont être différentes entre
celle-ci et lorsque nous savons
que nous attendons un
jeu de résultats et que j'essaie d'afficher
les deux ensembles de code à l'écran afin que nous puissions faire une analyse
comparative. Premièrement, on ne nous dira que combien de rôles
ont été affectés. Contrairement à ce que nous
recherchions lorsque
nous recherchions les équipes, nous savions que
nous obtiendrions un ensemble de résultats. Dans ce cas,
nous allons uniquement
récupérer une
variable indiquant nombre de lignes affectées. C'est bon. C'est donc tout ce que
nous obtenons. Ça en est un. Deuxièmement, lorsque nous faisions les autres, où nous savions que
nous étions en train de récupérer des données, nous savions sur quel type d'entité ou base de données les exécuter,
car on ne s'attendrait pas à interroger entraîneurs sur
Select Star,
mais à contextualiser cette équipe Nous savons que vous obtiendrez
simplement une erreur lorsqu'il essaiera d'exécuter complètement cette
méthode. Cependant, dans ce cas, comme nous ne savons pas
ce que va faire la
procédure stockée , nous ne savons pas avec quelle table elle interagit
directement. Nous parlons de
base de données de points contextuels au lieu de nom de l'ensemble de bases de données de points de
contexte. Donc, la base de données
de points contextuels , puis les méthodes que nous obtiendrons seront
légèrement différentes. Dans le cas de l'ensemble de bases de données, nous obtenons une interpolation à partir de CLR et
à partir de Q Dans ce cas, la
base de données exécute
SQL raw par point et elle possède une version
asynchrone Nous avons donc RAW et
R A sync. D'où l'esprit, où se
trouve dans l'asynchrone. Et puis de même, nous avons exécuté notre Async
interpolé qual Nous avons donc la version
interpolée et la version brute Maintenant, nous avons déjà
exploré la mauvaise utilisation de la méthode brute et
l'utilisation la plus acceptable et
la plus sûre de la méthode brute. La même chose s'applique ici. Nous ne savons pas quelle
procédure stockée nous allons suivre, mais nous savons que nous devons
transmettre une certaine valeur, qui proviendra
probablement de notre utilisateur. Nous voulons donc
nous protéger et utiliser une chaîne formatée
avec un espace réservé, non la
chaîne interpolée lorsque nous utilisons la synchronisation Execute Q R A. Et puis, bien sûr,
si vous ne voulez pas
avoir la responsabilité supplémentaire de réfléchir autant, pas de problème. C'est pourquoi ils
vous ont donné l'alternative vous suffit de transmettre la chaîne
interpolée,
et il en va de même pour vous Voyons donc ce que nous
obtenons lorsque nous exécutons ces
méthodes. C'est bon. Je regarde donc le kill
qui a été généré, et je vois ici qu'il a été paramétré avec l'identifiant d'équipe deux, et que tout
ressemble à ce à quoi je m'attendais Cependant, cela me dit que
cela a échoué. Pourquoi a-t-il échoué ? C'est à cause de cette contrainte de clé
étrangère que j'ai enregistrée. J'ai donc des matchs liés
à une équipe avec l'identifiant deux. Je peux donc utiliser celui-ci.
Ce sont mes mauvaises données. Laisse-moi réessayer. Très bien, donc j'ajuste mes valeurs
parce que je veux juste
rechercher des équipes dont je
sais qu'elles n'ont aucun match. Nous ne devrions donc plus avoir d'erreurs de contrainte de
clé étrangère . Laisse-moi réessayer. Et cette fois, nous avons atteint le
point de rupture, ce qui signifie que tout
a été correctement exécuté. Maintenant, si je regarde
les rôles concernés LC, un. Si je regarde en bas, j'en vois une. Cela vous indique donc que nous l'avons exécutée
avec succès, et c'est le nombre de
lignes affectées. Donc, si vous voulez qu'
un indicateur indique résultat
a été un succès ou non,
vous pouvez toujours dire le nombre de
lignes affectées
est supérieur à une, alors nous pouvons dire que c'est un
succès. D'accord ? est donc vraiment ce qu'
il faut pour exécuter des instructions de commande QL
sans requête en utilisant du QL brut. D'accord.
32. Semer des données: Salut, les gars, nous
reviendrons dans cette leçon. Nous allons jeter
un coup d'œil à l'une des routes les moins fréquentées, mais qu'il est essentiel de connaître
, à savoir comment générer des données. Maintenant, l'ensemencement des données, si vous
n'êtes pas familier avec
ce dont je parle, consiste à mettre des données dans la base de données dès le
début Ainsi, dès que votre
application est installée, pouvez
y trouver des données
par défaut dont vous avez
besoin, par exemple une liste de pays ou certains rôles ou
un utilisateur par
défaut, etc. Vous voulez
probablement simplement les avoir dans le système au moment de
la création. Dès que la
base de données est créée, ces éléments doivent s'y trouver. COR nous permet de le coder en dur afin que chaque fois que
notre base de données est générée à l'aide de ce
script ou que nous exécutons la base de données de mise à jour pour que la base de données soit opérationnelle, nous puissions réellement saisir du code qui sera considéré comme une migration afin que, lorsque cette
migration sera exécutée, ces données soient automatiquement
introduites dans la base
de données à partir du code d'obtention. C'est donc ce que nous voulons examiner rapidement dans cette leçon. Maintenant, le moyen le plus simple de procéder à
l'ensemencement est de le
faire à partir de la méthode de
création du modèle Dans tout cela, nous pouvons
dire point du constructeur de modèles, puis spécifier une entité. Disons que nous avons des équipes, des ligues, des
matches, des entraîneurs. Disons que je voulais intégrer
certains entraîneurs dans le système. Je vais dire que Entity Coach et cet Entity Coach ont des données, puis
ces données me permettent de
spécifier autant de
coachs que j'ai besoin. Ce n'est pas du cuivre,
ce sont des parenthèses. Et puis, entre parenthèses, je commencerais maintenant à
lui donner de nouveaux objets d'entraîneur Je peux donc parler de nouvel entraîneur. Je peux spécifier l'
identifiant dès le départ. Je vais utiliser certains identifiants dont je
sais qu'ils n'entreront pas en conflit avec
les identifiants existants. Le nom ID 20 est égal à Je vais utiliser mon
nom dans cette situation. Et l'identifiant de l'équipe. Eh bien, je peux aussi les laisser parce que je fais asseoir l'autocar. Maintenant, cela soulève un autre point
important. Si vous avez des données hiérarchiques, vous
devez vous
assurer que vous vous asseyez fonction de l'ordre ou
du niveau de dépendance, la même manière que nous
voulons créer les tables avec les dépendances de la
même manière que nous
devons ensemencer les données avec
ces dépendances. Parce que je ne peux pas m'attendre
à recruter Trevor Williams, l'entraîneur de la Team ID 5, mais après tout cela, je vais définir l'équipe avec l'ID 5 accord ? Permettez-moi donc de vous montrer
exactement ce que je veux dire. Si je dis équipe, je
veux une nouvelle équipe, je vais créer
une nouvelle équipe et cette équipe aura, disons, un identifiant 20 Le nom de l'équipe est Trevor Williams Sample
team. C'est bon. Je ne peux pas dire à
cet entraîneur que son identifiant d'équipe est l'ID 20,
car l'ordre dans lequel j'ai
défini ces commandes initiales est l'ordre dans lequel
le relevé
de la voiture va être généré. Je ne peux donc pas créer un
entraîneur et insérer entraîneur avec l'ID d'équipe 20 alors que
l'ID d'équipe 20 n'existe pas encore. Je dois donc m'
assurer de maintenir mes commandes en fonction
des niveaux de dépendance. Non, comme je l'ai dit, tu peux en
mettre autant que tu veux. J'ai donc un nouvel entraîneur ici, puis je peux simplement séparer autant d'objets du
nouvel entraîneur que nécessaire. Donc, si je voulais trois entraîneurs
dans le système au départ, bien
sûr, les identifiants peuvent entrer en conflit. Alors gardons simplement ce nom, échantillon un et échantillon deux. Et puis pour les équipes, eh bien, je ne peux pas être
l'entraîneur de la même équipe encore
et encore. Parce que nous connaissons les contraintes. Donc, quelles que soient les contraintes présentes dans la
base de données, elles
prévaudront, bien entendu, et les limites que vous aurez lorsque vous occupez votre
place, n'est-ce pas ? Vous voulez juste être
conscient de tout cela. Bien entendu, encore une fois, c'est probablement à
ce moment-là que le
système vient d'être installé. J'utilise donc les identifiants 2021 et 22 parce que j'ai déjà des équipes et des entraîneurs dans le système.
Je ne veux pas m'affronter. Cependant, dans un tout nouveau système
et un tout nouveau paradigme, vous
commenceriez probablement avec un, deux, trois ou quatre comme identifiants, car ce sont
les identifiants que vous voulez
absolument obtenir
avant toute autre chose. Maintenant, si vous deviez
ensemencer plusieurs tables, vous verrez que cela peut devenir assez fastidieux et honnêtement, je n'aime pas voir tout
cela dans la création du modèle C'est trop de code. Je veux que ça reste un peu plus propre. Donc, ce que je fais ou je vous recommande de
faire dans cette situation c'est de les extraire dans des classes de
configuration de départ. J'ai donc tendance à créer un dossier et je
vais le faire dans
le projet de données à
proximité des migrations. Je l'appelle donc configurations, puis j'ai un autre dossier dedans
car il peut y avoir plusieurs types de configuration
que nous pourrions vouloir faire. Je vais appeler
ça des entités. Et puis, à l'intérieur de cela, je vais avoir les différentes classes
de configuration par type d'entité. Donc, par exemple, je veux une configuration
Coach CD. Maintenant, dans cette classe, que je vais rendre publique, je vais hériter de la configuration du type d'
entité Je vais donc simplement saisir cette référence, et je vais dire que
c'est pour le type d'entraîneur. Et puis incluez tout ce
qui manque. Donc, pour le type d'
entraîneur, c'est ce que je veux. Alors maintenant, je vais devoir
implémenter cette interface, qui me donne cette méthode de
configuration et un constructeur local. Maintenant que j'ai ce générateur,
ce générateur a essentiellement le même objectif que cet objet de création de
modèles, n'est-ce pas ? Je peux donc simplement dire qu'il possède des données. Je vais juste prendre
cette partie en ce qui concerne l'équipe, laissez-moi simplement prendre la
partie contenant des données. Je vais couper, je vais
effacer tout cela
du contexte DV Et puis ici, je
veux dire builder, dot puis put on has data. Donc, tout ce que j'avais contient des données et au-delà s'inscrit
parfaitement dans cette méthode. Builder point contient donc des données, puis vous pouvez
en saisir autant d'
enregistrements que possible dans cette classe dédiée. Maintenant, bien sûr, si je
passe à une classe dédiée, j'ai besoin d'un moyen de la faire référence ou d'y
faire référence dans le contexte de la base de données. en revenir au contexte de la base de données, Pour en revenir au contexte de la base de données,
je vais dire model builder
point, appliquer la configuration, puis new et simplement transmettre le nom de cette
méthode ou, désolé, cette nouvelle classe que nous avons créée, qui est une nouvelle classe de
configuration. Je vous en transmets donc un
nouvel exemple, et c'est tout. Donc, autant de
classes de configuration que
vous créez, il vous suffit de
transmettre ces lignes. Encore une fois, maintenir
cet ordre. Je l'ai donc fait pour les sièges
d'autocar ou d'autocar. Faisons la même chose
pour les équipes, non ? Je vais donc
jouer au paresseux ici,
simplement copier-coller le fichier existant
et changer le nom en
siège d'équipe, configuration. Ensuite, je vais mettre à jour
les références du fichier. Il s'agit donc d'une
équipe de quatre types. C'est pour l'équipe. Et puis notre section de
données va en
découler directement. Je vais juste le copier-coller dans son fichier de
configuration dédié. Et pour en revenir au contexte de la DV, je peux simplement le dupliquer et dire «
team seed configuration »,
et
c' est parti Cela me semble donc beaucoup
plus propre, et c'est tout aussi efficace que d'avoir
tout dans le fichier. Mais bien sûr, cette
méthode reste un peu plus casher et est un peu plus belle
quand on la fait comme ça Voyons donc ce que nous obtenons lorsque nous essayons d'ajouter une migration. Et quand je fais cela, j'appelle cela des
équipes et des entraîneurs ajoutés par défaut. Je constate maintenant que le générateur de migration fait
quelque chose de différent. Nous ne l'avons jamais vu faire
cela auparavant. Il s'agit donc toujours de créer une
table ou de modifier une table. Maintenant, il insère des données dans les équipes de la table avec ces
colonnes avec ces valeurs, et il le fait
pour tout. Et encore une fois,
cet ordre est important. A voir, il a pris soin
de toutes les équipes. Ensuite, il s'
occupera de tous les entraîneurs qui dépendent des équipes,
n'est-ce pas ? Imaginez donc que si tout cela
était mélangé, nous essaierions d'
insérer un entraîneur avec
un identifiant d'équipe 21 avant même que l'équipe ayant l'ID 21 ne soit
créée, la recette du désastre. N'oubliez donc pas que les
commandes sont importantes. Et dans le D, les données de
suppression consistent simplement inverser toutes ces insertions
avec cette instruction de suppression Donc, si je mets à jour la base de données, je vais avoir cette
erreur, d'accord ? Je reçois ce message d'erreur
indiquant que j'ai un conflit avec l'équipe
et la colonne d'identification de la ligue. C'est bon. C'est très bien Dans cette situation, je dois modifier
ce qui se passe avec l'équipe parce que je
n'ai pas renseigné les données Vous devez
donc en être conscient. Vous devez être conscient
du fait que vos contraintes détermineront si les données peuvent entrer ou non. L'identifiant de la ligue ne peut donc pas être nul. Il s'agit d'une contrainte
qui s'applique à la base de données. Une équipe doit faire partie d'une ligue. Je ne peux donc pas faire siéger
des équipes sans ligues. Je vais donc rapidement créer une
ligue d'échantillons. Suivez donc les mêmes étapes, et je vais
vous encourager à faire une pause et à l'
essayer vous-même. Mais ce que j'ai fait, c'est
créer une nouvelle classe que j'appelle configuration de départ de la
ligue, suivant les mêmes
étapes héritées configuration
du type d'entité du type ligue Ensuite, nous allons simplement créer une ligue avec l'
ID 20, encore une fois, pour éviter tout conflit
dans la base de données, et le nom est Sample League. Ensuite, je mets à jour
rétroactivement configuration de
mon équipe de tête de série pour ajouter cet identifiant de ligue à
chacune de ces équipes
et, par extension, le contexte de
base de données dans lequel j'ai maintenant cette configuration de
tête de ligue avant
tout le reste Maintenant, j'ai fait une
erreur, d'accord ? J'ai généré cette migration
lorsque les données étaient incomplètes. Nous constatons maintenant que
cette migration
échoue . Comment revenir en arrière ? Eh bien, la première étape consiste
à supprimer la migration. Cela supprimera donc toujours
la migration la plus récente. Ensuite, je peux simplement continuer
et le générer à nouveau. Et cette fois, si nous y
regardons, nous voyons qu'il s'agit d'abord de créer
la ligue, puis de créer les
équipes, puis les entraîneurs. Jetons donc un autre coup d'œil
à la base de données des mises à jour. Et après des niveaux de journalisation
et de verbo, nous voyons que c'est fait, et nous savons
maintenant que nous avons ces données Donc, encore une fois,
il s'agit désormais d'une migration. Cela devrait donc se produire
tout au long de la chaîne, de migration
initiale à
la toute dernière migration que vous pourriez avoir
pour votre base de données. Il peut donc
arriver que vous deviez introduire différentes recherches et différentes
tables en cours de route, et vous ayez besoin de ces valeurs par défaut
dès le premier jour Eh bien, c'est parfait pour ça. Il vous suffit d'ajouter
les configurations, puis de
les placer dans le contexte de la base de données. Le modéliste
saura donc que lorsque
je construis le modèle,
je dois être au courant de ces
configurations pour les sièges.
33. Migrations à remonter: Salut, les gars, bienvenue dans cette leçon,
nous allons examiner le
retour en
arrière et la gestion des
migrations en général. Nous avons donc effectué
un certain nombre d'activités desquelles nous avons apporté quelques
modifications à notre base de données, et à chaque modification, nous avons effectué
une migration, puis nous avons mis à jour la base de données. Mais que se passe-t-il lorsque vous
effectuez une migration que vous ne souhaitez pas vraiment
ou que, rétrospectivement, vous souhaitez l'annuler, effectuer un ajustement et la refaire ? Dans cet exemple, j'ai déjà effectué une migration. Je vais
vous montrer les modifications que j'ai
apportées pour déclencher cette migration. J'ai modifié l'objet du domaine de base pour avoir ces quatre champs. Et ces champs sont généralement
utilisés à des fins d'audit. Vous savez, lorsque des personnes
saisissent
des données dans une base de données,
vous voulez savoir quand elles ont des données dans une base de données, été
créées, quand elles ont été
modifiées pour la dernière fois , par
qui et par qui. Maintenant, vous
voudriez généralement qu'ils soient assez clairs. Je les nomme donc délibérément mal, juste pour vous montrer qu'il s'agit d'une
erreur qui
justifierait probablement une correction une annulation ou
quelque chose comme ça Donc, dans cette situation, si vous regardez simplement
les noms des colonnes, ils ne sont pas vraiment
très cohérents, n'est-ce Date de création modifiée pour la dernière fois. Si je
regarde juste ce nom, je ne sais pas s'il s'
agit de la date de dernière modification ou s'il a été
modifié pour la dernière fois par qui. Je ne sais pas si
cette modification signifie date
modifiée ou la personne
qui l'a modifiée. Je ne sais pas. Tu
comprends ce que je veux dire. Donc, si, vous savez,
si vous êtes
obsédé par ces détails,
ces choses vous paraîtront un
peu moches Cependant, le fait est que j'ai apporté ces ajustements à
l'objet de domaine de base, qui, bien sûr,
est hérité
par tous les autres objets de domaine. Ainsi, lorsque j'ai généré
cette migration,
que j'ai simplement appelée champs d'audit
ajoutés, vous pouvez continuer et le faire pour, vous savez,
travailler à mes côtés. Mais quand je l'ai fait, vous avez
remarqué que cela ajoutait simplement ces colonnes à
chaque table existante. Cependant, de haut en bas. Ensuite, j'ai mis
à jour la base de données, ce qui s'est avéré une opération
réussie. Ainsi, à l'heure actuelle, chaque champ la base de données possède
ces colonnes d'audit. Maintenant, que se passe-t-il si je ne
suis plus
satisfait de cela ? Nous avons donc
déjà vu que lorsque nous
générons une migration et que
nous nous rendons compte qu'il y a
peut-être une erreur, nous pouvons toujours supprimer
la migration. Mais regardez ce qui se passe
lorsque j'essaie de supprimer le Et si je passe à
la commande et que je dis « supprimer la migration », tout
se construit et fonctionne. Mais ensuite, je reçois cette
erreur indiquant que la migration portant ce nom a déjà été appliquée
à la base de données. Annulez-le et réessayez. S'il a été appliqué
à d'autres bases de données,
envisagez d'annuler S'il a été appliqué
à d'autres bases de données, ses modifications Tu vois tout ça.
En d'autres termes, cette migration a
déjà été appliquée. Il ne peut donc pas simplement supprimer la migration, car la suppression de la
migration
supprime en fait la référence ou l'enregistrement de ce
fichier de migration du dossier C'est donc une solution
sûre, c'est dire que j'ai déjà pris note de
cette modification de la base de données. Je ne peux donc pas simplement le supprimer
de l'historique sans que vous ne
modifiiez la base de données. C'est pour cela que
nous sommes là pour comprendre comment nous
gérons cette annulation. Et c'est une procédure assez
simple. Je ne sais pas, peut-être que
ce message aurait pu nous donner
un indice plus important ou un meilleur indice sur la façon dont nous
pourrions rétablir la base de données, mais faisons-le ensemble Donc, rétablir la
base de données est vraiment une
activité de mise à jour de la base de données, n'est-ce pas ? Cela semble contradictoire, mais travaillez avec moi ici. Donc, pour rétablir la base de données à
une date antérieure, nous devons exécuter
notre
commande de mise à jour de la base de données et
lui indiquer à quelle migration
nous voulons effectuer notre
commande de mise à jour de la base de données et
lui indiquer la mise à jour, à
laquelle, si c'est dans le passé, elle revient réellement Je souhaite donc revenir à la migration que
j'ai effectuée où j'ai ajouté les équipes
et les entraîneurs par défaut juste avant d'ajouter les champs d'audit Je vais donc simplement
doubler le fichier très lentement, ou vous
pouvez à juste titre dire renommer, et je vais simplement
copier le nom de ce fichier Je n'ai pas besoin du CS. J'ai juste besoin du nom
parce que c'est le nom
de la migration qui
est réellement stockée,
le soulignement de l'horodatage et verbiage
que Donc, dans la console du gestionnaire de packages, je vais à nouveau dire mettre à jour la base de données. Ensuite, je vais simplement
passer le nom de la migration entre
guillemets et appuyer sur Entrée, et vous verrez alors que la migration a réellement fait ce qui
était prévu. accord ? C'est donc tout ce dont nous parlons lorsque vous avez le dessus
et que vous avez le travail à faire. Les commandes qui viennent d'être
exécutées
devaient donc être supprimées de
tout ce qui s'y trouvait. Il est en train de changer et
il supprime la colonne modifiée. Si vous regardez dans la partie faire, eh bien, le fichier de migration, désolé, si vous regardez dans la partie terminée
de ce fichier de migration, c'est tout ce
qu'il fait,
il lui demande de supprimer les colonnes. C'est donc un
exemple pratique de ce qui se passe :
nous revenons un en arrière et deux, lorsque cette baisse entre en
action, elle annule en fait
tout ce que la hausse Maintenant que nous avons rétabli
ou mis à jour la base de données
vers une version précédente, je peux maintenant continuer et dire en toute sécurité supprimer la migration Il le fera
volontiers, avec joie et sans aucune question ni aucun
scrupule, et c'est parti Il a supprimé cette migration
précédente. Je vais juste apporter des
ajustements à mon objet principal en
fonction de l'objet principal. Nous y voilà. J'ai mis à jour les noms de ces
colonnes pour qu'
ils soient un peu plus descriptifs de leur contenu. Créez une date, date modifiée, créée par, modifiée par. Après avoir fait tout cela, nous allons simplement
ajouter à
nouveau notre migration et ajouter la date que l'
audit indique. OK. Et quand ce sera fait,
je veux juste que nous regardions ce qui se passe
avec notre colonne de dates. Ce sont donc des colonnes de date et d'heure
et elles ne sont pas nullables. Ce
qui se passe, c'est lorsque vous avez un
champ de date et d'heure nul dans la base de données ou qu'il doit entrer une valeur C'est pourquoi nous obtenons cette valeur
par défaut partout où cette colonne de date et d'heure
va être ajoutée, n'est-ce pas ? Nous ne pouvons donc pas avoir de date
dans un champ de date nullable. Il s'agit donc de saisir
cette date par défaut, que
vous verrez probablement dans la base de données
01010001 C'est juste une
date par défaut, je suppose, depuis la nuit
des temps. C'est bon. Une fois tout cela fait, nous pouvons procéder à la
mise à jour de notre base de données. Et je vais exécuter cette commande sans
spécifier de migration, et ce sera une opération
réussie. Nous y voilà. À présent, notre base de données est dotée de
certains champs d'audit de base. Donc, lorsque les gens entrent, bien
sûr, nous voulons savoir quand ont-ils
créé cet enregistrement. Quand a-t-il été modifié pour la dernière fois, puis qui l'a créé
et qui l'a modifié pour la dernière fois.
34. Manipuler les entrées avant de sauvegarder les changements: Salut, les gars,
bienvenue dans cette leçon. Nous verrons comment manipuler les entrées
avant d'enregistrer les modifications. Maintenant, pour expliquer pourquoi vous voudriez faire
quelque chose comme ça,
c'est peut-être parce
que nous avons simplement ajouté
des champs d'audit pour toutes les tables, n'est-ce pas ? Nous avons donc simplement ajouté tous
les champs d'audit dans l'objet de domaine de base. Et évidemment, cela demande un peu plus de travail, car
nous avons vu que lorsque
nous ajoutons des données, nous devons formuler
les objets, puis les
ajouter et les ajouter au contexte
, puis enregistrer
les modifications Cela signifie que chaque fois que
quelqu'un ajoute une
équipe, une ligue, un match,
un entraîneur
ou quoi que ce soit à
la base de données ou qu'il la modifie,
nous nous imposons quelqu'un ajoute une
équipe, une ligue, un match,
un entraîneur
ou quoi que ce soit à la base de données ou qu'il la modifie, une
responsabilité
supplémentaire nous-mêmes ou à nos
développeurs, en disant de
toujours inscrire la date de création, toujours mettre une date de modification, moins si vous voulez que les
données soient standard Maintenant, le faire dans
un système plus vaste peut s'avérer très fastidieux, car nous ne travaillons qu'
avec quatre tables, et je
suis déjà ennuyé d'y penser Imaginez que vous ayez à gérer 20
à 30 tables ou plus. À ce stade,
il est donc bon de comprendre
comment le contexte vous
donne accès à tout ce
qui est sur le point d'être enregistré, et vous pouvez réellement
manipuler ce que vous devez manipuler avant
d'enregistrer les modifications. Je vais passer à
notre contexte de données ici, et ce sera une
expérience très intéressante maintenant, car nous pouvons annuler les modifications de
sauvegarde, n'est-ce pas ? Nous voyons donc un certain nombre
d'options de sauvegarde des modifications
à annuler. Nous avons celui par défaut, c'
est-à-dire lorsque nous appelons
context point save changes. Nous pouvons l'annuler. Ensuite, nous pouvons
effectuer certaines opérations ici avant de dire « enregistrer
réellement les modifications ». Vous remarquerez ici
que l'enregistrement des modifications renvoie en
fait un entier, qui est généralement
supérieur à
un en cas d'enregistrement réussi et inférieur à un ou zéro
en cas d'échec. Donc, si vous en avez besoin, vous pouvez probablement
l'intégrer à vos vérifications pour voir si l'opération de
sauvegarde a réussi ou non. Mais pour l'instant, nous n'
allons pas nous concentrer là-dessus.
Nous voulons savoir comment intercepter tout ce qui est sur le point d'être enregistré et manipuler ces valeurs
avant qu'elles ne soient enregistrées
dans la base de avant qu'elles ne soient enregistrées
dans la base Il y a un
certain nombre de choses à prendre en compte lorsque vous êtes
dans cette région. Tout d'abord, il nous a
été donné un objet appelé
Change Tracker. Je pense que nous avons
examiné cette question plus tôt, mais voyons simplement
ce que cela nous permet de faire. Nous avons donc changé de traceur ,
puis nous pouvons utiliser les entrées par points. Cela nous donne en fait
la liste des
entrées entrées dans la sauvegarde. Les modifications sont suivies par le
contexte en mémoire. Je peux dire que les entrées VR sont équivalentes aux entrées Change
Tracker Dot. OK. Une autre fonctionnalité
intéressante permettant de voir les entrées est d'
interroger ce que nous
appelons l'état de l'entité C'est donc une énumération qui nous est donnée. Une énumération n'est qu'une constante, et cette constante possède différents
états qui
représentent généralement l'état dans lequel se
trouverait votre entrée au moment où
elle sera enregistrée. Nous n'avons donc pas changé. Cela signifie que vous avez peut-être fait une requête, le suivi était activé,
donc il la suit, mais vous ne l'avez pas mise à jour, vous n'y avez rien fait, donc l'état est inchangé. Ajouté, je pense que cela va de
soi. Vous êtes sur le point d'ajouter
quelque chose à la base de données. Ainsi, chaque fois que vous créez
un objet et que vous dites « ajouter un point de
contexte »
puis que vous insérez l'objet, il est désormais dans un état ajouté. Détaché signifie qu'il n'est pas suivi
par le
contexte. D'accord ? Modifié signifie que,
eh bien, vous l'avez pris, vous y avez changé quelque chose, puis vous avez dit, le voici. Il était donc soit
suivi lorsqu'il a été modifié. Alors maintenant, il constate
que c'est
différent de ce qu'il
suivait initialement,
ou qu'il n'était pas suivi , et vous l'avez explicitement appelée mise à jour par point
contextuel
et vous l'avez transmise. Et puis il existe en fait
un autre moyen de mettre à jour où il
suffit de le marquer comme modifié, n'est-ce pas ? Vous pouvez donc
simplement le mettre dans l'état d'entité modifié pour que le
traqueur sache que je devrais le suivre en
tant qu'objet modifié. Texte autoexplicatif supprimé. Chaque fois que nous disons que le contexte
supprime et que nous lui donnons l'objet, il est maintenant dans un état supprimé. Ce sont donc vraiment
les États-entités à notre
disposition, n'est-ce pas ? Mais dans certaines situations, peut
que nous ayons besoin d'en suivre
certaines et de ne pas en suivre d'autres. Donc, avec les entrées, je ne veux pas voir
toutes les entrées. Je n'ai besoin de
rien qui n'ait été modifié ou qui
n'ait pas été ajouté, du moins à des fins
d'audit. Maintenant, encore une fois,
je vous donne juste un concept général que vous pouvez probablement adopter pour
différentes raisons, n'est-ce pas ? Vous pouvez donc avoir un journal d'audit
complexe ou une deuxième base de données dans
laquelle vous devez écrire des journaux. Vous devrez peut-être suivre, quand cela a-t-il été ajouté. Quand est-ce que cela a été modifié ? S'ils doivent être supprimés
et écrits dans
un magasin de données distinct,
quel qu'il soit, le suivi des modifications vous permet d'
intercepter ces entrées, faire ce que vous devez faire
avant que les modifications de sauvegarde ne soient exécutées Jetons donc un coup d'œil à cela. Ce que nous voulons faire, c'est obtenir toutes les entrées
qui sont sur le point d'être modifiées ou ajoutées, puis
mettre à jour les colonnes respectives Pour le
moment, nous allons simplement nous concentrer sur les dates. OK. Hein ? Ensuite, nous pouvons continuer et enregistrer les
modifications par la suite. Je peux donc étendre cet énumérable parce que cette fonction
renvoie simplement un énumérable, donc je peux simplement l'étendre et
dire où,
et nous pouvons utiliser notre
expression Lambda ici Je peux donc dire où Q ou
mon expression Lambda, puis je vais
chercher si l'état est égal à, puis je peux utiliser
ce nombre pour filtrer en cas d' ajout ou l'état Q est équivalent à l'état de l'entité
que je viens d'ajouter, donc cela serait maintenant modifié Ici, nous
filtrons et récupérons toutes les entrées qui sont point d'être ajoutées ou modifiées. OK. Ensuite, quatre lobes de chaque lobe vont
parcourir ces entrées, et je vais les
convertir
en objets du domaine de base. Alors regardez
ce qui se passe ici. Entrée dans les entrées. Maintenant, si nous examinons l'entrée, les entrées de type entity
entry. D'accord ? Donc, lorsque je le convertit, je peux simplement convertir l'entrée, mais je dois convertir l'entité du point
d'entrée. L'entrée comporte donc quelques
objets, quelques propriétés, vous pouvez voir les
valeurs actuelles de l'objet, vous pouvez voir les valeurs d'origine. Ainsi, même à des fins de
journalisation des audits, vous pouvez voir où se
trouvaient
les propriétés auparavant , où se trouvaient les valeurs
des propriétés plutôt avant et quelles sont
les valeurs actuelles. Vous pouvez examiner le contexte, et l'entité, bien entendu, incarne le type d'entité réel que le contexte connaît Maintenant que nous utilisons
l'objet de domaine de base et que tous les autres
types d'entités en héritent, je peux le ramener à
ce niveau afin modifier les champs de l'objet,
car pour le
moment, je ne sais pas
si je suis en train de sauver une équipe de football Je ne sais pas si je
sauve une allumette. Je ne sais pas quel type
d'entité apparaît
réellement dans l'entrée. Je le place simplement dans l' objet
du domaine de base afin pouvoir commencer à interagir
avec les champs. Pour chacun d'eux, je dirais que objets
auditables créent une date, beau et simple c'est égal à
date et heure point parce que je suis
sur le point d'enregistrer les modifications, il faut savoir que la
modification a été faite, désolé Date modifiée, c'est
la même heure. Mais ensuite, réfléchis à ça. Je cherche des éléments
ajoutés et modifiés, mais à chaque fois que
quelque chose est ajouté. Bien sûr, je veux
avoir la date de création, mais je ne veux pas avoir
la date de création à chaque fois que
quelque chose est modifié. Tu vois à quel point c'est délicat. Je regarde donc à la fois les éléments
ajoutés et les modifications, mais je mets
la date de modification chaque fois que quelque chose
va être modifié. Ou, désolé, je saisis
la date de création chaque
fois que quelque chose est
modifié, ce qui est faux. C'est bon. Je vais
retirer celui-ci. Donc, chaque fois que
nous cliquons sur Enregistrer les modifications, je tiens à dire que cela a été
modifié parce que c'est vrai. Qu'il ait été créé
ou modifié, date de modification est non. Cependant, je souhaite uniquement
définir la date de création si l'état du point d'entrée est équivalent au point d'état de l'entité créé ou ajouté, n'est-ce pas ? Donc, quand il sera adopté, il indiquera que pour cette entrée, je fixerai la date de modification. Donc, qu'il soit créé
ou réellement modifié, nous fixons la date de modification. Toutefois, s'il est ajouté, définissez la date de création. Sinon, il va simplement ignorer
cette étape. Cela ne servira à rien. Nous allons simplement passer à l'entrée suivante et faire tout cela
jusqu'à ce que ce soit terminé. Maintenant que tous ces
audits sont terminés, nous reste plus qu'à ne nous reste plus qu'à enregistrer les modifications. C'est comme un dernier hourra. Quelles que soient les données
reçues, nous ne savons pas,
nous ne savons pas de quel type d'ensemble de
bases de données d'entité il s'agit. Nous savons juste que tous ces éléments ont un objet
de domaine de base en commun. Une fois que cela est en place, nous pouvons passer
aux champs d'audit, quel que soit le type de niveau
supérieur, je dois dire, puis apporter les ajustements,
puis enregistrer les modifications. Maintenant, avant de passer à autre chose, je viens de remarquer qu'il n'
y a aucune référence
à cette méthode. Dans mon programme de CS, j'ai éliminé quelques-unes des anciennes méthodes que
nous aurions utilisées, et chacune de ces méthodes
appelle enregistrer les modifications, mais regardez cela,
enregistrer les modifications est une synchronisation Cependant, nous avons annulé les modifications de sauvegarde
uniquement. C'est ce que j'ai oublié
de ma part, non ? La méthode de remplacement que
nous recherchons vraiment consiste donc à enregistrer
les modifications Donc, ce que je vais faire, c'est réécrire cette dérogation parce que je pense qu'il y Je veux juste m'assurer que
nous choisissons le bon. Nous avons donc enregistrer
les modifications, enregistrer les modifications
et enregistrer les modifications, une synchronisation
qui prend deux paramètres, puis celle-ci qui prend un paramètre avec une valeur par défaut. Je pense donc que c'est
celui que nous voulons parce que si nous
utilisons l'autre, nous devons
fournir un lingot,
et eh bien, ce
jeton d'annulation est là par défaut, mais ensuite nous voulons celui
avec le code par défaut où nous savons que nous n'avons pas à
fournir de paramètres Je vais utiliser celui-ci et organiser mon code
ici, non ? Nous y voilà. Notre tâche de remplacement publique
dans Enregistrer la modification est donc une synchronisation, et c'est le paramètre Vous pouvez
procéder à cet ajustement, puis en plus de cela, nous
devons créer ce
syn parce que eh bien, c'est un syn, nous devons donc en
faire une méthode asynchrone Et puis s'il
appelle une méthode synchrone, c'est une méthode asynchrone, ce qui signifie que nous voulons également utiliser la méthode asynchrone ici. Je peux simplement changer
celui-ci pour sauver, c'est changer un péché et cela demande un certain poids. Je peux donc simplement transmettre ce
poids, et ça devrait être tout. J'ai donc de la cohérence. Je vais utiliser le
même
jeton d'annulation dans le paramètre
juste là. C'est bon. Donc, avec cet ajustement, non, je vois que les 12 références sont faites aux modifications de sauvegarde. C'est donc un peu
mieux maintenant. C'est bon. Cela signifie donc que lorsque nous
appelons le contexte à partir de notre fichier program.cs, il va vraiment accéder à
notre nouveau fichier personnalisé, puis il va
faire tout
cela avant d' appeler la base. D'accord ? C'est donc le pouvoir de
contourner tout cela. Alors allons-y et
essayons-y. C'est bon. Et si je n'ai pas indiqué
les méthodes que j'ai
dépoussiérées, je m'excuse Nous utilisons donc les méthodes simples d'
insertion lesquelles nous ajoutons une nouvelle ligue
et de nouvelles équipes par ligue, et je fais la simple
mise à jour du record de ligue,
nous mettons à jour le record de la ligue et le
record de l'équipe. Donc, jetez un œil à la console et aux
instructions SQL générées. Vous verrez ici que
j'ai P trois, et que j'ai cette
valeur de date et d'heure juste là, non ? Et quand il est
inséré, date de création, date de
modification,
P deux et P trois entrent. En conséquence, voici P one. Il y a P one, qui
est notre date de création. Et puis P deux est nul parce qu'il
serait créé ou
modifié par . Nous voyons donc
que nos dates entrent correctement
dans notre instruction SQL, n'est-ce pas ? Donc, encore une fois,
cette instruction SQL est générée au moment où
vous effectuez des modifications de sauvegarde. Maintenant, nous l'avons remplacé pour effectuer d' autres opérations
avant cette instruction Q. C'est donc une bonne petite façon d'
injecter votre propre petite logique
et un peu de cohérence ou de
nettoyage ou quoi que ce soit d'autre
que vous devez faire avant que les données ne soient réellement
validées dans la base Vous pouvez
alors toujours remplacer les
méthodes contextuelles de ce type Il existe maintenant un moyen
d'étendre encore
le contexte de base de données
pour faciliter certaines choses. Donc, dans le contexte, nous voulons indiquer
« peut-être modifié » par, par
exemple, un nom d'utilisateur ou quelque chose
à dire, qui l'a modifié. Évidemment, nous ne pouvons pas le faire ici car il n'y a aucun
moyen pour moi de transmettre une chaîne représentant
le nom d'utilisateur sous forme de valeur ici car safe changes
ne recherche que cela. Nous pouvons donc
étendre notre contexte pour
accepter des données supplémentaires que
le contexte par défaut n' accepter des données supplémentaires que accepterait pas, puis nous pouvons masser les données avant d'
appeler le contexte de base. Nous pourrons donc y réfléchir plus tard, et je pense que ce sera
une activité amusante. OK.
35. Élargir DbContext: Salut, les gars, bon retour. La dernière fois que nous sommes venus ici, nous étions en train d'étendre le contexte RDB pour gérer un peu de travail d'audit En d'autres termes, nous avons étendu les modifications de sauvegarde ou les avons
annulées pour pouvoir masser un peu
nos données avant enregistrer dans la Maintenant, nous en avons constaté les avantages,
car nous constatons maintenant que nous obtenons les dates
d'audit pour la date de modification et de création. Cependant, l'une des limites
est que nous ne connaissons la personne qui a créé aucun
moment
la personne qui a créé
ou modifié l'enregistrement. C'est donc l'une des
limites que nous ne faisons que contourner,
car nous sommes encore peu confinés à ce que les modifications
sécurisées par défaut nous réservent Je ne peux pas remplacer ce paramètre car le compte
demande un nom d'utilisateur Donc, pour le contexte ou le
programme, le point représente l'application que
l'utilisateur utilise, n'est-ce pas ? Lorsque quelqu'un utilise l'
application Web ou de bureau,
il ajoute un nouveau prospect. J'
aimerais enregistrer qui l'a fait. Je veux que leur
nom d'utilisateur soit enregistré dans le système. Je ne veux pas leur imposer leur
responsabilité, à
l'utilisateur de
me dire qui ils sont. Je veux savoir qui
était connecté lorsque cette action a été prise
contre cet enregistrement. Ce serait donc bien si
je pouvais transmettre un nom d'utilisateur dans les modifications de
sauvegarde afin que nous
puissions l'utiliser lors de l'
audit avant de sauvegarder. Donc, compte tenu de toutes ces limites
que nous comprenons et de
ce que nous voulons accomplir, ces limites
que nous
comprenons et de
ce que nous voulons accomplir,
je vais m'y attarder. Ce que nous allons faire,
c'est étendre le contexte pour y inclure une autre citation de version qui reprendra
le rôle de sauvegarde des modifications ou
remplacera les modifications de sauvegarde
, puis le transférera Cela semble donc un peu plus
compliqué qu'il ne l'est réellement, et
le travail a déjà commencé. J'ai donc créé une
toute nouvelle classe, j'ai
créée directement dans le même projet de données que
le contexte de base de données d'origine. Je parle simplement d'un contexte de base de données auditable, désolé, de la
ligue de football Maintenant, ce fichier contextuel de base de données d'audit de la
ligue de football est un résumé,
donc il ne serait pas,
vous savez,
instancié tout seul Et il hérite du contexte de base
de données. Ce que nous allons faire, c'est laisser le contexte de base de données d'origine
ou le contexte de base de données de ligue
de football hériter
de notre contexte de base de données de
ligue de football L'avantage de cette solution est
qu'en utilisant simplement celle-ci, nous obtenons toutes les fonctionnalités
disponibles dans la version auditable,
mais la version
auditable mais un peu plus de
flexibilité, car nous
ne sommes pas confinés au contexte de base de données
réel
et nous ne le contournons pas à cet
égard Cela
dit et fait,
je vais simplement supprimer
cette
méthode de je vais simplement supprimer sauvegarde des modifications AC du contexte de base de données de notre
ligue de football, et je vais la placer
dans la version abstraite, et je vais apporter quelques
modifications à ce stade. Premièrement, je vais supprimer
ce jeton d'annulation parce que je n'en ai pas vraiment besoin. Je vais l'
autoriser à appeler
les modifications de sauvegarde de base parce
que c' est
le contexte de la base de données, n'est-ce pas ? Mais je vais également étendre cette méthode pour prendre un
paramètre de chaîne appelé nom d'utilisateur. Maintenant, cela fait
savoir à
chaque méthode d'appel qu'elle doit transmettre un nom d'utilisateur pour pouvoir
appeler correctement cette méthode. Et je vais
supprimer cette dérogation
parce que nous ne la remplacons
plus Nous n'avons qu'une méthode
appelée enregistrer les modifications, qui va simplement
appeler la base. C'est donc comme une extension ou une méthode avant
la vraie méthode. Maintenant que ce paramètre de
nom d'utilisateur arrive, je peux maintenant dire que le point de l'objet
auditable à ce stade
serait modifié par, puis que le point modifié par
serait le nom d'utilisateur Et de même, le nom créé
par serait ce nom d'utilisateur. Maintenant, aucune référence.
Pourquoi est-ce le cas ? En effet, dans notre programme, il appelle toujours les modifications de sauvegarde
par défaut. Laissez-moi trouver l'une de ces
méthodes. Ça y est. Il appelle toujours
save changes async, c'est la méthode par défaut
pour le contexte Cependant, si je regarde les
surcharges qui s'offrent à moi, je constaterai qu'il
y a une nouvelle surcharge, qui me permet de transmettre
cette chaîne de nom d'utilisateur Allons-y. Je peux donc
transmettre un nom d'utilisateur. Disons simplement un utilisateur de
gestion de l'équipe de test. Je suis désolée J'essaie juste d'être
suffisamment explicite pour que nous puissions voir dans la requête de base de données où vont
entrer ces modifications de sauvegarde. Il s'agit d'une simple mise à jour. Nous pouvons donc rechercher cet utilisateur
ou tester la mise à jour. Laisse-moi rester simple.
Testez l'utilisateur de mise à jour. Ce record. Nous n'en avons pas besoin. Je vais laisser
celui-ci sans nom d'utilisateur. Cela modifie la ligue. Celui-ci n'aura
pas de nom d'utilisateur. Il s'agit d'un audit. Je peux donc changer le nom de
ma ligue. Vous
n'êtes donc pas obligée de le faire. Vous pouvez utiliser vos
anciennes données ou saisir vos propres données, mais c'est très bien. Mais je vais juste ajouter quelques remplacements : test
audit create user, puis je laisserai celui-ci sans nom d'utilisateur, n'est-ce pas ? Je vais donc simplement l'exécuter à
ce stade et voyons
exactement ce qui se passe. Donc, lorsque je regarde
certaines déclarations,
je vois ici, dans
les modifications de sauvegarde que j'ai ce test audit
create user. Allons-y. Cet
utilisateur de création d'audit de test est donc celui qui a créé
cette ligue de tests d'audit. C'est bon. Allons-y. Donc, cette personne, cet utilisateur comme P zéro et P deux. Et si nous regardons P
zéro est le créé par et P deux est le modifié par. C'est ainsi que nous pouvons intégrer
ces utilisateurs dans le système. Je remarque, même si je l'ai
cité ici, encore une fois, dans une vraie application
où des personnes se
connectent , etc., il existe des
moyens d'obtenir les noms d'utilisateur et de les connecter simplement
à la sauvegarde des modifications. Dans les applications Web principales du .NET, vous pouvez même injecter le contexte CTP en cours route et éviter de
le saisir
et de l'envoyer,
mais ce n'est pas mais ce J'essaie simplement de vous
montrer comment étendre le contexte de votre base de données
et manipuler vos données manière de plus
en plus créative afin de
garantir l'intégrité des données au moment où elles arrivent dans
la base de données. OK.
36. Mettre en œuvre un audit complet de base: Tous les bons gars. Donc, la dernière fois que nous étions ici, nous étions juste en train de concrétiser la façon dont nous faisons notre audit. D'accord. Donc, à savoir que l'audit est juste une date modifiée et modifiée par la création de la présence créée par. Mais alors vous pourriez avoir une autre nécessité où vous pourriez avoir besoin de vérifier l'ensemble du rouleau. Donc, vous pourriez être sur une base de données séparée ou c'est une table séparée, ou du moins c'est toujours fait traditionnellement. Parfois, ce que les gens font, c'est qu'ils mettent des déclencheurs dans la table de sorte que chaque fois que quelque chose est enregistré, modifié ou supprimé, il écrira automatiquement sont nécessaires à une autre table qui est le camionnage. L' activité qui s'est produite sur une table particulière est de prendre une copie de la table. Nous allons donc prendre une copie des valeurs d'origine avant l'opération, les nouvelles valeurs après
l'opération, les sérialiser dans une chaîne
et stocker cela à l'intérieur de la base de données. Comment il peut être lu. C' est à l'application et au développeur à la fois. Mais je vous montre juste à quel point EF Core est flexible dans l'accès aux données avant et après le fait et comment nous pouvons les manipuler pendant. Commençons donc par créer une nouvelle classe et je vais la mettre dans le domaine. Vous pourriez probablement le mettre en commun, mais ce sera vraiment une classe de domaine. Crée une nouvelle classe. Je ne veux pas l'appeler audit informatique. Donc, l'audit va avoir quelques champs, va avoir l'identifiant standard, une chaîne pour le nom de la table. Donc, nous le rendons public. Et puis on a mis dans les champs. Donc, il va avoir le nom de la table d'ID, datetime, ce qui
signifie que l'heure, bien sûr, il a été entré, la valeur clé. Donc, quelle que soit la clé primaire qui est hors de
l'enregistrement en cours d'audit, les anciennes valeurs de l'enregistrement et les nouvelles valeurs de l'enregistrement. Donc, après avoir répliqué cette classe d'audit, vous pouvez passer à notre contexte DB auditable. Et nous allons ajouter ce DB set, n'est-ce pas ? Donc, il va être dans le contexte DB auditable. Avez-vous besoin de définir l'audit ? Et je l'appelle juste audits. Alors nous allons aller dans des changements trompeurs. Et je veux vraiment faire des choses avant de sauvegarder les modifications, parce que avant de sauvegarder les modifications, nous devons prendre une copie des données qui arrivent, non ? Alors juste au-dessus où nous recevons nos changements de camion et savons ce qui s'est passé et ainsi de suite. Je vais voir avant d'enregistrer les modifications, n'est-ce pas ? Cette méthode n'existe pas, donc je vais juste contrôler dot et générer ce stub de méthode. Et on y va. Donc, cela va retourner une liste d'une autre classe que je suis sur le point de créer appelée entrée d'audit. Donc, si je fais Control dot, Voyons ce que Visual Studio peut faire pour nous. Il dit qu'il peut générer un type appelé entrée d'audit dans son propre fichier. Donc, nous allons juste aller de l'avant et le créer dans son propre dossier. Pas de mal, pas de faute. Sautez à l'entrée d'audit. Donc, une entrée d'audit va fondamentalement être une obstruction à ce dont nous avons besoin exactement, non ? Alors réglons cette classe un peu. Donc, je vais dire entrée d'audit public. Donc, c'est fondamentalement le constructeur. Et je veux l'entrée de l'entité. Donc, nous savons ce qu'est l'entrée d'entité. Cela vient d'EF Core. Et nous allons juste l'appeler entrée de l'entité et bien sûr. Et puis nous allons utiliser ce constructeur pour initialiser notre propriété. Donc, je peux contrôler cela et dire Créer comprendre la propriété appelée entrée d'entité. Et il le fait automatiquement pour moi, non ? Alors, je vais avoir d'autres champs autant de ce que nous avions dans l'audit, n'est-ce pas ? Donc, je vais avoir le nom de la table de chaînes. Je vais aussi avoir bien, vieilles vallées et de nouvelles valeurs et bien Key Vault est tout au sujet n'implique pas ce que je vais changer les types de données de ceux-ci. Donc, nous avons le nom de la table, nous avons la valeur clé qui va vraiment être comme un dictionnaire. Quelqu' un pour changer le type de données en dictionnaire de chaîne et d'objet. Donc, si vous n'avez jamais travaillé avec des dictionnaires est juste comme une paire de valeur de clé afin que je puisse être en mesure de résoudre JSON. Et c'est ce qu'est un dictionnaire. Une chaîne serait la clé et les objets seraient les données qui entrent à côté de la clé. Donc, le point de contrôle inclut cela. Et je vais juste l'initialiser pour qu'il ne sache jamais. Donc, prenez ceci et c est égal à un nouveau dictionnaire de chaîne, un objet. Et c'est à peu près tout ce que nous allons faire pour les anciennes valeurs et les nouvelles valeurs. Et nous faisons les mêmes initialisations et vous voyez tout ce genre d'apparence cohérente et petite balle plus effrayante bientôt vous verrez ce que nous cherchons à accomplir. La ligne suivante sera pour les propriétés temporaires. Donc, je vais dire une liste publique d'entrée de propriété. Qui vient aussi de la bibliothèque d'entrées d' entité de suivi des changements de tendances freeware, n'est-ce pas ? Ainsi, vous voyez une liste d'entrée de propriété, propriétés
temporaires est égale à une nouvelle liste. Je vais avoir une méthode rapide qui revient juste notre propriété plutôt que de retourner un booléen pour voir a des propriétés temporaires. Donc, dès que vous expliquez ce que les propriétés de tempérament signifient vraiment ou seront utilisées pour. Mais alors nous allons avoir une autre méthode qui va réellement construire ou audit requis sur je vais l'appeler pour vérification. D' accord. Je devrais juste inclure n'importe quel espace de noms là-bas. Là, nous allons à la vérification. Et puis nous pouvons commencer à construire toutes les fonctionnalités. Donc, quand on parle d'audit, on parle de construire l'entité réelle, son dossier. Donc var audits est égal à un nouvel audit. Initialiser un nouvel objet de type audits. Ensuite, nous commencerons à remplir tous les champs de l'audit. Donc, je peux utiliser cet initialiseur d'objet. Et puis je peux dire, d'accord, Est-ce que le temps nous savons que vous êtes Datetime dot nl no-brainer, non ? Donc, ce sont les points de temps. Non. Droit ? Puis le nom de la table, c'est assez facile et il ne devrait pas y avoir d'utiliser un point-virgule, excuses. Le nom de la table est égal au nom de la table provenant du local. D' accord ? Ensuite, nous avons les valeurs clés, ce qui serait une sérialisation des valeurs clés entrant, n'est-ce pas ? Donc, je vois juste les valeurs clés sont égales à JSON convertir, voir sérialiser ou valeurs d'objet et de clé, n'est-ce pas ? Donc à peu près rappelez-vous que c'est un dictionnaire. Donc nous allons avoir la clé, ce qui va être comme une pièce d'identité. Nous allons avoir la valeur est stockée en tant qu'objet, donc c'est un ID de chaîne, ou dans notre cas, nous utilisons int ids. Quoi qu'il en soit, va juste avoir cette paire de valeur clé et nous allons juste le stocker en JSON. Et franchement, ce sera la même chose pour les anciennes valeurs et les nouvelles valeurs. Mais il y a une sorte de rebondissements avec ça. Donc, nous allons voir quelque chose comme toutes les valeurs sont égales à toutes les valeurs points cônes étant 0. Si c'est 0, alors nous pouvons stocker null. Sinon, nous voulons convertir le volume venant de la valeur de clé apparaissent. Connaissez la pertinence de cela. Si nous faisons certaines opérations comme l'insertion de notre disque, alors il n'y a pas de vieille valeur pour ce disque parce qu'il s'agit d'un tout nouveau record. Donc, il n'y a aucun moyen d'obtenir les anciennes valeurs. Donc, il sera journalistique pour voir s'il y a des anciennes valeurs à stocker dans cet enregistrement
sinon null car alors nous pouvons supposer que c'était une opération d'ajout. Et puis nous pouvons aller de l'avant et sérialiser les valeurs si c'était que je n'ai pas mangé ou une mise à jour. Donc, de la même façon que nous avons fait tout de même, nous ferons de nouvelles valeurs. Donc, je vais juste dupliquer cette ligne et changer donc deux nouvelles valeurs. Et partout où il y avait une scission, de nouveaux copains. Donc, s'il n'y a pas de nouvelles valeurs, stockez null, bien que les yeux stockés dans les nouvelles valeurs. Je pense que je vais ajouter un champ de plus et c'est l'axone. Donc je vais, dans la table d'audit, ajouter des actions pour que nous sachions quel type d'opération était effectuée, ce qui est juste. Donc action, et je vais faire la même chose ici, vous appelez action. Et puis pour vérifier, je dirai que l'action est égale à notre action locale. J' ai entendu. Donc, nous savons ce qui se passait maintenant après avoir construit tout cet objet d'audit, cette méthode est censée retourner cet objet d'audit. Donc, nous retournons juste l'audit. C' est tout pour notre audit. Entrez au moins pour null au fur et à mesure que
nous allons, nous pourrions voir tous les ajustements qui sont nécessaires. Non, nous allons revenir à notre contexte DB auditable. Et pour moi, c'est plus facile, je vais juste enlever tout ça. Je vais le couper et je vais le mettre à l'intérieur de notre nouvelle méthode. Donc avant de sauvegarder les changements, ce
sont des choses que nous voulions faire de toute façon, non ? D' accord, donc je vais le refactoriser un peu au lieu d'
essayer d' obtenir seulement ces entrées mercredi, au lieu de passer par un processus d'élimination. Donc, je suis allé voir s'ils obtiennent les entrées de l'instructeur où l'état n'est pas égal à détaché et il n'est pas égal à sur la façon tricheurs serait de capturer plus de scénarios entre les deux, non ? Alors donnez-moi les entrées qui n'ont pas été
détachées ou inchangées et puis ce sont les intérêts que nous partageons à travers. Vous voyez ici que c'est qu'il se plaint sur le nom d'utilisateur. Voyons ce que controller.js pour nous, nous pouvons générer une propriété qui va bien. Ok, cela ajoute juste le paramètre. utilisateur du périmètre généré. Il y avait toutes sortes de choses que je cherchais. Donc maintenant, nous avons le nom d'utilisateur i, nous pouvons Boston que le nom d'utilisateur sur avant, voir si les changements et tout le monde est heureux. Très bien, donc nulle part obtenir tous les intérêts ne sont pas touchés,
pas inchangés sur notre mise en place de ces colonnes d'audit pour eux. Avant d'entrer dans ce domaine pour chacun, je veux une nouvelle liste d'entrées de vérification et nous allons compiler cette liste au fur et à mesure que nous passerons. Donc, pour chaque entrée, après avoir passé ces tests initiaux, je vais essayer de voir que je veux une nouvelle instance de politique d'entrée d' audit dans cette entrée venant de notre camionneur THE. Droit. Alors rappelez-vous que c'est quand nous avions le constructeur et audit pour s'assurer que l'entrée Tolkien comme paramètre. Ensuite, je vais obtenir le nom de la table en voyant le nom table de points d'entrée d'
audit est égal à et puis vous venez de vous dépêcher et de vous asseoir que c'est égal à entry.metadata. Donc, je suis juste en train de montrer beaucoup de données. Vous pouvez en fait obtenir un bateau, quelque chose qui est un boulon à enregistrer dans la base de données. Je peux obtenir les métadonnées, pas la relation. Laissez-moi voir votre événement relationnel doit
inclure une référence manquante ou simplement l'épeler correctement. Donc point relationnel ou en fait je pense que c'est un dotnet Core trois points un. Si core 3.1, voici, obtenez le nom de la table. On y va. Donc, dans la cour dotnet Core 5, il est encore plus facile d'obtenir un nom de table. Je vois juste le nom de la table GET. D'accord. Ensuite, nous allons ajouter cette nouvelle entrée d'audit à notre liste. Donc, je vais juste dire Ajouter et l'entrée d'audit comme fait ensemble. Il y a un autre domaine sur lequel je voudrais siéger à partir de maintenant,
et ce serait l'action. D' accord, donc nous devons savoir quelle action est menée. Et puis je pouvais juste voir le point d'entrée, état, point à chaîne, c'est la vente aux enchères. Sachez que nous avons cette partie du chemin et laissez-nous nous concentrer sur les propriétés. Nous devons donc évaluer certaines propriétés, une, pour copier leurs valeurs, qu'
il s'agisse de vieilles vallées ou de nouveaux pères ou de la clé primaire égale et éloignée. C' est notre dossier d'audit
, a un champ spécifique pour la clé primaire. Donc, ce que nous pouvons faire facilement est de commencer avec un foreach et nous pouvons dire propriété
var en entrée, propriétés de pensée. Donc, cela utilise ce que nous appellerons des réflexions et tout ce qui est l'une de ces grandes allocations nous est donné par des versions plus récentes de C sharp. Donc, nous pouvons voir si la propriété, désolé, si la propriété est temporaire. Donc, cela nous permettrait d'évaluer s'il y a la plus belle emprise de valeur à l'intérieur de la propriété. Donc, quand plus récent, expérimentant avec l'ajout d'enregistrements et ainsi de suite, vous verrez que la valeur id a un moins, je pense que c'est int Min moins 2 milliards et quelque chose de valeur dedans. C' est en fait une valeur temporaire jusqu'à ce que la valeur soit enregistrée. Droit. Nous voulons donc voir si la propriété est temporaire que les points d'audit. Les entrées d'audit sont des propriétés temporaires de cette propriété. D' accord. C'est donc tout ce que nous pouvons savoir si cela va être ajouté ou non. Vous verrez plus tard pourquoi c'est si important. Donc, après cela, nous pouvons continuer. Nous n'avons pas besoin de faire une autre opération sur cette propriété. S' il s'agit d'une propriété temporaire, nous l'ajoutons au dossier et ensuite nous continuons. Pas besoin de s'en soucier. Aucune autre chose que nous pourrions avoir à faire si elle ne
tombe pas dans cette catégorie est obtenir le nom de la propriété. Qui encore une fois, je vais devoir saisir property.metadata et nous utilisons
juste mon nom de point de données de propriété de presse-papiers. Donc, je reçois une inflammation et c'est ce que sont les métadonnées. Si property.me est la clé primaire. Et c'est une méthode. Donc on voit si on a affaire à une clé primaire, alors on veut stocker les copains clés. Donc ça va ressembler à ce qu'on a fait ici. Nous voyons toujours l'audit SI introduit des valeurs clés, puis nous obtenons le nom de la propriété comme clé ou l'indice de l'IRI. Et nous stockons la valeur. Donc, on va juste y aller et stocker ça. Donc c'est tout ce que nous obtenons que la valeur clé apparaît, non ? Donc, c'est une chaîne dans le dictionnaire, c'est comme un nom de propriété. Et puis la valeur ou l'objet serait la valeur actuelle de la clé primaire. Ensuite, on passe à un interrupteur où on voit me trouver l'état des entrées. Donc changer d'état d'entrée. Et puis on va faire quelques affaires. Nous allons vérifier s'il est ajouté, alors nous devons stocker les nouvelles valeurs avec le nom de la propriété sur la valeur actuelle. D' accord ? Bien que si elle est supprimée, nous avons besoin de stocker les anciennes valeurs avec le nom de la propriété et l'origine de nous ECF valeur actuelle et l'origine de la valeur. La valeur actuelle est ce qui est en train de mettre connaissance et les valeurs d'origine, peu importe ce qu'il était avant. Donc, cela est utile savoir quand nous vérifions si l'état NTT est dans un état modifié à ce moment où nous voyons s'il le
modifie sur une propriété a été modifiée, à droite. Donc, nous voyons si vous modifiez cette propriété particulière que nous examinons, alors nous voulons savoir quelle était la propriété originale d' Ardi et quelle est la valeur de la nouvelle propriété. D' accord. C' est donc à ça que sert cette instruction switch. Et bien, non, c'est tout ce que je fais là-dessus. Donc, une fois de plus, nous voulons stocker si c' est approprié si c'est une propriété temporaire, si c'est le cas, cela signifie
que c'est un enregistrement qui est un boulon à ajouter et qu'il
n'y a pas de clé primaire car c'est activé avant d'enregistrer les modifications. Donc rien ne se passe vraiment pour l'instant. Principales façons. Cependant, si elle fait une clé primaire qui ne serait présente que si elle était à la suppression ou une modification, alors nous allons de l'avant et faisons une note de la valeur de la clé. Sinon pour le reste des valeurs où l'enregistrement des nouvelles valeurs sont, ce que les anciennes valeurs sont, juste supprimé, et les deux si elle est modifiée. Donc, non, nous devons réellement enregistrer ces entrées d'audit ou au moins établir une liste d'audits à examiner plus tard, d'accord. Donc, je vais faire un pour chaque œil à nouveau, je ne veux pas enregistrer pour chaque entrée d'audit dans et je vais obtenir ces entrées d'audit de liste ancrées. Et je veux qu'ils soient là où nous avons notre expression lambda, q-dot a des propriétés temporaires. Nous pouvons voir est égal à tomber, ce qui signifie qu'il n'en a pas ou je peux utiliser. Je ne dis pas que je l'ai fait à des fins de lisibilité. Donc, nous sommes il y a des propriétés temporaires nulles et je ne peux pas utiliser l'entrée d'audit ici à nouveau, laissez-moi juste voir l'audit en attente d'audit pour m'assurer de me laisser utiliser cette entrée d'audit en attente. D' accord. Donc, pour chaque entrée d'audit en attente dans la liste que nous avons compilée à ce point où il y a des propriétés temporaires nulles, alors nous voulons l'ajouter à la base de données d'audit sit pour conduire à une blessure. Donc, en attente de point d'entrée d'audit et voici pourquoi nous avons eu cela à la méthode d'audit. Alors rappelez-vous que les deux bruit de vérification quand prendre n'importe quelle valeur était Boston et ce qui était assis ici et en fait créer sur les audits record pour retour. Droit ? Donc, nous voyons juste tout ce que nous venons de compiler, toutes les paires de valeurs clés sur. Donc, convertit en un enregistrement d'audit réel et éditer l'outil ou DB sit. Après tout cela, je veux retourner les entrées d'audit qui n'
ont pas ou désolé que double ont des propriétés en attente, des propriétés temporaires. Donc, je veux retourner où ils ont des propriétés en attente. Et bien sûr que c'est nous d'être une liste parce que j'ai besoin de cellules renvoyant une liste. On y va. C' est donc ce qui se passe avant d'enregistrer les modifications. Je comprends toujours ça, Aaron. Je pense que c'est parce que je l'ai fait c'est à l'intérieur de ça pour chacun et c'est sa carte. Donc, cela devrait arriver en dehors de ça pour chaque je m'excuse. Laisse-moi l'appeler rapidement. Et à la fin de la méthode, nous passons par des audits compilés et retournons ceux qui sont temporaires. On y va. Tout le monde est content de ça. Non, on l'a déjà fait. Enregistrement des modifications. D' accord. Et puis nous allons de l'avant et sauvegardons les changements. Maintenant, ce qui va se passer après avoir enregistré les modifications souvent à ce stade, c'est que nous allons
avoir tous les intérêts d'audit qui ont les valeurs
qu'il veut être ajouté là où ils n'avaient pas encore d'ID. Ils sont toujours stockés à l'intérieur de ce null. Je veux revenir en arrière et mettre à jour l'ID valide savoir qu'ils ont été stockés. Donc, au lieu de revenir à ces points, je vais mettre ceci dans une variable. Je vais juste l'appeler. Résultat ou résultat. Donc nous stockons juste ce que ce serait, non ? Et puis nous allons avoir une autre méthode que je vais appeler après avoir enregistré les modifications sur la stratégie où dans les entrées d'audit. Droit. Nous obtenons donc les entrées d'audit qui étaient dans un état d'ID temporaire. Nous voyons que g et g sont et tout ce qu'ils ont été mis à jour. Maintenant, nous devons faire quelque chose après les changements de sauvegarde. Donc, je vais effondrer l'on avant et je vais juste générer cette méthode. Et avec cela fait, ce que nous allons faire, c'est passer par les entrées d'audit et vérifier ce qu'il doit arriver, non ? En fait, cela peut même pas avoir besoin de se produire. Donc, je vais dire si les entrées d'audit ne sont pas égales à null, pour une raison quelconque, elles pourraient être nulles. Ou les cônes de points de blessures d'audit sont en fait supérieurs à 0, ce qui signifie que nous avons réellement des choses à traiter par la suite. Ensuite, vous pouvez appeler cette méthode. D' accord ? Donc, à l'intérieur de la méthode, ce que nous devons faire est de passer par là parce qu'à ce stade, nous
supposons que quelque chose est à l'intérieur des entrées d'audit, vous n'arriverez qu'ici. Si quelque chose l'était, alors ce que nous allons faire est d'évaluer chaque entrée de vérification et d'établir cette liste. Et puis nous obtenons les propriétés dans chacun d'entre eux, donc deux pour chaque liste pour chacun. Donc, je vais dire obtenir chaque accessoire dans propriétés temporaires point
d'entrée d'audit. Rappelez-vous donc que nous avons compilé une liste de toutes les propriétés temporaires. Ensuite, je suis allé avoir une instruction if pour voir si la propriété est notre clé primaire, puis nous ajoutons la valeur de clé pour être la valeur actuelle. D' accord. Donc, nous faisons juste une mise à jour rapide de cette valeur d'entrées d'audit pour être la valeur actuelle. Sinon, la nouvelle valeur est notre valeur actuelle. Donc, nous voyons juste si c'est une clé primaire, ce qui est plus que probable pourquoi elle finirait par être temporaire. Si quelque chose a été ajouté, mis à jour sur le volume actuel, sachez que tout a été enregistré. Sinon, si ce n'était pas notre clé primaire, qui pendant que je suis assis là, je peux penser à un scénario où vous auriez une valeur de bois pour XOM. Ce n'est pas la clé primaire. Mais dans ce cas,
nous le mettons toujours à jour. Pas de problème. Très bien, donc après ça, nous faisons le pour chacun, pour chacun que nous économisons, que nous allons certainement l'ajouter à l'audit. Juste j'appelle nous avons ajouté l'audit intéressé par les modifications avant d'enregistrer. Donc, nous vérifions juste point ajouter sous les deux audits afin qu'il puisse être converti. Ensuite, nous retournons un changement de sauvegarde. Nous devons donc appeler une mer de changements à ce stade. D' accord. Maintenant, après avoir enregistré ces modifications, nous pouvons retourner le résultat ici ou enregistrer les résultats plutôt. C' est donc vraiment ce que j'ai implémenté pour l'audit dans plusieurs applications. Et cela fonctionne assez bien parce que, comme je l'ai dit, c'est vraiment juste stocker des représentations de chaîne de ce que serait l'enregistrement entier. Et nous avons les anciennes valeurs et les nouvelles valeurs pour une comparaison côte à côte. Donc, sur une interface utilisateur, vous pouvez facilement imprimer le résultat parce que c'est JSON, il peut ne pas être facilement lisible par l'homme. Donc, vous pouvez vouloir le modifier un peu pour que les détails présentés un B, il est plus lisible, mais au moins vous pouvez voir tout ce qui se passe. Gardez un journal de tout ce qui est en cours de suppression, de modification ou d'application de gorge ajouté, quel que soit ce qu'ils sont vallées où à ce moment. Donc il peut aller de l'avant et faire quelques tests, faire des protistes, et regarder dans cet audit stable, bien sûr, vous savez, avec tous ces changements, nous devons érafler la table de nouvelle automobile. Donc, si la migration des annonces et nous disons ajouté tableau d'audit. Et puis après avoir obtenu cette migration, nous devons voir les données sont. Et avec tout cela fait, vous pouvez aller de l'avant et tester et me faire savoir comment cela fonctionne pour vous.
37. MISE À JOUR : Créer un audit complet de base - Réalisez: Hé les gars, c'est une solution rapide pour notre vidéo précédente. Vous auriez configuré votre audit et l'audit complet de la base de données. Et nous verrons comment il sérialise tout en JSON, stocke dans la base de données. Cependant, si vous essayez de faire plusieurs opérations, mais pour décrocher, vous risquez de rencontrer une situation difficile où il se plaint d'une répartition de type
pour un champ d'audit ou un dossier d'audit alors que cela ne devrait vraiment pas se produire. Et je suis juste là pour vous montrer la solution pour ça. Donc, dans notre sur avant d'enregistrer les changements ou d'enregistrer les changements, ce qui devrait arriver est que cela devrait filtrer tout ce qui est inchangé déjà touché pour savoir que nous savons que l'état de l'entité, je parie que tout soit insert va obtenir le ajouté. Et puis nous savons que nous avons l'état de l'entité pour supprimé et modifié ou ainsi. Mais la raison pour laquelle nous excluons ces deux-là est que nous n'avons pas besoin de vérifier quoi que ce soit qui est détaché, signifie qu'il n'est pas transporté par camion, nous ne devrions pas être suivis ou inchangés, ce qui signifie que rien ne s'est passé. Donc, lisez essentiellement ce qui se passe est qu'une fois que l'enregistrement des modifications est vraiment appelé, tout ce qui était suivi passe automatiquement à un état onchange. Donc, si vous effectuez plusieurs opérations, vous allez finir avec des entrées d'audit qui sont en cours d'enregistrement. Et puis vous allez et essayez de dire que quelque chose d'autre dans le framework est toujours le
suivi des anciens objets qui ont été récemment enregistrés, y compris l'enregistrement d'audit. C' est pourquoi il aurait besoin d'être
filtré à ce stade parce qu'il connaît un état onchange. Cependant, pour une raison quelconque ce filtre ne
fonctionne pas car je l'aurais aimé le travail peut-être pour vous, Amy anatta de ce programme, c'est bien. Mais j'ai vu ce problème s'est produit plus d'une fois. Donc je vais juste te montrer cette solution pour ça. Et c'est moins une solution sophistiquée. Tout ce que je vais faire est d'inverser la condition et cela fonctionne mieux pour certains. Donc, ce que nous allons faire est de dire, donnez-moi les entrées où nous savons que nous voulons les essayer, ce qui signifie que l'état est équivalent à mort, ou c'est un outil équivalent modifié. Et puis un de plus. Ou c'est équivalent à ceux de BreakLine supprimés. Droit ? Parce que nous savons que nous voulons les suivre. On ne veut pas suivre les deux autres. Mais quand nous essayons de les exclure pour quelque raison que ce soit, l'exclusion pourrait ne pas fonctionner comme il se doit. Donc, c'est bien. Nous allons juste travailler les nôtres pour
maintenir la qualité et l'intégrité de notre code. Nous ne voyons nulle part nous donner ceux que nous savons que nous allons certainement vouloir vérifier. Donc, nous obtenons ces entrées et puis tout le reste
tomberait dans la ligne parce qu'il y a qu'ils ont ou
instruction de cas basé sur quel état il est qui doit être ajouté à l'entrée d'audit. Donc c'est une solution rapide. Si vous avez eu cette difficulté, nous pouvons le faire et je suis sûr que vous aurez une meilleure expérience. Et si ce n'est pas le cas, bien sûr, nous continuerons à enquêter et à regarder parce que nous apprenons tous le rouge. C' est une bibliothèque très complexe et nous faisons de notre mieux pour en tirer le meilleur parti.
38. Validation des données avec des annotations de données: Salut, les gars, bon
retour. Dans cette leçon, nous verrons comment définir des
contraintes et des limites, des règles
générales concernant
les propriétés et les valeurs qu'
elles sont autorisées à avoir. Maintenant, j'aurais utilisé le
mot contrainte à plusieurs reprises. Et cela aurait été plus spécifique aux migrations,
où nous avons constaté que contraintes
s'ajoutaient pour relations avec
des clés étrangères ou pour des raisons d'
unicité, etc. Mais ce sont
toutes des migrations basées sur certaines des règles
que nous mettons
en place dans notre modèle de création
et sur
la base des types de données et de ce que nous avons défini comme
référence de clé étrangère, etc. Maintenant, outre ces situations
spécifiques, il y a des moments où
vous voulez être un peu plus calculé et avoir une meilleure idée pratique de ce qui est stocké et de la
manière dont il est stocké. C'est donc un exemple pratique. Lorsque nous examinons l'équipe, nous voyons que nous avons
une chaîne pour le nom, qui est traduite en
RCR dans la base de données, mais c'est VRTR Max Voulons-nous vraiment Vrtrmx comme nom
d'équipe, n'est-ce pas ? Donc, là, nous ouvrons la base de données à la
possibilité que quelqu'un puisse mettre un essai complet dans ce domaine et l'appeler
le nom de l'équipe. Ce n'est pas nécessairement ce que nous voulons. Les autres contraintes peuvent
inclure les valeurs par défaut. Nous avions donc ajouté ces objets
de domaine de base. Et j'utilise juste
ceci comme exemple où nous avons la date et l'heure. Mais il
peut également arriver que vous
souhaitiez des valeurs par défaut
dans ces propriétés. Ainsi, si aucune valeur n'est fournie par l'interface
ou par l'utilisateur, vous souhaitez toujours qu'elle
ait une valeur. Voyons comment limiter une partie de ce que
peuvent contenir nos colonnes de chaînes, par exemple. Donc, à partir du contexte DV, et cela utilise une API fluide Nous aurions donc examiné l'API
fluide plus tôt lorsque nous
avons spécifié certaines règles concernant ce que chaque
entité peut avoir. Toutes ces lignes
de code ou blocs de code sont vraiment fluides sur la
base d'une API fluide. Donc, ce que nous faisons maintenant, c'est utiliser API
fluide pour une certaine validation. Je veux donc dire
Model Builder point, et ensuite ce
sera en équipe cette fois. Je vais donc
parler de propriété point, qui s'ouvre ensuite pour
une autre expression Lambda Je vais utiliser P comme jeton. Je vais dire le point P, puis je peux choisir la
propriété qui m'intéresse. J'ai donc dit mon nom. Ensuite, je peux
dire quelles sont ses contraintes. Je peux donc dire à la base de données
que c'est obligatoire ou qu'elle a un type de
colonne spécifique. Et si je ne voulais pas nécessairement
que ce soit VT ? Et si je voulais que ce soit VT ? Par exemple. Et si je
voulais définir une longueur maximale, c'est
ce que nous sommes sur le point de faire. Je vais donc dire longueur maximale, puis tout ce dont il a besoin
est une valeur entière. Je dois dire qu'aucune équipe ne
devrait avoir un nom de plus de 25 caractères.
Je pense que c'est raisonnable. Certaines équipes portent de
longs noms, comme le Barça, Munch et Gladbach, en
Bundesliga Mais je pense que 25 c'est
suffisant ou
passons-le simplement à 50 pour être extrêmement prudent Aucune équipe ne devrait donc avoir
un nom supérieur à 50. Maintenant, à la
lumière des règles, cela définit
vraiment la contrainte
pour une propriété, et c'est à peu près
une propriété à la fois. Mais je peux le faire pour
plusieurs entités. Je veux donc que la même
contrainte soit imposée à une ligue. Je ne veux pas que le nom d'
une ligue soit un essai, et je ne veux pas que le nom d' un entraîneur soit trop
long. D'accord ? Parmi les autres choses que je pourrais faire, je pourrais configurer cette
propriété sous forme d'index. Lorsque nous parlons d'index, ce sont vraiment des points de recherche
rapides Je vais supprimer, j'ai juste dupliqué cette ligne, et au lieu de
dire propriété du point, je vais dire que le point a un index Et puis cela va
maintenant me
demander une expression Lambda Je vais donc simplement
utiliser H comme nous faisons index et je vais dire que
l'index se trouve sur le nom. Cela signifie que si nous
effectuons une recherche par nom, la vitesse devrait être élevée. Pointez sur les données, sorte que la requête devrait s'exécuter
relativement rapidement. Je peux
faire la même chose pour notre ligue et
pour notre entraîneur. Notez que ce que je fais
consiste simplement à
copier-coller et à remplacer
les noms en conséquence, car ils ont tous des structures
similaires Tout ce que
vous voudrez probablement
faire serait de spécifier que ces colonnes doivent être uniques ou que la valeur qu'
elles contiennent doit être unique. Donc, une étude de cas pour cela, eh bien, vous ne voudriez pas que deux
équipes portent le même nom, même si c'est très probable. Vous ne voudriez pas que deux
ligues portent le même nom, même si c'est, je
suppose, moins probable. Mais dans un
cadre plus pratique, si vous créez
une base de données pour un système
de gestion scolaire ou un livre, Storage. Vous avez l'ISBN, qui est un
numéro unique pour chaque livre, ou vous avez le numéro d'identification d'un
étudiant, qui est différent de l'identifiant incrémentiel
par défaut, mais uniquement l'identifiant qu'
ils utilisent à l'école, vous avez ce numéro d'identification, alors vous devez spécifier
qu'il est Je pourrais donc étendre
l'index has pour dire que cet index doit
également être unique. accord ? Et il
y a d'autres choses que vous pourriez appliquer. Je n'en ai
honnêtement jamais utilisé certains. Je n'ai jamais eu
besoin de les utiliser, mais c'est juste moi que vous pouvez
explorer et trouver une utilité. Donc, ici, je dis à la
base de données qu'il s'agit d'une zone de recherche rapide dans l'équipe de table
et qu'elle est unique. Si vous souhaitez avoir un
index sur plusieurs colonnes, vous pouvez
simplement l'enchaîner. Je peux donc créer un type d'objet
anonyme. Nous avons examiné cela plus tôt, donc je peux simplement dire dans le
Lambda, utilisons Coach Je dirais que l'
index dans le tableau des entraîneurs est une combinaison ou que le nom
et l' identifiant de l'équipe devraient
être des index, n'est-ce pas ? Je peux donc commencer mon expression
Lambda, exemple de nouvelles accolades ouvertes, afin qu'elle sache qu'
il s'agit d'un type d'objet Et puis à l'intérieur de cet objet, spécifiez
simplement plusieurs colonnes, nom du point
H, le point H. ID d'équipe, virgule,
séparé, etc.,
et puis par extension, et puis par extension, je peux rendre tout cela unique Cela signifie donc que cette combinaison
doit toujours être unique. Cela revient donc plus à créer une clé
composite à ce moment-là. accord ? Donc je ne fais que vous
montrer quelques informations Je ne sais pas dans quelle mesure ils sont
nécessairement
pratiques dans cette situation
particulière, mais vous pourriez rencontrer ces défis lors de
la conception de votre base de données, et si vous venez d'une base de données
stricte, vous savez à quel point c'est facile. Ou il est relativement
simple de le faire dans SQL Server
Management Studio. Cependant, dans le
cas où vous avez affaire à une base de données
axée sur le code,
vous voudriez, comme nous l'avons dit, gérer toutes les modifications apportées par
notre structure
d' entités
et les laisser
se répercuter sur la base de données au lieu
de les mélanger et de les associer Donc, une fois que j'ai apporté
toutes ces modifications, si je passe à la console
du gestionnaire de packages et que j'ajoute une nouvelle migration, je dirais des validations
ajoutées et je pense toujours à
sélectionner le bon projet Je passe donc de la console
aux données, toutes mes excuses. Mais maintenant, si nous examinons
nos nouvelles déclarations. Vous pouvez voir ici
le nom des équipes, il s'agit désormais du VRCR 50, et l'ancien type est
NVCR Max. D'accord ? Il existe donc de nombreuses inhibitions
de
performances, qui peuvent survenir en
laissant simplement vos
types de données sous la forme VRTA Ainsi, lorsque vous commencez
à introduire ces contraintes, vous rendez votre
base de données
plus compacte, plus efficace et plus performante , en évitant
simplement le
stress lié aux considérations
de conception à l'avenir. Nous avons donc la
colonne alter pour les noms. Donc, chacun est bien généré, puis nous avons l'index de création. Nous voyons donc ici, créer un
index sur le nom de l'équipe, et il devrait être unique. Ensuite, nous avons créé un index sur le nom des ligues, nous n'avons pas
spécifié comme étant unique et nous avons créé un index sur
le tableau des entraîneurs, et les colonnes sont le
nom et l'identifiant de l'équipe, et nous avons examiné ce code de
filtre plus tôt. Je vais donc simplement procéder à la mise à jour de la base de données, et je ne prévois aucun problème avec l'
exécution de cette commande.
Et nous y voilà. Nous avons une ligne rouge, non ? Voyons ce qu'est cette ligne rouge. Cela signifie donc que l'
instruction create
unique index s'est terminée car une
clé dupliquée a été trouvée. Nous constatons donc
que nous avons déjà des données dans le tableau des équipes, et nous
essayons de dire que créer cet index unique dans
la colonne du nom de l'équipe doit être unique. Vous pouvez donc voir mon
équipe stable ici.
J'ai beaucoup de choses à répéter, J'ai beaucoup de choses répéter
et à répéter. Mais il est également clair
que je ne peux pas dire que la colonne de nom doit
être unique alors que j'
ai un CMLN autant de
fois dans la accord ? Nous voyons donc que
la contrainte fonctionne. Je vais juste supprimer tout ce qui
ne figure pas dans les trois premiers. Voyons si j'ai d'
autres erreurs. Oui, je
m'attendais à obtenir une clé étrangère. Laisse-moi nettoyer ça. C'est bon. Donc, pour faire le ménage, j'ai dû m'adresser aux entraîneurs, assurer que
personne n'entraînait aucun de ces records que
je devais supprimer. Accédez également aux matchs et
assurez-vous qu'aucun
des enregistrements que je devais
supprimer ne correspondait. C'est donc un exemple
pratique de nos contraintes
opérationnelles, n'est-ce pas ? Parce que nous avons défini l'intégrité
référentielle pour qu'elle ne soit pas en cascade,
mais qu'elle soit restreinte Ces choses
ne peuvent donc tout simplement pas se produire une fois ces
contraintes établies, et nous
apprenons à
les appliquer à l'aide d'EF Core. C'est bon. tout cela nettoyé, arrière et
tentons à nouveau de mettre à jour
notre base de données. Et cette fois, je crois que
nous allons réussir, et c'est parti.
Terminé. C'est bon. C'est ainsi que vous pouvez configurer la
validation vos tables
à l'aide du FCR. D'accord.
39. Utiliser entièrement les fichiers de configuration: Hé les gars, Dans cette leçon, nous allons juste faire un peu de refactoring et apprendre à comprendre la pleine puissance de nos fichiers de configuration un peu plus. Donc, lorsque nous avons fait nos fichiers de configuration, ils
ont été vraiment conçus dans le but de faciliter nos configurations de démarrage. leur avons donc nommé la configuration des graines de ligue. Eh bien, la réalité de la question est que cette classe entière peut être utilisée pour toutes les configurations relatives aux objets de domaine cible. Donc, en d'autres termes, juste que j'appelle dans le contexte DB, nous avons en fait des configurations liées à la Ligue. Nous avons déjà cette classe de configuration de ligue. Nous pouvons réellement placer tout ce code à l'intérieur de cette
classe pour garder notre contexte DB entier propre. D' accord, ça va alors nous finirons avec beaucoup de ces blocs de configurations et de la boucle. Autant de tables que vous pouvez avoir de nombreuses configurations. Vous voulez garder tout dans les troncs afin que vous puissiez les
voir ou les trouver très facilement quand vous en avez besoin. Alors commencez par refactoriser notre équipe. Alors tout d'un coup, Commençons par les équipes. Donc nous voyons ici que nous avons cette configuration pour l'équipe, cette configuration, nous en avons deux autres ici. Et puis nous avons toute cette configuration avec l'ensemencement. Donc, d'abord, je vais renommer cela d'être une configuration de démarrage d'équipes à juste une configuration d'équipe. Et je vais juste laisser ce refactoriser toutes les références, jeter le code. Suivant. Ce que je vais faire est d'apporter toutes ces configurations du contexte DB. Donc, j'ai ModelBuilder dot n carte TTT, tout cela. Je voulais couper ça. Et je vais passer à cette configuration de semence, ce que nous allons renommer le fichier et le neveu, ne vous inquiétez pas pour ça, mais non, je voulais juste passer sur la configuration. Donc, c'est le constructeur a la configuration des données. Je vais aller en dessous qui est toujours dans la méthode configure. D' accord, et puis je vais coller toutes les configurations que je viens de mettre. Ensuite, vous verrez une erreur apparaissant avec ModelBuilder. Et c'est parce que nous n'avons rien appelé ModelBuilder dans ce fichier. Cependant, si vous regardez de près, ModelBuilder est comme une version générique sur notre implémentation Cela me permet de dire entité point
ModelBuilder et ensuite impliquer l'entité. Notre objet constructeur sur ce type est spécifique. C' est le générateur de type d'entité pour l'entité spécifique. Donc, toute cette implémentation incarne cette ligne entière. Bon, donc tous ces ensembles en tant qu'entité point ModelBuilder, cette équipe, je peux remplacer cela par constructeur. Et le constructeur sait qu'il est relatif à l'équipe. Donc tout ce que nous faisons ici est relatif à l'équipe. D' accord, donc je peux juste dire « Builder dot Tasmanie « et ensuite « énumérer toutes les règles. Remplacer cela aussi par constructeur, juste le déplacer vers le haut afin que nous puissions voir où il commence et s'arrête. Et puis je vais continuer avec les autres bits de configuration pour l'équipe, quelqu'un pour couper ça et ensuite je suis allé le placer juste là. Et encore une fois, je vais juste utiliser le constructeur pour remplacer ce model.py dans l'entité point ModelBuilder, ce truc d'équipe. Et on y va. D' accord, et puis c'est notre configuration. Donc, nous avons déjà cette configuration appelée ici. Donc, une fois qu'il frappe cette ligne va sauter planches ou le fichier de configuration et voir tout ce qui doit être fait pour une équipe. Donc, je ne peux pas réellement déplacer ces configurations au-dessus de l'a l'eta. Laissez-moi simplement renommer ce fichier rapidement avant que j'oublie. Et puis nous allons faire la même chose pour les autres fichiers de configuration. Donc, la configuration des graines de ligue, elle n'est plus spécifique à l'ensemencement. Donc je vais aller de l'avant et renommer ça. Ses amis vont de l'avant et renomment le fichier, puis je peux apporter des configurations liées à la ligue directement dans notre constructeur. Allez-y et remplacez ce que j'ai besoin de remplacer. Et puis je suis allé de l'avant et l'ai fait aussi pour l'entraîneur. Donc vous pouvez le faire, sachez que vous avez l'essentiel. Et à la fin de la journée, nous voyons des contextes RDB beaucoup plus propres. Et puis tous les trucs de configuration désordonnés là-bas dans des endroits spécifiques, soit appartenant ou projet.