Esercitazione: Informazioni sugli scenari EF avanzati per un'app Web MVC 5

  • Articolo

Nell'esercitazione precedente è stata implementata l'ereditarietà della tabella per gerarchia. Questa esercitazione include diversi argomenti utili per essere consapevoli di quando si superano le nozioni di base per lo sviluppo di ASP.NET applicazioni Web che usano Entity Framework Code First. Le prime sezioni includono istruzioni dettagliate che illustrano il codice e l'uso di Visual Studio per completare le attività Le sezioni che seguono diversi argomenti con brevi presentazioni seguite dai collegamenti alle risorse per altre informazioni.

Per la maggior parte di questi argomenti, si useranno le pagine già create. Per usare SQL non elaborato per eseguire aggiornamenti bulk, verrà creata una nuova pagina che aggiorna il numero di crediti di tutti i corsi nel database:

Update_Course_Credits_initial_page

In questa esercitazione:

  • Eseguire query SQL non elaborate
  • Eseguire query senza rilevamento
  • Esaminare le query SQL inviate al database

Sono disponibili anche informazioni su:

  • Creazione di un livello di astrazione
  • Classi proxy
  • Rilevamento automatico delle modifiche
  • Convalida automatica
  • Entity Framework Power Tools
  • Codice sorgente di Entity Framework

Prerequisito

Eseguire query SQL non elaborate

L'API First di Entity Framework Code include metodi che consentono di passare i comandi SQL direttamente al database. Sono disponibili le seguenti opzioni:

  • Usare il metodo DbSet.SqlQuery per le query che restituiscono tipi di entità. Gli oggetti restituiti devono essere del tipo previsto dall'oggetto DbSet e vengono rilevati automaticamente dal contesto del database, a meno che non si disattiva il rilevamento. Vedere la sezione seguente sul metodo AsNoTracking .
  • Usare il metodo Database.SqlQuery per le query che restituiscono tipi che non sono entità. I dati restituiti non vengono registrati dal contesto di database, anche se il metodo viene usato per recuperare i tipi di entità.
  • Usare Database.ExecuteSqlCommand per i comandi non query.

Uno dei vantaggi dell'utilizzo di Entity Framework è la mancanza di un collegamento troppo stretto del codice a un particolare metodo di archiviazione dei dati. Le query e i comandi SQL vengono generati automaticamente e non è necessario scriverli. Esistono tuttavia scenari eccezionali quando è necessario eseguire query SQL specifiche create manualmente e questi metodi consentono di gestire tali eccezioni.

Come avviene quando si eseguono comandi SQL in un'applicazione Web, è necessario adottare delle precauzioni per proteggere il sito dagli attacchi SQL injection. A questo scopo è possibile usare query parametrizzate per assicurarsi che le stringhe inviate da una pagina Web non possano essere interpretate come comandi SQL. In questa esercitazione verranno usate query parametrizzate quando l'input dell'utente viene integrato in una query.

Chiamata di una query che restituisce entità

La classe DbSet<TEntity> fornisce un metodo che è possibile usare per eseguire una query che restituisce un'entità di tipo TEntity. Per vedere come funziona si modifica il codice nel Details metodo del Department controller.

Nel metodo DepartmentController.csDetails sostituire la chiamata al db.Departments.FindAsync metodo con una db.Departments.SqlQuery chiamata al metodo, come illustrato nel codice evidenziato seguente:

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);
}

Per verificare il corretto funzionamento del nuovo codice, selezionare la scheda Departments e quindi Dettagli per uno dei reparti. Assicurarsi che tutti i dati vengano visualizzati come previsto.

Chiamata di una query che restituisce altri tipi di oggetti

In precedenza è stata creata una griglia delle statistiche degli studenti per la pagina About che visualizza il numero di studenti per ogni data di registrazione. Il codice che esegue questa operazione in HomeController.cs usa LINQ:

var data = from student in db.Students
           group student by student.EnrollmentDate into dateGroup
           select new EnrollmentDateGroup()
           {
               EnrollmentDate = dateGroup.Key,
               StudentCount = dateGroup.Count()
           };

Si supponga di voler scrivere il codice che recupera questi dati direttamente in SQL anziché usare LINQ. A tale scopo, è necessario eseguire una query che restituisce un elemento diverso da oggetti di entità, il che significa che è necessario usare il metodo Database.SqlQuery .

In HomeController.cs sostituire l'istruzione LINQ nel metodo con un'istruzione About SQL, come illustrato nel codice evidenziato seguente:

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());
}

Eseguire la pagina Informazioni. Verificare che visualizzi gli stessi dati averlo eseguito prima.

