Tutoriel : En savoir plus sur les scénarios EF avancés pour une application web MVC 5
Dans le tutoriel précédent, vous avez implémenté l’héritage table par hiérarchie. Ce tutoriel présente plusieurs rubriques qui sont utiles lorsque vous allez au-delà des principes de base du développement d’applications web ASP.NET qui utilisent Entity Framework Code First. Les premières sections contiennent des instructions pas à pas qui vous guident à travers le code et l’utilisation de Visual Studio pour effectuer des tâches Les sections suivantes présentent plusieurs rubriques avec de brèves introductions suivies de liens vers des ressources pour plus d’informations.
Pour la plupart de ces rubriques, vous allez utiliser les pages que vous avez déjà créées. Pour utiliser sql brut pour effectuer des mises à jour en bloc, vous allez créer une page qui met à jour le nombre de crédits de tous les cours de la base de données :
Dans ce tutoriel, vous allez :
- Exécuter des requêtes SQL brutes
- Exécuter des requêtes sans suivi
- Examiner les requêtes SQL envoyées à la base de données
Vous en apprendrez également sur :
- Création d’une couche d’abstraction
- Classes proxy
- Détection automatique des modifications
- Validation automatique
- Entity Framework Power Tools
- Code source d’Entity Framework
Prérequis
Exécuter des requêtes SQL brutes
L’API Entity Framework Code First inclut des méthodes qui vous permettent de passer des commandes SQL directement à la base de données. Les options suivantes s’offrent à vous :
- Utilisez la méthode DbSet.SqlQuery pour les requêtes qui retournent des types d’entités. Les objets retournés doivent être du type attendu par l’objet
DbSetet ils sont automatiquement suivis par le contexte de base de données, sauf si vous désactivez le suivi. (Consultez la section suivante sur la méthode AsNoTracking .) - Utilisez la méthode Database.SqlQuery pour les requêtes qui retournent des types qui ne sont pas des entités. Les données renvoyées ne font pas l’objet d’un suivi par le contexte de base de données, même si vous utilisez cette méthode pour récupérer des types d’entités.
- Utilisez Database.ExecuteSqlCommand pour les commandes autres que la requête.
L’un des avantages d’utiliser Entity Framework est que cela évite de lier votre code trop étroitement à une méthode particulière de stockage des données. Il le fait en générant des requêtes et des commandes SQL pour vous, ce qui vous évite d’avoir à les écrire vous-même. Toutefois, il existe des scénarios exceptionnels où vous devez exécuter des requêtes SQL spécifiques que vous avez créées manuellement, et ces méthodes vous permettent de gérer ces exceptions.
Comme c’est toujours le cas lorsque vous exécutez des commandes SQL dans une application web, vous devez prendre des précautions pour protéger votre site contre des attaques par injection de code SQL. Une manière de procéder consiste à utiliser des requêtes paramétrables pour vous assurer que les chaînes soumises par une page web ne peuvent pas être interprétées comme des commandes SQL. Dans ce didacticiel, vous utiliserez des requêtes paramétrables lors de l’intégration de l’entrée utilisateur dans une requête.
Appel d’une requête qui retourne des entités
La classe DbSet<TEntity> fournit une méthode que vous pouvez utiliser pour exécuter une requête qui retourne une entité de type TEntity. Pour voir comment cela fonctionne, vous allez modifier le code dans la Details méthode du Department contrôleur.
Dans DepartmentController.cs, dans la Details méthode, remplacez l’appel de db.Departments.FindAsync méthode par un db.Departments.SqlQuery appel de méthode, comme indiqué dans le code mis en évidence suivant :
public async Task<ActionResult> Details(int? id)
{
if (id == null)
{
return new HttpStatusCodeResult(HttpStatusCode.BadRequest);
}
// Commenting out original code to show how to use a raw SQL query.
//Department department = await db.Departments.FindAsync(id);
// Create and execute raw SQL query.
string query = "SELECT * FROM Department WHERE DepartmentID = @p0";
Department department = await db.Departments.SqlQuery(query, id).SingleOrDefaultAsync();
if (department == null)
{
return HttpNotFound();
}
return View(department);
}
Pour vérifier que le nouveau code fonctionne correctement, sélectionnez l’onglet Departments, puis Details pour l’un des services. Assurez-vous que toutes les données s’affichent comme prévu.
Appel d’une requête qui retourne d’autres types d’objets
Précédemment, vous avez créé une grille de statistiques des étudiants pour la page About, qui montrait le nombre d’étudiants pour chaque date d’inscription. Le code qui effectue cette opération dans HomeController.cs utilise LINQ :
var data = from student in db.Students
group student by student.EnrollmentDate into dateGroup
select new EnrollmentDateGroup()
{
EnrollmentDate = dateGroup.Key,
StudentCount = dateGroup.Count()
};
Supposons que vous souhaitiez écrire le code qui récupère ces données directement dans SQL plutôt que d’utiliser LINQ. Pour ce faire, vous devez exécuter une requête qui retourne autre chose que des objets d’entité, ce qui signifie que vous devez utiliser la méthode Database.SqlQuery .
Dans HomeController.cs, remplacez l’instruction LINQ dans la About méthode par une instruction SQL, comme indiqué dans le code en surbrillance suivant :
public ActionResult About()
{
// Commenting out LINQ to show how to do the same thing in SQL.
//IQueryable<EnrollmentDateGroup> = from student in db.Students
// group student by student.EnrollmentDate into dateGroup
// select new EnrollmentDateGroup()
// {
// EnrollmentDate = dateGroup.Key,
// StudentCount = dateGroup.Count()
// };
// SQL version of the above LINQ code.
string query = "SELECT EnrollmentDate, COUNT(*) AS StudentCount "
+ "FROM Person "
+ "WHERE Discriminator = 'Student' "
+ "GROUP BY EnrollmentDate";
IEnumerable<EnrollmentDateGroup> data = db.Database.SqlQuery<EnrollmentDateGroup>(query);
return View(data.ToList());
}
Exécutez la page À propos de. Vérifiez qu’il affiche les mêmes données qu’auparavant.
Appel d’une requête de mise à jour
Supposons que les administrateurs de Contoso University souhaitent être en mesure d’effectuer des modifications en bloc dans la base de données, telles que la modification du nombre de crédits pour chaque cours. Si l’université a un grand nombre de cours, il serait inefficace de les récupérer tous sous forme d’entités et de les modifier individuellement. Dans cette section, vous allez implémenter une page web qui permet à l’utilisateur de spécifier un facteur par lequel modifier le nombre de crédits pour tous les cours, et vous allez effectuer la modification en exécutant une instruction SQL UPDATE .
Dans CourseController.cs, ajoutez UpdateCourseCredits des méthodes pour HttpGet et HttpPost:
public ActionResult UpdateCourseCredits()
{
return View();
}
[HttpPost]
public ActionResult UpdateCourseCredits(int? multiplier)
{
if (multiplier != null)
{
ViewBag.RowsAffected = db.Database.ExecuteSqlCommand("UPDATE Course SET Credits = Credits * {0}", multiplier);
}
return View();
}
Lorsque le contrôleur traite une HttpGet requête, rien n’est retourné dans la ViewBag.RowsAffected variable, et la vue affiche une zone de texte vide et un bouton d’envoi.
Lorsque vous cliquez sur le bouton Mettre à jour , la HttpPost méthode est appelée et multiplier la valeur est entrée dans la zone de texte. Le code exécute ensuite le sql qui met à jour les cours et retourne le nombre de lignes affectées à la vue dans la ViewBag.RowsAffected variable. Lorsque la vue obtient une valeur dans cette variable, elle affiche le nombre de lignes mises à jour au lieu de la zone de texte et du bouton Envoyer.
Dans CourseController.cs, cliquez avec le UpdateCourseCredits bouton droit sur l’une des méthodes, puis cliquez sur Ajouter une vue. La boîte de dialogue Ajouter une vue s’affiche. Conservez les valeurs par défaut et sélectionnez Ajouter.
Dans Views\Course\UpdateCourseCredits.cshtml, remplacez le code du modèle par le code suivant :
@model ContosoUniversity.Models.Course
@{
ViewBag.Title = "UpdateCourseCredits";
}
<h2>Update Course Credits</h2>
@if (ViewBag.RowsAffected == null)
{
using (Html.BeginForm())
{
<p>
Enter a number to multiply every course's credits by: @Html.TextBox("multiplier")
</p>
<p>
<input type="submit" value="Update" />
</p>
}
}
@if (ViewBag.RowsAffected != null)
{
<p>
Number of rows updated: @ViewBag.RowsAffected
</p>
}
<div>
@Html.ActionLink("Back to List", "Index")
</div>
Exécutez la méthode UpdateCourseCredits en sélectionnant l’onglet Courses, puis en ajoutant « /UpdateCourseCredits » à la fin de l’URL dans la barre d’adresse du navigateur (par exemple : http://localhost:50205/Course/UpdateCourseCredits). Entrez un nombre dans la zone de texte :
Cliquez sur Update. Vous voyez le nombre de lignes affectées.
Cliquez sur Revenir à la liste pour afficher la liste des cours avec le nombre révisé de crédits.
Pour plus d’informations sur les requêtes SQL brutes, consultez Requêtes SQL brutes sur MSDN.
Pas de suivi des requêtes
Quand un contexte de base de données récupère des lignes de table et crée des objets entité qui les représentent, par défaut, il effectue le suivi du fait que les entités en mémoire sont ou non synchronisées avec ce qui se trouve dans la base de données. Les données en mémoire agissent comme un cache et sont utilisées quand vous mettez à jour une entité. Cette mise en cache est souvent inutile dans une application web, car les instances de contexte ont généralement une durée de vie courte (une instance est créée puis supprimée pour chaque requête) et le contexte qui lit une entité est généralement supprimé avant que cette entité soit réutilisée.
Vous pouvez désactiver le suivi des objets d’entité en mémoire à l’aide de la méthode AsNoTracking . Voici des scénarios classiques où vous voulez procéder ainsi :
- Une requête récupère un tel volume de données que la désactivation du suivi peut améliorer sensiblement les performances.
- Vous souhaitez attacher une entité afin de la mettre à jour, mais vous avez précédemment récupéré la même entité dans un autre but. Comme l’entité est déjà suivie par le contexte de base de données, vous ne pouvez pas attacher l’entité que vous voulez modifier. Une façon de gérer cette situation consiste à utiliser l’option
AsNoTrackingavec la requête précédente.
Pour obtenir un exemple qui montre comment utiliser la méthode AsNoTracking , consultez la version antérieure de ce didacticiel. Cette version du didacticiel ne définit pas l’indicateur Modifié sur une entité créée par un classeur de modèles dans la méthode Edit. Elle n’a donc pas besoin de AsNoTracking.
Examiner sql envoyé à la base de données
Il est parfois utile de pouvoir voir les requêtes SQL réelles qui sont envoyées à la base de données. Dans un tutoriel précédent, vous avez vu comment procéder dans le code d’intercepteur ; vous voyez maintenant quelques façons de le faire sans écrire de code d’intercepteur. Pour l’essayer, vous allez examiner une requête simple, puis examiner ce qui lui arrive lorsque vous ajoutez des options telles que le chargement, le filtrage et le tri.
Dans Controllers/CourseController, remplacez la Index méthode par le code suivant, afin d’arrêter temporairement le chargement rapide :
public ActionResult Index()
{
var courses = db.Courses;
var sql = courses.ToString();
return View(courses.ToList());
}
Définissez maintenant un point d’arrêt sur l’instruction return (F9 avec le curseur sur cette ligne). Appuyez sur F5 pour exécuter le projet en mode débogage, puis sélectionnez la page Index du cours. Lorsque le code atteint le point d’arrêt, examinez la sql variable. Vous voyez la requête envoyée à SQL Server. C’est une instruction simple Select .
{SELECT
[Extent1].[CourseID] AS [CourseID],
[Extent1].[Title] AS [Title],
[Extent1].[Credits] AS [Credits],
[Extent1].[DepartmentID] AS [DepartmentID]
FROM [Course] AS [Extent1]}
Cliquez sur la loupe pour afficher la requête dans le visualiseur de texte.
Vous allez maintenant ajouter une liste déroulante à la page Index des cours afin que les utilisateurs puissent filtrer pour un service particulier. Vous allez trier les cours par titre, et vous allez spécifier un chargement pressé pour la propriété de Department navigation.
Dans CourseController.cs, remplacez la Index méthode par le code suivant :
public ActionResult Index(int? SelectedDepartment)
{
var departments = db.Departments.OrderBy(q => q.Name).ToList();
ViewBag.SelectedDepartment = new SelectList(departments, "DepartmentID", "Name", SelectedDepartment);
int departmentID = SelectedDepartment.GetValueOrDefault();
IQueryable<Course> courses = db.Courses
.Where(c => !SelectedDepartment.HasValue || c.DepartmentID == departmentID)
.OrderBy(d => d.CourseID)
.Include(d => d.Department);
var sql = courses.ToString();
return View(courses.ToList());
}
Restaurez le point d’arrêt de l’instruction return .
La méthode reçoit la valeur sélectionnée de la liste déroulante dans le SelectedDepartment paramètre . Si rien n’est sélectionné, ce paramètre est null.
Une SelectList collection contenant tous les services est passée à la vue de la liste déroulante. Les paramètres passés au constructeur spécifient le SelectList nom du champ de valeur, le nom du champ de texte et l’élément sélectionné.
Pour la Get méthode du Course référentiel, le code spécifie une expression de filtre, un ordre de tri et un chargement pressé pour la Department propriété de navigation. L’expression de filtre retourne true toujours si rien n’est sélectionné dans la liste déroulante (autrement dit, SelectedDepartment est null).
Dans Views\Course\Index.cshtml, immédiatement avant la balise d’ouverture table , ajoutez le code suivant pour créer la liste déroulante et un bouton Envoyer :
@using (Html.BeginForm())
{
<p>Select Department: @Html.DropDownList("SelectedDepartment","All")
<input type="submit" value="Filter" /></p>
}
Le point d’arrêt étant toujours défini, exécutez la page Index de cours. Poursuivez les premières fois que le code atteint un point d’arrêt, afin que la page s’affiche dans le navigateur. Sélectionnez un service dans la liste déroulante, puis cliquez sur Filtrer.
Cette fois, le premier point d’arrêt sera pour la requête des services pour la liste déroulante. Ignorez cela et affichez la query variable la prochaine fois que le code atteint le point d’arrêt afin de voir à quoi ressemble désormais la Course requête. Vous verrez quelque chose comme ceci :
SELECT
[Project1].[CourseID] AS [CourseID],
[Project1].[Title] AS [Title],
[Project1].[Credits] AS [Credits],
[Project1].[DepartmentID] AS [DepartmentID],
[Project1].[DepartmentID1] AS [DepartmentID1],
[Project1].[Name] AS [Name],
[Project1].[Budget] AS [Budget],
[Project1].[StartDate] AS [StartDate],
[Project1].[InstructorID] AS [InstructorID],
[Project1].[RowVersion] AS [RowVersion]
FROM ( SELECT
[Extent1].[CourseID] AS [CourseID],
[Extent1].[Title] AS [Title],
[Extent1].[Credits] AS [Credits],
[Extent1].[DepartmentID] AS [DepartmentID],
[Extent2].[DepartmentID] AS [DepartmentID1],
[Extent2].[Name] AS [Name],
[Extent2].[Budget] AS [Budget],
[Extent2].[StartDate] AS [StartDate],
[Extent2].[InstructorID] AS [InstructorID],
[Extent2].[RowVersion] AS [RowVersion]
FROM [dbo].[Course] AS [Extent1]
INNER JOIN [dbo].[Department] AS [Extent2] ON [Extent1].[DepartmentID] = [Extent2].[DepartmentID]
WHERE @p__linq__0 IS NULL OR [Extent1].[DepartmentID] = @p__linq__1
) AS [Project1]
ORDER BY [Project1].[CourseID] ASC
Vous pouvez voir que la requête est désormais une JOIN requête qui charge Department des données avec les Course données et qu’elle inclut une WHERE clause.
Supprimez la var sql = courses.ToString() ligne.
Créer une couche d’abstraction
De nombreux développeurs écrivent du code pour implémenter les modèles d’unité de travail et de référentiel comme un wrapper autour du code qui fonctionne avec Entity Framework. Ces modèles sont destinés à créer une couche d’abstraction entre la couche d’accès aux données et la couche de logique métier d’une application. L’implémentation de ces modèles peut favoriser l’isolation de votre application face à des modifications dans le magasin de données et peut faciliter le test unitaire automatisé ou le développement piloté par les tests (TDD). Toutefois, l’écriture de code supplémentaire pour implémenter ces modèles n’est pas toujours le meilleur choix pour les applications qui utilisent EF, pour plusieurs raisons :
- La classe de contexte EF elle-même isole votre code face au code spécifique de magasin de données.
- La classe de contexte EF peut agir comme une classe d’unité de travail pour les mises à jour de base de données que vous effectuez à l’aide d’EF.
- Les fonctionnalités introduites dans Entity Framework 6 facilitent l’implémentation de TDD sans écrire de code de dépôt.
Pour plus d’informations sur l’implémentation du référentiel et des modèles d’unité de travail, consultez la version Entity Framework 5 de cette série de didacticiels. Pour plus d’informations sur les façons d’implémenter TDD dans Entity Framework 6, consultez les ressources suivantes :
- Comment EF6 active plus facilement les dbSets fictifs
- Test avec une infrastructure moqueuse
- Test avec vos propres doubles de test
Classes proxy
Quand Entity Framework crée des instances d’entité (par exemple, lorsque vous exécutez une requête), il les crée souvent en tant qu’instances d’un type dérivé généré dynamiquement qui fait office de proxy pour l’entité. Par exemple, consultez les deux images de débogueur suivantes. Dans la première image, vous voyez que la student variable est le type attendu Student immédiatement après l’instanciation de l’entité. Dans la deuxième image, une fois qu’EF a été utilisé pour lire une entité d’étudiant à partir de la base de données, vous voyez la classe proxy.
Cette classe proxy remplace certaines propriétés virtuelles de l’entité pour insérer des hooks pour effectuer des actions automatiquement lorsque la propriété est accessible. L’une des fonctions pour laquelle ce mécanisme est utilisé est le chargement paresseux.
La plupart du temps, vous n’avez pas besoin d’être conscient de cette utilisation de proxys, mais il existe des exceptions :
- Dans certains scénarios, vous pouvez empêcher Entity Framework de créer des instances proxy. Par exemple, lorsque vous sérialisez des entités, vous souhaitez généralement utiliser les classes POCO, et non les classes proxy. Une façon d’éviter les problèmes de sérialisation consiste à sérialiser des objets de transfert de données (DTO) au lieu d’objets d’entité, comme indiqué dans le didacticiel Utilisation de l’API web avec Entity Framework . Une autre façon consiste à désactiver la création de proxy.
- Lorsque vous instanciez une classe d’entité à l’aide de l’opérateur
new, vous n’obtenez pas de proxy instance. Cela signifie que vous n’obtenez pas de fonctionnalités telles que le chargement paresseux et le suivi automatique des modifications. C’est généralement correct. vous n’avez généralement pas besoin d’un chargement paresseux, car vous créez une entité qui ne se trouve pas dans la base de données, et vous n’avez généralement pas besoin du suivi des modifications si vous marquez explicitement l’entité commeAdded. Toutefois, si vous avez besoin d’un chargement différé et que vous avez besoin d’un suivi des modifications, vous pouvez créer de nouvelles instances d’entité avec des proxys à l’aide de la méthode Create de laDbSetclasse . - Vous souhaiterez peut-être obtenir un type d’entité réel à partir d’un type proxy. Vous pouvez utiliser la méthode GetObjectType de la
ObjectContextclasse pour obtenir le type d’entité réel d’un type proxy instance.
Pour plus d’informations, consultez Utilisation des proxys sur MSDN.
Détection automatique des modifications
Entity Framework détermine la manière dont une entité a changé (et par conséquent les mises à jour qui doivent être envoyées à la base de données) en comparant les valeurs en cours d’une entité avec les valeurs d’origine. Les valeurs d’origine sont stockées lorsque l’entité fait l’objet d’une requête ou d’une jointure. Certaines des méthodes qui provoquent la détection automatique des modifications sont les suivantes :
DbSet.FindDbSet.LocalDbSet.RemoveDbSet.AddDbSet.AttachDbContext.SaveChangesDbContext.GetValidationErrorsDbContext.EntryDbChangeTracker.Entries
Si vous suivez un grand nombre d’entités et que vous appelez l’une de ces méthodes plusieurs fois dans une boucle, vous pouvez obtenir des améliorations significatives des performances en désactivant temporairement la détection automatique des modifications à l’aide de la propriété AutoDetectChangesEnabled . Pour plus d’informations, consultez Détection automatique des modifications sur MSDN.
Validation automatique
Lorsque vous appelez la SaveChanges méthode, par défaut, Entity Framework valide les données dans toutes les propriétés de toutes les entités modifiées avant de mettre à jour la base de données. Si vous avez mis à jour un grand nombre d’entités et que vous avez déjà validé les données, ce travail n’est pas nécessaire et vous pouvez faire en sorte que le processus d’enregistrement des modifications prenne moins de temps en désactivant temporairement la validation. Vous pouvez le faire à l’aide de la propriété ValidateOnSaveEnabled . Pour plus d’informations, consultez Validation sur MSDN.
Entity Framework Power Tools
Entity Framework Power Tools est un complément Visual Studio qui a été utilisé pour créer les diagrammes de modèle de données présentés dans ces didacticiels. Les outils peuvent également effectuer d’autres fonctions, telles que générer des classes d’entité basées sur les tables d’une base de données existante afin que vous puissiez utiliser la base de données avec Code First. Une fois les outils installés, d’autres options s’affichent dans les menus contextuels. Par exemple, lorsque vous cliquez avec le bouton droit sur votre classe de contexte dans Explorateur de solutions, l’option Entity Framework s’affiche. Cela vous permet de générer un diagramme. Lorsque vous utilisez Code First, vous ne pouvez pas modifier le modèle de données dans le diagramme, mais vous pouvez déplacer les éléments pour le rendre plus facile à comprendre.
Code source d’Entity Framework
Le code source d’Entity Framework 6 est disponible sur GitHub. Vous pouvez enregistrer des bogues et apporter vos propres améliorations au code source EF.
Bien que le code source soit ouvert, Entity Framework est entièrement pris en charge en tant que produit Microsoft. L’équipe Microsoft Entity Framework garde le contrôle sur le choix des contributions qui sont acceptées et teste toutes les modifications du code pour garantir la qualité de chaque version.
Remerciements
- Tom Dykstra a écrit la version originale de ce tutoriel, co-écrit la mise à jour EF 5 et écrit la mise à jour EF 6. Tom est rédacteur de programmation senior au sein de l’équipe de contenu Microsoft Web Platform and Tools.
- Rick Anderson (twitter @RickAndMSFT) a effectué la majeure partie du travail de mise à jour du tutoriel pour EF 5 et MVC 4 et a co-écrit la mise à jour EF 6. Rick est rédacteur de programmation senior pour Microsoft se concentrant sur Azure et MVC.
- Rowan Miller et d’autres membres de l’équipe Entity Framework ont aidé à réviser le code et à déboguer de nombreux problèmes liés aux migrations qui se sont présentés lors de la mise à jour du tutoriel pour EF 5 et EF 6.
Résolution des erreurs courantes
Impossible de créer/cliché instantané
Message d’erreur :
Impossible de créer/copier instantané '<filename>' lorsque ce fichier existe déjà.
Solution
Attendez quelques secondes et actualisez la page.
Update-Database non reconnu
Message d’erreur (à partir de la Update-Database commande dans le PMC) :
Le terme « Update-Database » n’est pas reconnu comme nom d’une applet de commande, d’une fonction, d’un fichier de script ou d’un programme opérable. Vérifiez l’orthographe du nom ou, si un chemin d’accès a été inclus, vérifiez que le chemin d’accès est correct et réessayez.
Solution
Quittez Visual Studio. Rouvrez le projet et réessayez.
Échec de validation
Message d’erreur (à partir de la Update-Database commande dans le PMC) :
La validation a échoué pour une ou plusieurs entités. Pour plus d’informations, consultez la propriété « EntityValidationErrors ».
Solution
L’une des causes de ce problème est les erreurs de validation lors de l’exécution de la Seed méthode. Pour obtenir des conseils sur le débogage de la méthode, consultez Amorçage et débogage des bases de données d’EntitySeed Framework (EF).
Erreur HTTP 500.19
Message d’erreur :
Erreur HTTP 500.19 - Erreur interne du serveur Impossible d’accéder à la page demandée, car les données de configuration associées pour la page ne sont pas valides.
Solution
Vous pouvez obtenir cette erreur en utilisant plusieurs copies de la solution, chacune utilisant le même numéro de port. Vous pouvez généralement résoudre ce problème en quittant toutes les instances de Visual Studio, puis en redémarrant le projet sur lequel vous travaillez. Si cela ne fonctionne pas, essayez de modifier le numéro de port. Cliquez avec le bouton droit sur le fichier projet, puis cliquez sur Propriétés. Sélectionnez l’onglet Web , puis modifiez le numéro de port dans la zone de texte Url du projet .
Erreur lors de la localisation de l’instance SQL Server
Message d’erreur :
Une erreur liée au réseau ou propre à une instance s’est produite lors de l’établissement d’une connexion à SQL Server. Le serveur est introuvable ou inaccessible. Vérifiez que le nom de l’instance est correct et que SQL Server est configuré pour autoriser les connexions à distance. (fournisseur : interfaces réseau SQL, erreur : 26 - Erreur lors de la localisation du serveur/de l’instance spécifiés)
Solution
Vérifiez la chaîne de connexion. Si vous avez supprimé manuellement la base de données, modifiez le nom de la base de données dans la chaîne de construction.
Obtenir le code
Ressources supplémentaires
Pour plus d’informations sur l’utilisation des données à l’aide d’Entity Framework, consultez la page de documentation EF sur MSDN et ASP.NET Data Access - Ressources recommandées.
Pour plus d’informations sur le déploiement de votre application web après l’avoir créée, consultez ASP.NET déploiement web - Ressources recommandées dans MSDN Library.
Pour plus d’informations sur d’autres sujets liés à MVC, tels que l’authentification et l’autorisation, consultez le ASP.NET MVC - Ressources recommandées.
Étapes suivantes
Dans ce tutoriel, vous allez :
- Exécuter des requêtes SQL brutes
- Requêtes sans suivi effectuées
- Requêtes SQL examinées envoyées à la base de données
Vous avez également découvert les points suivants :
- Création d’une couche d’abstraction
- Classes proxy
- Détection automatique des modifications
- Validation automatique
- Entity Framework Power Tools
- Code source d’Entity Framework
Cette série de tutoriels sur l’utilisation d’Entity Framework dans une application MVC ASP.NET est terminée. Si vous souhaitez en savoir plus sur EF Database First, consultez la série de tutoriels DB First.
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour