Introduzione a Entity Framework 4.0 Database First e ASP.NET 4 Web Form - Parte 7

di Tom Dykstra

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

Utilizzo di Stored Procedure

Nel tutorial precedente, hai implementato un modello di ereditarietà tabella-per-gerarchia. Questa esercitazione illustra come usare le 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 di database potrebbe richiedere che tutti gli accessi al database vengano sottoposti a stored procedure per motivi di sicurezza. In altri casi è possibile compilare la logica di business in alcuni dei processi usati da Entity Framework quando aggiorna il database. Ad esempio, ogni volta che un'entità viene eliminata, è possibile copiarla in un database di archivio. In alternativa, ogni volta che una riga viene aggiornata, è 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 verranno create nuove pagine. Si modificherà invece il modo in cui Entity Framework accede al database per alcune delle pagine già create.

In questa esercitazione si creeranno stored procedure nel database per l'inserimento Student e delle entità Instructor. Verranno aggiunti al modello di dati e si specifica che Entity Framework deve usarli per aggiungere Student e Instructor entità al database. Creerai anche una stored procedure che è possibile utilizzare per recuperare Course entità.

Creazione di Stored Procedures 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 Procedures e scegliere Aggiungi Nuova Stored Procedure.

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

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 record della nuova riga in modo che Entity Framework possa tenere traccia di tale chiave 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 anche stored procedure per le entità Student e Instructor. Il database dispone già di una DeletePerson stored procedure che funzionerà per entrambe le entità Instructor e Student.

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, ovvero 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 a stored procedure senza eseguire il mapping degli altri, con un'eccezione: se si esegue il mapping della funzione di aggiornamento ma non della funzione delete, Entity Framework genererà un'eccezione quando si tenta di eliminare un'entità. In Entity Framework versione 3.5, non avevi così tanta flessibilità nelle procedure memorizzate: se mappavi una funzione, eri obbligato a mappare tutte e tre.

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

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

Aggiunta delle procedure memorizzate 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 da 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.

Mappatura delle stored procedure

Nella progettazione di modelli di dati, fare clic con il pulsante destro del mouse sull'entità Student e selezionare mappatura delle stored procedure.

Viene visualizzata la finestra Dettagli di mappatura in cui è possibile specificare le stored procedure che l'Entity Framework deve usare per l'inserimento, l'aggiornamento e l'eliminazione di entità di questo tipo.

Impostare la funzione Insert su InsertStudent. Nella finestra viene visualizzato un elenco di parametri della stored procedure, ognuno dei quali deve essere mappato a una proprietà di entità. Due di queste vengono mappate automaticamente perché i nomi sono gli stessi. Non esiste 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é hai cambiato il nome della proprietà FirstName in FirstMidName nella prima esercitazione.

Nella stessa finestra Dettagli mappatura, mappare la Update funzione alla UpdateStudent procedura memorizzata (assicurarsi di specificare FirstMidName come valore del parametro per FirstName, come è stato fatto per la Insert procedura memorizzata) e la Delete funzione alla DeletePerson procedura memorizzata.

Seguire la stessa procedura per mappare le stored procedure di inserimento, aggiornamento ed eliminazione per gli istruttori all'entità Instructor.

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

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

Utilizzo di stored procedure di inserimento, aggiornamento ed eliminazione

Le stored procedure per inserire, aggiornare ed eliminare i dati vengono usate automaticamente da Entity Framework dopo averle aggiunte al modello di dati ed eseguirne il mapping 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 delete funzioni.

Utilizzo di select stored procedure

Entity Framework non esegue automaticamente stored procedure come GetCourses e non è possibile utilizzarle con il controllo EntityDataSource. Per usarli, chiamarli dal codice.

Aprire il file InstructorsCourses.aspx.cs . Il PopulateDropDownLists metodo utilizza una query LINQ-to-Entities per recuperare tutte le entità corso, in modo da poter scorrere l'elenco e determinare a quali corsi è assegnato un istruttore e quali sono non assegnati.

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

Sostituire con il codice seguente:

var allCourses = context.GetCourses();

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

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

Nell'esercitazione successiva si apprenderà come usare la funzionalità Dynamic Data per semplificare il programmare e testare le regole di formattazione e convalida dei dati. Anziché specificare in ogni regola della pagina Web, ad esempio stringhe di formato dati e se è necessario o meno un campo, è possibile specificare tali regole nei metadati del modello di dati e applicarle automaticamente in ogni pagina.