Chiamata di una query di aggiornamento

Si supponga che gli amministratori di Contoso University possano eseguire modifiche bulk nel database, ad esempio modificando il numero di crediti per ogni corso. Se il numero di corsi dell'università è elevato, potrebbe non essere utile recuperarli tutti come entità e modificarli singolarmente. In questa sezione si implementerà una pagina Web che consente all'utente di specificare un fattore in base al quale modificare il numero di crediti per tutti i corsi e si eseguirà la modifica eseguendo un'istruzione SQL UPDATE .

In CourseController.cs aggiungere UpdateCourseCredits metodi per HttpGet e 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();
}

Quando il controller elabora una HttpGet richiesta, non viene restituito alcun elemento nella ViewBag.RowsAffected variabile e la visualizzazione visualizza una casella di testo vuota e un pulsante di invio.

Quando si fa clic sul pulsante Update , viene chiamato il HttpPost metodo e multiplier il valore immesso nella casella di testo. Il codice esegue quindi sql che aggiorna i corsi e restituisce il numero di righe interessate alla visualizzazione nella ViewBag.RowsAffected variabile. Quando la visualizzazione ottiene un valore in tale variabile, visualizza il numero di righe aggiornate anziché la casella di testo e il pulsante invia.

In CourseController.cs fare clic con il pulsante destro del UpdateCourseCredits mouse su uno dei metodi e quindi scegliere Aggiungi visualizzazione. Viene visualizzata la finestra di dialogo Aggiungi visualizzazione . Lasciare le impostazioni predefinite e selezionare Aggiungi.

In Views\Course\UpdateCourseCredits.cshtml sostituire il codice modello con il codice seguente:

@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>

Eseguire il metodo UpdateCourseCredits selezionando la scheda Courses, quindi aggiungendo "/UpdateCourseCredits" alla fine dell'URL nella barra degli indirizzi del browser (ad esempio: http://localhost:50205/Course/UpdateCourseCredits). Immettere un numero nella casella di testo:

Update_Course_Credits_initial_page_with_2_entered

Fare clic su Aggiorna. Viene visualizzato il numero di righe interessate.

Fare clic su Torna all'elenco per visualizzare l'elenco dei corsi con il numero di crediti modificato.

Per altre informazioni sulle query SQL non elaborate, vedere Query SQL non elaborate in MSDN.

Query senza registrazione

Quando un contesto di database recupera righe di tabella e crea oggetti entità che le rappresentano, per impostazione predefinita rileva se le entità in memoria sono sincronizzate con ciò che è presente nel database. I dati in memoria svolgono la funzione di una cache e vengono usati per l'aggiornamento di un'entità. Questa memorizzazione nella cache spesso non è necessaria in un'applicazione Web poiché le istanze del contesto hanno spesso una durata breve (viene creata ed eliminata una nuova istanza per ogni richiesta) e il contesto che legge un'entità viene in genere eliminato prima che l'entità venga riutilizzata.

È possibile disabilitare il rilevamento degli oggetti entità in memoria usando il metodo AsNoTracking . Gli scenari tipici in cui viene disabilitata la registrazione includono i seguenti:

  • Una query recupera un volume di dati di grandi dimensioni che disattivano il rilevamento potrebbero migliorare notevolmente le prestazioni.
  • Si vuole collegare un'entità per aggiornarla, ma è stata recuperata in precedenza la stessa entità per uno scopo diverso. Poiché l'entità viene già registrata dal contesto di database, non è possibile collegare l'entità che si vuole modificare. Un modo per gestire questa situazione consiste nell'usare l'opzione con la AsNoTracking query precedente.

Per un esempio che illustra come usare il metodo AsNoTracking , vedere la versione precedente di questa esercitazione. Questa versione dell'esercitazione non imposta il flag Modificato in un'entità creata da modello nel metodo Edit, quindi non è necessaria AsNoTracking.

Esaminare SQL inviato al database

A volte può essere utile visualizzare le query SQL inviate al database. In un'esercitazione precedente è stato illustrato come eseguire questa operazione nel codice dell'intercettatore; ora vedrai alcuni modi per farlo senza scrivere codice di intercettatore. Per provare questa operazione, si esaminerà una semplice query e quindi si esaminerà ciò che accade quando si aggiungono opzioni come il caricamento, il filtro e l'ordinamento.

In Controller/CourseController sostituire il metodo con il codice seguente per arrestare temporaneamente il Index caricamento ansioso:

public ActionResult Index()
{
    var courses = db.Courses;
    var sql = courses.ToString();
    return View(courses.ToList());
}

