Erstellen eines benutzerdefinierten Anbieters für datenbankgesteuerte Siteübersichten (VB)

von Scott Mitchell

PDF herunterladen

Der Standardmäßige Websitezuordnungsanbieter in ASP.NET 2.0 ruft seine Daten aus einer statischen XML-Datei ab. Während der XML-basierte Anbieter für viele kleine und mittelgroße Websites geeignet ist, benötigen größere Webanwendungen eine dynamischere Sitemap. In diesem Tutorial erstellen wir einen benutzerdefinierten Sitemap-Anbieter, der seine Daten aus der Business-Logik-Schicht abruft, die wiederum Daten aus der Datenbank abruft.

Einführung

ASP.NET 2.0s Sitemap-Funktion ermöglicht es einem Seitenentwickler, eine Sitemap einer Webanwendung in einem dauerhaften Medium zu definieren, z. B. in einer XML-Datei. Nach der Definition kann auf die Website-Struktur-Daten programmgesteuert über die SiteMap Klasse im System.Web Namespace oder über eine Vielzahl von Navigations-Websteuerelementen, z. B. die SiteMapPath, Menü und TreeView Steuerelemente, zugegriffen werden. Das Sitemapsystem nutzt das Providermodell, sodass verschiedene Implementierungen der Sitemap-Serialisierung erstellt und in eine Webanwendung eingebunden werden können. Der standardmäßige Sitemap-Anbieter, der mit ASP.NET 2.0 ausgeliefert wird, speichert die Struktur der Site-Mapping in einer XML-Datei. Im Rahmen des Lernprogramms "Gestaltungsvorlagen" und "Website-Navigation" haben wir eine Datei mit dem Namen Web.sitemap erstellt, die diese Struktur enthielt und deren XML mit jedem neuen Tutorialabschnitt aktualisiert wurde.

Der standardmäßige XML-basierte Sitemap-Provider funktioniert gut, wenn die Struktur der Sitemap relativ statisch ist, z. B. für diese Lernprogramme. In vielen Szenarien ist jedoch eine dynamischere Standortkarte erforderlich. Betrachten Sie die in Abbildung 1 dargestellte Websitekarte, in der jede Kategorie und jedes Produkt als Abschnitte in der Websitestruktur angezeigt werden. Wenn Sie diese Websiteübersicht verwenden, könnte der Besuch der Webseite, die dem Stammknoten entspricht, alle Kategorien auflisten, während der Besuch einer bestimmten Kategorie-Webseite die Produkte dieser Kategorie auflistet und die Webseite eines bestimmten Produkts die Produktdetails anzeigt.

Die Kategorien und Produkte bilden die Struktur der Sitemap.

