Stored procedure CUD della finestra di progettazione

Questa procedura dettagliata illustra come eseguire il mapping delle operazioni create\insert, update ed delete (CUD) di un tipo di entità alle stored procedure usando Entity Framework Designer (EF Designer).  Per impostazione predefinita, Entity Framework genera automaticamente le istruzioni SQL per le operazioni CUD, ma è anche possibile eseguire il mapping delle stored procedure a queste operazioni.  

Si noti che Code First non supporta il mapping a stored procedure o funzioni. È tuttavia possibile chiamare stored procedure o funzioni usando il metodo System.Data.Entity.DbSet.SqlQuery. Ad esempio:

var query = context.Products.SqlQuery("EXECUTE [dbo].[GetAllProducts]");

Considerazioni relative al mapping delle operazioni CUD alle stored procedure

Quando si esegue il mapping delle operazioni CUD alle stored procedure, si applicano le considerazioni seguenti:

• Se si esegue il mapping di una delle operazioni CUD a una stored procedure, eseguirne il mapping. Se non si esegue il mapping di tutti e tre, le operazioni non mappate avranno esito negativo se eseguite e verrà generata un'eccezione UpdateException .
• È necessario eseguire il mapping di ogni parametro della stored procedure alle proprietà dell'entità.
• Se il server genera il valore della chiave primaria per la riga inserita, è necessario eseguire di nuovo il mapping di questo valore alla proprietà chiave dell'entità. Nell'esempio seguente la stored procedure InsertPerson restituisce la chiave primaria appena creata come parte del set di risultati della stored procedure. La chiave primaria viene mappata alla chiave di entità (PersonID) usando la <funzionalità Aggiungi binding di risultati> di Entity Designer.
• Le chiamate di stored procedure vengono mappate a 1:1 con le entità nel modello concettuale. Ad esempio, se si implementa una gerarchia di ereditarietà nel modello concettuale e quindi si esegue il mapping delle stored procedure CUD per le entità Padre (base) e figlio(derivato), il salvataggio delle modifiche figlio chiamerà solo le stored procedure figlio, non attiverà le chiamate alle stored procedure padre.

Prerequisiti

Per completare questa procedura dettagliata, sarà necessario:

• Una versione recente di Visual Studio.
• Database di esempio School.

Configurare il progetto

• Aprire Visual Studio 2012.
• Selezionare File -> Nuovo -> Progetto
• Nel riquadro sinistro fare clic su Visual C#, quindi selezionare il modello console .
• Immettere CUDSProcsSample come nome.
• Seleziona OK.

Create a Model (Creare un modello)

• Fare clic con il pulsante destro del mouse sul nome del progetto in Esplora soluzioni e scegliere Aggiungi -> Nuovo elemento.

• Selezionare Dati dal menu a sinistra e quindi selezionare ADO.NET Entity Data Model nel riquadro Modelli.

• Immettere CUDSProcs.edmx come nome file e quindi fare clic su Aggiungi.

• Nella finestra di dialogo Scegli contenuto modello selezionare Genera dal database e quindi fare clic su Avanti.

• Fare clic su Nuovo Connessione ion. Nella finestra di dialogo Proprietà Connessione ion immettere il nome del server ( ad esempio (localdb)\mssqllocaldb), selezionare il metodo di autenticazione, digitare School per il nome del database e quindi fare clic su OK. La finestra di dialogo Choose Your Data Connessione ion viene aggiornata con l'impostazione di connessione al database.

• Nella finestra di dialogo Scegli oggetti di database selezionare la tabella Person nel nodo Tabelle.

• Selezionare anche le stored procedure seguenti nel nodo Stored procedure e funzioni : DeletePerson, InsertPerson e UpdatePerson.

• A partire da Visual Studio 2012 Ef Designer supporta l'importazione bulk di stored procedure. L'opzione Importa stored procedure e funzioni selezionate nel modello di entità viene controllata per impostazione predefinita. Poiché in questo esempio sono presenti stored procedure che inseriscono, aggiornano ed eliminano i tipi di entità, non vogliamo importarli e deselezionare questa casella di controllo.

  

• Fare clic su Fine. Ef Designer, che fornisce un'area di progettazione per la modifica del modello, viene visualizzata.

Eseguire il mapping dell'entità person alle stored procedure

• Fare clic con il pulsante destro del mouse sul tipo di entità Person (Persona ) e selezionare Stored procedure Mapping (Mapping stored procedure).

• I mapping delle stored procedure vengono visualizzati nella finestra Dettagli mapping.

