Introduzione con Entity Framework 4.0 Database First e ASP.NET 4 Web Forms - Parte 7

di Tom Dykstra

L'applicazione Web di esempio Contoso University illustra come creare applicazioni Web Forms ASP.NET usando Entity Framework 4.0 e Visual Studio 2010. Per informazioni sulla serie di esercitazioni, vedere la prima esercitazione nella serie

Utilizzo delle stored procedure

Nell'esercitazione precedente è stato implementato un modello di ereditarietà di tabella per gerarchia. Questa esercitazione illustra come usare stored procedure per ottenere un maggiore controllo sull'accesso al database.

Entity Framework consente di specificare che deve usare stored procedure per l'accesso al database. Per qualsiasi tipo di entità, è possibile specificare una stored procedure da usare per la creazione, l'aggiornamento o l'eliminazione di entità di tale tipo. Nel modello di dati è quindi possibile aggiungere riferimenti alle stored procedure che è possibile usare per eseguire attività come il recupero di set di entità.

L'uso di stored procedure è un requisito comune per l'accesso al database. In alcuni casi un amministratore del database può richiedere che l'accesso a tutti i database venga eseguito tramite stored procedure per motivi di sicurezza. In altri casi è possibile creare logica di business in alcuni dei processi usati da Entity Framework quando aggiorna il database. Ad esempio, ogni volta che un'entità viene eliminata, potrebbe essere necessario copiarla in un database di archiviazione. Oppure ogni volta che viene aggiornata una riga, è possibile scrivere una riga in una tabella di registrazione che registra chi ha apportato la modifica. È possibile eseguire questi tipi di attività in una stored procedure chiamata ogni volta che Entity Framework elimina un'entità o aggiorna un'entità.

Come nell'esercitazione precedente, non si creeranno nuove pagine. Verrà invece modificato il modo in cui Entity Framework accede al database per alcune delle pagine già create.

In questa esercitazione verranno create stored procedure nel database per l'inserimento Student e Instructor le entità. Verranno aggiunti al modello di dati e si specifica che Entity Framework deve usarli per aggiungere Student ed Instructor entità al database. Si creerà anche una stored procedure che è possibile usare per recuperare Course le entità.

Creazione di stored procedure nel database

Se si usa il file School.mdf dal progetto disponibile per il download con questa esercitazione, è possibile ignorare questa sezione perché le stored procedure esistono già.

In Esplora server espandere School.mdf, fare clic con il pulsante destro del mouse su Stored Procedure e scegliere Aggiungi nuova stored procedure.

Copiare le istruzioni SQL seguenti e incollarle nella finestra della stored procedure, sostituendo la stored procedure scheletro.

CREATE PROCEDURE [dbo].[InsertStudent]
    @LastName nvarchar(50),
    @FirstName nvarchar(50),
    @EnrollmentDate datetime
    AS
    INSERT INTO dbo.Person (LastName, 
                FirstName, 
                EnrollmentDate)
    VALUES (@LastName, 
        @FirstName, 
        @EnrollmentDate);
    SELECT SCOPE_IDENTITY() as NewPersonID;

Student le entità hanno quattro proprietà: PersonID, LastName, FirstNamee EnrollmentDate. Il database genera automaticamente il valore ID e la stored procedure accetta parametri per gli altri tre. La stored procedure restituisce il valore della chiave del record della nuova riga in modo che Entity Framework possa tenere traccia di tale valore nella versione dell'entità che mantiene in memoria.

Salvare e chiudere la finestra della stored procedure.

Creare una InsertInstructor stored procedure nello stesso modo usando le istruzioni SQL seguenti:

CREATE PROCEDURE [dbo].[InsertInstructor]
        @LastName nvarchar(50),
    @FirstName nvarchar(50),
    @HireDate datetime
    AS
    INSERT INTO dbo.Person (LastName, 
                FirstName, 
                HireDate)
    VALUES (@LastName, 
        @FirstName, 
        @HireDate);
    SELECT SCOPE_IDENTITY() as NewPersonID;

Creare Update stored procedure anche per Student e Instructor entità. Il database dispone già di una DeletePerson stored procedure che funzionerà sia per InstructorStudent le entità.

CREATE PROCEDURE [dbo].[UpdateStudent]
    @PersonID int,
    @LastName nvarchar(50),
    @FirstName nvarchar(50),
    @EnrollmentDate datetime
    AS
    UPDATE Person SET LastName=@LastName, 
            FirstName=@FirstName,
            EnrollmentDate=@EnrollmentDate
    WHERE PersonID=@PersonID;

CREATE PROCEDURE [dbo].[UpdateInstructor]
    @PersonID int,
    @LastName nvarchar(50),
    @FirstName nvarchar(50),
    @HireDate datetime
    AS
    UPDATE Person SET LastName=@LastName, 
            FirstName=@FirstName,
            HireDate=@HireDate
    WHERE PersonID=@PersonID;

In questa esercitazione verranno mappate tutte e tre le funzioni, ad esempio inserimento, aggiornamento ed eliminazione, per ogni tipo di entità. Entity Framework versione 4 consente di eseguire il mapping di una o due di queste funzioni alle stored procedure senza eseguire il mapping degli altri, con un'eccezione: se si esegue il mapping della funzione di aggiornamento, ma non la funzione di eliminazione, Entity Framework genererà un'eccezione quando si tenta di eliminare un'entità. Nella versione 3.5 di Entity Framework non è stata necessaria questa flessibilità nelle stored procedure di mapping: se è stata mappata una funzione necessaria per eseguire il mapping di tutte e tre.

