Creazione di un livello di accesso ai dati (VB)

di Scott Mitchell

Scarica il PDF

In questa esercitazione si inizierà dall'inizio e si creerà il livello di accesso ai dati (DAL), usando set di dati tipizzato, per accedere alle informazioni in un database.

Introduzione

Gli sviluppatori Web riguardano l'uso dei dati. I database vengono creati per archiviare i dati, il codice per recuperarlo e modificarlo e le pagine Web da raccogliere e riepilogarlo. Questa è la prima esercitazione di una serie lunga che esplorerà le tecniche per implementare questi modelli comuni in ASP.NET 2.0. Si inizierà con la creazione di un'architettura software composta da un livello di accesso ai dati (DAL) usando set di dati tipiti, un livello BLL (Business Logic Layer) che applica regole business personalizzate e un livello di presentazione composto da ASP.NET pagine che condividono un layout di pagina comune. Una volta che questo lavoro di base back-end è stato disposto, si passerà alla creazione di report, mostrando come visualizzare, riepilogare, raccogliere e convalidare i dati da un'applicazione Web. Queste esercitazioni sono concepite per essere concise e fornire istruzioni dettagliate con un sacco di screenshot per illustrare visivamente il processo. Ogni esercitazione è disponibile nelle versioni di C# e Visual Basic e include un download del codice completo usato. Questa prima esercitazione è piuttosto lunga, ma il resto viene presentato in blocchi molto più digeribili.

Per queste esercitazioni verrà usata una versione di Microsoft SQL Server 2005 Express Edition del database Northwind inserita nella App_Data directory . Oltre al file di database, la App_Data cartella contiene anche gli script SQL per la creazione del database, nel caso in cui si voglia usare una versione del database diversa. Se si usa una versione diversa SQL Server del database Northwind, sarà necessario aggiornare l'impostazione NORTHWNDConnectionString nel file dell'applicazioneWeb.config. L'applicazione Web è stata compilata usando Visual Studio 2005 Professional Edition come progetto di sito Web basato sul file system. Tuttavia, tutte le esercitazioni funzioneranno altrettanto bene con la versione gratuita di Visual Studio 2005, Visual Web Developer.

In questa esercitazione si inizierà dall'inizio e si creerà il livello di accesso ai dati (DAL), seguito dalla creazione del livello di logica di business (BLL) nella seconda esercitazione e si userà il layout e lo spostamento della pagina nella terza. Le esercitazioni dopo il terzo si baseranno sulle fondamenta poste nei primi tre. In questa prima esercitazione sono disponibili molti argomenti, quindi è possibile avviare Visual Studio e iniziare.

Passaggio 1: Creazione di un progetto Web e connessione al database

Prima di poter creare il livello di accesso ai dati (DAL), è necessario creare un sito Web e configurare il database. Per iniziare, creare un nuovo sito Web basato sul file system ASP.NET. A tale scopo, passare al menu File e scegliere Nuovo sito Web, visualizzando la finestra di dialogo Nuovo sito Web. Scegliere il modello sito Web ASP.NET, impostare l'elenco a discesa Percorso su File System, scegliere una cartella in cui inserire il sito Web e impostare la lingua su Visual Basic.

