Creazione di un'interfaccia per la selezione di un account utente tra diversi account (C#)

di Scott Mitchell

In questa esercitazione verrà creata un'interfaccia utente con una griglia di paging e filtrabile. In particolare, l'interfaccia utente sarà costituita da una serie di linkbutton per filtrare i risultati in base alla lettera iniziale del nome utente e a un controllo GridView per mostrare gli utenti corrispondenti. Si inizierà elencando tutti gli account utente in un controllo GridView. Nel passaggio 3 si aggiungerà quindi il filtro LinkButtons. Il passaggio 4 esamina il paging dei risultati filtrati. L'interfaccia costruita nei passaggi da 2 a 4 verrà usata nelle esercitazioni successive per eseguire attività amministrative per un account utente specifico.

Introduzione

Nell'esercitazione Assegnazione di ruoli agli utenti è stata creata un'interfaccia rudimentale per consentire a un amministratore di selezionare un utente e gestire i ruoli. In particolare, l'interfaccia ha presentato all'amministratore un elenco a discesa di tutti gli utenti. Tale interfaccia è adatta quando ci sono ma una dozzina o così account utente, ma è difficile per i siti con centinaia o migliaia di account. Una griglia di paging e filtrabile è più adatta per i siti Web con basi utente di grandi dimensioni.

In questa esercitazione verrà creata un'interfaccia utente di questo tipo. In particolare, l'interfaccia utente sarà costituita da una serie di linkbutton per filtrare i risultati in base alla lettera iniziale del nome utente e a un controllo GridView per mostrare gli utenti corrispondenti. Si inizierà elencando tutti gli account utente in un controllo GridView. Nel passaggio 3 si aggiungerà quindi il filtro LinkButtons. Il passaggio 4 esamina il paging dei risultati filtrati. L'interfaccia costruita nei passaggi da 2 a 4 verrà usata nelle esercitazioni successive per eseguire attività amministrative per un account utente specifico.

È possibile iniziare subito.

Passaggio 1: Aggiunta di nuove pagine ASP.NET

In questa esercitazione e le due successive verranno esaminate varie funzioni e funzionalità correlate all'amministrazione. Sarà necessaria una serie di ASP.NET pagine per implementare gli argomenti esaminati in queste esercitazioni. Creare queste pagine e aggiornare la mappa del sito.

Per iniziare, creare una nuova cartella nel progetto denominato Administration. Aggiungere quindi due nuove pagine ASP.NET alla cartella, collegando ogni pagina alla Site.master pagina master. Denominare le pagine:

• ManageUsers.aspx
• UserInformation.aspx

Aggiungere anche due pagine alla directory radice del sito Web: ChangePassword.aspx e RecoverPassword.aspx.

A questo punto, queste quattro pagine devono avere due controlli Contenuto, uno per ognuno dei ContentPlaceHolders della pagina master: MainContent e LoginContent.

<asp:Content ID="Content1" ContentPlaceHolderID="MainContent" Runat="Server">
</asp:Content>
<asp:Content ID="Content2" ContentPlaceHolderID="LoginContent" Runat="Server">
</asp:Content>

Si vuole visualizzare il markup predefinito della pagina master per LoginContent ContentPlaceHolder per queste pagine. Rimuovere quindi il markup dichiarativo per il Content2 controllo Contenuto. Dopo questa operazione, il markup delle pagine deve contenere un solo controllo Contenuto.

Le pagine ASP.NET nella Administration cartella sono destinate esclusivamente agli utenti amministratori. È stato aggiunto un ruolo Administrators al sistema nell'esercitazione Creazione e gestione dei ruoli . Limitare l'accesso a queste due pagine a questo ruolo. A tale scopo, aggiungere un Web.config file alla Administration cartella e configurarne <authorization> l'elemento per ammettere gli utenti nel ruolo Administrators e negare tutti gli altri.