Per creare una stored procedure che legge anziché aggiornare i dati, crearne una che seleziona tutte le Course entità usando le istruzioni SQL seguenti:

CREATE PROCEDURE [dbo].[GetCourses]
            AS
            SELECT CourseID, Title, Credits, DepartmentID FROM dbo.Course

Aggiunta delle stored procedure al modello di dati

Le stored procedure sono ora definite nel database, ma devono essere aggiunte al modello di dati per renderle disponibili per Entity Framework. Aprire SchoolModel.edmx, fare clic con il pulsante destro del mouse sull'area di progettazione e scegliere Aggiorna modello dal database. Nella scheda Aggiungi della finestra di dialogo Scegli oggetti di database espandere Stored Procedure, selezionare le stored procedure appena create e la DeletePerson stored procedure e quindi fare clic su Fine.

Mapping delle stored procedure

Nella finestra di progettazione modelli di dati fare clic con il pulsante destro del mouse sull'entità Student e scegliere Mapping stored procedure.

Viene visualizzata la finestra Dettagli mapping in cui è possibile specificare stored procedure che Entity Framework deve usare per inserire, aggiornare ed eliminare entità di questo tipo.

Impostare la funzione Insert su InsertStudent. La finestra mostra un elenco di parametri della stored procedure, ognuno dei quali deve essere mappato a una proprietà di entità. Due di questi vengono mappati automaticamente perché i nomi sono uguali. Non è presente alcuna proprietà di entità denominata FirstName, quindi è necessario selezionare manualmente FirstMidName da un elenco a discesa che mostra le proprietà dell'entità disponibili. Questo perché è stato modificato il nome della FirstName proprietà FirstMidName in nella prima esercitazione.

Nella stessa finestra Dettagli mapping eseguire il mapping della Update funzione alla UpdateStudent stored procedure (assicurarsi di specificare FirstMidName come valore del parametro per FirstName, come si è fatto per la Insert stored procedure) e la Delete funzione nella DeletePerson stored procedure.

Seguire la stessa procedura per eseguire il mapping delle stored procedure di inserimento, aggiornamento ed eliminazione per gli insegnanti all'entità Instructor .

Per le stored procedure che leggono anziché aggiornare i dati, usare la finestra Browser modello per eseguire il mapping della stored procedure al tipo di entità restituito. Nella finestra di progettazione modelli di dati fare clic con il pulsante destro del mouse sull'area di progettazione e selezionare Browser modello. Aprire il nodo SchoolModel.Store e quindi aprire il nodo Stored Procedure . Fare quindi clic con il pulsante destro del mouse sulla GetCourses stored procedure e scegliere Aggiungi importazione funzione.

Nella finestra di dialogo Aggiungi importazione funzione , in Restituisce una raccolta dientità selezionata e quindi selezionare Course come tipo di entità restituito. Al termine, fare clic su OK. Salvare e chiudere il file edmx .

Uso di stored procedure di inserimento, aggiornamento ed eliminazione

Le stored procedure per inserire, aggiornare ed eliminare i dati vengono usati automaticamente da Entity Framework dopo averli aggiunti al modello di dati e mapparli alle entità appropriate. È ora possibile eseguire la pagina StudentsAdd.aspx e ogni volta che si crea un nuovo studente, Entity Framework userà la InsertStudent stored procedure per aggiungere la nuova riga alla Student tabella.

Eseguire la pagina Students.aspx e il nuovo studente viene visualizzato nell'elenco.

Modificare il nome per verificare che la funzione di aggiornamento funzioni e quindi eliminare lo studente per verificare che la funzione di eliminazione funzioni.

Uso di stored procedure selezionate

Entity Framework non esegue automaticamente stored procedure, GetCoursesad esempio , e non è possibile usarle con il EntityDataSource controllo. Per usarli, chiamarli dal codice.

Aprire il file InstructorsCourses.aspx.cs . Il PopulateDropDownLists metodo usa una query LINQ-to-Entityes per recuperare tutte le entità del corso in modo che possa eseguire il ciclo attraverso l'elenco e determinare quali un insegnante viene assegnato a e quali entità non vengono assegnate:

var allCourses = (from c in context.Courses
                  select c).ToList();

Sostituire questa operazione con il codice seguente:

var allCourses = context.GetCourses();

La pagina usa ora la stored procedure per recuperare l'elenco GetCourses di tutti i corsi. Eseguire la pagina per verificare che funzioni come fatto in precedenza.

Le proprietà di spostamento delle entità recuperate da una stored procedure potrebbero non essere popolate automaticamente con i dati correlati a tali entità, a seconda ObjectContext delle impostazioni predefinite. Per altre informazioni, vedere Caricamento di oggetti correlati in MSDN Library.

Nell'esercitazione successiva si apprenderà come usare la funzionalità Dati dinamici per semplificare il programmare e testare le regole di formattazione e convalida dei dati. Invece di specificare in ogni regole di pagina Web, ad esempio stringhe di formato dati e se è necessario un campo, è possibile specificare tali regole nei metadati del modello di dati e vengono applicati automaticamente in ogni pagina.