Creazione di un livello di accesso ai dati (VB)
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
Come sviluppatori Web, la nostra vita ruota intorno all'uso dei dati. I database vengono creati per archiviare i dati, il codice per recuperarli e modificarli e le pagine Web da raccogliere e riepilogare. 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 costituito da pagine ASP.NET che condividono un layout di pagina comune. Una volta disposta questa attività di base back-end, 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 si userà 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 diversa del database. Se si usa una versione diversa di SQL Server del database Northwind, sarà necessario aggiornare l'impostazione NORTHWNDConnectionString nel file dell'applicazione Web.config . L'applicazione Web è stata compilata usando Visual Studio 2005 Professional Edition come progetto di sito Web basato su file system. Tuttavia, tutte le esercitazioni funzionano altrettanto bene con la versione gratuita di Visual Studio 2005, Visual Web Developer.
In questa esercitazione si inizierà fin dall'inizio e si creerà il livello di accesso ai dati (DAL), seguito dalla creazione del livello BLL (Business Logic Layer) nella seconda esercitazione e l'uso del layout e dello spostamento della pagina nel terzo. Le esercitazioni dopo il terzo si baseranno sulle fondamenta poste nei primi tre. Abbiamo molto da coprire in questa prima esercitazione, quindi attiva Visual Studio e iniziamo subito!
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 sito Web basato su file system (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 set di dati tipizzato. 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'installazione del server di database di Microsoft SQL Server 2000 o 2005 che si desidera utilizzare.
Utilizzo di un database nellaApp_Datacartella
Se non si dispone di un server di database di 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 di 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 che nel computer sia installato SQL Server 2005 Express Edition, 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 file di Microsoft Access .mdb , che, come le controparti di 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 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 alcune funzionalità a livello di database non 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 ha già installato il database Northwind, è 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 Connessioni dati e scegliere Aggiungi connessione. Se Esplora server non viene visualizzato, passare a Visualizza/Esplora server o 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 Connessioni dati. È 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 al livello di presentazione. L'approccio consigliato, tuttavia, consiste nel separare la logica di accesso ai dati dal livello di presentazione. Questo livello separato viene definito livello di accesso ai dati, DAL per brevità 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 "Ulteriori 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 , INSERTUPDATE, e DELETE così via, deve trovarsi in DAL. Il livello di presentazione non deve contenere riferimenti a tale codice di accesso ai dati, ma deve invece effettuare chiamate a DAL per qualsiasi richiesta di dati e per tutte le richieste di dati. I livelli di accesso ai dati in genere contengono metodi per accedere ai dati del database sottostanti. Il database Northwind, ad esempio, contiene Products e Categories tabelle 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 categorieGetProducts(), che restituirà informazioni su tutti i prodottiGetProductsByCategoryID(categoryID), che restituirà tutti i prodotti appartenenti a una categoria specificataGetProductByProductID(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 potrebbero semplicemente restituire un oggetto DataSet o DataReader popolato dalla query di database, ma idealmente questi risultati devono essere restituiti usando oggetti fortemente tipizzati. Un oggetto fortemente tipizzato è un oggetto 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 tipizzati in modo 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 viene mostrata dal fatto che è necessario accedere al nome della colonna usando un indice stringa o 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 utilizzare set di dati tipizzati. Un oggetto business viene implementato dallo sviluppatore come classe le cui proprietà in genere riflettono le colonne della tabella di database sottostante rappresentata dall'oggetto business. Un oggetto 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 a datatable fortemente tipizzato, i dataset 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 al database.
Nota
Per altre informazioni sui vantaggi e sugli svantaggi dell'uso di dataset tipizzati e 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 è retrocesso al DAL (fare clic per visualizzare l'immagine a dimensione intera)
Creazione di un dataset tipizzato e di un adattatore di tabella
Per iniziare a creare il file DAL, si inizia aggiungendo un oggetto 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 dall'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ì. Verrà quindi visualizzata la finestra di progettazione per il dataset tipizzato e verrà avviata la Configurazione guidata TableAdapter, consentendo di aggiungere il primo Oggetto TableAdapter al dataset tipizzato.
Un dataset tipizzato funge da raccolta fortemente tipizzata di dati; è costituito da istanze DataTable fortemente tipate, ognuna delle quali è a sua volta composta da istanze DataRow fortemente tipate. In questa serie di esercitazioni verrà creata una DataTable fortemente tipizzata per ognuna delle tabelle di database sottostanti da usare. Si inizierà con la creazione di una tabella DataTable per la Products tabella.
Tenere presente che le tabelle DataTable fortemente tipate 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, che verranno richiamati dal livello di presentazione. Il ruolo di DataTable deve 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 i database in Esplora server. Se non è stato aggiunto il database Northwind a Esplora server, è possibile fare clic sul pulsante Nuova connessione al momento per eseguire questa operazione.
Figura 5: Scegliere il database Northwind dall'elenco a discesa (fare clic per visualizzare l'immagine a dimensione intera)
Dopo aver selezionato il database e aver fatto clic su Avanti, verrà chiesto se si desidera salvare il stringa di connessione nel Web.config file. Salvando il stringa di connessione si evita di averlo codificato in modo rigido nelle classi TableAdapter, semplificando le operazioni se le informazioni stringa di connessione cambiano in futuro. Se si sceglie di salvare il stringa di connessione nel file di configurazione che viene inserito nella <connectionStrings> sezione , che può essere crittografato facoltativamente per una maggiore sicurezza o modificato in un secondo momento tramite la nuova pagina delle proprietà ASP.NET 2.0 all'interno dello strumento di amministrazione gui di IIS, che è più ideale per gli amministratori.
Figura 6: Salvare la stringa di connessione in Web.config (fare clic per visualizzare l'immagine a dimensione intera)
Successivamente, è necessario definire lo schema per la prima DataTable fortemente tipizzata e fornire il primo metodo da usare per TableAdapter quando si popola il DataSet fortemente tipizzato. Questi due passaggi vengono eseguiti simultaneamente creando una query che restituisce le colonne della tabella che si desidera riflettere nell'oggetto DataTable. Alla fine della procedura guidata verrà assegnato un nome di metodo a questa query. Dopo aver completato questa operazione, questo metodo può essere richiamato dal livello di presentazione. Il metodo eseguirà la query definita e popola una DataTable 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 si useranno istruzioni SQL ad hoc.
Figura 7: Eseguire una query sui dati usando un'istruzione SQL ad hoc (fare clic per visualizzare un'immagine a dimensione intera)
A questo punto è possibile digitare la query SQL a mano. Quando si crea il primo metodo nell'oggetto TableAdapter, in genere si desidera che la query restituisca le colonne che devono essere espresse nell'oggetto DataTable corrispondente. A tale scopo, è possibile creare 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 dimensione intera)
In alternativa, usare Generatore query e costruire graficamente la query, come illustrato nella figura 9.
Figura 9: Creare graficamente la query tramite il Editor di query (fare clic per visualizzare l'immagine a dimensione intera)
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". Nelle esercitazioni future verrà esaminata la concorrenza ottimistica.
Figura 10: Selezionare solo l'opzione Genera istruzioni Di inserimento, Aggiornamento ed Eliminazione (fare clic per visualizzare l'immagine a dimensione intera)
Dopo aver verificato le opzioni avanzate, fare clic su Avanti per passare alla schermata finale. In questo caso viene chiesto di selezionare i metodi da aggiungere all'oggetto TableAdapter. Esistono due modelli per popolare i dati:
- Compilare un oggetto DataTable con questo approccio viene creato un metodo che accetta un oggetto DataTable come parametro e lo popola in base ai risultati della query. La classe ADO.NET DataAdapter, ad esempio, implementa questo modello con il relativo
Fill()metodo. - Restituisce un oggetto DataTable con questo approccio, il metodo crea e riempie dataTable automaticamente e lo restituisce come valore restituito dai metodi.
È possibile che TableAdapter implementi uno o entrambi questi modelli. È anche possibile rinominare i metodi forniti qui. Lasciare entrambe le caselle di controllo selezionate, anche se verranno usate solo le ultime esercitazioni. Si rinomina anche il metodo piuttosto generico GetData in GetProducts.
Se selezionata, la casella di controllo finale "GenerateDBDirectMethods" crea Insert()i metodi , Update()e Delete() per TableAdapter. Se si lascia deselezionata questa opzione, tutti gli aggiornamenti dovranno essere eseguiti tramite il metodo unico Update() di TableAdapter, che accetta l'oggetto DataSet tipizzato, un DataTable, un singolo DataRow o una matrice di DataRows. Se è stata deselezionata l'opzione "Genera istruzioni Inserisci, Aggiorna ed Elimina" dalle proprietà avanzate nella figura 9 questa impostazione della 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 dimensione intera)
Completare la procedura guidata facendo clic su Fine. Dopo la chiusura della procedura guidata, viene visualizzata la finestra di progettazione dataset che mostra l'oggetto DataTable appena creato. È possibile visualizzare l'elenco di colonne in Products DataTable (ProductID, ProductNamee così via), nonché i metodi di ProductsTableAdapter (Fill() e GetProducts()).
Figura 12: DataTable Products ed ProductsTableAdapter è stato aggiunto al dataset tipizzato (fare clic per visualizzare l'immagine a dimensione intera)
A questo punto è disponibile un dataset tipizzato con un singolo oggetto DataTable (Northwind.Products) e una classe DataAdapter fortemente tipizzata (NorthwindTableAdapters.ProductsTableAdapter) con un GetProducts() metodo . Questi oggetti possono essere usati per accedere a un elenco di tutti i prodotti dal codice, ad esempio:
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 dell'accesso ai dati. Non è stato necessario creare un'istanza di alcuna classe ADO.NET, non è stato necessario fare riferimento ad alcuna stringa di connessione, query SQL o stored procedure. TableAdapter fornisce invece il codice di accesso ai dati di basso livello.
Ogni oggetto usato in questo esempio è anche fortemente tipizzato, consentendo a Visual Studio di fornire IntelliSense e il controllo dei tipi in fase di compilazione. E meglio di tutte le tabelle DataTable restituite dal TableAdapter possono essere associate a ASP.NET controlli Web dati, ad esempio GridView, DetailsView, DropDownList, CheckBoxList e molti altri. L'esempio seguente illustra l'associazione di DataTable restituita dal GetProducts() metodo a un controllo GridView in appena 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 dimensione intera)
Anche se in questo esempio sono necessarie tre righe di codice nel gestore eventi della Page_Load pagina ASP.NET, nelle esercitazioni future verrà esaminato come usare ObjectDataSource per recuperare in modo dichiarativo i dati dal dal. Con ObjectDataSource non è necessario scrivere codice e si 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 dispone di un metodo, GetProducts(), che restituisce tutti i prodotti nel database. Anche se essere in grado di lavorare con tutti i prodotti è sicuramente utile, ci sono momenti in cui vogliamo recuperare informazioni su un prodotto specifico o tutti i prodotti che appartengono a una particolare categoria. Per aggiungere tali funzionalità al livello di accesso ai dati, è possibile aggiungere metodi con parametri all'oggetto TableAdapter.
Aggiungere il GetProductsByCategoryID(categoryID) metodo . Per aggiungere un nuovo metodo a DAL, tornare a Progettazione set di dati, fare clic con il pulsante destro del mouse nella ProductsTableAdapter sezione e scegliere Aggiungi query.
Figura 14: Fare clic con il pulsante destro del mouse su TableAdapter 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 sceglierà di usare di nuovo un'istruzione SQL ad hoc. Verrà quindi chiesto il tipo di query SQL che si vuole usare. Poiché si desidera 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 restituisca righe (fare clic per visualizzare l'immagine SELECTa dimensione intera)
Il passaggio successivo consiste nel definire la query SQL usata per accedere ai dati. Poiché si vuole restituire solo i prodotti che appartengono a una determinata categoria, si usa la stessa SELECT istruzione da GetProducts(), ma si aggiunge la clausola seguente: . WHERE CategoryID = @CategoryIDWHERE Il @CategoryID parametro indica alla procedura guidata TableAdapter che il metodo che si sta creando richiederà un parametro di input del tipo corrispondente (vale a dire un numero intero nullable).
Figura 16: Immettere una query per restituire solo i prodotti in una categoria specificata (fare clic per visualizzare l'immagine a dimensione intera)
Nel passaggio finale è possibile scegliere i modelli di accesso ai dati da usare, nonché personalizzare i nomi dei metodi generati. Per il criterio Fill, si modificherà il nome in FillByCategoryID e per restituire un modello restituito DataTable (i GetX metodi), si userà GetProductsByCategoryID.
Figura 17: Scegliere i nomi per i metodi TableAdapter (fare clic per visualizzare l'immagine a dimensione intera)
Al termine della procedura guidata, Progettazione set di dati include i nuovi metodi TableAdapter.
Figura 18: I prodotti possono ora essere sottoposti a query per categoria
Per aggiungere un GetProductByProductID(productID) metodo, usare la stessa tecnica.
Queste query con parametri possono essere testate direttamente da Progettazione 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: Vengono visualizzati i prodotti appartenenti alla categoria Bevande (fare clic per visualizzare l'immagine a dimensione intera)
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 inclusi nella categoria Beverages, che hanno un CategoryID valore pari a 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: Tali prodotti nella categoria Bevande vengono visualizzati (fare clic per visualizzare l'immagine a dimensione intera)
Passaggio 4: Inserimento, aggiornamento ed eliminazione di dati
Esistono due modelli comunemente usati per l'inserimento, l'aggiornamento e l'eliminazione di dati. Il primo modello, che chiamerò il modello diretto del database, prevede la creazione di metodi che, quando richiamati, eseguono 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 tabella il Products metodo delete accetta un parametro integer, che indica l'oggetto ProductID del record da eliminare, mentre il metodo insert accetta una stringa per ProductName, un decimale per UnitPrice, un numero 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 a dimensione intera)
L'altro modello, a cui si fa riferimento come modello di aggiornamento batch, consiste nell'aggiornare un intero oggetto DataSet, DataTable o una raccolta di DataRows in una chiamata al metodo. Con questo modello uno sviluppatore elimina, inserisce e modifica DataRows in una DataTable e quindi li passa a un metodo di aggiornamento. Questo metodo enumera quindi i DatiRows passati, determina se sono stati modificati, aggiunti o eliminati (tramite il valore della proprietà RowState di DataRow) e rilascia la richiesta di database appropriata per ogni record.
Figura 22: Tutte le modifiche vengono sincronizzate con il database quando viene richiamato il metodo update (fare clic per visualizzare l'immagine a dimensione intera)
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 ed 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 al DataSet tipizzato, a dataTable fortemente tipizzato o a uno o più DataRows. Se si lascia la casella di controllo "GenerateDBDirectMethods" selezionata quando si crea per la prima volta tableAdapter il modello diretto del database verrà implementato anche tramite Insert()i metodi , Update()e Delete() .
Entrambi i modelli di modifica dei dati usano le proprietà , e di InsertCommandTableAdapter per eseguire INSERTi relativi comandi , UPDATEe DELETE al DeleteCommand database. UpdateCommand È possibile esaminare e modificare le InsertCommandproprietà , UpdateCommande DeleteCommand facendo clic su TableAdapter in Progettazione set di dati e quindi passando al Finestra Proprietà. Assicurarsi di aver selezionato TableAdapter e che l'oggetto ProductsTableAdapter sia quello selezionato nell'elenco a discesa nel Finestra Proprietà.
Figura 23: TableAdapter ha InsertCommandproprietà , UpdateCommande DeleteCommand (fare clic per visualizzare l'immagine a dimensione intera)
Per esaminare o modificare una di queste proprietà dei comandi di database, fare clic sulla CommandText sottoproprietà, che visualizzerà Generatore query.
Figura 24: Configurare le INSERTistruzioni , UPDATEe DELETE in Generatore query (fare clic per visualizzare l'immagine a dimensione intera)
L'esempio di codice seguente illustra come usare il modello di aggiornamento batch per raddoppiare il prezzo di tutti i prodotti non sospesi 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 aggiungerne 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 non è particolarmente chiaro quale Products colonna di tabella esegue il Update() mapping a ogni parametro di input ai metodi e Insert() . In alcuni casi potrebbe essere necessario aggiornare solo una singola colonna o due oppure si desidera un metodo personalizzato Insert() che, ad esempio, restituisca il valore del campo del IDENTITY record appena inserito (incremento automatico).
Per creare un metodo personalizzato di questo tipo, tornare a Progettazione DataSet. Fare clic con il pulsante destro del mouse su TableAdapter e scegliere Aggiungi query, tornando alla procedura guidata TableAdapter. Nella seconda schermata è possibile indicare il tipo di query da creare. Verrà ora creato un metodo che aggiunge un nuovo prodotto e quindi restituisce il valore del record ProductIDappena aggiunto. Pertanto, scegliere di creare una INSERT query.
Figura 25: Creare un metodo per aggiungere una nuova riga alla Products tabella (fare clic per visualizzare l'immagine a dimensione intera)
Nella schermata successiva viene visualizzato l'oggetto InsertCommand.CommandText Aumentare questa query aggiungendo SELECT SCOPE_IDENTITY() alla fine della query, che restituirà l'ultimo valore Identity inserito in una IDENTITY colonna nello stesso ambito. Per altre informazioni e sui SCOPE_IDENTITY() motivi per cui probabilmente si vuole usare SCOPE_IDENTITY() al posto di @@IDENTITY, vedere la documentazione tecnica. 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 dimensione intera)
Infine, denominare il nuovo metodo InsertProduct.
Figura 27: Impostare il nuovo nome del metodo su InsertProduct (fare clic per visualizzare l'immagine a dimensione intera)
Quando si torna a Progettazione DataSet, si noterà che contiene ProductsTableAdapter un nuovo metodo, InsertProduct. Se questo nuovo metodo non ha un parametro per ogni colonna della Products tabella, è probabile che si dimentica di terminare l'istruzione INSERT con un punto e virgola. Configurare il InsertProduct metodo e assicurarsi di disporre di un punto e virgola che delimita le INSERT istruzioni e SELECT .
Per impostazione predefinita, i metodi di inserimento eseguono metodi non di 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à in Scalar (Fare clic per visualizzare l'immagineExecuteMode a dimensione intera)
Il codice seguente illustra 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 della Categories tabella o della CompanyName colonna della Suppliers tabella, anche se queste sono probabilmente le colonne che si desidera visualizzare quando vengono visualizzate le informazioni sul prodotto. È possibile aumentare il metodo iniziale di TableAdapter, GetProducts(), per includere sia i valori di CategoryName colonna e CompanyName che aggiorneranno dataTable fortemente tipizzato per includere anche queste nuove colonne.
Questo può presentare un problema, tuttavia, poiché i metodi di TableAdapter per l'inserimento, l'aggiornamento e l'eliminazione di dati sono basati su questo metodo iniziale. Fortunatamente, i metodi generati automaticamente per l'inserimento, l'aggiornamento e l'eliminazione non sono interessati dalle sottoquery nella SELECT clausola . Prendendo cura di aggiungere le query a Categories e Suppliers come sottoquery, invece di JOIN s, si evita di dover rielaborare tali metodi per modificare i dati. Fare clic con il pulsante destro del GetProducts() ProductsTableAdapter mouse sul metodo in e scegliere Configura. Modificare quindi la SELECT clausola in modo che abbia un aspetto 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'immagine SELECTa dimensione intera)
Dopo aver aggiornato il GetProducts() metodo per usare questa nuova query, DataTable includerà due nuove colonne: CategoryName e SupplierName.
Figura 30: DataTable Products ha due nuove colonne
È necessario attendere alcuni minuti per aggiornare anche la SELECT clausola nel GetProductsByCategoryID(categoryID) metodo .
Se si aggiorna la GetProducts() SELECT sintassi tramite JOIN La finestra di progettazione DataSet non sarà in grado di generare automaticamente i metodi per l'inserimento, l'aggiornamento e l'eliminazione dei dati di database tramite il modello diretto del database. Sarà invece necessario crearli manualmente in modo analogo al InsertProduct metodo usato in precedenza in questa esercitazione. Inoltre, è necessario specificare manualmente i valori delle InsertCommandproprietà , UpdateCommande DeleteCommand se si vuole usare il modello di aggiornamento batch.
Aggiunta degli oggetti TableAdapter rimanenti
Fino ad ora, è 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 DataTable correlate. Per completare il processo DAL, è quindi necessario aggiungere DataTable per le altre tabelle che verranno usati in queste esercitazioni. Per aggiungere un nuovo TableAdapter a un dataset tipizzato, aprire Progettazione set di dati, fare clic con il pulsante destro del mouse nella finestra di progettazione e scegliere Aggiungi/TableAdapter. Verrà creato un nuovo oggetto DataTable e TableAdapter e verrà illustrata la procedura guidata esaminata in precedenza in questa esercitazione.
Per creare i metodi e gli oggetti TableAdapter seguenti, usare le query seguenti. Si noti che le query in ProductsTableAdapter includono le sottoquery per acquisire i nomi di categoria e fornitore di ogni prodotto. Inoltre, se è stato seguito, sono già stati aggiunti i metodi e GetProductsByCategoryID(categoryID) della ProductsTableAdapter GetProducts() classe.
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 ProductsGetProductsByCategoryID:
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 = @CategoryIDGetProductsBySupplierID:
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 = @SupplierIDGetProductByProductID:
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 CategoriesGetCategoryByCategoryID:
SELECT CategoryID, CategoryName, Description FROM Categories WHERE CategoryID = @CategoryID
SuppliersTableAdapter
GetSuppliers:
SELECT SupplierID, CompanyName, Address, City, Country, Phone FROM SuppliersGetSuppliersByCountry:
SELECT SupplierID, CompanyName, Address, City, Country, Phone FROM Suppliers WHERE Country = @CountryGetSupplierBySupplierID:
SELECT SupplierID, CompanyName, Address, City, Country, Phone FROM Suppliers WHERE SupplierID = @SupplierID
EmployeesTableAdapter
GetEmployees:
SELECT EmployeeID, LastName, FirstName, Title, HireDate, ReportsTo, Country FROM EmployeesGetEmployeesByManager:
SELECT EmployeeID, LastName, FirstName, Title, HireDate, ReportsTo, Country FROM Employees WHERE ReportsTo = @ManagerIDGetEmployeeByEmployeeID:
SELECT EmployeeID, LastName, FirstName, Title, HireDate, ReportsTo, Country FROM Employees WHERE EmployeeID = @EmployeeID
Figura 31: Progettazione set di dati 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 in fase di compilazione 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 nelle classi TableAdapter o Typed DataSet. 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 Typed DataSet 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 alle classi generate automaticamente senza doversi preoccupare della sovrascrittura delle personalizzazioni di Visual Studio.
Per illustrare come personalizzare il 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 durante la compilazione della Northwind.SuppliersRow classe per includere il GetProducts() metodo appena definito. Se si compila il progetto e quindi si torna alla visualizzazione classi, verrà GetProducts() ora elencato 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:
- Un 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 dal deve essere uno dei primi passaggi, prima di iniziare a creare il livello di presentazione. Con Visual Studio, la creazione di un dal basato su set di dati tipizzato è 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 si definiranno diverse regole business e si vedrà come implementarle in un livello di logica di business separato.
Buon programmatori!
Altre informazioni
Per altre informazioni sugli argomenti illustrati in questa esercitazione, vedere le risorse seguenti:
- Compilazione di un'entità DA 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 tramite 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 fortemente tipizzato 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 una griglia di dati
- 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, ha lavorato 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, che può essere trovato all'indirizzo http://ScottOnWriting.NET.
Grazie speciale a
Questa serie di esercitazioni è stata esaminata da molti revisori utili. I revisori potenziali per 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, rilasciarmi una riga in mitchell@4GuysFromRolla.com.