Abbildung 1: Die Kategorien und Produkte bilden die Struktur der Websiteübersicht (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Obwohl diese kategorie- und produktbasierte Struktur in der Web.sitemap Datei hartcodiert werden konnte, muss die Datei jedes Mal aktualisiert werden, wenn eine Kategorie oder ein Produkt hinzugefügt, entfernt oder umbenannt wurde. Folglich würde die Wartung der Websiteübersicht erheblich vereinfacht, wenn ihre Struktur aus der Datenbank oder idealerweise aus der Business Logic Layer der Anwendungsarchitektur abgerufen wurde. Auf diese Weise würde die Websiteübersicht automatisch aktualisiert, da Produkte und Kategorien hinzugefügt, umbenannt oder gelöscht wurden.

Da die Sitemap-Serialisierung von ASP.NET 2.0 auf dem Anbietermodell basiert, können wir einen eigenen benutzerdefinierten Sitemap-Anbieter erstellen, der seine Daten aus einem alternativen Datenspeicher abruft, z. B. einer Datenbank oder einer anderen Architektur. In diesem Tutorial werden wir einen benutzerdefinierten Anbieter erstellen, der seine Daten aus der BLL abruft. Los geht's!

Schritt 1: Erstellen der Webseiten des benutzerdefinierten Sitemapanbieters

Bevor wir mit dem Erstellen eines benutzerdefinierten Websiteübersichtsanbieters beginnen, fügen wir zunächst die ASP.NET Seiten hinzu, die wir für dieses Lernprogramm benötigen. Beginnen Sie mit dem Hinzufügen eines neuen Ordners mit dem Namen SiteMapProvider. Fügen Sie als Nächstes die folgenden ASP.NET Seiten zu diesem Ordner hinzu, und stellen Sie sicher, dass jede Seite der Site.master Gestaltungsvorlage zugeordnet wird:

• Default.aspx
• ProductsByCategory.aspx
• ProductDetails.aspx

Fügen Sie dem CustomProviders Ordner auch einen App_Code Unterordner hinzu.

Abbildung 2: Hinzufügen der ASP.NET Seiten für anbieterbezogene Lernprogramme zur Websitezuordnung

Da es nur ein Lernprogramm für diesen Abschnitt gibt, müssen Default.aspx wir die Lernprogramme des Abschnitts nicht auflisten. Default.aspx Stattdessen werden die Kategorien in einem GridView-Steuerelement angezeigt. Wir werden dies in Schritt 2 angehen.

Aktualisieren Sie als Nächstes Web.sitemap, um einen Verweis auf die Seite Default.aspx einzuschließen. Fügen Sie insbesondere das folgende Markup nach dem Zwischenspeichern <siteMapNode>hinzu:

<siteMapNode 
    title="Customizing the Site Map" url="~/SiteMapProvider/Default.aspx" 
    description="Learn how to create a custom provider that retrieves the site map 
                 from the Northwind database." />

Nehmen Sie sich nach dem Aktualisieren Web.sitemap einen Moment Zeit, um die Tutorials-Website in einem Browser anzuzeigen. Das Menü auf der linken Seite enthält nun ein Element für das einzige Sitemap-Anbietertutorial.

Abbildung 3: Die Sitemap enthält jetzt einen Eintrag für das Tutorial zum Sitemap-Anbieter.

Dieser Schwerpunkt dieses Lernprogramms besteht darin, das Erstellen eines benutzerdefinierten Websitezuordnungsanbieters zu veranschaulichen und eine Webanwendung für die Verwendung dieses Anbieters zu konfigurieren. Insbesondere erstellen wir einen Anbieter, der eine Websitekarte zurückgibt, die einen Stammknoten zusammen mit einem Knoten für jede Kategorie und jedes Produkt enthält, wie in Abbildung 1 dargestellt. Jeder Knoten in der Sitemap kann im Allgemeinen eine URL angeben. Für unsere Sitemap lautet die URL des Stammknotens ~/SiteMapProvider/Default.aspx, die alle Kategorien in der Datenbank auflistet. Jeder Kategorieknoten in der Sitemap hat eine URL, die auf ~/SiteMapProvider/ProductsByCategory.aspx?CategoryID=categoryID verweist, über die alle Produkte in der angegebenen Kategorie-ID aufgeführt werden. Schließlich verweist jeder Produkt-Sitemapknoten auf ~/SiteMapProvider/ProductDetails.aspx?ProductID=productID, der die spezifischen Produktdetails anzeigt.

Um zu beginnen, müssen wir die Default.aspx, ProductsByCategory.aspxund ProductDetails.aspx Seiten erstellen. Diese Seiten werden in den Schritten 2, 3 und 4 jeweils abgeschlossen. Da der Schwerpunkt dieses Lernprogramms auf Anbietern von Sitemaps liegt und in früheren Lernprogrammen die Erstellung solcher mehrseitigen Master-/Detailberichte behandelt wurde, werden wir die Schritte 2 bis 4 schnell durchgehen. Wenn Sie eine Auffrischung zum Erstellen von Master-/Detailberichten benötigen, die sich über mehrere Seiten erstrecken, lesen Sie das Lernprogramm „Master/Detailfilterung über zwei Seiten“.

Schritt 2: Anzeigen einer Liste von Kategorien

Öffnen Sie die Default.aspx-Seite im SiteMapProvider-Ordner, ziehen Sie eine GridView aus der Toolbox auf den Designer und setzen Sie ihr ID auf Categories. Binden Sie das Smarttag von GridView an eine neue ObjectDataSource namens CategoriesDataSource und konfigurieren Sie sie so, dass sie ihre Daten mithilfe der CategoriesBLL-Klasse und ihrer GetCategories-Methode abruft. Da diese GridView nur die Kategorien anzeigt und keine Datenänderungsfunktionen bereitstellt, legen Sie die Dropdownlisten in den Registerkarten UPDATE, INSERT und DELETE auf (Keine) fest.

Abbildung 4: Konfigurieren der ObjectDataSource zum Zurückgeben von Kategorien mithilfe der GetCategories Methode (Klicken, um das Bild in voller Größe anzuzeigen)

Abbildung 5: Festlegen der Dropdownlisten in den Registerkarten UPDATE, INSERT und DELETE auf (Keine) (Klicken, um das Bild in voller Größe anzuzeigen)

Nach Abschluss des Assistenten zum Konfigurieren von Datenquellen fügt Visual Studio ein BoundField für CategoryID, CategoryName, Description, NumberOfProducts und BrochurePath hinzu. Bearbeiten Sie die GridView so, dass sie nur die CategoryName- und Description-BoundFields enthält, und aktualisieren Sie die Eigenschaft HeaderText des CategoryName-BoundField zu „Category“.

Fügen Sie als Nächstes ein HyperLinkField hinzu und positionieren Sie es so, dass es das linkeste Feld ist. Legen Sie die DataNavigateUrlFields-Eigenschaft auf CategoryID und die DataNavigateUrlFormatString-Eigenschaft auf ~/SiteMapProvider/ProductsByCategory.aspx?CategoryID={0} fest. Legen Sie die Text Eigenschaft auf "Produkte anzeigen" fest.

Abbildung 6: Hinzufügen eines HyperLinkFields Categories zur GridView

Nach dem Erstellen der ObjectDataSource und dem Anpassen der GridView-Felder sehen die beiden deklarativen Steuerelemente wie folgt aus:

<asp:GridView ID="Categories" runat="server" AutoGenerateColumns="False" 
    DataKeyNames="CategoryID" DataSourceID="CategoriesDataSource" 
    EnableViewState="False">
    <Columns>
        <asp:HyperLinkField DataNavigateUrlFields="CategoryID" 
            DataNavigateUrlFormatString=
                "~/SiteMapProvider/ProductsByCategory.aspx?CategoryID={0}"
            Text="View Products" />
        <asp:BoundField DataField="CategoryName" HeaderText="Category" 
            SortExpression="CategoryName" />
        <asp:BoundField DataField="Description" HeaderText="Description" 
            SortExpression="Description" />
    </Columns>
</asp:GridView>
<asp:ObjectDataSource ID="CategoriesDataSource" runat="server" 
    OldValuesParameterFormatString="original_{0}" SelectMethod="GetCategories" 
    TypeName="CategoriesBLL"></asp:ObjectDataSource>

Abbildung 7 zeigt Default.aspx, wenn es über einen Browser betrachtet wird. Wenn Sie auf den Link "Produkte anzeigen" einer Kategorie klicken, gelangen Sie zu ProductsByCategory.aspx?CategoryID=categoryID, den wir in Schritt 3 erstellen werden.

Abbildung 7: Jede Kategorie wird zusammen mit einem Link "Produkte anzeigen" aufgelistet (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Schritt 3: Auflisten der Produkte der ausgewählten Kategorie

Öffnen Sie die ProductsByCategory.aspx Seite, und fügen Sie eine GridView hinzu, wobei sie ProductsByCategorybenannt wird. Binden Sie das GridView-Element von seinem Smarttag an eine neue ObjectDataSource mit dem Namen ProductsByCategoryDataSource. Konfigurieren Sie objectDataSource so, dass sie die Methode der ProductsBLL Klasse GetProductsByCategoryID(categoryID) verwendet, und legen Sie die Dropdownlisten auf (Keine) auf den Registerkarten UPDATE, INSERT und DELETE fest.

Abbildung 8: Verwenden der Methode der ProductsBLL Klasse GetProductsByCategoryID(categoryID) (Zum Anzeigen des Bildes in voller Größe klicken)

Der letzte Schritt im Assistenten zum Konfigurieren der Datenquelle fragt nach einer Parameterquelle für categoryID. Da diese Informationen über das Abfragezeichenfolgenfeld CategoryIDübergeben werden, wählen Sie "QueryString" aus der Dropdownliste aus, und geben Sie "CategoryID" in das Textfeld "QueryStringField" ein, wie in Abbildung 9 dargestellt. Klicken Sie auf Fertig stellen, um den Assistenten abzuschließen.

Abbildung 9: Verwenden des CategoryID Abfragezeichenfolgenfelds für den CategoryID-Parameter (Klicken, um das Bild in voller Größe anzuzeigen)

Nach Abschluss des Assistenten fügt Visual Studio die entsprechenden gebundenen Felder und ein Kontrollkästchenfeld für die Produktdatenfelder zur GridView hinzu. Entfernen Sie alle außer den ProductName, UnitPrice und SupplierName BoundFields. Passen Sie diese drei BoundFields-Eigenschaften HeaderText an, um Produkt, Preis und Lieferant zu lesen. Formatieren Sie das UnitPrice BoundField als Währung.

Fügen Sie als Nächstes ein HyperLinkField hinzu, und verschieben Sie es an die linksste Position. Legen Sie die Text Eigenschaft auf "Details anzeigen", dessen DataNavigateUrlFields Eigenschaft auf ProductID und dessen DataNavigateUrlFormatString Eigenschaft auf ~/SiteMapProvider/ProductDetails.aspx?ProductID={0} fest.

Abbildung 10: Hinzufügen eines HyperLinkFields für Ansichtsdetails, das auf ProductDetails.aspx

Nachdem Sie diese Anpassungen vorgenommen haben, sollte das deklarative Markup von GridView und ObjectDataSource wie folgt aussehen:

<asp:GridView ID="ProductsByCategory" runat="server" AutoGenerateColumns="False"
    DataKeyNames="ProductID" DataSourceID="ProductsByCategoryDataSource" 
    EnableViewState="False">
    <Columns>
        <asp:HyperLinkField DataNavigateUrlFields="ProductID" 
            DataNavigateUrlFormatString=
                "~/SiteMapProvider/ProductDetails.aspx?ProductID={0}"
            Text="View Details" />
        <asp:BoundField DataField="ProductName" HeaderText="Product"
            SortExpression="ProductName" />
        <asp:BoundField DataField="UnitPrice" DataFormatString="{0:c}" 
            HeaderText="Price" HtmlEncode="False" 
            SortExpression="UnitPrice" />
        <asp:BoundField DataField="SupplierName" HeaderText="Supplier" 
            ReadOnly="True" SortExpression="SupplierName" />
    </Columns>
</asp:GridView>
<asp:ObjectDataSource ID="ProductsByCategoryDataSource" runat="server" 
    OldValuesParameterFormatString="original_{0}"
    SelectMethod="GetProductsByCategoryID" TypeName="ProductsBLL">
    <SelectParameters>
        <asp:QueryStringParameter Name="categoryID" 
            QueryStringField="CategoryID" Type="Int32" />
    </SelectParameters>
</asp:ObjectDataSource>

Kehren Sie im Browser zu Default.aspx zurück und klicken Sie auf den Link "Produkte anzeigen" für Getränke. Dadurch gelangen Sie zu ProductsByCategory.aspx?CategoryID=1, wo die Namen, Preise und Lieferanten der Produkte in der Northwind-Datenbank angezeigt werden, die zur Kategorie "Getränke" gehören (siehe Abbildung 11). Sie können diese Seite weiter verbessern, um einen Link zur Kategorieauflistungsseite (Default.aspx) sowie ein DetailsView- oder FormView-Steuerelement einzuschließen, das den Namen und die Beschreibung der ausgewählten Kategorie anzeigt.

Abbildung 11: Die Getränkenamen, Preise und Lieferanten werden angezeigt (Zum Anzeigen des Bilds "Vollbild" klicken)

Schritt 4: Anzeigen der Produktdetails

Auf der letzten Seite ProductDetails.aspxwerden die ausgewählten Produktdetails angezeigt. Öffnen Sie ProductDetails.aspx und ziehen Sie eine DetailsView aus der Toolbox auf den Designer. Legen Sie die Eigenschaft des DetailsView ID auf ProductInfo fest und löschen Sie die Werte der Eigenschaften Height und Width. Binden Sie das DetailsView-Element von seinem Smarttag an eine neue ObjectDataSource mit dem Namen ProductDataSource, wobei die ObjectDataSource so konfiguriert wird, dass die Daten aus der Methode der ProductsBLL Klasse GetProductByProductID(productID) abgerufen werden. Wie bei den vorherigen Webseiten, die in Schritt 2 und 3 erstellt wurden, legen Sie die Dropdownlisten in den Registerkarten UPDATE, INSERT und DELETE auf (Keine) fest.

Abbildung 12: Konfigurieren der ObjectDataSource für die Verwendung der GetProductByProductID(productID) Methode (Klicken, um das Bild in voller Größe anzuzeigen)

Der letzte Schritt des Assistenten zum Konfigurieren der Datenquelle fordert zur Angabe der Quelle des productID-Parameters auf. Da diese Daten durch das Abfragezeichenfolgenfeld ProductIDkommen, legen Sie die Dropdownliste auf QueryString und das QueryStringField-Textfeld auf "ProductID" fest. Klicken Sie abschließend auf die Schaltfläche "Fertig stellen", um den Assistenten abzuschließen.

Abbildung 13: Konfigurieren des productID-Parameters zum Abrufen des Werts aus dem ProductID Abfragezeichenfolgenfeld (Klicken Sie, um das Bild in voller Größe anzuzeigen)

Nach Abschluss des Assistenten zum Konfigurieren von Datenquellen erstellt Visual Studio entsprechende BoundFields und ein CheckBoxField in der DetailsView für die Produktdatenfelder. Entfernen Sie die ProductID, SupplierIDund CategoryID BoundFields, und konfigurieren Sie die verbleibenden Felder, wie Sie sehen. Nach einer Handvoll ästhetischer Konfigurationen sah mein deklaratives Markup von DetailsView und ObjectDataSource wie folgt aus:

<asp:DetailsView ID="ProductInfo" runat="server" AutoGenerateRows="False" 
    DataKeyNames="ProductID" DataSourceID="ProductDataSource" 
    EnableViewState="False">
    <Fields>
        <asp:BoundField DataField="ProductName" HeaderText="Product" 
            SortExpression="ProductName" />
        <asp:BoundField DataField="CategoryName" HeaderText="Category" 
            ReadOnly="True" SortExpression="CategoryName" />
        <asp:BoundField DataField="SupplierName" HeaderText="Supplier" 
            ReadOnly="True" SortExpression="SupplierName" />
        <asp:BoundField DataField="QuantityPerUnit" HeaderText="Qty/Unit" 
            SortExpression="QuantityPerUnit" />
        <asp:BoundField DataField="UnitPrice" DataFormatString="{0:c}" 
            HeaderText="Price" HtmlEncode="False" 
            SortExpression="UnitPrice" />
        <asp:BoundField DataField="UnitsInStock" HeaderText="Units In Stock" 
            SortExpression="UnitsInStock" />
        <asp:BoundField DataField="UnitsOnOrder" HeaderText="Units On Order" 
            SortExpression="UnitsOnOrder" />
        <asp:BoundField DataField="ReorderLevel" HeaderText="Reorder Level" 
            SortExpression="ReorderLevel" />
        <asp:CheckBoxField DataField="Discontinued" HeaderText="Discontinued" 
            SortExpression="Discontinued" />
    </Fields>
</asp:DetailsView>
<asp:ObjectDataSource ID="ProductDataSource" runat="server" 
    OldValuesParameterFormatString="original_{0}"
    SelectMethod="GetProductByProductID" TypeName="ProductsBLL">
    <SelectParameters>
        <asp:QueryStringParameter Name="productID" 
            QueryStringField="ProductID" Type="Int32" />
    </SelectParameters>
</asp:ObjectDataSource>

Um diese Seite zu testen, kehren Sie zur Default.aspx Kategorie "Getränke" zurück, und klicken Sie auf "Produkte anzeigen". Klicken Sie in der Liste der Getränkeprodukte auf den Link "Details anzeigen" für Chai Tea. Dadurch werden Sie zu ProductDetails.aspx?ProductID=1 weitergeleitet, wo die Details eines Chai-Tees angezeigt werden (siehe Abbildung 14).

Abbildung 14: Chai Teas Lieferant, Kategorie, Preis und andere Informationen werden angezeigt (Zum Anzeigen des Bilds mit voller Größe klicken)

Schritt 5: Grundlegendes zur inneren Funktionsweise eines Websitekartenanbieters

Die Sitemap wird im Arbeitsspeicher des Webservers als eine Sammlung von SiteMapNode Instanzen dargestellt, die eine Hierarchie bilden. Es muss genau ein Stamm vorhanden sein, alle Nicht-Stammknoten müssen genau einen übergeordneten Knoten aufweisen, und alle Knoten verfügen möglicherweise über eine beliebige Anzahl untergeordneter Elemente. Jedes SiteMapNode Objekt stellt einen Abschnitt in der Websitestruktur dar; diese Abschnitte weisen häufig eine entsprechende Webseite auf. Folglich verfügt die SiteMapNode Klasse über Eigenschaften wie Title, Url, und Description, die Informationen für den Abschnitt bereitstellen, das die SiteMapNode repräsentiert. Es gibt auch eine Key Eigenschaft, die jede SiteMapNode in der Hierarchie eindeutig identifiziert, sowie Eigenschaften, die verwendet werden, um diese Hierarchie ChildNodes, , ParentNode, NextSibling, PreviousSiblingusw. zu erstellen.

Abbildung 15 zeigt die allgemeine Struktur der Websiteübersicht aus Abbildung 1, aber mit den Implementierungsdetails, die in detaillierteren Details skizziert wurden.

Abbildung 15: Jede SiteMapNode enthält Eigenschaften wie Title, Url, usw Key. (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Auf die Websiteübersicht kann über die SiteMap Klasse im System.Web Namespace zugegriffen werden. Diese Eigenschaft der Klasse RootNode gibt die Wurzelinstanz der Sitemap SiteMapNode zurück; CurrentNode gibt die SiteMapNode-Instanz zurück, deren Url-Eigenschaft der URL der aktuell angeforderten Seite entspricht. Diese Klasse wird intern von ASP.NET 2.0-Navigationswebsteuerelementen verwendet.

Wenn auf die Eigenschaften der SiteMap-Klasse zugegriffen wird, muss sie die Struktur der Sitemap von einem persistenten Medium in den Arbeitsspeicher serialisieren. Die Serialisierungslogik für die Sitemap ist jedoch nicht fest in die SiteMap Klasse codiert. Stattdessen bestimmt die SiteMap-Klasse zur Laufzeit, welcher Site-Map-Anbieter für die Serialisierung verwendet werden soll. Standardmäßig wird die XmlSiteMapProvider Klasse verwendet, die die Struktur der Sitemap aus einer ordnungsgemäß formatierten XML-Datei liest. Mit etwas Arbeit können wir jedoch unseren eigenen benutzerdefinierten Sitemap-Anbieter erstellen.

Alle Sitemap-Anbieter müssen von der SiteMapProvider Klasse abgeleitet werden, die die wesentlichen Methoden und Eigenschaften enthält, die für Sitemap-Anbieter erforderlich sind, jedoch viele der Implementierungsdetails auslässt. Eine zweite Klasse erweitert StaticSiteMapProviderdie SiteMapProvider Klasse und enthält eine robustere Implementierung der erforderlichen Funktionen. Intern speichert die StaticSiteMapProviderSiteMapNode-Instanzen der Websiteübersicht in einem Hashtable und stellt Methoden wie AddNode(child, parent), RemoveNode(siteMapNode), und Clear() bereit, die SiteMapNode-Elemente zum internen Hashtable hinzufügen und entfernen. XmlSiteMapProvider wird von StaticSiteMapProvider abgeleitet.

Beim Erstellen eines benutzerdefinierten Site-Map-Anbieters, der StaticSiteMapProvider erweitert, gibt es zwei abstrakte Methoden, die überschrieben werden müssen: BuildSiteMap und GetRootNodeCore. BuildSiteMap, entsprechend seinem Namen, ist dafür verantwortlich, die Sitemap-Struktur aus dem persistenten Speicher zu laden und sie im Arbeitsspeicher zu erstellen. GetRootNodeCore gibt den Stammknoten in der Sitemap zurück.

Bevor eine Webanwendung einen Websitezuordnungsanbieter verwenden kann, muss er in der Anwendungskonfiguration registriert werden. Standardmäßig wird die XmlSiteMapProvider Klasse mit dem Namen AspNetXmlSiteMapProviderregistriert. Um zusätzliche Websiteübersichtsanbieter zu registrieren, fügen Sie das folgende Markup zu Web.config hinzu:

<configuration>
    <system.web>
        ...
        <siteMap defaultProvider="defaultProviderName">
          <providers>
            <add name="name" type="type" />
          </providers>
        </siteMap>
    </system.web>
</configuration>

Der Name-Wert weist dem Anbieter einen lesbaren Namen zu, während der Typ den vollqualifizierten Typnamen des Sitemap-Anbieters angibt. Wir werden konkrete Werte für den Namen und die Typwerte in Schritt 7 untersuchen, nachdem wir unseren benutzerdefinierten Sitemapanbieter erstellt haben.

Die Sitemap-Anbieterklasse wird instanziiert, wenn sie zum ersten Mal von der SiteMap Klasse aus aufgerufen wird und verbleibt während der gesamten Lebensdauer der Webanwendung im Arbeitsspeicher. Da es nur eine Instanz des Site-Map-Anbieters gibt, die von mehreren gleichzeitigen Websitebesuchern aufgerufen werden kann, ist es unerlässlich, dass die Methoden des Anbieters threadsicher sind.

Aus Leistungs- und Skalierbarkeitsgründen ist es wichtig, dass wir die Struktur der Speicherwebsitezuordnung zwischenspeichern und diese zwischengespeicherte Struktur zurückgeben, anstatt sie jedes Mal neu zu erstellen, wenn die BuildSiteMap Methode aufgerufen wird. BuildSiteMap kann pro Benutzer bei jeder Seitenanforderung mehrmals aufgerufen werden, abhängig von den Navigationssteuerungselementen, die auf der Seite verwendet werden, und von der Struktur der Sitemap. Auf jeden Fall, wenn wir die Sitemap-Struktur in BuildSiteMap nicht zwischenspeichern, müssen wir jedes Mal, wenn sie aufgerufen wird, die Produkt- und Kategorieinformationen erneut aus der Architektur abrufen (was zu einer Abfrage der Datenbank führen würde). Wie wir in den vorherigen Lernprogrammen zum Zwischenspeichern erläutert haben, können zwischengespeicherte Daten veraltet werden. Um dem entgegenzuwirken, können wir entweder zeit- oder SQL-Cacheabhängigkeitsbasierte Ablaufzeiten verwenden.

Schritt 6: Erstellen des benutzerdefinierten Sitemap-Anbieters

Um einen benutzerdefinierten Sitemap-Anbieter zu erstellen, der die Sitemap aus den Kategorien und Produkten in der Northwind-Datenbank erstellt, müssen wir eine Klasse erstellen, die von StaticSiteMapProvider abgeleitet ist. In Schritt 1 habe ich Sie gebeten, einen CustomProviders Ordner im App_Code Ordner hinzuzufügen, fügen Sie diesem Ordner eine neue Klasse mit dem Namen NorthwindSiteMapProvider hinzu. Fügen Sie der NorthwindSiteMapProvider-Klasse folgenden Code hinzu:

Imports System.Web
Imports System.Web.Caching
Public Class NorthwindSiteMapProvider
    Inherits StaticSiteMapProvider
    Private ReadOnly siteMapLock As New Object()
    Private root As SiteMapNode = Nothing
    Public Const CacheDependencyKey As String = "NorthwindSiteMapProviderCacheDependency"
    Public Overrides Function BuildSiteMap() As System.Web.SiteMapNode
        ' Use a lock to make this method thread-safe
        SyncLock siteMapLock
            ' First, see if we already have constructed the
            ' rootNode. If so, return it...
            If root IsNot Nothing Then
                Return root
            End If
            ' We need to build the site map!
            ' Clear out the current site map structure
            MyBase.Clear()
            ' Get the categories and products information from the database
            Dim productsAPI As New ProductsBLL()
            Dim products As Northwind.ProductsDataTable = productsAPI.GetProducts()
            ' Create the root SiteMapNode
            root = New SiteMapNode( _
                Me, "root", "~/SiteMapProvider/Default.aspx", "All Categories")
            AddNode(root)
            ' Create SiteMapNodes for the categories and products
            For Each product As Northwind.ProductsRow In products
                ' Add a new category SiteMapNode, if needed
                Dim categoryKey, categoryName As String
                Dim createUrlForCategoryNode As Boolean = True
                If product.IsCategoryIDNull() Then
                    categoryKey = "Category:None"
                    categoryName = "None"
                    createUrlForCategoryNode = False
                Else
                    categoryKey = String.Concat("Category:", product.CategoryID)
                    categoryName = product.CategoryName
                End If
                Dim categoryNode As SiteMapNode = FindSiteMapNodeFromKey(categoryKey)
                ' Add the category SiteMapNode if it does not exist
                If categoryNode Is Nothing Then
                    Dim productsByCategoryUrl As String = String.Empty
                    If createUrlForCategoryNode Then
                        productsByCategoryUrl = _
                            "~/SiteMapProvider/ProductsByCategory.aspx?CategoryID=" & _
                            product.CategoryID
                    End If
                    categoryNode = New SiteMapNode _
                        (Me, categoryKey, productsByCategoryUrl, categoryName)
                    AddNode(categoryNode, root)
                End If
                ' Add the product SiteMapNode
                Dim productUrl As String = _
                    "~/SiteMapProvider/ProductDetails.aspx?ProductID=" & _
                    product.ProductID
                Dim productNode As New SiteMapNode _
                    (Me, String.Concat("Product:", product.ProductID), _
                    productUrl, product.ProductName)
                AddNode(productNode, categoryNode)
            Next
            ' Add a "dummy" item to the cache using a SqlCacheDependency
            ' on the Products and Categories tables
            Dim productsTableDependency As New _
                System.Web.Caching.SqlCacheDependency("NorthwindDB", "Products")
            Dim categoriesTableDependency As New _
                System.Web.Caching.SqlCacheDependency("NorthwindDB", "Categories")
            ' Create an AggregateCacheDependency
            Dim aggregateDependencies As New System.Web.Caching.AggregateCacheDependency()
            aggregateDependencies.Add(productsTableDependency, categoriesTableDependency)
            ' Add the item to the cache specifying a callback function
            HttpRuntime.Cache.Insert( _
                CacheDependencyKey, DateTime.Now, aggregateDependencies, _
                Cache.NoAbsoluteExpiration, Cache.NoSlidingExpiration, _
                CacheItemPriority.Normal, AddressOf OnSiteMapChanged)
            ' Finally, return the root node
            Return root
        End SyncLock
    End Function
    Protected Overrides Function GetRootNodeCore() As System.Web.SiteMapNode
        Return BuildSiteMap()
    End Function
    Protected Sub OnSiteMapChanged _
    (key As String, value As Object, reason As CacheItemRemovedReason)
        SyncLock siteMapLock
            If String.Compare(key, CacheDependencyKey) = 0 Then
                ' Refresh the site map
                root = Nothing
            End If
        End SyncLock
    End Sub
    Public ReadOnly Property CachedDate() As Nullable(Of DateTime)
        Get
            Dim value As Object = HttpRuntime.Cache(CacheDependencyKey)
            If value Is Nothing OrElse Not TypeOf value Is Nullable(Of DateTime) Then
                Return Nothing
            Else
                Return CType(value, Nullable(Of DateTime))
            End If
        End Get
    End Property
End Class

Beginnen wir mit der Erkundung dieser Klassenmethode BuildSiteMap , die mit einer lock Anweisung beginnt. Die lock-Anweisung erlaubt es jeweils nur einem Thread, in den Code einzutreten, wodurch der Zugriff auf den Code serialisiert wird und verhindert wird, dass zwei gleichzeitige Threads sich in die Quere kommen.

Die Variable SiteMapNode auf Klassenebene root wird verwendet, um die Sitemap-Struktur zu speichern. Wenn die Sitemap zum ersten Mal erstellt wird oder zum ersten Mal nach der Änderung der zugrunde liegenden Daten erstellt wird, rootNothing wird die Struktur der Websiteübersicht erstellt. Der Stammknoten der Websiteübersicht wird während des Konstruktionsprozesses an root zugewiesen, sodass beim nächsten Aufruf dieser Methode root nicht Nothing ist. Solange root nicht Nothing ist, wird die Sitemap-Struktur an den Aufrufer zurückgegeben, ohne dass sie neu erstellt werden muss.

Wenn der Root Nothing ist, wird die Sitemap-Struktur aus den Produkt- und Kategorieinformationen erstellt. Die Sitemap wird erstellt, indem die SiteMapNode Instanzen erstellt und dann die Hierarchie durch Aufrufe der Methode AddNode der StaticSiteMapProvider Klasse gebildet wird. AddNode führt die interne Buchführung aus und speichert die sortierten SiteMapNode Instanzen in einer Hashtable. Bevor wir mit dem Erstellen der Hierarchie beginnen, rufen wir zunächst die Clear Methode auf, die die Elemente aus dem internen HashtableLöscht. Als Nächstes werden die ProductsBLL-Klassenmethode und das resultierende ProductsDataTable in lokalen Variablen gespeichert.

Die Konstruktion der Sitemap beginnt mit dem Erstellen des Stammknotens und seiner Zuweisung an root. Die hier und im gesamten BuildSiteMap verwendete Überladung des SiteMapNode Konstruktors erhält die folgenden Informationen übergeben:

• Ein Verweis auf den Sitemap-Anbieter (Me).
• Die SiteMapNode s Key. Dieser erforderliche Wert muss für jeden SiteMapNodeeindeutigen Wert sein.
• Die SiteMapNode s Url. Url ist optional, aber wenn angegeben, muss jeder SiteMapNode s-Wert Url eindeutig sein.
• Das SiteMapNode s Title ist erforderlich.

Der AddNode(root) Methodenaufruf fügt die SiteMapNoderoot Sitemap als Stamm hinzu. Als Nächstes wird jede ProductRow in der ProductsDataTable durchgezählt. Wenn bereits eine SiteMapNode für die aktuelle Produktkategorie vorhanden ist, wird darauf verwiesen. Andernfalls wird eine neue SiteMapNode für die Kategorie erstellt und als untergeordnetes Element des SiteMapNode``root hinzugefügt, indem der Methode AddNode(categoryNode, root) aufgerufen wird. Nachdem der entsprechende Kategorieknoten SiteMapNode gefunden oder erstellt wurde, wird ein SiteMapNode für das aktuelle Produkt erstellt und als untergeordnetes Element der Kategorie SiteMapNode über AddNode(productNode, categoryNode)hinzugefügt. Beachten Sie, dass der Eigenschaftswert der Kategorie SiteMapNodeUrl~/SiteMapProvider/ProductsByCategory.aspx?CategoryID=categoryID ist, während die Eigenschaft SiteMapNode des Produkts Url~/SiteMapNode/ProductDetails.aspx?ProductID=productID zugewiesen ist.

Nach dem Erstellen der Sitemap wird ein willkürliches Objekt mithilfe einer SQL-Cacheabhängigkeit von den Tabellen Categories und Products über ein AggregateCacheDependency-Objekt dem Datencache hinzugefügt. Wir haben die Verwendung von SQL-Cacheabhängigkeiten im vorherigen Lernprogramm unter Verwendung von SQL-Cacheabhängigkeiten untersucht. Der benutzerdefinierte Sitemap-Anbieter verwendet jedoch eine Überladung der Methode im Datencache Insert, die wir noch nicht untersucht haben. Diese Überladung akzeptiert als endgültigen Eingabeparameter einen Delegaten, der aufgerufen wird, wenn das Objekt aus dem Cache entfernt wird. Insbesondere übergeben wir einen neuen CacheItemRemovedCallback Delegaten , der auf die OnSiteMapChanged weiter unten in der NorthwindSiteMapProvider Klasse definierte Methode verweist.

Die Methode BuildSiteMap wird abgeschlossen, indem der Stammknoten der Sitemap zurückgegeben wird.

Die übrigen Methoden sind recht einfach. GetRootNodeCore ist für die Rückgabe des Stammknotens verantwortlich. Da BuildSiteMap den Stamm liefert, gibt GetRootNodeCore einfach den Rückgabewert von BuildSiteMap zurück. Die OnSiteMapChanged-Methode setzt root auf Nothing zurück, wenn das Cache-Element entfernt wird. Wenn der Stamm wieder auf Nothing zurückgesetzt wird, wird beim nächsten Aufruf BuildSiteMap die Sitemap neu aufgebaut. Schließlich gibt die CachedDate Eigenschaft den im Datencache gespeicherten Datums- und Uhrzeitwert zurück, wenn ein solcher Wert vorhanden ist. Diese Eigenschaft kann von einem Seitenentwickler verwendet werden, um zu bestimmen, wann die Websitezuordnungsdaten zuletzt zwischengespeichert wurden.

Schritt 7: Registrierung desNorthwindSiteMapProvider

Damit unsere Webanwendung den in Schritt 6 erstellten Sitemap-Anbieter verwenden kann, müssen wir ihn im Abschnitt <siteMap> von Web.config registrieren. Fügen Sie insbesondere das folgende Markup innerhalb des <system.web> Elements in Web.config hinzu.

<siteMap defaultProvider="AspNetXmlSiteMapProvider">
  <providers>
    <add name="Northwind" type="NorthwindSiteMapProvider" />
  </providers>
</siteMap>

Dieses Markup führt zwei Dinge aus: Erstens gibt es an, dass der integrierte AspNetXmlSiteMapProvider Anbieter der Standard-Sitemap ist. Zweitens registriert es den benutzerdefinierten Sitemap-Anbieter, der in Schritt 6 mit dem benutzerfreundlichen Namen Northwind erstellt wurde.

Nehmen Sie sich nach dem Aktualisieren Web.config einen Moment Zeit, um eine beliebige Seite aus den Tutorials in einem Browser anzusehen. Beachten Sie, dass die Navigationsoberfläche links weiterhin die Abschnitte und Tutorials anzeigt, wie in Web.sitemap definiert. Dies liegt daran, dass wir AspNetXmlSiteMapProvider als Standardanbieter beibehalten haben. Um ein Navigationselement zu erstellen, das das NorthwindSiteMapProvider verwendet, müssen wir explizit angeben, dass der Northwind-Site-Map-Anbieter verwendet werden soll. Dies wird in Schritt 8 erläutert.

Schritt 8: Anzeigen von Websiteübersichtsinformationen mithilfe des benutzerdefinierten Siteübersichtsanbieters

Mit dem benutzerdefinierten Websitekartenanbieter, der in Web.config erstellt und registriert wurde, können wir Navigationssteuerelemente zu den Seiten Default.aspx, ProductsByCategory.aspx und ProductDetails.aspx im Ordner SiteMapProvider hinzufügen. Öffnen Sie zunächst die Default.aspx Seite und ziehen Sie eine SiteMapPath aus der Toolbox auf den Designer. Das SiteMapPath-Steuerelement befindet sich im Navigationsbereich der Toolbox.

Abbildung 16: Hinzufügen eines SiteMapPath-Objekts Default.aspx (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Das SiteMapPath-Steuerelement zeigt ein Breadcrumb an, das die Position der aktuellen Seite innerhalb der Sitemap angibt. Im Tutorial „Master Pages und Site-Navigation“ haben wir oben auf der Masterseite ein SiteMapPath hinzugefügt.

Nehmen Sie sich einen Moment Zeit, um diese Seite in einem Browser anzusehen. Der in Abbildung 16 hinzugefügte SiteMapPath verwendet den Standardmäßigen Websitezuordnungsanbieter und ruft seine Daten aus Web.sitemap. Daher zeigt das Breadcrumb Home > Customizing the Site Map an, genau wie das Breadcrumb in der oberen rechten Ecke.

Abbildung 17: Das Breadcrumb verwendet den standardmäßigen Sitemap-Anbieter (Klicken Sie, um das Bild in voller Größe anzuzeigen)

Damit der SiteMapPath in Abbildung 16 hinzugefügt wird, verwenden Sie den benutzerdefinierten SiteMap-Anbieter, den wir in Schritt 6 erstellt haben, und legen Sie dessen SiteMapProvider-Eigenschaft auf Northwind fest, den Namen, den wir dem NorthwindSiteMapProvider in Web.config zugewiesen haben. Leider verwendet der Designer weiterhin den Standardmäßigen Websitekartenanbieter, aber wenn Sie die Seite über einen Browser besuchen, nachdem Sie diese Eigenschaft geändert haben, sehen Sie, dass der Breadcrumb jetzt den benutzerdefinierten Websitekartenanbieter verwendet.

Abbildung 18: Das Breadcrumb verwendet jetzt den benutzerdefinierten Anbieter für die Seitenübersicht NorthwindSiteMapProvider (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Das SiteMapPath-Steuerelement zeigt eine funktionalere Benutzeroberfläche auf den ProductsByCategory.aspx Und ProductDetails.aspx Seiten an. Fügen Sie diesen Seiten einen SiteMapPath hinzu, und legen Sie die SiteMapProvider-Eigenschaft in beiden auf Northwind fest. Klicken Default.aspx Sie auf den Link "Produkte anzeigen" für Getränke und dann auf den Link "Details anzeigen" für Chai Tea. Wie in Abbildung 19 dargestellt, enthält der Navigationspfad den aktuellen Abschnitt der Sitemap (Chai Tea) und dessen übergeordnete Kategorien: Getränke und Alle Kategorien.

Abbildung 19: Das Breadcrumb verwendet jetzt den benutzerdefinierten Siteübersichtsanbieter NorthwindSiteMapProvider (Klicken Sie hier, um das Bild in voller Größe anzuzeigen)

Andere Navigationsbenutzeroberflächenelemente können zusätzlich zu SiteMapPath verwendet werden, z. B. die Steuerelemente "Menu" und "TreeView". Die Default.aspx, ProductsByCategory.aspx und ProductDetails.aspx Seiten im Download für dieses Tutorial enthalten zum Beispiel alle Menüsteuerelemente (siehe Abbildung 20). Eine ausführlichere Übersicht über die Navigationssteuerelemente und das Site-Map-System in ASP.NET 2.0 finden Sie in den anspruchsvollen Websitenavigationsfunktionen von ASP.NET 2.0 und im Abschnitt „Verwenden von Navigationssteuerelementen“ der ASP.NET 2.0 QuickStarts.

Abbildung 20: Das Menüsteuerelement listet jede der Kategorien und Produkte auf (Klicken, um das Bild in voller Größe anzuzeigen)

Wie weiter oben in diesem Lernprogramm erwähnt, kann programmgesteuert über die Klasse auf die SiteMap Sitemap-Struktur zugegriffen werden. Der folgende Code gibt den Stamm SiteMapNode des Standardanbieters zurück:

Dim root As SiteMapNode = SiteMap.RootNode

Da der AspNetXmlSiteMapProvider der Standardanbieter für unsere Anwendung ist, würde der obige Code den Wurzelknoten zurückgeben, der in Web.sitemap definiert ist. Um auf einen anderen Sitemap-Anbieter als den Standard zu verweisen, verwenden Sie die Providers Eigenschaft der SiteMap Klasse wie folgt:

Dim root As SiteMapNode = SiteMap.Providers("name").RootNode

Dabei handelt es sich um den Namen des benutzerdefinierten Siteübersichtsanbieters ( Northwind, für unsere Webanwendung).

Um auf ein Mitglied zuzugreifen, das für einen Sitemap-Anbieter spezifisch ist, verwenden Sie SiteMap.Providers["name"], um die Anbieterinstanz abzurufen, und wandeln Sie sie dann in den entsprechenden Typ um. Wenn Sie beispielsweise die NorthwindSiteMapProvider Eigenschaft s CachedDate auf einer ASP.NET Seite anzeigen möchten, verwenden Sie den folgenden Code:

Dim customProvider As NorthwindSiteMapProvider = _
    TryCast(SiteMap.Providers("Northwind"), NorthwindSiteMapProvider)
If customProvider IsNot Nothing Then
    Dim lastCachedDate As Nullable(Of DateTime) = customProvider.CachedDate
    If lastCachedDate.HasValue Then
        SiteMapLastCachedDate.Text = _
            "Site map cached on: " & lastCachedDate.Value.ToString()
    Else
        SiteMapLastCachedDate.Text = "The site map is being reconstructed!"
    End If
End If

Zusammenfassung

ASP.NET 2.0-Website-Navigationsfunktionen umfassen eine SiteMap Klasse, eine Reihe integrierter Navigations-Websteuerelemente und einen standardmäßigen Websitezuordnungsanbieter, der erwartet, dass die Websitezuordnungsinformationen in einer XML-Datei gespeichert sind. Um Websitezuordnungsinformationen aus einer anderen Quelle wie z. B. aus einer Datenbank, der Anwendungsarchitektur oder einem Remotewebdienst zu verwenden, müssen wir einen benutzerdefinierten Websitezuordnungsanbieter erstellen. Dies umfasst das Erstellen einer Klasse, die direkt oder indirekt von der SiteMapProvider Klasse abgeleitet wird.

In diesem Tutorial haben wir gelernt, wie man einen benutzerdefinierten Site-Map-Anbieter erstellt, der die Sitemap basierend auf den Produkt- und Kategorieinformationen aus der Architektur der Anwendung ableitet. Unser Anbieter erweiterte die StaticSiteMapProvider Klasse und führte zum Erstellen einer BuildSiteMap Methode zum Abrufen der Daten, zum Erstellen der Websitezuordnungshierarchie und zum Zwischenspeichern der resultierenden Struktur in einer Variablen auf Klassenebene. Wir haben eine SQL-Cacheabhängigkeit mit einer Rückruffunktion verwendet, um die zwischengespeicherte Struktur zu ungültig machen, wenn die zugrunde liegenden Categories oder Products Daten geändert werden.

Glückliche Programmierung!

Weitere Lektüre

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

• Speichern von Sitemaps in SQL Server und Der SQL-Sitemap-Provider, den Sie erwartet haben
• Das Provider Toolkit
• Sophistizierte Site-Navigationsfunktionen von ASP.NET 2.0

Zum Autor

Scott Mitchell, Autor von sieben ASP/ASP.NET Büchern und Gründer von 4GuysFromRolla.com, arbeitet seit 1998 mit Microsoft Web Technologies zusammen. Scott arbeitet als unabhängiger Berater, Trainer und Schriftsteller. Sein neuestes Buch ist Sams Teach Yourself ASP.NET 2.0 in 24 Stunden. Er kann bei mitchell@4GuysFromRolla.comerreicht werden.

Besonderer Dank an

Diese Lernprogrammreihe wurde von vielen hilfreichen Prüfern überprüft. Leitende Prüfer für dieses Lernprogramm waren Dave Gardner, Zack Jones, Teresa Murphy und Bernadette Leigh. Möchten Sie meine bevorstehenden MSDN-Artikel überprüfen? Wenn ja, schicken Sie mir eine Nachricht an mitchell@4GuysFromRolla.com.