Figura 1: Creare un nuovo file System-Based sito Web (fare clic per visualizzare l'immagine a dimensione intera)

Verrà creato un nuovo sito Web con una Default.aspx pagina ASP.NET, una App_Data cartella e un Web.config file.

Dopo aver creato il sito Web, il passaggio successivo consiste nell'aggiungere un riferimento al database in Esplora server di Visual Studio. Aggiungendo un database a Esplora server, è possibile aggiungere tabelle, stored procedure, viste e così via dall'interno di Visual Studio. È anche possibile visualizzare i dati della tabella o creare query personalizzate manualmente o graficamente tramite Generatore query. Inoltre, quando si compilano i set di dati tipiti per DAL, è necessario puntare Visual Studio al database da cui devono essere costruiti i dataset tipiti. Sebbene sia possibile fornire queste informazioni di connessione in quel momento, Visual Studio popola automaticamente un elenco a discesa dei database già registrati in Esplora server.

I passaggi per l'aggiunta del database Northwind a Esplora server dipendono dal fatto che si voglia utilizzare il database SQL Server 2005 Express Edition nella App_Data cartella o se si dispone di un server di database microsoft SQL Server 2000 o 2005 che si desidera utilizzare.

Uso di un database nellaApp_Datacartella

Se non si dispone di un server di database SQL Server 2000 o 2005 a cui connettersi o si vuole semplicemente evitare di dover aggiungere il database a un server di database, è possibile usare la versione SQL Server 2005 Express Edition del database Northwind che si trova nella cartella del App_Data sito Web scaricato (NORTHWND.MDF).

Un database inserito nella App_Data cartella viene aggiunto automaticamente a Esplora server. Supponendo di avere SQL Server 2005 Express Edition installato nel computer, dovrebbe essere visualizzato un nodo denominato NORTHWND. MDF in Esplora server, che è possibile espandere ed esplorare le relative tabelle, viste, stored procedure e così via (vedere la figura 2).

La App_Data cartella può contenere anche i file di Microsoft Access.mdb, che, come le controparti SQL Server, vengono aggiunti automaticamente a Esplora server. Se non si vuole usare alcuna delle opzioni di SQL Server, è sempre possibile installare il database e le app Northwind Traders e passare alla App_Data directory. Tenere presente, tuttavia, che i database di Access non sono così ricchi di funzionalità come SQL Server e non sono progettati per essere usati in scenari di siti Web. Inoltre, un paio di esercitazioni 35+ utilizzeranno determinate funzionalità a livello di database che non sono supportate da Access.

Connessione al database in un server di database di Microsoft SQL Server 2000 o 2005

In alternativa, è possibile connettersi a un database Northwind installato in un server di database. Se il server di database non dispone già del database Northwind installato, è prima necessario aggiungerlo al server di database eseguendo lo script di installazione incluso nel download di questa esercitazione.

Dopo aver installato il database, passare a Esplora server in Visual Studio, fare clic con il pulsante destro del mouse sul nodo Data Connections e scegliere Aggiungi connessione. Se Esplora server non viene visualizzato, passare a Visualizza/Esplora server oppure premere CTRL+ALT+S. Verrà visualizzata la finestra di dialogo Aggiungi connessione, in cui è possibile specificare il server a cui connettersi, le informazioni di autenticazione e il nome del database. Dopo aver configurato correttamente le informazioni di connessione al database e aver fatto clic sul pulsante OK, il database verrà aggiunto come nodo sotto il nodo Data Connections. È possibile espandere il nodo del database per esplorare tabelle, viste, stored procedure e così via.

Figura 2: Aggiungere una connessione al database Northwind del server di database

Passaggio 2: Creazione del livello di accesso ai dati

Quando si lavora con i dati, un'opzione consiste nell'incorporare la logica specifica dei dati direttamente nel livello presentazione (in un'applicazione Web, le pagine ASP.NET costituiscono il livello di presentazione). Questo può assumere la forma di scrittura di codice ADO.NET nella parte di codice della pagina ASP.NET o usando il controllo SqlDataSource dalla parte di markup. In entrambi i casi, questo approccio associa strettamente la logica di accesso ai dati con il livello presentazione. L'approccio consigliato, tuttavia, consiste nel separare la logica di accesso ai dati dal livello presentazione. Questo livello separato viene definito livello di accesso ai dati, DAL per breve e viene in genere implementato come progetto di libreria di classi separato. I vantaggi di questa architettura a più livelli sono ben documentati (vedere la sezione "Altre letture" alla fine di questa esercitazione per informazioni su questi vantaggi) ed è l'approccio che verrà adottato in questa serie.

Tutto il codice specifico dell'origine dati sottostante, ad esempio la creazione di una connessione al database, l'emissione SELECTdi comandi , INSERT, UPDATEe DELETE così via deve trovarsi in DAL. Il livello presentazione non deve contenere riferimenti a tale codice di accesso ai dati, ma deve invece effettuare chiamate a DAL per tutte le richieste di dati. I livelli di accesso ai dati contengono in genere metodi per accedere ai dati del database sottostanti. Il database Northwind, ad esempio, contiene Products tabelle e Categories che registrano i prodotti in vendita e le categorie a cui appartengono. In DAL saranno disponibili metodi come:

• GetCategories(), che restituirà informazioni su tutte le categorie
• GetProducts(), che restituirà informazioni su tutti i prodotti
• GetProductsByCategoryID(categoryID), che restituirà tutti i prodotti che appartengono a una categoria specificata
• GetProductByProductID(productID), che restituirà informazioni su un determinato prodotto

Questi metodi, quando richiamati, si connetteranno al database, eseguiranno la query appropriata e restituiranno i risultati. Il modo in cui vengono restituiti questi risultati è importante. Questi metodi possono semplicemente restituire un oggetto DataSet o DataReader popolato dalla query del database, ma idealmente questi risultati devono essere restituiti usando oggetti fortemente tipizzati. Un oggetto fortemente tipizzato è uno il cui schema è definito rigidamente in fase di compilazione, mentre l'opposto, un oggetto di tipo libero, è uno il cui schema non è noto fino al runtime.

Ad esempio, DataReader e DataSet (per impostazione predefinita) sono oggetti di tipo libero poiché il relativo schema è definito dalle colonne restituite dalla query di database usata per popolarle. Per accedere a una determinata colonna da una DataTable di tipo libero, è necessario usare la sintassi come : DataTable.Rows(index)("columnName"). La digitazione libera di DataTable in questo esempio è rappresentata dal fatto che è necessario accedere al nome della colonna usando una stringa o un indice ordinale. Un Oggetto DataTable fortemente tipizzato, d'altra parte, avrà ognuna delle relative colonne implementate come proprietà, con un codice simile a : DataTable.Rows(index).columnName.

Per restituire oggetti fortemente tipizzati, gli sviluppatori possono creare oggetti business personalizzati o usare set di dati tipizzati. Un oggetto business viene implementato dallo sviluppatore come classe le cui proprietà riflettono in genere le colonne della tabella di database sottostante rappresentata dall'oggetto business. Un dataset tipizzato è una classe generata automaticamente da Visual Studio in base a uno schema di database e i cui membri sono fortemente tipizzato in base a questo schema. L'oggetto DataSet tipizzato è costituito da classi che estendono le classi DataSet, DataTable e DataRow ADO.NET. Oltre alle tabelle DataTable fortemente tipizzate, i set di dati tipizzato ora includono anche TableAdapter, che sono classi con metodi per popolare le tabelle DataTable di DataSet e propagando le modifiche all'interno delle tabelle DataTable nel database.

Nota

Per altre informazioni sui vantaggi e gli svantaggi dell'uso di set di dati tipizzati rispetto agli oggetti business personalizzati, vedere Progettazione di componenti del livello dati e passaggio di livelli dati tramite livelli.

Per queste esercitazioni si useranno set di dati fortemente tipizzato. La figura 3 illustra il flusso di lavoro tra i diversi livelli di un'applicazione che usa set di dati tipizzato.

Figura 3: Tutto il codice di accesso ai dati viene retrocesso a DAL (fare clic per visualizzare l'immagine a dimensione intera)

Creazione di un set di dati tipizzato e di un adattatore di tabella

Per iniziare a creare il dal, si inizia aggiungendo un dataset tipizzato al progetto. A tale scopo, fare clic con il pulsante destro del mouse sul nodo del progetto nel Esplora soluzioni e scegliere Aggiungi un nuovo elemento. Selezionare l'opzione DataSet nell'elenco dei modelli e denominarla Northwind.xsd.

Figura 4: Scegliere di aggiungere un nuovo set di dati al progetto (fare clic per visualizzare l'immagine a dimensione intera)

Dopo aver fatto clic su Aggiungi, quando viene richiesto di aggiungere il set di dati alla App_Code cartella, scegliere Sì. Il Designer per il set di dati tipizzato verrà quindi visualizzato e verrà avviata la Configurazione guidata TableAdapter, consentendo di aggiungere il primo TableAdapter al DataSet tipizzato.

Un DataSet tipizzato funge da raccolta fortemente tipizzata di dati; è costituito da istanze di DataTable fortemente tipizzata, ognuna delle quali è a sua volta composta da istanze dataRow fortemente tipizzata. Verrà creata una tabella dati fortemente tipizzata per ognuna delle tabelle di database sottostanti che è necessario usare in questa serie di esercitazioni. Iniziamo con la creazione di una tabella DataTable per la Products tabella.

Tenere presente che datatable fortemente tipizzato non includono informazioni su come accedere ai dati dalla tabella di database sottostante. Per recuperare i dati per popolare DataTable, viene usata una classe TableAdapter, che funziona come livello di accesso ai dati. Products Per DataTable, TableAdapter conterrà i metodi GetProducts(), GetProductByCategoryID(categoryID)e così via verrà richiamato dal livello di presentazione. Il ruolo di DataTable consiste nel fungere da oggetti fortemente tipizzati usati per passare i dati tra i livelli.

La Configurazione guidata TableAdapter inizia richiedendo di selezionare il database da usare. L'elenco a discesa mostra tali database in Esplora server. Se non è stato aggiunto il database Northwind a Esplora server, è possibile fare clic sul pulsante Nuova connessione in questo momento per eseguire questa operazione.

Figura 5: scegliere il database Northwind dall'elenco Drop-Down (fare clic per visualizzare l'immagine a dimensioni complete)

Dopo aver selezionato il database e fare clic su Avanti, verrà chiesto se si vuole salvare il stringa di connessione nel Web.config file. Salvando la stringa di connessione si eviterà di averlo codificato in modo rigido nelle classi TableAdapter, che semplifica le operazioni se le informazioni stringa di connessione cambiano in futuro. Se si sceglie di salvare l'stringa di connessione nel file di configurazione inserito nella <connectionStrings> sezione, che può essere crittografato facoltativamente per migliorare la sicurezza o modificato in un secondo momento tramite la nuova pagina delle proprietà ASP.NET 2.0 all'interno dello strumento gui Amministrazione IIS, che è più ideale per gli amministratori.

Figura 6: Salvare la stringa di connessione in Web.config (Fare clic per visualizzare l'immagine full-size)

Successivamente, è necessario definire lo schema per la prima DataTable fortemente tipizzata e fornire il primo metodo per l'uso di TableAdapter quando si popola il DataSet fortemente tipizzato. Questi due passaggi vengono eseguiti simultaneamente creando una query che restituisce le colonne dalla tabella che si vuole riflettere nella tabella DataTable. Alla fine della procedura guidata verrà assegnato un nome di metodo a questa query. Una volta eseguita questa operazione, questo metodo può essere richiamato dal livello di presentazione. Il metodo eseguirà la query definita e popola una tabella dati fortemente tipizzata.

Per iniziare a definire la query SQL, è prima necessario indicare come si vuole che TableAdapter esegua la query. È possibile usare un'istruzione SQL ad hoc, creare una nuova stored procedure o usare una stored procedure esistente. Per queste esercitazioni verranno usate istruzioni SQL ad hoc.

Figura 7: Eseguire una query sui dati usando un'istruzione SQL ad hoc (fare clic per visualizzare l'immagine full-size)

A questo punto è possibile digitare nella query SQL in base alla mano. Quando si crea il primo metodo in TableAdapter, in genere si vuole che la query restituisca le colonne che devono essere espresse nella tabella dati corrispondente. È possibile eseguire questa operazione creando una query che restituisce tutte le colonne e tutte le righe della Products tabella:

Figura 8: immettere la query SQL nella casella di testo (fare clic per visualizzare l'immagine a dimensioni complete)

In alternativa, usare Query Builder e costruire graficamente la query, come illustrato nella figura 9.

Figura 9: Creare graficamente query tramite la Editor di query (fare clic per visualizzare l'immagine a dimensioni complete)

Dopo aver creato la query, ma prima di passare alla schermata successiva, fare clic sul pulsante Opzioni avanzate. Nei progetti del sito Web "Genera istruzioni Insert, Update ed Delete" è l'unica opzione avanzata selezionata per impostazione predefinita; se si esegue questa procedura guidata da una libreria di classi o da un progetto Windows, verrà selezionata anche l'opzione "Usa concorrenza ottimistica". Lasciare deselezionata l'opzione "Usa concorrenza ottimistica" per il momento. Verranno esaminate le concorrenza ottimistiche nelle esercitazioni future.

Figura 10: selezionare solo l'opzione Genera istruzioni Insert, Update ed Delete (Fare clic per visualizzare l'immagine full-size)

Dopo aver verificato le opzioni avanzate, fare clic su Avanti per procedere alla schermata finale. Di seguito viene chiesto di selezionare i metodi da aggiungere all'oggetto TableAdapter. Esistono due modelli per popolare i dati:

• Compilare una tabella dati con questo approccio viene creato un metodo che accetta in una tabella dati come parametro e lo popola in base ai risultati della query. La classe DataAdapter ADO.NET, ad esempio, implementa questo modello con il Fill() relativo metodo.
• Restituire un oggetto DataTable con questo approccio, il metodo crea e riempie DataTable per l'utente e lo restituisce come valore restituito dai metodi.

È possibile implementare uno o entrambi questi modelli. È anche possibile rinominare i metodi forniti qui. Lasciare entrambe le caselle di controllo selezionate, anche se si userà solo il modello in queste esercitazioni. Inoltre, si rinomina il metodo piuttosto generico GetData in GetProducts.

Se selezionata, la casella di controllo finale "GenerateDBDirectMethods", crea Insert(), Update()e Delete() i metodi per TableAdapter. Se si lascia deselezionata questa opzione, è necessario eseguire tutti gli aggiornamenti tramite il metodo unico Update() di TableAdapter, che accetta in Typed DataSet, un oggetto DataTable, un singolo DataRow o una matrice di DataRows. Se è stata deselezionata l'opzione "Genera istruzioni Inserisci, Aggiornamento ed Elimina" dalle proprietà avanzate nella figura 9 questa casella di controllo non avrà alcun effetto. Lasciare selezionata questa casella di controllo.

Figura 11: Modificare il nome del metodo da GetData a GetProducts (Fare clic per visualizzare l'immagine a dimensioni complete)

Completare la procedura guidata facendo clic su Fine. Dopo la chiusura della procedura guidata, viene restituito al Designer DataSet che mostra la tabella dati appena creata. È possibile visualizzare l'elenco Products di colonne in DataTable (ProductID, ProductNamee così via), nonché i metodi di ProductsTableAdapter (Fill() e GetProducts()).

Figura 12: DataTable Products e ProductsTableAdapter sono stati aggiunti al dataset tipizzato (fare clic per visualizzare l'immagine full-size)

A questo punto è disponibile un DataSet tipizzato con una singola tabella DataTable () e una classe DataAdapter fortemente tipizzata (Northwind.ProductsNorthwindTableAdapters.ProductsTableAdapter) con un GetProducts() metodo. Questi oggetti possono essere usati per accedere a un elenco di tutti i prodotti dal codice come:

Dim productsAdapter As New NorthwindTableAdapters.ProductsTableAdapter()
Dim products as Northwind.ProductsDataTable
products = productsAdapter.GetProducts()
For Each productRow As Northwind.ProductsRow In products
    Response.Write("Product: " & productRow.ProductName & "<br />")
Next

Questo codice non richiedeva di scrivere un bit di codice specifico per l'accesso ai dati. Non è necessario creare un'istanza di classi ADO.NET, non è necessario fare riferimento a stringhe di connessione, query SQL o stored procedure. Invece, TableAdapter fornisce il codice di accesso ai dati di basso livello per noi.

Ogni oggetto usato in questo esempio è anche fortemente tipizzato, consentendo a Visual Studio di fornire il controllo dei tipi IntelliSense e del tipo di compilazione. E meglio di tutti i dataTable restituiti da TableAdapter può essere associato a ASP.NET controlli Web dati, ad esempio GridView, DetailsView, DropDownList, CheckBoxList e diversi altri. Nell'esempio seguente viene illustrato l'associazione GetProducts() di DataTable restituita dal metodo a gridView in solo tre righe di codice all'interno del Page_Load gestore eventi.

AllProducts.aspx

<%@ Page Language="VB" AutoEventWireup="true" CodeFile="AllProducts.aspx.vb"
    Inherits="AllProducts" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>View All Products in a GridView</title>
    <link href="Styles.css" rel="stylesheet" type="text/css" />
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <h1>
            All Products</h1>
        <p>
            <asp:GridView ID="GridView1" runat="server"
             CssClass="DataWebControlStyle">
               <HeaderStyle CssClass="HeaderStyle" />
               <AlternatingRowStyle CssClass="AlternatingRowStyle" />
            </asp:GridView>
             </p>
    </div>
    </form>
</body>
</html>

AllProducts.aspx.vb

Imports NorthwindTableAdapters
Partial Class AllProducts
    Inherits System.Web.UI.Page
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) _
        Handles Me.Load
        Dim productsAdapter As New ProductsTableAdapter
        GridView1.DataSource = productsAdapter.GetProducts()
        GridView1.DataBind()
    End Sub
End Class

Figura 13: l'elenco dei prodotti viene visualizzato in Un controllo GridView (fare clic per visualizzare l'immagine a dimensioni complete)

Anche se in questo esempio sono necessarie tre righe di codice nel gestore eventi della Page_Load pagina di ASP.NET, nelle esercitazioni future si esaminerà come usare ObjectDataSource per recuperare in modo dichiarativo i dati dal DAL. Con ObjectDataSource non sarà necessario scrivere codice e otterrà anche il supporto per il paging e l'ordinamento.

Passaggio 3: Aggiunta di metodi con parametri al livello di accesso ai dati

A questo punto la ProductsTableAdapter classe ha un metodo, GetProducts(), che restituisce tutti i prodotti nel database. Sebbene sia in grado di lavorare con tutti i prodotti è sicuramente utile, ci sono momenti in cui si vogliono recuperare informazioni su un prodotto specifico o tutti i prodotti che appartengono a una determinata categoria. Per aggiungere tali funzionalità al livello di accesso ai dati, è possibile aggiungere metodi con parametri all'oggetto TableAdapter.

Aggiungiamo il GetProductsByCategoryID(categoryID) metodo. Per aggiungere un nuovo metodo a DAL, tornare al dataset Designer, fare clic con il pulsante destro del ProductsTableAdapter mouse nella sezione e scegliere Aggiungi query.

Figura 14: Right-Click nella tabellaAdapter e scegliere Aggiungi query

Viene innanzitutto richiesto se si vuole accedere al database usando un'istruzione SQL ad hoc o una stored procedure nuova o esistente. Si sceglie di usare di nuovo un'istruzione SQL ad hoc. Viene quindi chiesto il tipo di query SQL che si vuole usare. Poiché si vuole restituire tutti i prodotti appartenenti a una categoria specificata, si vuole scrivere un'istruzione SELECT che restituisce righe.

Figura 15: scegliere di creare un'istruzione che restituisce righe (fare clic per visualizzare l'immagineSELECT a dimensioni complete)

Il passaggio successivo consiste nel definire la query SQL usata per accedere ai dati. Poiché si vuole restituire solo i prodotti appartenenti a una determinata categoria, usare la stessa SELECT istruzione da GetProducts(), ma aggiungere la clausola seguente WHERE : WHERE CategoryID = @CategoryID. Il @CategoryID parametro indica alla procedura guidata TableAdapter che il metodo creato richiederà un parametro di input del tipo corrispondente (ovvero un intero nullable).

Figura 16: immettere una query solo per restituire i prodotti in una categoria specificata (fare clic per visualizzare un'immagine full-size)

Nel passaggio finale è possibile scegliere quali modelli di accesso ai dati usare, nonché personalizzare i nomi dei metodi generati. Per il modello Fill, si modifica il nome in FillByCategoryID e per restituire un modello restituito di DataTable (i GetX metodi), si userà GetProductsByCategoryID.

Figura 17: scegliere i nomi per i metodi TableAdapter (Fare clic per visualizzare l'immagine a dimensioni complete)

Al termine della procedura guidata, il Designer DataSet include i nuovi metodi TableAdapter.

Figura 18: i prodotti possono ora essere sottoposti a query per categoria

Prendere un momento per aggiungere un GetProductByProductID(productID) metodo usando la stessa tecnica.

Queste query con parametri possono essere testate direttamente dall'Designer DataSet. Fare clic con il pulsante destro del mouse sul metodo in TableAdapter e scegliere Anteprima dati. Immettere quindi i valori da usare per i parametri e fare clic su Anteprima.

Figura 19: i prodotti appartenenti alla categoria Bevande sono visualizzati (fare clic per visualizzare l'immagine full-size)

Con il GetProductsByCategoryID(categoryID) metodo in DAL, è ora possibile creare una pagina di ASP.NET che visualizza solo i prodotti in una categoria specificata. L'esempio seguente mostra tutti i prodotti presenti nella categoria Drinks, che hanno un valore pari a CategoryID 1.

Beverages.aspx

<%@ Page Language="VB" AutoEventWireup="true" CodeFile="Beverages.aspx.vb"
    Inherits="Beverages" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Untitled Page</title>
    <link href="Styles.css" rel="stylesheet" type="text/css" />
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <h1>Beverages</h1>
        <p>
            <asp:GridView ID="GridView1" runat="server"
             CssClass="DataWebControlStyle">
               <HeaderStyle CssClass="HeaderStyle" />
               <AlternatingRowStyle CssClass="AlternatingRowStyle" />
            </asp:GridView>
             </p>
    </div>
    </form>
</body>
</html>

Beverages.aspx.vb

Imports NorthwindTableAdapters
Partial Class Beverages
    Inherits System.Web.UI.Page
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) _
        Handles Me.Load
        Dim productsAdapter As New ProductsTableAdapter
        GridView1.DataSource =
         productsAdapter.GetProductsByCategoryID(1)
        GridView1.DataBind()
    End Sub
End Class

Figura 20: i prodotti nella categoria Bevande vengono visualizzati (fare clic per visualizzare l'immagine a dimensioni complete)

Passaggio 4: Inserimento, aggiornamento ed eliminazione di dati

Esistono due modelli comunemente usati per l'inserimento, l'aggiornamento e l'eliminazione dei dati. Il primo modello, che chiamerò il modello diretto del database, prevede la creazione di metodi che, quando richiamati, generano un INSERTcomando , UPDATEo DELETE al database che opera su un singolo record di database. Tali metodi vengono in genere passati in una serie di valori scalari (numeri interi, stringhe, booleani, DateTimes e così via) che corrispondono ai valori da inserire, aggiornare o eliminare. Ad esempio, con questo modello per la Products tabella il metodo delete accetta in un parametro integer, che indica l'oggetto ProductID del record da eliminare, mentre il metodo insert accetta in una stringa per , un decimale per ProductNameUnitPricel'intero per UnitsOnStocke così via.

Figura 21: ogni richiesta di inserimento, aggiornamento ed eliminazione viene inviata immediatamente al database (fare clic per visualizzare l'immagine full-size)

L'altro modello, a cui si fa riferimento come modello di aggiornamento batch, consiste nell'aggiornare un intero DataSet, DataTable o una raccolta di DataRows in una chiamata al metodo. Con questo modello uno sviluppatore elimina, inserisce e modifica i DataRows in una tabella dati e quindi passa tali dataRows o DataTable in un metodo di aggiornamento. Questo metodo enumera quindi i DataRows passati, determina se sono stati modificati, aggiunti o eliminati (tramite il valore della proprietà RowState di DataRow) e genera la richiesta di database appropriata per ogni record.

Figura 22: Tutte le modifiche vengono sincronizzate con il database Quando viene richiamato il metodo di aggiornamento (fare clic per visualizzare l'immagine a dimensioni complete)

TableAdapter usa il modello di aggiornamento batch per impostazione predefinita, ma supporta anche il modello diretto del database. Poiché è stata selezionata l'opzione "Genera istruzioni Insert, Update e Delete" dalle proprietà avanzate durante la creazione di TableAdapter, contiene ProductsTableAdapter un Update() metodo, che implementa il modello di aggiornamento batch. In particolare, TableAdapter contiene un Update() metodo che può essere passato a DataSet tipizzato, a DataTable fortemente tipizzato o a uno o più DataRows. Se si lascia la casella di controllo "GenerateDBDirectMethods" selezionata quando si crea prima tableAdapter il modello diretto del database verrà implementato anche tramite Insert(), Update()e Delete() metodi.

Entrambi i modelli di modifica dei dati usano le proprietà , e di InsertCommandTableAdapter per rilasciare INSERTUPDATEi comandi , e DeleteCommandDELETE al database. UpdateCommand È possibile controllare e modificare le InsertCommandproprietà , UpdateCommande DeleteCommand facendo clic su TableAdapter nella Designer DataSet e quindi passando alla Finestra Proprietà. Assicurarsi di aver selezionato TableAdapter e che l'oggetto ProductsTableAdapter sia quello selezionato nell'elenco a discesa nella Finestra Proprietà.

Figura 23: TableAdapter ha InsertCommand, UpdateCommande DeleteCommand Proprietà (Fare clic per visualizzare l'immagine a dimensioni complete)

Per esaminare o modificare una di queste proprietà dei comandi di database, fare clic sulla CommandText sottoproperty, che verrà visualizzata da Generatore query.

Figura 24: Configurare le INSERTistruzioni , UPDATEe DELETE in Generatore query (fare clic per visualizzare l'immagine full-size)

Nell'esempio di codice seguente viene illustrato come usare il modello di aggiornamento batch per raddoppiare il prezzo di tutti i prodotti non interrotti e che hanno 25 unità in magazzino o meno:

Dim productsAdapter As New NorthwindTableAdapters.ProductsTableAdapter()
Dim products As Northwind.ProductsDataTable = productsAdapter.GetProducts()
For Each product As Northwind.ProductsRow In products
   If Not product.Discontinued AndAlso product.UnitsInStock <= 25 Then
      product.UnitPrice *= 2
   End if
Next
productsAdapter.Update(products)

Il codice seguente illustra come usare il modello diretto del database per eliminare a livello di codice un determinato prodotto, quindi aggiornare uno e quindi aggiungere uno nuovo:

Dim productsAdapter As New NorthwindTableAdapters.ProductsTableAdapter()
productsAdapter.Delete(3)
productsAdapter.Update( _
    "Chai", 1, 1, "10 boxes x 20 bags", 18.0, 39, 15, 10, false, 1)
productsAdapter.Insert( _
    "New Product", 1, 1, "12 tins per carton", 14.95, 15, 0, 10, false)

Creazione di metodi di inserimento, aggiornamento ed eliminazione personalizzati

I Insert()metodi , Update()e Delete() creati dal metodo diretto del database possono essere un po'complicati, soprattutto per le tabelle con molte colonne. Esaminando l'esempio di codice precedente, senza IntelliSense è utile che non sia particolarmente chiaro quale Products colonna di tabella esegue il mapping a ogni parametro di input ai Update() metodi e Insert() . Potrebbero verificarsi momenti in cui si vuole aggiornare solo una singola colonna o due o si vuole un metodo personalizzato Insert() che, ad esempio, restituisce il valore del campo del record IDENTITY appena inserito (incremento automatico).

Per creare un metodo personalizzato, tornare all'Designer DataSet. Fare clic con il pulsante destro del mouse su TableAdapter e scegliere Aggiungi query, tornare alla procedura guidata TableAdapter. Nella seconda schermata è possibile indicare il tipo di query da creare. Verrà creato un metodo che aggiunge un nuovo prodotto e quindi restituisce il valore del record ProductIDappena aggiunto. Di conseguenza, scegliere di creare una INSERT query.

Figura 25: Creare un metodo per aggiungere una nuova riga alla tabella (fare clic per visualizzare l'immagineProducts full-size)

Nella schermata successiva viene visualizzata la InsertCommandschermata CommandText successiva. Aumentare questa query aggiungendo SELECT SCOPE_IDENTITY() alla fine della query, che restituirà l'ultimo valore di identità inserito in una IDENTITY colonna nello stesso ambito. Vedere la documentazione tecnica per altre informazioni SCOPE_IDENTITY() e perché probabilmente si vuole usare SCOPE_IDENTITY() al posto di @@IDENTITY. Assicurarsi di terminare l'istruzione INSERT con un punto e virgola prima di aggiungere l'istruzione SELECT .

Figura 26: Aumentare la query per restituire il valore (fare clic per visualizzare l'immagineSCOPE_IDENTITY() a dimensioni complete)

Infine, assegnare al nuovo metodo InsertProductil nome .

Figura 27: Impostare il nuovo nome del metodo su InsertProduct (Fare clic per visualizzare l'immagine a dimensioni complete)

Quando si torna al dataset Designer si noterà che contiene ProductsTableAdapter un nuovo metodo, InsertProduct. Se questo nuovo metodo non ha un parametro per ogni colonna della Products tabella, le probabilità di terminare l'istruzione INSERT con un punto e virgola. Configurare il InsertProduct metodo e assicurarsi di avere un punto e virgola delimitando le INSERT istruzioni e SELECT .

Per impostazione predefinita, i metodi di inserimento rilasciano metodi non query, ovvero restituiscono il numero di righe interessate. Tuttavia, si vuole che il InsertProduct metodo restituisca il valore restituito dalla query, non il numero di righe interessate. A tale scopo, modificare la InsertProduct proprietà del ExecuteMode metodo su Scalar.

Figura 28: Modificare la proprietà su Scalar (Fare clic per visualizzare l'immagineExecuteMode full-size)

Il codice seguente mostra questo nuovo InsertProduct metodo in azione:

Dim productsAdapter As New NorthwindTableAdapters.ProductsTableAdapter()
Dim new_productID As Integer = Convert.ToInt32(productsAdapter.InsertProduct( _
    "New Product", 1, 1, "12 tins per carton", 14.95, 10, 0, 10, false))
productsAdapter.Delete(new_productID)

Passaggio 5: Completamento del livello di accesso ai dati

Si noti che la ProductsTableAdapters classe restituisce i CategoryID valori e SupplierID della Products tabella, ma non include la CategoryName colonna dalla Categories tabella o dalla CompanyName colonna Suppliers della tabella, anche se queste sono probabilmente le colonne che si desidera visualizzare durante la visualizzazione delle informazioni sul prodotto. È possibile aumentare il metodo iniziale di TableAdapter, , GetProducts()per includere sia i CategoryName valori di colonna che CompanyName i valori di colonna, che aggiorneranno la tabella dati fortemente tipizzata per includere anche queste nuove colonne.

Ciò può presentare un problema, tuttavia, come i metodi di TableAdapter per l'inserimento, l'aggiornamento e l'eliminazione dei dati sono basati su questo metodo iniziale. Fortunatamente, i metodi generati automaticamente per l'inserimento, l'aggiornamento e l'eliminazione SELECT non sono interessati dalle sottoquerie nella clausola. Prendendo cura di aggiungere le query a Categories e Suppliers come sottoquery, anziché JOIN di s, si evita di dover rielaborare tali metodi per modificare i dati. Fare clic con il pulsante destro del mouse sul GetProducts() metodo in ProductsTableAdapter e scegliere Configura. Modificare quindi la SELECT clausola in modo che sia simile al seguente:

SELECT     ProductID, ProductName, SupplierID, CategoryID,
QuantityPerUnit, UnitPrice, UnitsInStock, UnitsOnOrder, ReorderLevel, Discontinued,
(SELECT CategoryName FROM Categories
WHERE Categories.CategoryID = Products.CategoryID) as CategoryName,
(SELECT CompanyName FROM Suppliers
WHERE Suppliers.SupplierID = Products.SupplierID) as SupplierName
FROM         Products

Figura 29: Aggiornare l'istruzione per il GetProducts() metodo (fare clic per visualizzare l'immagineSELECT full-size)

Dopo aver aggiornato il GetProducts() metodo per usare questa nuova query, DataTable includerà due nuove colonne: CategoryName e SupplierName.

Figura 30: DataTable Products include due nuove colonne

È necessario aggiornare anche la SELECT clausola nel GetProductsByCategoryID(categoryID) metodo.

Se si aggiorna la GetProducts()SELECT sintassi con JOIN la sintassi DataSet Designer non sarà in grado di generare automaticamente i metodi per l'inserimento, l'aggiornamento e l'eliminazione dei dati del database usando il modello diretto del database. Sarà invece necessario crearli manualmente come abbiamo fatto con il InsertProduct metodo precedente in questa esercitazione. Inoltre, sarà necessario specificare manualmente i valori delle InsertCommandproprietà , UpdateCommande DeleteCommand se si vuole usare il modello di aggiornamento batch.

Aggiunta di TableAdapter rimanenti

Fino a questo momento, è stato esaminato solo l'uso di un singolo TableAdapter per una singola tabella di database. Tuttavia, il database Northwind contiene diverse tabelle correlate che sarà necessario usare nell'applicazione Web. Un DataSet tipizzato può contenere più tabelle dati correlate. Di conseguenza, per completare il servizio di gestione dati, è necessario aggiungere DataTables per le altre tabelle che verranno usati in queste esercitazioni. Per aggiungere un nuovo TableAdapter a un DataSet tipizzato, aprire l'Designer DataSet, fare clic con il pulsante destro del mouse sul Designer e scegliere Aggiungi/TableAdapter. Verrà creato un nuovo DataTable e TableAdapter e si esaminerà la procedura guidata esaminata in precedenza in questa esercitazione.

Eseguire alcuni minuti per creare i metodi e tableadapter seguenti usando le query seguenti. Si noti che le query nell'oggetto ProductsTableAdapter includono le sottoquerie per acquisire le categorie e i nomi dei fornitori di ogni prodotto. Inoltre, se si sta seguendo, sono già stati aggiunti i metodi e GetProductsByCategoryID(categoryID) della ProductsTableAdapter classeGetProducts().

• ProductsTableAdapter

  • GetProducts:

    SELECT     ProductID, ProductName, SupplierID, 
    CategoryID, QuantityPerUnit, UnitPrice, UnitsInStock, 
    UnitsOnOrder, ReorderLevel, Discontinued, 
    (SELECT CategoryName FROM Categories WHERE
    Categories.CategoryID = Products.CategoryID) as 
    CategoryName, (SELECT CompanyName FROM Suppliers
    WHERE Suppliers.SupplierID = Products.SupplierID) 
    as SupplierName
    FROM         Products
    

  • GetProductsByCategoryID:

    SELECT     ProductID, ProductName, SupplierID, CategoryID,
    QuantityPerUnit, UnitPrice, UnitsInStock, UnitsOnOrder,
    ReorderLevel, Discontinued, (SELECT CategoryName
    FROM Categories WHERE Categories.CategoryID = 
    Products.CategoryID) as CategoryName,
    (SELECT CompanyName FROM Suppliers WHERE
    Suppliers.SupplierID = Products.SupplierID)
    as SupplierName
    FROM         Products
    WHERE      CategoryID = @CategoryID
    

  • GetProductsBySupplierID:

    SELECT     ProductID, ProductName, SupplierID, CategoryID,
    QuantityPerUnit, UnitPrice, UnitsInStock, UnitsOnOrder,
    ReorderLevel, Discontinued, (SELECT CategoryName
    FROM Categories WHERE Categories.CategoryID = 
    Products.CategoryID) as CategoryName, 
    (SELECT CompanyName FROM Suppliers WHERE 
    Suppliers.SupplierID = Products.SupplierID) as SupplierName
    FROM         Products
    WHERE SupplierID = @SupplierID
    

  • GetProductByProductID:

    SELECT     ProductID, ProductName, SupplierID, CategoryID,
    QuantityPerUnit, UnitPrice, UnitsInStock, UnitsOnOrder,
    ReorderLevel, Discontinued, (SELECT CategoryName 
    FROM Categories WHERE Categories.CategoryID = 
    Products.CategoryID) as CategoryName, 
    (SELECT CompanyName FROM Suppliers WHERE Suppliers.SupplierID = Products.SupplierID) 
    as SupplierName
    FROM         Products
    WHERE ProductID = @ProductID
    

• CategoriesTableAdapter

  • GetCategories:

    SELECT     CategoryID, CategoryName, Description
    FROM         Categories
    

  • GetCategoryByCategoryID:

    SELECT     CategoryID, CategoryName, Description
    FROM         Categories
    WHERE CategoryID = @CategoryID
    

• SuppliersTableAdapter

  • GetSuppliers:

    SELECT     SupplierID, CompanyName, Address,
    City, Country, Phone
    FROM         Suppliers
    

  • GetSuppliersByCountry:

    SELECT     SupplierID, CompanyName, Address,
    City, Country, Phone
    FROM         Suppliers
    WHERE Country = @Country
    

  • GetSupplierBySupplierID:

    SELECT     SupplierID, CompanyName, Address,
    City, Country, Phone
    FROM         Suppliers
    WHERE SupplierID = @SupplierID
    

• EmployeesTableAdapter

  • GetEmployees:

    SELECT     EmployeeID, LastName, FirstName, Title,
    HireDate, ReportsTo, Country
    FROM         Employees
    

  • GetEmployeesByManager:

    SELECT     EmployeeID, LastName, FirstName, Title, 
    HireDate, ReportsTo, Country
    FROM         Employees
    WHERE ReportsTo = @ManagerID
    

  • GetEmployeeByEmployeeID:

    SELECT     EmployeeID, LastName, FirstName, Title,
    HireDate, ReportsTo, Country
    FROM         Employees
    WHERE EmployeeID = @EmployeeID
    

Figura 31: DataSet Designer dopo l'aggiunta dei quattro tableadapter (fare clic per visualizzare l'immagine a dimensione intera)

Aggiunta di codice personalizzato a DAL

Gli oggetti TableAdapter e DataTable aggiunti al DataSet tipizzato vengono espressi come file xml Schema Definition (Northwind.xsd). È possibile visualizzare queste informazioni sullo schema facendo clic con il pulsante destro del Northwind.xsd mouse sul file nel Esplora soluzioni e scegliendo Visualizza codice.

Figura 32: File XSD (XML Schema Definition) per il DataSet tipizzato Northwinds (fare clic per visualizzare l'immagine a dimensione intera)

Queste informazioni sullo schema vengono convertite in codice C# o Visual Basic in fase di progettazione quando vengono compilate o in fase di esecuzione (se necessario), a questo punto è possibile eseguirne l'istruzione con il debugger. Per visualizzare questo codice generato automaticamente, passare a Visualizzazione classi ed eseguire il drill-down delle classi TableAdapter o DataSet tipizzato. Se la visualizzazione classi non è visualizzata sullo schermo, passare al menu Visualizza e selezionarla da questa posizione oppure premere CTRL+MAIUSC+C. Dalla visualizzazione classi è possibile visualizzare le proprietà, i metodi e gli eventi delle classi DataSet tipizzate e TableAdapter. Per visualizzare il codice per un metodo specifico, fare doppio clic sul nome del metodo nella visualizzazione classi oppure fare clic con il pulsante destro del mouse su di esso e scegliere Vai a definizione.

Figura 33: Esaminare il codice generato automaticamente selezionando Vai a definizione dalla visualizzazione Classi

Anche se il codice generato automaticamente può essere un ottimo risparmio di tempo, il codice è spesso molto generico e deve essere personalizzato per soddisfare le esigenze specifiche di un'applicazione. Il rischio di estendere il codice generato automaticamente, tuttavia, è che lo strumento che ha generato il codice potrebbe decidere che è il momento di "rigenerare" e sovrascrivere le personalizzazioni. Con il nuovo concetto di classe parziale di .NET 2.0, è facile suddividere una classe tra più file. In questo modo è possibile aggiungere metodi, proprietà ed eventi personalizzati alle classi generate automaticamente senza doversi preoccupare della sovrascrittura delle personalizzazioni di Visual Studio.

Per illustrare come personalizzare DAL, aggiungere un GetProducts() metodo alla SuppliersRow classe . La SuppliersRow classe rappresenta un singolo record nella Suppliers tabella. Ogni fornitore può fornire zero a molti prodotti, quindi GetProducts() restituirà tali prodotti del fornitore specificato. A tale scopo, creare un nuovo file di classe nella App_Code cartella denominata SuppliersRow.vb e aggiungere il codice seguente:

Imports NorthwindTableAdapters
Partial Public Class Northwind
    Partial Public Class SuppliersRow
        Public Function GetProducts() As Northwind.ProductsDataTable
            Dim productsAdapter As New ProductsTableAdapter
            Return productsAdapter.GetProductsBySupplierID(Me.SupplierID)
        End Function
    End Class
End Class

Questa classe parziale indica al compilatore che quando si compila la Northwind.SuppliersRow classe per includere il GetProducts() metodo appena definito. Se si compila il progetto e quindi si torna alla visualizzazione classi, verrà GetProducts() visualizzato come metodo di Northwind.SuppliersRow.

Figura 34: Il GetProducts() metodo fa ora parte della Northwind.SuppliersRow classe

Il GetProducts() metodo può ora essere usato per enumerare il set di prodotti per un determinato fornitore, come illustrato nel codice seguente:

Dim suppliersAdapter As New NorthwindTableAdapters.SuppliersTableAdapter()
Dim suppliers As Northwind.SuppliersDataTable = suppliersAdapter.GetSuppliers()
For Each supplier As Northwind.SuppliersRow In suppliers
    Response.Write("Supplier: " & supplier.CompanyName)
    Response.Write("<ul>")
    Dim products As Northwind.ProductsDataTable = supplier.GetProducts()
    For Each product As Northwind.ProductsRow In products
        Response.Write("<li>" & product.ProductName & "</li>")
    Next
    Response.Write("</ul><p> </p>")
Next

Questi dati possono essere visualizzati anche in qualsiasi ASP. Controlli Web dati di NET. La pagina seguente usa un controllo GridView con due campi:

• Oggetto BoundField che visualizza il nome di ogni fornitore e
• Oggetto TemplateField che contiene un controllo BulletedList associato ai risultati restituiti dal GetProducts() metodo per ogni fornitore.

Si esaminerà come visualizzare tali report master-dettagli nelle esercitazioni future. Per il momento, questo esempio è progettato per illustrare l'uso del metodo personalizzato aggiunto alla Northwind.SuppliersRow classe .

SuppliersAndProducts.aspx

<%@ Page Language="VB" CodeFile="SuppliersAndProducts.aspx.vb"
    AutoEventWireup="true" Inherits="SuppliersAndProducts" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head runat="server">
    <title>Untitled Page</title>
    <link href="Styles.css" rel="stylesheet" type="text/css" />
</head>
<body>
    <form id="form1" runat="server">
    <div>
        <h1>
            Suppliers and Their Products</h1>
        <p>
            <asp:GridView ID="GridView1" runat="server"
             AutoGenerateColumns="False"
             CssClass="DataWebControlStyle">
                <HeaderStyle CssClass="HeaderStyle" />
                <AlternatingRowStyle CssClass="AlternatingRowStyle" />
                <Columns>
                    <asp:BoundField DataField="CompanyName"
                      HeaderText="Supplier" />
                    <asp:TemplateField HeaderText="Products">
                        <ItemTemplate>
                            <asp:BulletedList ID="BulletedList1"
                             runat="server" DataSource="<%# CType(CType(Container.DataItem, System.Data.DataRowView).Row, Northwind.SuppliersRow).GetProducts() %>"
                                 DataTextField="ProductName">
                            </asp:BulletedList>
                        </ItemTemplate>
                    </asp:TemplateField>
                </Columns>
            </asp:GridView>
             </p>
    </div>
    </form>
</body>
</html>

SuppliersAndProducts.aspx.vb

Imports NorthwindTableAdapters
Partial Class SuppliersAndProducts
    Inherits System.Web.UI.Page
    Protected Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) _
        Handles Me.Load
        Dim suppliersAdapter As New SuppliersTableAdapter
        GridView1.DataSource = suppliersAdapter.GetSuppliers()
        GridView1.DataBind()
    End Sub
End Class

Figura 35: Il nome della società del fornitore è elencato nella colonna sinistra, i relativi prodotti a destra (fare clic per visualizzare l'immagine a dimensione intera)

Riepilogo

Quando si crea un'applicazione Web che crea dal deve essere uno dei primi passaggi, prima di iniziare a creare il livello presentazione. Con Visual Studio, la creazione di un dal basato su set di dati tipiti è un'attività che può essere eseguita in 10-15 minuti senza scrivere una riga di codice. Le esercitazioni in futuro si baseranno su questo dal. Nell'esercitazione successiva verranno definite alcune regole business e verrà illustrato come implementarle in un livello di logica di business separato.

Buon programmatori!

Altre informazioni

Per altre informazioni sugli argomenti descritti in questa esercitazione, vedere le risorse seguenti:

• Compilazione di un'interfaccia DAL con tableadapter fortemente tipizzato e tabelle DataTable in VS 2005 e ASP.NET 2.0
• Progettazione di componenti del livello dati e passaggio di dati attraverso livelli
• Crittografia delle informazioni di configurazione nelle applicazioni ASP.NET 2.0
• Panoramica degli oggetti TableAdapter
• Utilizzo di un set di dati tipizzato
• Uso dell'accesso ai dati Strongly-Typed in Visual Studio 2005 e ASP.NET 2.0
• Come estendere i metodi TableAdapter

Formazione video sugli argomenti contenuti in questa esercitazione

• Livelli di accesso ai dati nelle applicazioni ASP.NET
• Come associare manualmente un set di dati a un datagrid
• Come usare set di dati e filtri da un'applicazione ASP

Informazioni sull'autore

Scott Mitchell, autore di sette libri ASP/ASP.NET e fondatore di 4GuysFromRolla.com, lavora con le tecnologie Web Microsoft dal 1998. Scott lavora come consulente indipendente, formatore e scrittore. Il suo ultimo libro è Sams Teach Yourself ASP.NET 2.0 in 24 ore. Può essere raggiunto all'indirizzo mitchell@4GuysFromRolla.com. o tramite il suo blog, disponibile all'indirizzo http://ScottOnWriting.NET.

Grazie speciale a

Questa serie di esercitazioni è stata esaminata da molti revisori utili. I revisori principali di questa esercitazione erano Ron Green, Hilton Giesenow, Dennis Patterson, Liz Shulok, Abel Gomez e Carlos Santos. Si è interessati a esaminare i prossimi articoli MSDN? In tal caso, rilasciami una riga in mitchell@4GuysFromRolla.com.

IndietroAvanti