• Fare clic su <Seleziona funzione inserisci>. Questo campo diventa l'elenco a discesa delle stored procedure contenute nel modello di archiviazione che possono essere mappate ai tipi di entità del modello concettuale. Selezionare InserisciPersone nell'elenco a discesa.

• Vengono visualizzati i mapping predefiniti tra i parametri delle stored procedure e le proprietà dell'entità. Come indicato dalle frecce, che mostrano la direzione del mapping, per i parametri delle stored procedure vengono specificati i valori delle proprietà.

• Fare clic su <Aggiungi associazione risultati>.

• Digitare NewPersonID, il nome del parametro restituito dalla stored procedure InsertPerson . Assicurarsi di non digitare spazi iniziali o finali.

• Premere INVIO.

• Per impostazione predefinita, NewPersonID viene mappato alla chiave di entità PersonID. Come indicato dalle frecce, che mostrano la direzione del mapping, per la proprietà viene specificato il valore della colonna dei risultati.

  

• Fare clic su <Seleziona funzione di aggiornamento> e selezionare UpdatePerson nell'elenco a discesa risultante.

• Vengono visualizzati i mapping predefiniti tra i parametri delle stored procedure e le proprietà dell'entità.

• Fare clic su <Seleziona funzione elimina> e selezionare DeletePerson nell'elenco a discesa risultante.

• Vengono visualizzati i mapping predefiniti tra i parametri delle stored procedure e le proprietà dell'entità.

Le operazioni di inserimento, aggiornamento ed eliminazione del tipo di entità Person vengono ora mappate alle stored procedure.

Se si vuole abilitare il controllo della concorrenza durante l'aggiornamento o l'eliminazione di un'entità con stored procedure, usare una delle opzioni seguenti:

• Utilizzare un parametro OUTPUT per restituire il numero di righe interessate dalla stored procedure e selezionare la casella di controllo Rows Affected Parameter accanto al nome del parametro. Se il valore restituito è zero quando viene chiamata l'operazione, verrà generata un'eccezione OptimisticConcurrencyException .
• Selezionare la casella di controllo Usa valore originale accanto a una proprietà che si vuole usare per il controllo della concorrenza. Quando si tenta di eseguire un aggiornamento, il valore della proprietà originariamente letta dal database verrà utilizzato durante la scrittura dei dati nel database. Se il valore non corrisponde al valore nel database, verrà generata un'eccezione OptimisticConcurrencyException .

Usare il modello

Aprire il file Program.cs in cui è definito il metodo Main . Aggiungere il codice seguente alla funzione Main.

Il codice crea un nuovo oggetto Person , quindi aggiorna l'oggetto e infine elimina l'oggetto.

    using (var context = new SchoolEntities())
    {
        var newInstructor = new Person
        {
            FirstName = "Robyn",
            LastName = "Martin",
            HireDate = DateTime.Now,
            Discriminator = "Instructor"
        }

        // Add the new object to the context.
        context.People.Add(newInstructor);

        Console.WriteLine("Added {0} {1} to the context.",
            newInstructor.FirstName, newInstructor.LastName);

        Console.WriteLine("Before SaveChanges, the PersonID is: {0}",
            newInstructor.PersonID);

        // SaveChanges will call the InsertPerson sproc.  
        // The PersonID property will be assigned the value
        // returned by the sproc.
        context.SaveChanges();

        Console.WriteLine("After SaveChanges, the PersonID is: {0}",
            newInstructor.PersonID);

        // Modify the object and call SaveChanges.
        // This time, the UpdatePerson will be called.
        newInstructor.FirstName = "Rachel";
        context.SaveChanges();

        // Remove the object from the context and call SaveChanges.
        // The DeletePerson sproc will be called.
        context.People.Remove(newInstructor);
        context.SaveChanges();

        Person deletedInstructor = context.People.
            Where(p => p.PersonID == newInstructor.PersonID).
            FirstOrDefault();

        if (deletedInstructor == null)
            Console.WriteLine("A person with PersonID {0} was deleted.",
                newInstructor.PersonID);
    }

• Compilare l'applicazione ed eseguirla. Il programma produce l'output seguente *

Nota

PersonID viene generato automaticamente dal server, quindi è molto probabile che venga visualizzato un numero diverso*

Added Robyn Martin to the context.
Before SaveChanges, the PersonID is: 0
After SaveChanges, the PersonID is: 51
A person with PersonID 51 was deleted.

Se si usa la versione Ultimate di Visual Studio, è possibile usare Intellitrace con il debugger per visualizzare le istruzioni SQL che vengono eseguite.