<?xml version="1.0"?>
<configuration>
 <system.web>
 <authorization>
 <allow roles="Administrators" />
 <deny users="*"/>
 </authorization>
 </system.web>
</configuration>

A questo punto il Esplora soluzioni del progetto dovrebbe essere simile allo screenshot illustrato nella figura 1.

Figura 1: Quattro nuove pagine e un Web.config file sono stati aggiunti al sito Web (fare clic per visualizzare l'immagine a dimensione intera)

Infine, aggiornare la mappa del sito (Web.sitemap) per includere una voce nella ManageUsers.aspx pagina. Aggiungere il codice XML seguente dopo l'aggiunta <siteMapNode> di per le esercitazioni sui ruoli.

<siteMapNode title="User Administration" url="~/Administration/ManageUsers.aspx"/>

Dopo l'aggiornamento della mappa del sito, visitare il sito tramite un browser. Come illustrato nella figura 2, lo spostamento a sinistra include ora gli elementi per le esercitazioni sull'amministrazione.

Figura 2: La mappa del sito include un nodo intitolato Amministrazione utenti (fare clic per visualizzare l'immagine a dimensione intera)

Passaggio 2: Presentazione di tutti gli account utente in un controllo GridView

L'obiettivo finale di questa esercitazione è creare una griglia di paging e filtrabile tramite cui un amministratore può selezionare un account utente da gestire. Per iniziare, elencare tutti gli utenti in un controllo GridView. Al termine, verranno aggiunte le interfacce di filtro e paging e le funzionalità.

Aprire la ManageUsers.aspx pagina nella Administration cartella e aggiungere un controllo GridView, impostandone ID il valore su UserAccounts. In un momento si scriverà codice per associare il set di account utente a GridView usando il Membership metodo della GetAllUsers classe. Come illustrato nelle esercitazioni precedenti, il metodo GetAllUsers restituisce un MembershipUserCollection oggetto , ovvero una raccolta di MembershipUser oggetti . Ogni MembershipUser oggetto della raccolta include proprietà come UserName, Email, IsApprovede così via.

Per visualizzare le informazioni sull'account utente desiderate in GridView, impostare la proprietà di AutoGenerateColumns GridView su False e aggiungere BoundFields per le UserNameproprietà , Emaile Comment e CheckBoxFields per le proprietà , e per le IsApprovedproprietà , IsLockedOute IsOnline . Questa configurazione può essere applicata tramite il markup dichiarativo del controllo o tramite la finestra di dialogo Campi. La figura 3 mostra una schermata della finestra di dialogo Campi dopo che la casella di controllo Genera automaticamente i campi è stata deselezionata e sono stati aggiunti e configurati i campi BoundFields e CheckBoxFields.

Figura 3: Aggiungere tre campi boundfield e tre campi checkbox a GridView (fare clic per visualizzare l'immagine a dimensione intera)

Dopo aver configurato GridView, assicurarsi che il markup dichiarativo sia simile al seguente:

<asp:GridView ID="UserAccounts" runat="server" AutoGenerateColumns="False">
 <Columns>
 <asp:BoundField DataField="UserName" HeaderText="UserName"/>
 <asp:BoundField DataField="Email" HeaderText="Email" />
 <asp:CheckBoxField DataField="IsApproved" HeaderText="Approved?"/>
 <asp:CheckBoxField DataField="IsLockedOut" HeaderText="Locked Out?" />
 <asp:CheckBoxField DataField="IsOnline" HeaderText="Online?"/>
 <asp:BoundField DataField="Comment" HeaderText="Comment"/>
 </Columns>
</asp:GridView>

Successivamente, è necessario scrivere codice che associa gli account utente a GridView. Creare un metodo denominato BindUserAccounts per eseguire questa attività e quindi chiamarlo dal Page_Load gestore eventi nella prima pagina visita.

protected void Page_Load(object sender, EventArgs e)
{
    if (!Page.IsPostBack)
    BindUserAccounts();
}

private void BindUserAccounts()
{
    UserAccounts.DataSource = Membership.GetAllUsers();
    UserAccounts.DataBind();
}

Eseguire un test della pagina tramite un browser. Come illustrato nella UserAccounts figura 4, GridView elenca il nome utente, l'indirizzo di posta elettronica e altre informazioni relative all'account per tutti gli utenti del sistema.

Figura 4: Gli account utente sono elencati in GridView (fare clic per visualizzare l'immagine a dimensione intera)

Passaggio 3: Filtro dei risultati in base alla prima lettera del nome utente

UserAccounts GridView mostra attualmente tutti gli account utente. Per i siti Web con centinaia o migliaia di account utente, è fondamentale che l'utente sia in grado di ridurre rapidamente gli account visualizzati. Questa operazione può essere eseguita aggiungendo filtri LinkButtons alla pagina. Aggiungere 27 LinkButtons alla pagina: una intitolata All insieme a un LinkButton per ogni lettera dell'alfabeto. Se un visitatore fa clic su All LinkButton, GridView mostrerà tutti gli utenti. Se fanno clic su una lettera specifica, verranno visualizzati solo gli utenti il cui nome utente inizia con la lettera selezionata.

La prima attività consiste nell'aggiungere i 27 controlli LinkButton. Un'opzione consiste nel creare i 27 LinkButton in modo dichiarativo, uno alla volta. Un approccio più flessibile consiste nell'usare un controllo Repeater con un ItemTemplate oggetto che esegue il rendering di un controllo LinkButton e quindi associa le opzioni di filtro al Repeater come string matrice.

Per iniziare, aggiungere un controllo Repeater alla pagina sopra UserAccounts GridView. Impostare la proprietà repeater su IDFilteringUI. Configurare i modelli di Repeater in modo che ne ItemTemplate esegua il rendering di un LinkButton le cui Text proprietà e CommandName sono associate all'elemento della matrice corrente. Come illustrato nell'esercitazione Assegnazione di ruoli agli utenti , questa operazione può essere eseguita usando la sintassi di Container.DataItem associazione dati. Usare repeater per SeparatorTemplate visualizzare una linea verticale tra ogni collegamento.

<asp:Repeater ID="FilteringUI" runat="server">
 <ItemTemplate>
 <asp:LinkButton runat="server" ID="lnkFilter"
 Text='<%# Container.DataItem %>'
 CommandName='<%# Container.DataItem %>'></asp:LinkButton>
 </ItemTemplate>
 <SeparatorTemplate>|</SeparatorTemplate>
</asp:Repeater>

Per popolare questo repeater con le opzioni di filtro desiderate, creare un metodo denominato BindFilteringUI. Assicurarsi di chiamare questo metodo dal Page_Load gestore eventi al caricamento della prima pagina.

protected void Page_Load(object sender, EventArgs e)
{
    if (!Page.IsPostBack)
    {
        BindUserAccounts();
        BindFilteringUI();
    }
}

private void BindFilteringUI()
{
    string[] filterOptions = { "All", "A", "B", "C","D", "E", "F", "G", "H", "I","J", "K", "L", "M", "N", "O","P", "Q", "R", "S", "T", "U","V", "W", "X", "Y", "Z" };
    FilteringUI.DataSource = filterOptions;
    FilteringUI.DataBind();
}

Questo metodo specifica le opzioni di filtro come elementi nella string matrice filterOptions. Per ogni elemento della matrice, il repeater eseguirà il rendering di un oggetto LinkButton con le relative Text proprietà e CommandName assegnate al valore dell'elemento della matrice.

La figura 5 mostra la ManageUsers.aspx pagina visualizzata tramite un browser.

Figura 5: Il ripetitore Elenchi 27 pulsanti di filtro (fare clic per visualizzare l'immagine a dimensione intera)

Nota

I nomi utente possono iniziare con qualsiasi carattere, inclusi numeri e punteggiatura. Per visualizzare questi account, l'amministratore dovrà usare l'opzione All LinkButton. In alternativa, è possibile aggiungere un linkbutton per restituire tutti gli account utente che iniziano con un numero. Lascio questo come esercizio per il lettore.

Se si fa clic su uno dei pulsanti di filtro, viene generato un postback e viene generato l'evento ItemCommand Repeater, ma non viene apportata alcuna modifica nella griglia perché è ancora necessario scrivere codice per filtrare i risultati. La Membership classe include un FindUsersByName metodo che restituisce gli account utente il cui nome utente corrisponde a un criterio di ricerca specificato. È possibile usare questo metodo per recuperare solo gli account utente i cui nomi utente iniziano con la lettera specificata dall'oggetto CommandName del linkButton filtrato selezionato.

Per iniziare, aggiornare la ManageUser.aspx classe code-behind della pagina in modo che includa una proprietà denominata UsernameToMatch. Questa proprietà rende persistente la stringa di filtro nome utente tra i postback:

private string UsernameToMatch
{
 get
 {
 object o = ViewState["UsernameToMatch"];
 if (o == null)
 return string.Empty;
 else
 return (string)o;
 }
 set
 {
 ViewState["UsernameToMatch"] = value;
 }
}

La UsernameToMatch proprietà archivia il relativo valore assegnato alla ViewState raccolta usando la chiave UsernameToMatch. Quando il valore di questa proprietà viene letto, verifica se esiste un valore nella ViewState raccolta. In caso contrario, restituisce il valore predefinito, una stringa vuota. La UsernameToMatch proprietà mostra un modello comune, ovvero rendere permanente un valore per visualizzare lo stato in modo che le modifiche apportate alla proprietà vengano mantenute tra postback. Per altre informazioni su questo modello, vedere Informazioni sullo stato di visualizzazione ASP.NET.

Aggiornare quindi il BindUserAccounts metodo in modo che invece di chiamare Membership.GetAllUsers, chiama Membership.FindUsersByName, passando il valore della UsernameToMatch proprietà aggiunto con il carattere jolly SQL, %.

private void BindUserAccounts()
{
    UserAccounts.DataSource = Membership.FindUsersByName(this.UsernameToMatch + "%");
    UserAccounts.DataBind();
}

Per visualizzare solo gli utenti il cui nome utente inizia con la lettera A, impostare la UsernameToMatch proprietà su A e quindi chiamare BindUserAccounts. Ciò comporta una chiamata a Membership.FindUsersByName("A%"), che restituirà tutti gli utenti il cui nome utente inizia con A. Analogamente, per restituire tutti gli utenti, assegnare una stringa vuota alla UsernameToMatch proprietà in modo che il BindUserAccounts metodo richiamerà Membership.FindUsersByName("%"), quindi restituisce tutti gli account utente.

Creare un gestore eventi per l'evento ItemCommand Repeater. Questo evento viene generato ogni volta che viene fatto clic su uno dei filtri LinkButtons; viene passato il valore di CommandName LinkButton fatto clic tramite l'oggetto RepeaterCommandEventArgs . È necessario assegnare il valore appropriato alla UsernameToMatch proprietà e quindi chiamare il BindUserAccounts metodo. CommandName Se è Tutto, assegnare una stringa vuota a UsernameToMatch in modo che vengano visualizzati tutti gli account utente. In caso contrario, assegnare il CommandName valore a UsernameToMatch.

protected void FilteringUI_ItemCommand(object source, RepeaterCommandEventArgs e)
{
    if (e.CommandName == "All")
        this.UsernameToMatch = string.Empty;
    else
        this.UsernameToMatch e.CommandName;
    BindUserAccounts();
}

Con questo codice sul posto, testare la funzionalità di filtro. Quando la pagina viene visitata per la prima volta, vengono visualizzati tutti gli account utente (fare riferimento alla figura 5). Facendo clic su A LinkButton viene generato un postback e filtra i risultati, visualizzando solo gli account utente che iniziano con A .

Figura 6: Usare il filtro linkButtons per visualizzare gli utenti il cui nome utente inizia con una determinata lettera (fare clic per visualizzare un'immagine full-size)

Passaggio 4: Aggiornamento di GridView per l'uso del paging

GridView illustrato nella figura 5 e 6 elenca tutti i record restituiti dal FindUsersByName metodo . Se ci sono centinaia o migliaia di account utente, questo può causare l'overload di informazioni durante la visualizzazione di tutti gli account , come accade quando si fa clic su All LinkButton o quando si visita inizialmente la pagina. Per presentare gli account utente in blocchi più gestibili, configurare GridView per visualizzare 10 account utente alla volta.

Il controllo GridView offre due tipi di paging:

• Paging predefinito : facile da implementare, ma inefficiente. In breve, con il paging predefinito GridView prevede tutti i record dall'origine dati. Visualizza quindi solo la pagina appropriata dei record.
• Paging personalizzato : richiede più lavoro da implementare, ma è più efficiente del paging predefinito perché con il paging personalizzato l'origine dati restituisce solo il set preciso di record da visualizzare.

La differenza di prestazioni tra il paging predefinito e il paging personalizzato possono essere molto sostanziali durante il paging di migliaia di record. Poiché si sta creando questa interfaccia presupponendo che ci siano centinaia o migliaia di account utente, si userà il paging personalizzato.

Nota

Per una discussione più approfondita sulle differenze tra paging predefinito e personalizzato, nonché sulle sfide coinvolte nell'implementazione di paging personalizzati, vedere Paging efficiente tramite grandi quantità di dati.

Per implementare il paging personalizzato è necessario prima di tutto un meccanismo per cui recuperare il sottoinsieme preciso dei record visualizzati da GridView. La buona notizia è che il Membership metodo della FindUsersByName classe ha un overload che consente di specificare l'indice della pagina e le dimensioni della pagina e restituisce solo gli account utente che rientrano in tale intervallo di record.

In particolare, questo overload ha la firma seguente: FindUsersByName(usernameToMatch, pageIndex, pageSize, totalRecords).

Il parametro pageIndex specifica la pagina degli account utente da restituire; pageSize indica il numero di record da visualizzare per pagina. Il parametro totalRecords è un out parametro che restituisce il numero di account utente totali nell'archivio utenti.

Nota

I dati restituiti da vengono ordinati in FindUsersByName base al nome utente. Non è possibile personalizzare i criteri di ordinamento.

GridView può essere configurato per usare il paging personalizzato, ma solo quando associato a un controllo ObjectDataSource. Per il controllo ObjectDataSource per implementare il paging personalizzato, è necessario due metodi: uno passato a un indice di riga iniziale e il numero massimo di record da visualizzare e restituisce il subset preciso di record che rientrano in tale intervallo; e un metodo che restituisce il numero totale di record da scorrere. L'overload FindUsersByName accetta un indice di pagina e una dimensione di pagina e restituisce il numero totale di record tramite un out parametro. Quindi c'è una mancata corrispondenza dell'interfaccia qui.

Un'opzione consiste nel creare una classe proxy che espone l'interfaccia prevista dall'oggetto ObjectDataSource e quindi chiama internamente il FindUsersByName metodo. Un'altra opzione, che verrà usata per questo articolo, consiste nel creare un'interfaccia di paging personalizzata e usarla anziché l'interfaccia di paging predefinita di GridView.

Creazione di un'interfaccia First, Previous, Next, Last Paging

Si creerà un'interfaccia di paging con First, Previous, Next e Last LinkButtons. Il primo linkButton, quando viene fatto clic, porterà l'utente alla prima pagina dei dati, mentre Precedente lo restituirà alla pagina precedente. Analogamente, Avanti e Ultimo spostano rispettivamente l'utente nella pagina successiva e nell'ultima pagina. Aggiungere i quattro controlli LinkButton sotto UserAccounts GridView.

<p>
 <asp:LinkButton ID="lnkFirst" runat="server"> First</asp:LinkButton> |
 <asp:LinkButton ID="lnkPrev" runat="server">  Prev</asp:LinkButton>|
 <asp:LinkButton ID="lnkNext" runat="server">Next  </asp:LinkButton>|
 <asp:LinkButton ID="lnkLast" runat="server">Last  </asp:LinkButton>
</p>

Creare quindi un gestore eventi per ognuno degli eventi di LinkButton Click .

La figura 7 mostra i quattro LinkButton visualizzati tramite la visualizzazione Visual Web Developer Design.

Figura 7: Aggiungere Prima, Precedente, Avanti e Ultimo LinkButtons Sotto GridView (Fare clic per visualizzare l'immagine full-size)

Tenere traccia dell'indice di pagina corrente

Quando un utente visita prima la ManageUsers.aspx pagina o fa clic su uno dei pulsanti di filtro, si vuole visualizzare la prima pagina dei dati in GridView. Quando l'utente fa clic su uno dei linkbutton di spostamento, è tuttavia necessario aggiornare l'indice della pagina. Per mantenere l'indice della pagina e il numero di record da visualizzare per pagina, aggiungere le due proprietà seguenti alla classe code-behind della pagina:

private int PageIndex
{
 get
 {
 object o = ViewState["PageIndex"];
 if (o == null)
 return 0;
 else
 return (int)o;
 }
 set
 {
 ViewState["PageIndex"] = value;
 }
}

private int PageSize
{
 get
 {
 return 10;
 }
}

Analogamente alla proprietà, la UsernameToMatchPageIndex proprietà mantiene il valore per visualizzare lo stato. La proprietà di sola PageSize lettura restituisce un valore hardcoded, 10. Invito il lettore interessato a aggiornare questa proprietà per usare lo stesso modello di PageIndex, quindi per aumentare la pagina in modo che la persona che visita la ManageUsers.aspx pagina possa specificare il numero di account utente da visualizzare per pagina.

Recupero dei record della pagina corrente, aggiornamento dell'indice di pagina e abilitazione e disabilitazione del collegamento dell'interfaccia di pagingButton

Con l'interfaccia di paging sul posto e le PageIndex proprietà e PageSize aggiunte, è possibile aggiornare il metodo in modo che usi l'overload BindUserAccounts appropriato FindUsersByName . Inoltre, è necessario abilitare o disabilitare l'interfaccia di paging a seconda della pagina visualizzata. Quando si visualizza la prima pagina dei dati, i collegamenti First e Previous devono essere disabilitati; Successivamente e Last deve essere disabilitato quando si visualizza l'ultima pagina.

Aggiornare il metodo BindUserAccounts con il codice seguente:

private void BindUserAccounts()
{
 int totalRecords;
 UserAccounts.DataSource = Membership.FindUsersByName(this.UsernameToMatch + "%",this.PageIndex, this.PageSize, out totalRecords);
 UserAccounts.DataBind();

 // Enable/disable the paging interface
 bool visitingFirstPage = (this.PageIndex == 0);
 lnkFirst.Enabled = !visitingFirstPage;
 lnkPrev.Enabled = !visitingFirstPage;

 int lastPageIndex = (totalRecords - 1) / this.PageSize;
 bool visitingLastPage = (this.PageIndex >= lastPageIndex);
 lnkNext.Enabled = !visitingLastPage;
 lnkLast.Enabled = !visitingLastPage;
}

Si noti che il numero totale di record visualizzati tramite viene determinato dall'ultimo parametro del FindUsersByName metodo. Si tratta di un out parametro, quindi è prima necessario dichiarare una variabile per contenere questo valore (totalRecords) e quindi prefisso con la out parola chiave.

Dopo aver restituito la pagina specificata degli account utente, i quattro LinkButton sono abilitati o disabilitati, a seconda che venga visualizzata la prima o l'ultima pagina dei dati.

L'ultimo passaggio consiste nel scrivere il codice per i quattro gestori eventi Click LinkButtons. Questi gestori eventi devono aggiornare la PageIndex proprietà e quindi ribinare i dati in GridView tramite una chiamata a BindUserAccounts. I gestori eventi First, Previous e Next sono molto semplici. Il Click gestore eventi per Last LinkButton, tuttavia, è un po'più complesso perché è necessario determinare il numero di record visualizzati per determinare l'indice dell'ultima pagina.

protected void lnkFirst_Click(object sender, EventArgs e)
{
 this.PageIndex = 0;
 BindUserAccounts();
}

protected void lnkPrev_Click(object sender, EventArgs e)
{
 this.PageIndex -= 1;
 BindUserAccounts();
}

protected void lnkNext_Click(object sender, EventArgs e)
{
 this.PageIndex += 1;
 BindUserAccounts();
}

protected void lnkLast_Click(object sender, EventArgs e)
{
 // Determine the total number of records
 int totalRecords;
 Membership.FindUsersByName(this.UsernameToMatch + "%", this.PageIndex,this.PageSize, out totalRecords);
 // Navigate to the last page index
 this.PageIndex = (totalRecords - 1) / this.PageSize;
 BindUserAccounts();
}

Le figure 8 e 9 mostrano l'interfaccia di paging personalizzata in azione. La figura 8 mostra la pagina quando si visualizza la ManageUsers.aspx prima pagina di dati per tutti gli account utente. Si noti che vengono visualizzati solo 10 degli account 13. Facendo clic sul collegamento Avanti o Ultimo viene generato un postback, viene aggiornato PageIndex su 1 e viene associata la seconda pagina degli account utente alla griglia (vedere la figura 9).

Figura 8: vengono visualizzati i primi 10 account utente (fare clic per visualizzare l'immagine full-size)

Figura 9: fare clic sul collegamento successivo visualizza la seconda pagina degli account utente (fare clic per visualizzare l'immagine a dimensioni complete)

Riepilogo

Gli amministratori spesso devono selezionare un utente dall'elenco di account. Nelle esercitazioni precedenti è stato esaminato l'uso di un elenco a discesa popolato con gli utenti, ma questo approccio non viene ridimensionato correttamente. In questa esercitazione è stata esaminata un'alternativa migliore: un'interfaccia filtrabile i cui risultati vengono visualizzati in una pagina GridView. Con questa interfaccia utente, gli amministratori possono individuare in modo rapido ed efficiente e selezionare un account utente tra migliaia.

Programmazione felice!

Altre informazioni

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

• Paging personalizzato in ASP.NET con SQL Server 2005
• Paging efficiente tramite grandi quantità di dati

Informazioni sull'autore

Scott Mitchell, autore di più libri ASP/ASP.NET e fondatore di 4GuysFromRolla.com, ha lavorato con le tecnologie Web Microsoft dal 1998. Scott lavora come consulente indipendente, allenatore e scrittore. Il suo ultimo libro è Sams Teach Yourself ASP.NET 2,0 in 24 Ore. Scott può essere raggiunto all'indirizzo mitchell@4guysfromrolla.com o tramite il suo blog all'indirizzo http://ScottOnWriting.NET.

Grazie speciali

Questa serie di esercitazioni è stata esaminata da molti revisori utili. Il revisore lead per questa esercitazione è Alicja Maziarz. Interessati a esaminare i prossimi articoli MSDN? In tal caso, lasciami una riga in mitchell@4GuysFromRolla.com

Avanti