Impostare ora un punto di interruzione sull'istruzione return (F9 con il cursore sulla riga). Premere F5 per eseguire il progetto in modalità di debug e selezionare la pagina Indice corso. Quando il codice raggiunge il punto di interruzione, esaminare la sql variabile. Viene visualizzata la query inviata a SQL Server. È un'istruzione semplice Select .

{SELECT 
[Extent1].[CourseID] AS [CourseID], 
[Extent1].[Title] AS [Title], 
[Extent1].[Credits] AS [Credits], 
[Extent1].[DepartmentID] AS [DepartmentID]
FROM [Course] AS [Extent1]}

Fare clic sulla lente di ingrandimento per visualizzare la query nel Visualizzatore di testo.

Screenshot che mostra il controller del corso con una riga di codice evidenziata. Un altro screenshot che mostra il visualizzatore di testo aperto e una lente di ingrandimento è cerchiata in rosso nel campo Valore.

A questo punto si aggiungerà un elenco a discesa alla pagina Indice corsi in modo che gli utenti possano filtrare per un determinato reparto. Si ordinano i corsi in base al titolo e si specifica il caricamento ansioso per la proprietà di Department navigazione.

In CourseController.cs sostituire il metodo con il Index codice seguente:

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());
}

Ripristinare il punto di interruzione nell'istruzione return .

Il metodo riceve il valore selezionato dell'elenco a discesa nel SelectedDepartment parametro. Se non viene selezionato nulla, questo parametro sarà Null.

Una SelectList raccolta contenente tutti i reparti viene passata alla visualizzazione per l'elenco a discesa. I parametri passati al SelectList costruttore specificano il nome del campo valore, il nome del campo di testo e l'elemento selezionato.

Per il Get metodo del repository, il codice specifica un'espressione di filtro, un ordine di Course ordinamento e un caricamento ansioso per la proprietà di Department spostamento. L'espressione filtro restituisce true sempre se non viene selezionato nulla nell'elenco a discesa , ovvero SelectedDepartment null.

In Views\Course\Index.cshtml, immediatamente prima del tag di apertura table , aggiungere il codice seguente per creare l'elenco a discesa e un pulsante di invio:

@using (Html.BeginForm())
{
    <p>Select Department: @Html.DropDownList("SelectedDepartment","All")   
    <input type="submit" value="Filter" /></p>
}

Con il punto di interruzione ancora impostato, eseguire la pagina Indice corso. Continuare fino alla prima volta che il codice raggiunge un punto di interruzione, in modo che la pagina venga visualizzata nel browser. Selezionare un reparto dall'elenco a discesa e fare clic su Filtra.

Questa volta il primo punto di interruzione sarà per la query dei reparti per l'elenco a discesa. Ignorare e visualizzare la query variabile al successivo raggiungimento del punto di interruzione per visualizzare l'aspetto della Course query. Verrà visualizzato un aspetto simile al seguente:

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

È possibile notare che la query è ora una JOIN query che carica Department i dati insieme ai Course dati e che include una WHERE clausola.

Rimuovere la var sql = courses.ToString() riga.

Creare un livello di astrazione

Molti sviluppatori scrivono codice per implementare i modelli di repository e unità di lavoro come wrapper per il codice usato con Entity Framework. Questi modelli sono progettati per la creazione di un livello di astrazione tra il livello di accesso ai dati e il livello della logica di business di un'applicazione. L'implementazione di questi modelli può essere utile per isolare l'applicazione dalle modifiche nell'archivio dati e può semplificare il testing unità automatizzato o lo sviluppo basato su test (TDD). Tuttavia, la scrittura di codice aggiuntivo per implementare questi modelli non è sempre la scelta migliore per le applicazioni che usano EF, per diversi motivi:

  • La classe del contesto EF isola il codice dal codice specifico dell'archivio dati.
  • La classe del contesto di EF può svolgere la funzione di classe di unità di lavoro per gli aggiornamenti di database eseguiti usando EF.
  • Le funzionalità introdotte in Entity Framework 6 semplificano l'implementazione di TDD senza scrivere codice del repository.

Per altre informazioni su come implementare il repository e l'unità di modelli di lavoro, vedere la versione di Entity Framework 5 di questa serie di esercitazioni. Per informazioni sui modi per implementare TDD in Entity Framework 6, vedere le risorse seguenti:

Classi proxy

Quando Entity Framework crea istanze di entità, ad esempio quando si esegue una query, viene spesso creata come istanze di un tipo derivato generato dinamicamente che funge da proxy per l'entità. Ad esempio, vedere le due immagini del debugger seguenti. Nella prima immagine viene visualizzato che la variabile è il student tipo previsto Student immediatamente dopo aver creato un'istanza dell'entità. Nella seconda immagine, dopo che EF è stata usata per leggere un'entità studente dal database, viene visualizzata la classe proxy.

