Erstellen eine Schnittstelle zum Auswählen eines Benutzerkontos aus vielen (C#)

von Scott Mitchell

In diesem Tutorial erstellen wir eine Benutzeroberfläche mit einem ausgelagerten, filterbaren Raster. Insbesondere besteht unsere Benutzeroberfläche aus einer Reihe von LinkButtons zum Filtern der Ergebnisse basierend auf dem Anfangsbuchstaben des Benutzernamens und einem GridView-Steuerelement, um die übereinstimmenden Benutzer anzuzeigen. Wir beginnen damit, alle Benutzerkonten in einer GridView aufzulisten. Anschließend fügen wir in Schritt 3 den Filter LinkButtons hinzu. Schritt 4 befasst sich mit der Paginierung der gefilterten Ergebnisse. Die in den Schritten 2 bis 4 erstellte Schnittstelle wird in den nachfolgenden Tutorials verwendet, um administrative Aufgaben für ein bestimmtes Benutzerkonto auszuführen.

Einführung

Im Tutorial Zuweisen von Rollen zu Benutzern haben wir eine rudimentäre Benutzeroberfläche erstellt, über die ein Administrator einen Benutzer auswählen und seine Rollen verwalten kann. Insbesondere hat die Benutzeroberfläche dem Administrator eine Dropdownliste aller Benutzer angezeigt. Eine solche Schnittstelle eignet sich, wenn es nur ein Dutzend Benutzerkonten gibt, ist aber für Websites mit Hunderten oder Tausenden von Konten unübersichtlich. Ein ausgelagertes, filterbares Raster eignet sich besser für Websites mit großen Benutzerbasen.

In diesem Tutorial erstellen wir eine solche Benutzeroberfläche. Insbesondere besteht unsere Benutzeroberfläche aus einer Reihe von LinkButtons zum Filtern der Ergebnisse basierend auf dem Anfangsbuchstaben des Benutzernamens und einem GridView-Steuerelement, um die übereinstimmenden Benutzer anzuzeigen. Wir beginnen damit, alle Benutzerkonten in einer GridView aufzulisten. Anschließend fügen wir in Schritt 3 den Filter LinkButtons hinzu. Schritt 4 befasst sich mit der Paginierung der gefilterten Ergebnisse. Die in den Schritten 2 bis 4 erstellte Schnittstelle wird in den nachfolgenden Tutorials verwendet, um administrative Aufgaben für ein bestimmtes Benutzerkonto auszuführen.

Jetzt geht‘s los!

Schritt 1: Hinzufügen neuer ASP.NET Pages

In diesem Und den nächsten beiden Lernprogramm werden verschiedene verwaltungsbezogene Funktionen und Funktionen untersucht. Wir benötigen eine Reihe von ASP.NET Seiten, um die in diesen Tutorials behandelten Themen zu implementieren. Wir erstellen diese Seiten und aktualisieren die Siteübersicht.

Erstellen Sie zunächst einen neuen Ordner im Projekt mit dem Namen Administration. Fügen Sie dem Ordner als Nächstes zwei neue ASP.NET Seiten hinzu, wobei jede Seite mit der Site.master master Seite verknüpft wird. Nennen Sie die Seiten:

• ManageUsers.aspx
• UserInformation.aspx

Fügen Sie außerdem zwei Seiten zum Stammverzeichnis der Website hinzu: ChangePassword.aspx und RecoverPassword.aspx.

Diese vier Seiten sollten zu diesem Zeitpunkt über zwei Inhaltssteuerelemente verfügen, eines für jedes der Master ContentPlaceHolders der Seite: MainContent und LoginContent.

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

Wir möchten das Standardmarkup der master Seite für den LoginContent ContentPlaceHolder für diese Seiten anzeigen. Entfernen Sie daher das deklarative Markup für das Content2 Content-Steuerelement. Danach sollte das Markup der Seiten nur ein Content-Steuerelement enthalten.

Die ASP.NET Seiten im Administration Ordner sind ausschließlich für Administratoren bestimmt. Im Tutorial Erstellen und Verwalten von Rollen wurde dem System die Rolle "Administratoren" hinzugefügt. Der Zugriff auf diese beiden Seiten wird auf diese Rolle beschränkt. Um dies zu erreichen, fügen Sie dem Ordner eine Web.config Datei hinzu, und konfigurieren Sie dessen Administration<authorization> Element so, dass Benutzer in der Rolle "Administratoren" zugelassen und alle anderen personen verweigert werden.

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

An diesem Punkt sollte die Projektmappen-Explorer Ihres Projekts ähnlich dem Screenshot in Abbildung 1 aussehen.

Abbildung 1: Vier neue Seiten und eine Web.config Datei wurden der Website hinzugefügt (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Aktualisieren Sie schließlich die Websiteübersicht (Web.sitemap), um einen Eintrag auf der ManageUsers.aspx Seite einzuschließen. Fügen Sie den folgenden XML-Code nach dem hinzu, den <siteMapNode> wir für die Rollentutorials hinzugefügt haben.

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

Nachdem die Websitekarte aktualisiert wurde, besuchen Sie die Website über einen Browser. Wie in Abbildung 2 dargestellt, enthält die Navigation auf der linken Seite nun Elemente für die Tutorials zur Verwaltung.

Abbildung 2: Die Siteübersicht enthält einen Knoten mit dem Titel "Benutzerverwaltung" (Klicken Sie hier, um ein Bild in voller Größe anzuzeigen)

Schritt 2: Auflisten aller Benutzerkonten in einer GridView

Unser Endziel für dieses Tutorial besteht darin, ein ausgelagertes, filterbares Raster zu erstellen, über das ein Administrator ein zu verwaltende Benutzerkonto auswählen kann. Beginnen wir damit, alle Benutzer in einer GridView aufzulisten. Sobald dies abgeschlossen ist, fügen wir die Filter- und Pagingschnittstellen und -funktionen hinzu.

Öffnen Sie die ManageUsers.aspx Seite im Administration Ordner, und fügen Sie eine GridView hinzu, und legen Sie dessen ID auf fest UserAccounts. In einem Moment schreiben wir Code, um den Satz von Benutzerkonten mithilfe der -Methode der -Klasse GetAllUsers an GridView Membership zu binden. Wie in früheren Tutorials erläutert, gibt die GetAllUsers-Methode ein MembershipUserCollection -Objekt zurück, bei dem es sich um eine Auflistung von MembershipUser -Objekten handelt. Jede MembershipUser in der Auflistung enthält Eigenschaften wie UserName, Email, IsApprovedusw.

Um die gewünschten Benutzerkontoinformationen in GridView anzuzeigen, legen Sie die Eigenschaft von AutoGenerateColumns GridView auf False fest, und fügen Sie BoundFields für die UserNameEigenschaften , Emailund Comment und sowie CheckBoxFields für die Eigenschaften , IsLockedOutund IsOnline hinzuIsApproved. Diese Konfiguration kann über das deklarative Markup des Steuerelements oder über das Dialogfeld Felder angewendet werden. Abbildung 3 zeigt einen Screenshot des Dialogfelds Felder, nachdem das Kontrollkästchen Felder automatisch generieren deaktiviert und die BoundFields und CheckBoxFields hinzugefügt und konfiguriert wurden.

Abbildung 3: Hinzufügen von drei BoundFields und Drei CheckBoxFields zu GridView (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Stellen Sie nach dem Konfigurieren Von GridView sicher, dass das deklarative Markup wie folgt aussieht:

<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>

Als Nächstes müssen wir Code schreiben, der die Benutzerkonten an GridView bindet. Erstellen Sie eine Methode mit dem Namen BindUserAccounts , um diese Aufgabe auszuführen, und rufen Sie sie dann auf dem ersten Seitenbesuch aus dem Page_Load Ereignishandler auf.

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

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

Nehmen Sie sich einen Moment Zeit, um die Seite über einen Browser zu testen. Wie abbildung 4 zeigt, listet GridView UserAccounts den Benutzernamen, die E-Mail-Adresse und andere relevante Kontoinformationen für alle Benutzer im System auf.

Abbildung 4: Die Benutzerkonten werden in GridView aufgelistet (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Schritt 3: Filtern der Ergebnisse nach dem ersten Buchstaben des Benutzernamens

Derzeit werden in GridView UserAccountsalle Benutzerkonten angezeigt. Für Websites mit Hunderten oder Tausenden von Benutzerkonten ist es zwingend erforderlich, dass Benutzer die angezeigten Konten schnell analysieren können. Dies kann erreicht werden, indem Sie der Seite FilterlinkButtons hinzufügen. Fügen wir der Seite 27 LinkButtons hinzu: eins mit dem Titel All und ein LinkButton für jeden Buchstaben des Alphabets. Wenn ein Besucher auf all LinkButton klickt, werden in GridView alle Benutzer angezeigt. Wenn sie auf einen bestimmten Buchstaben klicken, werden nur die Benutzer angezeigt, deren Benutzername mit dem ausgewählten Buchstaben beginnt.

Unsere erste Aufgabe besteht darin, die 27 LinkButton-Steuerelemente hinzuzufügen. Eine Möglichkeit wäre, die 27 LinkButtons deklarativ nacheinander zu erstellen. Ein flexiblerer Ansatz besteht darin, ein Repeater-Steuerelement mit einem ItemTemplate zu verwenden, das ein LinkButton rendert und dann die Filteroptionen als string Array an den Repeater bindet.

Fügen Sie zunächst der Seite oberhalb von UserAccounts GridView ein Repeater-Steuerelement hinzu. Legen Sie die Eigenschaft des ID Repeaters auf fest FilteringUI. Konfigurieren Sie die Vorlagen des Repeaters so, dass ein ItemTemplate LinkButton gerendert wird, dessen Text Eigenschaften und CommandName an das aktuelle Arrayelement gebunden sind. Wie wir im Tutorial Zuweisen von Rollen zu Benutzern gesehen haben, kann dies mithilfe der Container.DataItem Datenbindungssyntax erreicht werden. Verwenden Sie den Repeater, SeparatorTemplate um eine vertikale Linie zwischen den einzelnen Verknüpfungen anzuzeigen.

<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>

Um diesen Repeater mit den gewünschten Filteroptionen aufzufüllen, erstellen Sie eine Methode mit dem Namen BindFilteringUI. Achten Sie darauf, dass Sie diese Methode beim laden der ersten Seite aus dem Page_Load Ereignishandler aufrufen.

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();
}

Diese Methode gibt die Filteroptionen als Elemente im string Array filterOptionsan. Für jedes Element im Array rendert der Repeater ein LinkButton-Element, dessen Text Eigenschaften und CommandName dem Wert des Arrayelements zugewiesen sind.

Abbildung 5 zeigt die ManageUsers.aspx Seite, wenn sie über einen Browser angezeigt wird.

Abbildung 5: Der Repeater Listen 27 Filtern von LinkButtons (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Hinweis

Benutzernamen können mit einem beliebigen Zeichen beginnen, einschließlich Zahlen und Interpunktion. Um diese Konten anzuzeigen, muss der Administrator die Option All LinkButton verwenden. Alternativ können Sie ein LinkButton-Element hinzufügen, um alle Benutzerkonten zurückzugeben, die mit einer Zahl beginnen. Ich belasse dies als Übung für den Leser.

Das Klicken auf eines der filternden LinkButtons verursacht ein Postback und löst das Ereignis des ItemCommand Repeaters aus, aber es gibt keine Änderung im Raster, da wir noch keinen Code zum Filtern der Ergebnisse schreiben müssen. Die Membership -Klasse enthält eine FindUsersByName -Methode , die die Benutzerkonten zurückgibt, deren Benutzername mit einem angegebenen Suchmuster übereinstimmt. Wir können diese Methode verwenden, um nur die Benutzerkonten abzurufen, deren Benutzernamen mit dem Buchstaben beginnen, der durch den CommandName des gefilterten LinkButton-Elements angegeben wird, auf das geklickt wurde.

Aktualisieren Sie zunächst die CodeBehind-Klasse der ManageUser.aspx Seite, sodass sie eine Eigenschaft namens enthält UsernameToMatch. Diese Eigenschaft speichert die Zeichenfolge des Benutzernamenfilters über Postbacks hinweg:

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

Die UsernameToMatch -Eigenschaft speichert ihren Wert, den sie der ViewState Auflistung mit dem Schlüssel UsernameToMatch zugewiesen wird. Wenn der Wert dieser Eigenschaft gelesen wird, überprüft sie, ob ein Wert in der ViewState Auflistung vorhanden ist. Andernfalls wird der Standardwert zurückgegeben, eine leere Zeichenfolge. Die UsernameToMatch -Eigenschaft weist ein gängiges Muster auf, nämlich einen Wert zum Anzeigen des Zustands beizubehalten, sodass alle Änderungen an der Eigenschaft über Postbacks hinweg beibehalten werden. Weitere Informationen zu diesem Muster finden Sie unter Grundlegendes zu ASP.NET Ansichtszustand.

Aktualisieren Sie als Nächstes die BindUserAccounts -Methode so, dass anstelle von Membership.GetAllUsersaufgerufen wird , dass der Membership.FindUsersByNameWert der Eigenschaft übergeben wird, die UsernameToMatch mit dem SQL-Wildcardzeichen %angefügt wird.

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

Um nur die Benutzer anzuzeigen, deren Benutzername mit dem Buchstaben A beginnt, legen Sie die UsernameToMatch Eigenschaft auf A fest, und rufen Sie dann auf BindUserAccounts. Dies würde zu einem Aufruf Membership.FindUsersByName("A%")von führen, der alle Benutzer zurückgibt, deren Benutzername mit A beginnt. Um alle Benutzer zurückzugeben, weisen Sie der UsernameToMatch -Eigenschaft eine leere Zeichenfolge zu, sodass die BindUserAccounts -Methode aufruft Membership.FindUsersByName("%"), wodurch alle Benutzerkonten zurückgegeben werden.

Erstellen Sie einen Ereignishandler für das Ereignis des ItemCommand Repeaters. Dieses Ereignis wird ausgelöst, wenn auf einen der FilterlinkButtons geklickt wird. Der Wert des geklickten LinkButton CommandName wird über das RepeaterCommandEventArgs -Objekt übergeben. Wir müssen der UsernameToMatch -Eigenschaft den entsprechenden Wert zuweisen und dann die BindUserAccounts -Methode aufrufen. Wenn alle CommandName ist, weisen Sie eine leere Zeichenfolge zu, damit UsernameToMatch alle Benutzerkonten angezeigt werden. Andernfalls weisen Sie den CommandName Wert zu UsernameToMatch.

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

Testen Sie mit diesem Code die Filterfunktion. Wenn die Seite zum ersten Mal besucht wird, werden alle Benutzerkonten angezeigt (siehe Abbildung 5). Das Klicken auf A LinkButton bewirkt ein Postback und filtert die Ergebnisse, wobei nur die Benutzerkonten angezeigt werden, die mit A beginnen.

Abbildung 6: Verwenden Sie die FilterlinkButtons, um die Benutzer anzuzeigen, deren Benutzername mit einem bestimmten Buchstaben beginnt (Klicken Sie hier, um das bild in voller Größe anzuzeigen)

Schritt 4: Aktualisieren der GridView für die Verwendung von Paging

Die GridView in Abbildungen 5 und 6 listet alle von der FindUsersByName -Methode zurückgegebenen Datensätze auf. Wenn Hunderte oder Tausende von Benutzerkonten vorhanden sind, kann dies zu einer Informationsüberladung führen, wenn alle Konten angezeigt werden (wie es beim Klicken auf die Schaltfläche "Alle Link" oder beim ersten Besuch der Seite der Fall ist). Um die Benutzerkonten in besser verwaltbaren Blöcken darzustellen, konfigurieren wir GridView so, dass 10 Benutzerkonten gleichzeitig angezeigt werden.

Das GridView-Steuerelement bietet zwei Arten von Paging:

• Standard paging – einfach zu implementieren, aber ineffizient. Kurz gesagt, bei standard paging erwartet GridView alle Datensätze aus der Datenquelle. Anschließend wird nur die entsprechende Seite mit Datensätzen angezeigt.
• Benutzerdefiniertes Paging : Erfordert mehr Aufwand bei der Implementierung, ist aber effizienter als das Standardpahing, da die Datenquelle beim benutzerdefinierten Paging nur den genauen Satz von Datensätzen zurückgibt, die angezeigt werden sollen.

Der Leistungsunterschied zwischen standard- und benutzerdefiniertem Paging kann erheblich sein, wenn Tausende von Datensätzen durchlaufen werden. Da wir diese Schnittstelle unter der Annahme erstellen, dass hunderte oder Tausende von Benutzerkonten vorhanden sein können, verwenden wir benutzerdefiniertes Paging.

Hinweis

Eine ausführlichere Diskussion zu den Unterschieden zwischen Standard- und benutzerdefiniertem Paging sowie zu den Herausforderungen bei der Implementierung benutzerdefinierter Pagings finden Sie unter Effizientes Paging durch große Datenmengen.

Zum Implementieren des benutzerdefinierten Pagings benötigen wir zunächst einen Mechanismus, mit dem die genaue Teilmenge der Datensätze abgerufen werden kann, die von gridView angezeigt werden. Die gute Nachricht ist, dass die Methode der Membership Klasse FindUsersByName über eine Überladung verfügt, die es uns ermöglicht, den Seitenindex und die Seitengröße anzugeben, und nur die Benutzerkonten zurückgibt, die in diesen Datensatzbereich fallen.

Insbesondere hat diese Überladung die folgende Signatur: FindUsersByName(usernameToMatch, pageIndex, pageSize, totalRecords).

Der pageIndex-Parameter gibt die Seite der zurückzugebenden Benutzerkonten an. pageSize gibt an, wie viele Datensätze pro Seite angezeigt werden sollen. Der totalRecords-Parameter ist ein out Parameter, der die Gesamtzahl der Benutzerkonten im Benutzerspeicher zurückgibt.

Hinweis

Die von zurückgegebenen FindUsersByName Daten werden nach Benutzername sortiert. Die Sortierkriterien können nicht angepasst werden.

Die GridView kann so konfiguriert werden, dass benutzerdefiniertes Paging verwendet wird, aber nur, wenn sie an ein ObjectDataSource-Steuerelement gebunden ist. Damit das ObjectDataSource-Steuerelement benutzerdefiniertes Paging implementieren kann, benötigt es zwei Methoden: eine, die einen Startzeilenindex übergeben wird, und die maximale Anzahl von Datensätzen, die angezeigt werden sollen, und gibt die genaue Teilmenge der Datensätze zurück, die innerhalb dieser Spanne liegen. und eine Methode, die die Gesamtanzahl der Datensätze zurückgibt, die ausgelagert werden. Die FindUsersByName Überladung akzeptiert einen Seitenindex und die Seitengröße und gibt die Gesamtzahl der Datensätze über einen out Parameter zurück. Hier besteht also ein Schnittstellenkonflikt.

Eine Option wäre, eine Proxyklasse zu erstellen, die die von ObjectDataSource erwartete Schnittstelle verfügbar macht und dann intern die FindUsersByName Methode aufruft. Eine weitere Option - und die, die wir für diesen Artikel verwenden - besteht darin, eine eigene Pagingschnittstelle zu erstellen und diese anstelle der integrierten Pagingschnittstelle von GridView zu verwenden.

Erstellen einer Ersten, vorherigen, nächsten, letzten Pagingschnittstelle

Erstellen Wir eine Pagingschnittstelle mit First, Previous, Next und Last LinkButtons. Wenn der Erste LinkButton geklickt wird, wird der Benutzer zur ersten Datenseite weitergeleitet, während Previous ihn zur vorherigen Seite zurückgibt. Ebenso wird der Benutzer auf die nächste und letzte Seite verschoben. Fügen Sie die vier LinkButton-Steuerelemente unterhalb von UserAccounts GridView hinzu.

<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>

Erstellen Sie als Nächstes einen Ereignishandler für jedes Der LinkButton-Ereignisse Click .

Abbildung 7 zeigt die vier LinkButtons, wenn sie über die Entwurfsansicht von Visual Web Developer angezeigt werden.

Abbildung 7: Hinzufügen der Schaltflächen "First", "Previous", "Next" und "Last LinkButtons" unterhalb der GridView (Klicken Sie hier, um das bild in voller Größe anzuzeigen)

Nachverfolgen des aktuellen Seitenindex

Wenn ein Benutzer die ManageUsers.aspx Seite zum ersten Mal besucht oder auf eine der Filterschaltflächen klickt, soll die erste Seite der Daten in GridView angezeigt werden. Wenn der Benutzer jedoch auf eine der LinkButtons der Navigation klickt, müssen wir den Seitenindex aktualisieren. Um den Seitenindex und die Anzahl der pro Seite anzuzeigenden Datensätze beizubehalten, fügen Sie der CodeBehind-Klasse der Seite die folgenden beiden Eigenschaften hinzu:

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;
 }
}

Wie die UsernameToMatch -Eigenschaft behält die PageIndex Eigenschaft ihren Wert zum Anzeigen des Zustands bei. Die schreibgeschützte PageSize Eigenschaft gibt den hartcodierten Wert 10 zurück. Ich lade den interessierten Leser ein, diese Eigenschaft so zu aktualisieren, dass sie dasselbe Muster wie PageIndexverwendet, und dann die ManageUsers.aspx Seite so zu erweitern, dass die Person, die die Seite besucht, angeben kann, wie viele Benutzerkonten pro Seite angezeigt werden sollen.

Abrufen der Datensätze der aktuellen Seite, Aktualisieren des Seitenindexes und Aktivieren und Deaktivieren der LinkButtons-Pagingschnittstelle

Nachdem die Pagingschnittstelle vorhanden ist und die PageIndex Eigenschaften und PageSize hinzugefügt wurden, können wir die BindUserAccounts Methode aktualisieren, sodass sie die entsprechende FindUsersByName Überladung verwendet. Darüber hinaus muss diese Methode die Pagingschnittstelle je nach angezeigter Seite aktivieren oder deaktivieren. Beim Anzeigen der ersten Datenseite sollten die Links "Erster" und "Vorheriger" deaktiviert werden. Next und Last sollten beim Anzeigen der letzten Seite deaktiviert werden.

Aktualisieren Sie die BindUserAccounts-Methode mit folgendem Code:

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;
}

Beachten Sie, dass die Gesamtanzahl der Datensätze, die ausgelagert werden, durch den letzten Parameter der FindUsersByName -Methode bestimmt wird. Dies ist ein out Parameter. Daher müssen wir zuerst eine Variable deklarieren, um diesen Wert (totalRecords) zu enthalten, und dann dem out Schlüsselwort (keyword) voranzustellen.

Nachdem die angegebene Seite der Benutzerkonten zurückgegeben wurde, sind die vier LinkButtons entweder aktiviert oder deaktiviert, je nachdem, ob die erste oder letzte Seite der Daten angezeigt wird.

Der letzte Schritt besteht darin, den Code für die vier LinkButtons-Ereignishandler Click zu schreiben. Diese Ereignishandler müssen die PageIndex -Eigenschaft aktualisieren und dann die Daten über einen Aufruf von an BindUserAccountsgridView neu binden. Die Ereignishandler First, Previous und Next sind sehr einfach. Der Click Ereignishandler für den Last LinkButton ist jedoch etwas komplexer, da wir bestimmen müssen, wie viele Datensätze angezeigt werden, um den Index der letzten Seite zu bestimmen.

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();
}

