Creazione di un livello di accesso ai dati (C#)
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 directory App_Data . Oltre al file di database, la cartella App_Data 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 di SQL Server del database Northwind, sarà necessario aggiornare l'impostazione NORTHWNDConnectionString nel file Web.config dell'applicazione. 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 di sito Web ASP.NET, impostare l'elenco a discesa Percorso su File System, scegliere una cartella in cui inserire il sito Web e impostare il linguaggio su C#.
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 pagina Default.aspx ASP.NET e una cartella App_Data .
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 cartella App_Data 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 nella cartella App_Data
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 App_Data del sito Web scaricato (NORTHWND. MDF).
Un database inserito nella cartella App_Data 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 cartella App_Data può contenere anche file di .mdb di Microsoft Access, 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 directory App_Data . 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 per l'origine dati sottostante, ad esempio la creazione di una connessione al database, l'emissione di comandi SELECT, INSERT, UPDATE e DELETE e 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, include tabelle Products e Categories che registrano i prodotti per la 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 appartenenti 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 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, ad esempio 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. Una dataTable fortemente tipizzata, 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 cartella App_Code , 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 tabella Products .
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. Per Products DataTable, TableAdapter conterrà i metodi GetProducts(), GetProductByCategoryID(categoryID)e così via verrà richiamato 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 vuole salvare il stringa di connessione nel file Web.config. 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 <sezione connectionStrings>, 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 tabella Products :
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 metodo Fill().
- 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 GetData piuttosto generico in GetProducts.
Se selezionata, la casella di controllo finale , "GenerateDBDirectMethods", crea i metodi Insert(), Update()e Delete() per TableAdapter. Se si lascia deselezionata questa opzione, tutti gli aggiornamenti dovranno essere eseguiti tramite il solo metodo 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 delle colonne in Products DataTable (ProductID, ProductName e così via), nonché i metodi di ProductsTableAdapter (Fill() e GetProducts()).
Figura 12: L'oggetto Products DataTable e ProductsTableAdapter sono stati aggiunti 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 metodo GetProducts(). Questi oggetti possono essere usati per accedere a un elenco di tutti i prodotti dal codice, ad esempio:
NorthwindTableAdapters.ProductsTableAdapter productsAdapter =
new NorthwindTableAdapters.ProductsTableAdapter();
Northwind.ProductsDataTable products;
products = productsAdapter.GetProducts();
foreach (Northwind.ProductsRow productRow in products)
Response.Write("Product: " + productRow.ProductName + "<br />");
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 metodo GetProducts() a un controllo GridView in poche tre righe di codice all'interno del gestore eventi Page_Load .
AllProducts.aspx
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="AllProducts.aspx.cs"
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>
<h2>
All Products</h2>
<p>
<asp:GridView ID="GridView1" runat="server"
CssClass="DataWebControlStyle">
<HeaderStyle CssClass="HeaderStyle" />
<AlternatingRowStyle CssClass="AlternatingRowStyle" />
</asp:GridView>
</p>
</div>
</form>
</body>
</html>
AllProducts.aspx.cs
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using NorthwindTableAdapters;
public partial class AllProducts : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
ProductsTableAdapter productsAdapter = new
ProductsTableAdapter();
GridView1.DataSource = productsAdapter.GetProducts();
GridView1.DataBind();
}
}
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 è necessario scrivere tre righe di codice nel gestore eventi Page_Load della pagina ASP.NET , nelle esercitazioni future si esaminerà come usare ObjectDataSource per recuperare in modo dichiarativo i dati da 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 classe ProductsTableAdapter ha 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 ora il metodo GetProductsByCategoryID(categoryID). Per aggiungere un nuovo metodo a DAL, tornare a Progettazione set di dati, fare clic con il pulsante destro del mouse nella sezione ProductsTableAdapter 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 SELECT che restituisce righe (fare clic per visualizzare l'immagine a dimensione intera)
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, si usa la stessa istruzione SELECT di GetProducts(), ma si aggiunge la clausola WHERE seguente: WHERE CategoryID = @CategoryID. Il parametro @CategoryID 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 metodi GetX ), 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
Aggiungere un metodo GetProductByProductID(productID) usando 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 metodo GetProductsByCategoryID(categoryID) in DAL, è ora possibile creare una pagina di ASP.NET che visualizza solo i prodotti in una categoria specificata. Nell'esempio seguente vengono illustrati tutti i prodotti inclusi nella categoria Beverages, che hanno un Id categoria pari a 1.
Beverages.asp
<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Beverages.aspx.cs"
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>
<h2>Beverages</h2>
<p>
<asp:GridView ID="GridView1" runat="server"
CssClass="DataWebControlStyle">
<HeaderStyle CssClass="HeaderStyle" />
<AlternatingRowStyle CssClass="AlternatingRowStyle" />
</asp:GridView>
</p>
</div>
</form>
</body>
</html>
Beverages.aspx.cs
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using NorthwindTableAdapters;
public partial class Beverages : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
ProductsTableAdapter productsAdapter = new
ProductsTableAdapter();
GridView1.DataSource =
productsAdapter.GetProductsByCategoryID(1);
GridView1.DataBind();
}
}
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, emettono un comando INSERT, UPDATE o 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 Products il metodo delete accetta un parametro integer, che indica l'ID Prodotto del record da eliminare, mentre il metodo insert accetta una stringa per ProductName, un decimale per UnitPrice, un numero intero per UnitsOnStock e 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, ProductsTableAdapter contiene un metodo Update(), che implementa il modello di aggiornamento batch. In particolare, TableAdapter contiene un metodo Update() che può essere passato al DataSet tipizzato, a dataTable fortemente tipizzato o a uno o più DataRows. Se è stata lasciata la casella di controllo "GenerateDBDirectMethods" selezionata quando si crea per la prima volta tableAdapter, il modello diretto del database verrà implementato anche tramite i metodi Insert(), Update()e Delete().
Entrambi i modelli di modifica dei dati usano le proprietà InsertCommand, UpdateCommand e DeleteCommand di TableAdapter per eseguire i comandi INSERT, UPDATE e DELETE al database. È possibile esaminare e modificare le proprietà InsertCommand, UpdateCommand e DeleteCommand facendo clic su TableAdapter in Progettazione DataSet e quindi passando al Finestra Proprietà. Assicurarsi di aver selezionato TableAdapter e che L'oggetto ProductsTableAdapter è quello selezionato nell'elenco a discesa nel Finestra Proprietà.
Figura 23: TableAdapter ha proprietà InsertCommand, UpdateCommand e DeleteCommand (fare clic per visualizzare l'immagine a dimensione intera)
Per esaminare o modificare una di queste proprietà del comando di database, fare clic sulla sottoproprietà CommandText , che visualizzerà Generatore query.
Figura 24: Configurare le istruzioni INSERT, UPDATE e 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:
NorthwindTableAdapters.ProductsTableAdapter productsAdapter =
new NorthwindTableAdapters.ProductsTableAdapter();
// For each product, double its price if it is not discontinued and
// there are 25 items in stock or less
Northwind.ProductsDataTable products = productsAdapter.GetProducts();
foreach (Northwind.ProductsRow product in products)
if (!product.Discontinued && product.UnitsInStock <= 25)
product.UnitPrice *= 2;
// Update the products
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:
NorthwindTableAdapters.ProductsTableAdapter productsAdapter =
new NorthwindTableAdapters.ProductsTableAdapter();
// Delete the product with ProductID 3
productsAdapter.Delete(3);
// Update Chai (ProductID of 1), setting the UnitsOnOrder to 15
productsAdapter.Update("Chai", 1, 1, "10 boxes x 20 bags",
18.0m, 39, 15, 10, false, 1);
// Add a new product
productsAdapter.Insert("New Product", 1, 1,
"12 tins per carton", 14.95m, 15, 0, 10, false);
Creazione di metodi di inserimento, aggiornamento ed eliminazione personalizzati
I metodi Insert(), 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 colonna della tabella Products esegue il mapping a ogni parametro di input ai metodi Update() e Insert(). In alcuni casi potrebbe essere necessario aggiornare solo una singola colonna o due oppure un metodo Insert() personalizzato che restituirà, ad esempio, il valore del campo IDENTITY (incremento automatico) del record appena inserito.
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. Si creerà un metodo che aggiunge un nuovo prodotto e quindi restituisce il valore del ProductID del record appena aggiunto. Pertanto, scegliere di creare una query INSERT .
Figura 25: Creare un metodo per aggiungere una nuova riga alla tabella Products (fare clic per visualizzare l'immagine a dimensione intera)
Nella schermata successiva viene visualizzato il controllo CommandText di InsertCommand. Aumentare questa query aggiungendo SELECT SCOPE_IDENTITY() alla fine della query, che restituirà l'ultimo valore Identity inserito in una colonna IDENTITY nello stesso ambito. Vedere la documentazione tecnica per altre informazioni su SCOPE_IDENTITY() e sui motivi per cui è probabile che si voglia 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 SCOPE_IDENTITY() (fare clic per visualizzare l'immagine 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 alla finestra di progettazione dataset, si noterà che ProductsTableAdapter contiene un nuovo metodo, InsertProduct. Se questo nuovo metodo non ha un parametro per ogni colonna nella tabella Products , è probabile che si dimentica di terminare l'istruzione INSERT con un punto e virgola. Configurare il metodo InsertProduct e assicurarsi di disporre di un punto e virgola che delimita le istruzioni INSERT 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 metodo InsertProduct restituisca il valore restituito dalla query, non il numero di righe interessate. A tale scopo, modificare la proprietà ExecuteMode del metodo InsertProduct su Scalar.
Figura 28: Modificare la proprietà ExecuteMode in Scalar (fare clic per visualizzare l'immagine a dimensione intera)
Il codice seguente illustra questo nuovo metodo InsertProduct in azione:
NorthwindTableAdapters.ProductsTableAdapter productsAdapter =
new NorthwindTableAdapters.ProductsTableAdapter();
// Add a new product
int new_productID = Convert.ToInt32(productsAdapter.InsertProduct
("New Product", 1, 1, "12 tins per carton", 14.95m, 10, 0, 10, false));
// On second thought, delete the product
productsAdapter.Delete(new_productID);
Passaggio 5: Completamento del livello di accesso ai dati
Si noti che la classe ProductsTableAdapters restituisce i valori CategoryID e SupplierID della tabella Products, ma non include la colonna CategoryName della tabella Categories o della colonna CompanyName della tabella Suppliers, 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 colonna CategoryName che CompanyName , che aggiorneranno dataTable fortemente tipizzato in modo da 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 clausola SELECT . Prendendo cura di aggiungere le query a Categorie e Fornitori come sottoquery, anziché JOIN , si evita di dover rielaborare tali metodi per modificare i dati. Fare clic con il pulsante destro del mouse sul metodo GetProducts() in ProductsTableAdapter e scegliere Configura. Modificare quindi la clausola SELECT 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 SELECT per il metodo GetProducts() (fare clic per visualizzare l'immagine a dimensione intera)
Dopo aver aggiornato il metodo GetProducts() per usare questa nuova query, DataTable includerà due nuove colonne: CategoryName e SupplierName.
Figura 30: La tabella Dati Products include due nuove colonne
Aggiornare la clausola SELECT anche nel metodo GetProductsByCategoryID(categoryID).
Se si aggiorna GetProducts() SELECT usando la sintassi JOIN, Progettazione DataSet non sarà in grado di generare automaticamente i metodi per l'inserimento, l'aggiornamento e l'eliminazione dei dati di database usando il modello diretto del database. Sarà invece necessario crearli manualmente come è stato fatto con il metodo InsertProduct in precedenza in questa esercitazione. Inoltre, dovrai specificare manualmente i valori della proprietà InsertCommand, UpdateCommand e DeleteCommand se vuoi 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 nell'oggetto ProductsTableAdapter includono le sottoquery per acquisire i nomi di categoria e fornitore di ogni prodotto. Inoltre, se sono già stati aggiunti i metodi GetProducts() e GetProductsByCategoryID(categoryID) della classe ProductsTableAdapter.
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 di definizione dello schema XML (Northwind.xsd). È possibile visualizzare queste informazioni sullo schema facendo clic con il pulsante destro del mouse sul file Northwind.xsd 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 metodo GetProducts() alla classe SuppliersRow . La classe SuppliersRow rappresenta un singolo record nella tabella Suppliers . Ogni fornitore può fornire zero a molti prodotti, quindi GetProducts() restituirà i prodotti del fornitore specificato. A tale scopo, creare un nuovo file di classe nella cartella App_Code denominata SuppliersRow.cs e aggiungere il codice seguente:
using System;
using System.Data;
using NorthwindTableAdapters;
public partial class Northwind
{
public partial class SuppliersRow
{
public Northwind.ProductsDataTable GetProducts()
{
ProductsTableAdapter productsAdapter =
new ProductsTableAdapter();
return
productsAdapter.GetProductsBySupplierID(this.SupplierID);
}
}
}
Questa classe parziale indica al compilatore che quando si compila la classe Northwind.SuppliersRow per includere il metodo GetProducts() appena definito. Se si compila il progetto e quindi si torna alla visualizzazione classi, verrà visualizzato GetProducts() ora elencato come metodo di Northwind.SuppliersRow.
Figura 34: Il metodo GetProducts() fa ora parte della classe Northwind.SuppliersRow
Il metodo GetProducts() può ora essere usato per enumerare il set di prodotti per un determinato fornitore, come illustrato nel codice seguente:
NorthwindTableAdapters.SuppliersTableAdapter suppliersAdapter =
new NorthwindTableAdapters.SuppliersTableAdapter();
// Get all of the suppliers
Northwind.SuppliersDataTable suppliers =
suppliersAdapter.GetSuppliers();
// Enumerate the suppliers
foreach (Northwind.SuppliersRow supplier in suppliers)
{
Response.Write("Supplier: " + supplier.CompanyName);
Response.Write("<ul>");
// List the products for this supplier
Northwind.ProductsDataTable products = supplier.GetProducts();
foreach (Northwind.ProductsRow product in products)
Response.Write("<li>" + product.ProductName + "</li>");
Response.Write("</ul><p> </p>");
}
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 metodo GetProducts() 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 classe Northwind.SuppliersRow .
SuppliersAndProducts.aspx
<%@ Page Language="C#" CodeFile="SuppliersAndProducts.aspx.cs"
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>
<h2>
Suppliers and Their Products</h2>
<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="<%# ((Northwind.SuppliersRow) ((System.Data.DataRowView) Container.DataItem).Row).GetProducts() %>"
DataTextField="ProductName">
</asp:BulletedList>
</ItemTemplate>
</asp:TemplateField>
</Columns>
</asp:GridView>
</p>
</div>
</form>
</body>
</html>
SuppliersAndProducts.aspx.cs
using System;
using System.Data;
using System.Configuration;
using System.Collections;
using System.Web;
using System.Web.Security;
using System.Web.UI;
using System.Web.UI.WebControls;
using System.Web.UI.WebControls.WebParts;
using System.Web.UI.HtmlControls;
using NorthwindTableAdapters;
public partial class SuppliersAndProducts : System.Web.UI.Page
{
protected void Page_Load(object sender, EventArgs e)
{
SuppliersTableAdapter suppliersAdapter = new
SuppliersTableAdapter();
GridView1.DataSource = suppliersAdapter.GetSuppliers();
GridView1.DataBind();
}
}
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.