Prima della classe proxy

Dopo la classe proxy

Questa classe proxy esegue l'override di alcune proprietà virtuali dell'entità per inserire hook per eseguire automaticamente le azioni quando la proprietà è accessibile. Questa funzione viene usata per il caricamento lazy.

La maggior parte dei casi in cui non è necessario tenere presente questo uso di proxy, ma esistono eccezioni:

  • In alcuni scenari è possibile impedire a Entity Framework di creare istanze proxy. Ad esempio, quando si serializzano le entità si desiderano in genere le classi POCO, non le classi proxy. Un modo per evitare problemi di serializzazione consiste nel serializzare gli oggetti di trasferimento dei dati anziché gli oggetti di entità, come illustrato nell'esercitazione Uso dell'API Web con Entity Framework . Un altro modo consiste nel disabilitare la creazione del proxy.
  • Quando si crea un'istanza di una classe di entità usando l'operatore, non si ottiene un'istanza new proxy. Ciò significa che non si ottengono funzionalità come il caricamento lazy e il rilevamento automatico delle modifiche. Questo è in genere ok; in genere non è necessario caricare lazy, perché si sta creando una nuova entità che non è nel database e in genere non è necessario tenere traccia delle modifiche se si contrassegna in modo esplicito l'entità come Added. Tuttavia, se è necessario il caricamento lazy e è necessario il rilevamento delle modifiche, è possibile creare nuove istanze di entità con proxy usando il metodo Create della DbSet classe.
  • Potrebbe essere necessario ottenere un tipo di entità effettivo da un tipo di proxy. È possibile usare il metodo GetObjectType della classe per ottenere il tipo di entità effettivo di un'istanza ObjectContext del tipo proxy.

Per altre informazioni, vedere Uso dei proxy in MSDN.

Rilevamento automatico delle modifiche

Entity Framework determina come è stata modificata un'entità (e di conseguenza gli aggiornamenti da inviare al database) confrontando i valori correnti di un'entità con i valori originali. I valori originali vengono memorizzati quando viene eseguita una query sull'entità o quando viene collegata. I metodi che causano il rilevamento automatico delle modifiche includono:

  • DbSet.Find
  • DbSet.Local
  • DbSet.Remove
  • DbSet.Add
  • DbSet.Attach
  • DbContext.SaveChanges
  • DbContext.GetValidationErrors
  • DbContext.Entry
  • DbChangeTracker.Entries

Se si esegue il rilevamento di un numero elevato di entità e si chiama uno di questi metodi molte volte in un ciclo, è possibile ottenere miglioramenti significativi sulle prestazioni disattivando temporaneamente il rilevamento delle modifiche automatiche usando la proprietà AutoDetectChangesEnabled . Per altre informazioni, vedere Rilevamento automatico delle modifiche in MSDN.

Convalida automatica

Quando si chiama il SaveChanges metodo, per impostazione predefinita Entity Framework convalida i dati in tutte le proprietà di tutte le entità modificate prima di aggiornare il database. Se si è aggiornato un numero elevato di entità e i dati sono già stati convalidati, questo lavoro non è necessario e il processo di salvataggio delle modifiche richiede meno tempo disattivando temporaneamente la convalida. È possibile eseguire questa operazione usando la proprietà ValidateOnSaveEnabled . Per altre informazioni, vedere Convalida in MSDN.

Entity Framework Power Tools

Entity Framework Power Tools è un componente aggiuntivo di Visual Studio usato per creare i diagrammi del modello di dati illustrati in queste esercitazioni. Gli strumenti possono anche eseguire altre funzioni, ad esempio generare classi di entità in base alle tabelle in un database esistente, in modo da poter usare il database con Code First. Dopo aver installato gli strumenti, alcune opzioni aggiuntive vengono visualizzate nei menu di scelta rapida. Ad esempio, quando si fa clic con il pulsante destro del mouse sulla classe di contesto in Esplora soluzioni, viene visualizzata e l'opzione Entity Framework. In questo modo è possibile generare un diagramma. Quando si usa Code First, non è possibile modificare il modello di dati nel diagramma, ma è possibile spostarsi in giro per semplificare la comprensione.

Diagramma EF

Codice sorgente di Entity Framework

Il codice sorgente per Entity Framework 6 è disponibile in GitHub. È possibile registrare bug ed è possibile contribuire ai propri miglioramenti al codice sorgente EF.