Abbildungen 8 und 9 zeigen die benutzerdefinierte Pagingschnittstelle in Aktion. Abbildung 8 zeigt die ManageUsers.aspx Seite beim Anzeigen der ersten Datenseite für alle Benutzerkonten. Beachten Sie, dass nur 10 der 13 Konten angezeigt werden. Wenn Sie auf den Link Weiter oder Zuletzt klicken, wird ein Postback ausgeführt, der PageIndex auf 1 aktualisiert und die zweite Seite der Benutzerkonten an das Raster gebunden (siehe Abbildung 9).

Abbildung 8: Die ersten 10 Benutzerkonten werden angezeigt (Klicken Sie, um das bild in voller Größe anzuzeigen)

Abbildung 9: Klicken auf den nächsten Link Zeigt die zweite Seite der Benutzerkonten an (Klicken, um das bild in voller Größe anzuzeigen)

Zusammenfassung

Administratoren müssen häufig einen Benutzer aus der Liste der Konten auswählen. In früheren Tutorials haben wir die Verwendung einer Dropdownliste mit den Benutzern untersucht, aber dieser Ansatz lässt sich nicht gut skalieren. In diesem Tutorial haben wir eine bessere Alternative untersucht: eine filterbare Schnittstelle, deren Ergebnisse in einer ausgelagerten GridView angezeigt werden. Mit dieser Benutzeroberfläche können Administratoren schnell und effizient ein Benutzerkonto unter Tausenden finden und auswählen.

Viel Spaß beim Programmieren!

Weitere Informationen

Weitere Informationen zu den in diesem Tutorial erläuterten Themen finden Sie in den folgenden Ressourcen:

• Benutzerdefinierte Paging in ASP.NET mit SQL Server 2005
• Effizientes Paging durch große Datenmengen

Zum Autor

Scott Mitchell, Autor mehrerer ASP/ASP.NET-Bücher und Gründer von 4GuysFromRolla.com, arbeitet seit 1998 mit Microsoft-Webtechnologien. Scott arbeitet als unabhängiger Berater, Trainer und Autor. Sein neuestes Buch ist Sams Teach Yourself ASP.NET 2.0 in 24 Stunden. Scott kann unter mitchell@4guysfromrolla.com oder über seinen Blog unter http://ScottOnWriting.NETerreicht werden.

Besonderen Dank an

Diese Tutorialreihe wurde von vielen hilfreichen Prüfern überprüft. Lead Reviewer für dieses Tutorial war Alicja Maziarz. Möchten Sie meine anstehenden MSDN-Artikel lesen? Wenn dies der Fall ist, legen Sie mir eine Zeile unter mitchell@4GuysFromRolla.com

Nächste