Anche se il codice sorgente è aperto, Entity Framework è completamente supportato come prodotto Microsoft. Il team di Microsoft Entity Framework controlla i contributi accettati ed esegue il test di tutte le modifiche al codice per garantire la qualità di ogni rilascio.

Ringraziamenti

  • Tom Dykstra ha scritto la versione originale di questa esercitazione, ha creato l'aggiornamento EF 5 e ha scritto l'aggiornamento ef 6. Tom è uno scrittore di programmazione senior nel team di contenuto di Microsoft Web Platform and Tools.
  • Rick Anderson (twitter @RickAndMSFT) ha eseguito la maggior parte del lavoro aggiornando l'esercitazione per EF 5 e MVC 4 e co-autore dell'aggiornamento ef 6. Rick è un senior programming writer per Microsoft che si concentra su Azure e MVC.
  • Rowan Miller e altri membri del team di Entity Framework hanno assistito con le revisioni del codice e hanno contribuito a eseguire il debug di molti problemi con le migrazioni che si sono verificati durante l'aggiornamento dell'esercitazione per EF 5 e EF 6.

Risolvere gli errori comuni

Non è possibile creare/ombreggiatura la copia

Messaggio di errore:

Impossibile creare/ombreggiatura la copia '<nome file>' quando tale file esiste già.

Soluzione

Attendere alcuni secondi e aggiornare la pagina.

Update-Database non riconosciuto

Messaggio di errore (dal Update-Database comando nel PMC):

Il termine 'Update-Database' non viene riconosciuto come nome di un cmdlet, di una funzione, di un file di script o di un programma operabile. Verificare l'ortografia del nome, che il percorso sia incluso e corretto, quindi riprovare.

Soluzione

Uscire da Visual Studio. Riaprire il progetto e riprovare.

Convalida non riuscita

Messaggio di errore (dal Update-Database comando nel PMC):

Convalida non riuscita per una o più entità. Per altre informazioni, vedere la proprietà 'EntityValidationErrors'.

Soluzione

Una causa di questo problema è errori di convalida quando viene eseguito il Seed metodo. Per suggerimenti sul debug del Seed metodo, vedere Seeding and Debug Entity Framework (EF).

Errore HTTP 500.19

Messaggio di errore:

Errore HTTP 500.19 - Errore interno server Impossibile accedere alla pagina richiesta perché i dati di configurazione correlati per la pagina non sono validi.

Soluzione

Un modo per ottenere questo errore consiste nell'avere più copie della soluzione, ognuna delle quali usa lo stesso numero di porta. In genere è possibile risolvere questo problema chiudendo tutte le istanze di Visual Studio, quindi riavviando il progetto in uso. In caso contrario, provare a modificare il numero di porta. Fare clic con il pulsante destro del mouse sul file di progetto e quindi scegliere proprietà. Selezionare la scheda Web e quindi modificare il numero di porta nella casella di testo Url progetto .

Errore di individuazione dell'istanza di SQL Server

Messaggio di errore:

Si è verificato un errore di rete o specifico dell'istanza mentre veniva stabilita la connessione a SQL Server. Il server non è stato trovato o non è accessibile. Verificare che il nome dell'istanza sia corretto e che il server sia configurato in modo da consentire connessioni remote. (provider: interfacce di rete SQL, errore: 26 - Errore nell'individuazione del server/dell'istanza specificata)

Soluzione

Controllare la stringa di connessione. Se il database è stato eliminato manualmente, modificare il nome del database nella stringa di costruzione.

Ottenere il codice

Scaricare il progetto completato

Risorse aggiuntive

Per altre informazioni su come usare i dati usando Entity Framework, vedere la pagina della documentazione di EF in MSDN e ASP.NET Accesso ai dati - Risorse consigliate.

Per altre informazioni su come distribuire l'applicazione Web dopo averla compilata, vedere ASP.NET distribuzione Web - Risorse consigliate in MSDN Library.

Per informazioni su altri argomenti correlati a MVC, ad esempio l'autenticazione e l'autorizzazione, vedere la ASP.NET MVC - Risorse consigliate.

Passaggi successivi

In questa esercitazione:

  • Eseguire query SQL non elaborate
  • Esecuzione di query senza rilevamento
  • Query SQL esaminate inviate al database

Si è anche appreso quanto segue:

  • Creazione di un livello di astrazione
  • Classi proxy
  • Rilevamento automatico delle modifiche
  • Convalida automatica
  • Entity Framework Power Tools
  • Codice sorgente di Entity Framework

Questa serie di esercitazioni viene completata usando Entity Framework in un'applicazione MVC ASP.NET. Per informazioni su EF Database First, vedere la serie di esercitazioni di DB First.

Entity Framework Database First