Portal Starter Kit: Design und Implementierung

In diesem Artikel werden die Design- und Architekturentscheidungen für das ASP.NET Portal Starter Kit beschrieben. Außerdem wird der zur Erweiterung erforderliche Code ausführlich beschrieben.

Auf dieser Seite

Übersicht
Anwendungsarchitektur
Datenbank
Das Portalframework
Verwalten des ASP.NET Portal Starter Kit
Erweitern des ASP.NET Portal Starter Kit
Schlussbemerkung

Übersicht

Was ist das Portal Starter Kit?

Das Portal Starter Kit demonstriert, wie Sie ASP.NET und das Microsoft .NET Framework verwenden können, um Anwendungen für Intranet- oder Internetportale zu erstellen. Das Beispiel veranschaulicht viele wichtige mit ASP.NET zur Verfügung stehende Features und stellt außerdem eine Anwendung mit bewährten Methoden bereit, die Entwickler als Grundlage für die Erstellung ihrer eigenen ASP.NET-Anwendungen verwenden können.

Das Portal präsentiert zahlreiche Features der ASP.NET-Technologie. Dazu gehören:

• Browserübergreifende Unterstützung für Netscape und Internet Explorer

• Unterstützung mobiler Geräte für WAP/WML sowie Pocket Browser-Geräte

• Saubere Trennung zwischen Code und HTML-Inhalt durch Verwendung von Serversteuerelementen

• Seiten, die aus dynamisch geladenen Benutzersteuerelementen erstellt werden

• Konfigurierbare Ausgabezwischenspeicherung von Portalseitenregionen

• Mehrstufige Anwendungsarchitektur

• ADO.NET-Datenzugriff mit Hilfe von gespeicherten SQL-Prozeduren

• Windows-Authentifizierung - Benutzername/Kennwort in Active DS oder NT SAM

• Formularauthentifizierung mit einer Datenbank für Benutzernamen/Kennwörter

• Rollenbasierte Sicherheit zur Steuerung des Benutzerzugriffs auf den Portalinhalt

Dieses Whitepaper enthält ausführliche Informationen über das Portal und ermöglicht einen Einblick aus Sicht der Entwickler. Dieser Artikel enthält zudem Informationen darüber, wie das Portal Starter Kit als Vorlage zum Erstellen von Onlineportalen verwendet werden kann. Hierbei werden viele wichtige Anwendungsfeatures und die bei ihrer Implementierung verwendete Technologie erläutert.

Das Portal Starter Kit wurde als Inline- und als Codebehind-Version entwickelt. Die SDK-Version ist inline codiert und für das ASP.NET Web Matrix Project sowie das .NET Framework SDK optimiert. Die zweite Version wurde in Microsoft ® Visual Studio.NET™ unter Verwendung des Codebehind-Modells geschrieben. Beide Versionen enthalten Implementierungen, die in C# und VB.NET geschrieben sind.

Anwendungsarchitektur

Das Portal verwendet eine mehrstufige Anwendungsarchitektur. Es enthält zwei Datenquellen. Die Konfigurationseinstellungen werden in PortalCFG.xml gespeichert, und der Inhalt für die Anwendung wird in einer SQL Server-Datenbank gespeichert. Der Datenzugriff wird über eine Microsoft .NET-Assemblierung bereitgestellt, die den Zugriff auf die Datenquelle über die gespeicherten Prozeduren ermöglicht. Darüber hinaus wird das Portalframework über eine Reihe von Assemblierungen erstellt, die für die Sicherheit und die Konfiguration des Portals sorgen. Web Forms und Benutzersteuerelemente bilden die Präsentationsebenen und übernehmen die Anzeige und die Verwaltung der Portaldaten für den Benutzer.

Datenbank

Der gesamte Inhalt des Portals wird in einer SQL Server-Datenbank gespeichert. Dadurch können Serveradministratoren das Front-End des Portals über eine Reihe von Servern in einer Serverfarm verwalten, wobei die Daten aus einem einzigen eindeutigen Datenspeicher abgerufen werden. Dieser Abschnitt enthält eine Übersicht über die im Portal verwendeten Datenbanken.

Datenbankschema

Das Portaldatenbankschema ist ein sehr einfaches Schema mit einem einfachen Repository für den Modulinhalt und drei Tabellen zum Speichern von Benutzern und Benutzerrollen. Das physische Schema wird in Abbildung 1 dargestellt.

Abbildung 1. Physisches Datenbankschema

XML-Schema für die Portalkonfiguration

Das auf der Datei PortalCFG.xml basierende Schema enthält alle Konfigurationseinstellungen für das Portal. Das Schema ist einfach und leicht verständlich. Die XML-Konfigurationsdatei speichert alle Basisdefinitionen für das Portal, die Registerkarten und die Module. Die Konfigurationseinstellungen werden in einem Zwischenspeicher gespeichert, und GetSiteSettings() liest die Daten aus der XML-Datei nur dann, wenn sich die Einstellungen geändert haben. Das physische Schema wird in Abbildung 2 dargestellt.

Abbildung 2. PortalCFG.xsd-Schema

Gespeicherte Prozeduren

Das Portal verwendet gespeicherte Prozeduren, um alle Datenbankabfragen zu kapseln. Dadurch wird eine saubere Trennung zwischen der Datenbank und der mittleren Ebene, d. h. der Datenzugriffsebene, erzielt. Dadurch wird die Wartung vereinfacht, da Änderungen am Datenbankschema in den Datenzugriffskomponenten nicht sichtbar sind. Die Verwendung gespeicherter Prozeduren bietet weitere Leistungsvorteile, da die Prozeduren bei der ersten Ausführung optimiert und anschließend für nachfolgende Aufrufe im Speicher verbleiben.

Das Portalframework

Das Portal enthält ein erweiterbares Framework, das den Benutzern das Erstellen und Verwenden einzelner Portalmodule für die Anzeige und Verwaltung von Daten ermöglicht. Die folgenden Abschnitte erläutern die grundlegenden Bestandteile, aus denen sich das Portalframework zusammensetzt, und beschreibt, wie es erstellt wurde.

Portaleinstellungen
Die Portaleinstellungen werden durch die PortalSettings-Klasse repräsentiert, die in der Konfigurationsgeschäftskomponente definiert wird. Zu diesen Einstellungen gehören:

• die Portal-ID

• der Portalname

• die Auflistung der Desktopregisterkarten

• die Auflistung der Registerkarten für mobile Geräte

• die derzeit aktive Registerkarte

• die Einstellung AlwaysShowEditButton

Die PortalSettings-Klasse wird aktualisiert und bei jeder Webanfrage der Portalanwendung im Context-Objekt abgelegt. Dies erfolgt durch die Verwendung des Application_BeginRequest-Ereignisses in der Datei Global.asax.

Context.Items.Add("PortalSettings", New PortalSettings(tabIndex, tabId))

Nach dem Speichern im Context-Objekt können diese Einstellungen aus allen Bereichen der Anwendung abgerufen werden, einschließlich aller Seiten, Komponenten und Steuerelemente. Der Abruf erfolgt durch den Zugriff auf das Context-Element mit dem Namen PortalSettings.

Dim portalSettings As portalSettings = _ 
CType(HttpContext.Current.Items("PortalSettings"), portalSettings)

Portalregisterkarten
Die Registerkarten werden in zwei öffentlichen Feldern des PortalSettings-Objekts gespeichert, das im vorherigen Abschnitt beschrieben wurde. Die Felder DesktopTabs und MobileTabs sind vom Typ ArrayList und enthalten Instanzen der TabStripDetails-Klasse, die eine einzelne Registerkarte repräsentiert. Der Zugriff auf die Auflistung der Registerkarten erfolgt über das Context-Element von PortalSettings.

Dim portalSettings As portalSettings = _ 
CType(HttpContext.Current.Items("PortalSettings"), portalSettings) 
Dim i As Integer 
For i = 0 To portalSettings.DesktopTabs.Count - 1 
Dim tab As TabStripDetails = CType(portalSettings.DesktopTabs(i), TabStripDetails) 
Next I

Die Anzeige der Registerkarten (siehe Abbildung 3 unten) wird durch das Benutzersteuerelement DesktopPortalBanner.ascx verarbeitet. Das Steuerelement durchläuft die Registerkartenauflistung wie oben gezeigt und prüft dabei, ob der aktuelle Benutzer Berechtigungen zur Anzeige der Registerkarte besitzt. Wenn dem Benutzer die erforderliche Rolle zugeordnet ist, wird die Registerkarte zu einer anderen Auflistung hinzugefügt, die an eine DataList gebunden wird.

Abbildung 3. Portalregisterkarten

Wenn ein Benutzer auf eine bestimmte Registerkarte klickt, wird das PortalSettings-Objekt so aktualisiert, dass die neue ActiveTab einbezogen wird. Wenn DesktopPortalBanner.ascx neu geladen wird, wird das Element in der DataList, das dem Index der aktiven Registerkarte entspricht, auf die DataList-Eigenschaft SelectedIndex gesetzt.

Portalmodule

Portalmodule stellen den tatsächlichen Inhalt des Portal Starter Kit zur Verfügung. Die Module sind Benutzersteuerelemente, die die PortalModuleControl-Basisklasse erben, die wiederum die erforderliche Kommunikation zwischen den Modulen und dem zugrunde liegenden Portalframework bereitstellt. Das Portal umfasst elf integrierte Portalmodule, die sofort einsetzbar sind. Sieben davon sind in Abbildung 3, dargestellt.

Abbildung 4. Portalmodule

Portalsicherheit

Das Sicherheitsdesign im Portal verwendet sowohl Authentifizierung als auch Autorisierung. Die Authentifizierung ist der Prozess, bei dem die Anwendung die Identität und die Anmeldeinformationen eines Benutzers überprüft. Bei der Autorisierung werden die Berechtigungen eines authentifizierten Benutzers für den Zugriff auf eine angeforderte Ressource überprüft.

Das Portal unterstützt die formularbasierte und die Windows-basierte Authentifizierung. Der Authentifizierungsmodus wird in der Datei web.config definiert, und die Eigenschaft User.Identity.Name verwaltet den Benutzernamen. Die formularbasierte Authentifizierung speichert die Benutzernamen und Kennwörter in der Datenbank, und die Windows-Authentifizierung verwendet ein Domänen-/Active Directory mit dem NTLM-Challenge/Response-Protokoll. Die Autorisierung für das Portal wird über rollenbasierte Sicherheit verarbeitet, um festzustellen, ob ein Benutzer Zugriff auf eine bestimmte Ressource hat oder nicht. Benutzer werden in unterschiedliche Rollen eingeteilt (Admins, Hauptbenutzer, Entwickler usw.), und die Rollenzuordnungen erfolgen in der Datenbank. Die Registerkarten und Module im Portal verwenden Zugriffssteuerungslisten (ACLs), um festzustellen, welcher Benutzer auf das Steuerelement zugreifen kann. Dadurch wird verhindert, dass ein normaler Benutzer auf die Verwaltungsfunktionen zugreifen kann.

Im Page_Load-Ereignis des Admin-Steuerelements Tabs.ascx erfolgt zum Beispiel ein Aufruf von IsInRoles():

' Verify that the current user has access to access this page 
If PortalSecurity.IsInRoles("Admins") = False Then 
 Response.Redirect("~/Admin/EditAccessDenied.aspx") 
End If

Die Rollenzuordnungen des aktuellen Benutzers werden für die Anforderung in Global.asax im Application_AuthenticateRequest()-Ereignis eingerichtet. Der Context.User wird dann mit der GenericPrincipal-Methode eingerichtet, und User.IsInRole kann verwendet werden, um festzustellen, ob der aktuelle Benutzer zu einer bestimmten Rolle gehört.

Sub Application_AuthenticateRequest(ByVal sender As Object, _  
   ByVal e As EventArgs) 
 If Request.IsAuthenticated = True Then 
  Dim roles() As String  
  ' Create the roles cookie if it doesn't exist yet for  
  ' this session. 
  If Request.Cookies("portalroles") Is Nothing Then 
   ' Get roles from UserRoles table, and add to cookie 
   Dim _user As New UsersDB() 
   roles = _user.GetRoles(User.Identity.Name) 
   ' Create a string to persist the roles 
   Dim roleStr As String = "" 
   Dim role As String 
   For Each role In roles 
 roleStr += role 
 roleStr += ";" 
   Next role 
   ' Create a cookie authentication ticket. 
   '   version 
   '   user name 
   '   issue time 
   '   expires every hour 
   '   don't persist cookie 
   '   roles 
   Dim ticket As New FormsAuthenticationTicket(1, _ 
 Context.User.Identity.Name, _ 
 DateTime.Now, _ 
 DateTime.Now.AddHours(1), _ 
 False, _ 
 roleStr) 
   ' Encrypt the ticket 
   Dim cookieStr As String = FormsAuthentication.Encrypt(ticket) 
   ' Send the cookie to the client 
   Response.Cookies("portalroles").Value = cookieStr 
   Response.Cookies("portalroles").Path = "/" 
   Response.Cookies("portalroles").Expires = _ 
 DateTime.Now.AddMinutes(1) 
  Else 
   ' Get roles from roles cookie 
   Dim ticket As FormsAuthenticationTicket = _ 
 FormsAuthentication.Decrypt(Context.Request.Cookies("portalroles").Value) 
   'convert the string representation of the role data  
   'into a string array 
   Dim userRoles As New ArrayList() 
   Dim role As String 
   For Each role In ticket.UserData.Split(New Char() {";"c}) 
 userRoles.Add(role) 
   Next role 
   roles = CType(userRoles.ToArray(GetType(String)), String()) 
  End If 
  ' Add our own custom principal to the request containing  
  ' the roles in the auth ticket 
  Context.User = New GenericPrincipal(Context.User.Identity, roles) 
 End If 
End Sub

Die Datenbankaufrufe für alle rollenbasierten Prüfungen befinden sich in Security.vb.

Verwalten des ASP.NET Portal Starter Kit

Das Portal besitzt ein Onlineverwaltungstool, mit dem Benutzer der Rolle "Admins" die Sicherheit, das Layout und den Inhalt des Portals verwalten können. Angemeldeten Benutzern, die zur Rolle "Admins" gehören, wird die Registerkarte "Admins" angezeigt, über die das Verwaltungstool aufgerufen werden kann. Dieses Tool ist in Abbildung 5 unten dargestellt.

Abbildung 5. Portalverwaltung

Die Portalverwaltung ermöglicht dem Benutzer die Durchführung einer Vielzahl von Sitemanagement- und Konfigurationsaufgaben. Hier können Sie neue Module hinzufügen, Registerkarten konfigurieren, die am oberen Rand in einer horizontalen Liste angezeigt werden, und die Sicherheitsrollen definieren.

Erweitern des ASP.NET Portal Starter Kit

Bei der Entwicklung des Portals haben wir großen Wert auf Möglichkeiten zur Erweiterung gelegt, um Entwicklern das einfache Hinzufügen von Portalmodulen zu ermöglichen, die sich in das Framework "pluggen" lassen. In diesem Abschnitt werden die Schritte beschrieben, die Sie durchführen müssen, um Ihre eigenen Portalmodule zu erstellen. Zu diesem Zweck erstellen wir ein Meilenstein-Projektmodul für die Anzeige von Projektmeilensteinen.

Erweitern der Datenebene

Die meisten Portalmodule verwenden die Portaldatenbank als primären Datenspeicher. Für dieses Beispiel werden wir genauso vorgehen. Deshalb besteht der erste Schritt in der Erweiterung der Datenebene. Wir beginnen mit der Erstellung einer neuen Tabelle mit dem Namen Milestones wie in Abbildung 6.

Abbildung 6. Tabelle "Milestones"

Anschließend erstellen wir die gespeicherten Prozeduren, die zur Handhabung des Zugriffs auf die Milestones-Tabelle erforderlich sind. Folgende gespeicherte Prozeduren werden benötigt:

• AddMilestone

• DeleteMilestone

• GetMilestone

• GetSingleMilestone

• UpdateMilestone

Nach der Erstellung der gespeicherten Prozeduren müssen wir eine Datenzugriffsebene (Data Access Layer oder DAL) erstellen, um den Zugriff auf die Meilensteinprozeduren bereitzustellen. Wir definieren die folgenden Methoden, wovon nur die erste unten in Liste 1 dargestellt ist. Die anderen Methoden, die zur besseren Übersicht nicht in die Liste aufgenommen wurden, befinden sich in der Datei MilestonesDB.vb im Milestone-Erweiterungspaket auf der Downloadseite für das ASP.NET Portal Starter Kit.

• ASPNET.StarterKit.Portal.MilestonesDB.GetMilestones()

• ASPNET.StarterKit.Portal.MilestonesDB.GetSingleMilestone()

• ASPNET.StarterKit.Portal.MilestonesDB.DeleteMilestone()

• ASPNET.StarterKit.Portal.MilestonesDB.AddMilestone()

• ASPNET.StarterKit.Portal.MilestonesDB.UpdateMilestone()

Liste 1

Imports System 
Imports System.Configuration 
Imports System.Data 
Imports System.Data.SqlClient 
Imports ASPNET.StarterKit.Portal 
Namespace ASPNET.StarterKit.Portal 
  Public Class MilestonesDB 
 Public Function GetMilestones(ByVal moduleId As Integer) As DataSet 
   ' Create Instance of Connection and Command Object 
   Dim myConnection As _  
  New SqlConnection(ConfigurationSettings.AppSettings("connectionString")) 
   Dim myCommand As New SqlDataAdapter("GetMilestones", myConnection) 
   ' Mark the Command as a SPROC 
   myCommand.SelectCommand.CommandType = CommandType.StoredProcedure 
   ' Add Parameters to SPROC 
   Dim parameterModuleId As New SqlParameter("@ModuleId", SqlDbType.Int, 4) 
   parameterModuleId.Value = moduleId 
   myCommand.SelectCommand.Parameters.Add(parameterModuleId) 
   ' Create and Fill the DataSet 
   Dim myDataSet As New DataSet() 
   myCommand.Fill(myDataSet) 
   ' Return the DataSet 
   Return myDataSet 
 End Function 
 ' Other methods elided for clarity. 
  End Class 
End Namespace

Erstellen des Benutzersteuerelements
Nachdem wir uns mit der Datenbank beschäftigt haben, besteht der nächste Schritt in der Erstellung des Benutzersteuerelements, das für die Meilensteinbenutzeroberfläche verantwortlich ist. Das Benutzersteuerelement enthält ein DataGrid, das drei Spalten definiert: Titel, Abschlussdatum und Status. Die Implementierung des Benutzersteuerelements wird unten in Liste 2 gezeigt.

Liste 2

<script runat="server"> 
  Sub Page_Load(ByVal sender As Object, ByVal e As EventArgs) 
 Dim milestones As New ASPNET.StarterKit.Portal.MilestonesDB() 
 myDataGrid.DataSource = milestones.GetMilestones(ModuleId) 
 myDataGrid.DataBind() 
  End Sub  
</script> 
<asp:DataGrid  
id="myDataGrid"  
HeaderStyle-CssClass="Normal"  
HeaderStyle-Font-Bold="true"  
ItemStyle-CssClass="Normal"  
AutoGenerateColumns="false"  
CellPadding="5"  
Border="0"  
Width="100%"  
EnableViewState="false"  
runat="server"> 
  <Columns> 
 <asp:TemplateColumn> 
   <ItemTemplate> 
 <asp:HyperLink  
   id="editLink"  
   ImageUrl="~/images/edit.gif"  
   NavigateUrl='<%# "~/DesktopModules/EditMilestones.aspx?ItemID=" & 
 DataBinder.Eval(Container.DataItem,"ItemID") & "&mid=" & ModuleId %>'  
 Visible="<%# IsEditable %>" runat="server" /> 
   </ItemTemplate> 
 </asp:TemplateColumn> 
 <asp:BoundColumn DataField="Title" HeaderText="Title"  
   runat="server" /> 
 <asp:BoundColumn DataField="EstCompleteDate"  
   HeaderText="Comp. Date" runat="server"  
   DataFormatString="{0:d}" /> 
 <asp:BoundColumn DataField="Status" HeaderText="Status" runat="server" /> 
  </Columns> 
</asp:DataGrid>

Vererben der "ASPNET.StarterKit.PortalModuleControl"-Basisklasse
Alle Portalmodule sind im Prinzip nur einfache ASP.NET-Benutzersteuerelemente, die die PortalModuleControl-Basisklasse erben. Diese Basisklasse stellt alle Hooks bereit, die das Portalmodul zum Interagieren mit dem Framework benötigt. Zum Erben der Basisklasse müssen Sie die folgende Zeile am Anfang des Benutzersteuerelements einfügen.

<%@ Control language="VB" Inherits=" ASPNET.StarterKit.Portal.PortalModuleControl" %>

Hinzufügen des Modultitels
Eines der für Portalmodule verfügbaren Benutzersteuerelemente ist das Title-Benutzersteuerelement. Dieses Steuerelement erzeugt den entsprechenden HTML-Code.

<portal:title runat="server" />

Hinzufügen von Unterstützung für eine Bearbeitungsseite
Um den Benutzern die Bearbeitung von Meilensteinen sowie das Hinzufügen neuer Meilensteine zu ermöglichen, muss Unterstützung für eine Bearbeitungsseite hinzugefügt werden. Dazu werden zwei weitere Eigenschaften zum Benutzersteuerelement für den Modultitel hinzugefügt.

<portal:title  
EditText="Add New Milestone" 
EditUrl="~/DesktopModules/EditMilestones.aspx"  
runat="server" />

Erstellen der Bearbeitungsseite
Nach dem Hinzufügen der Unterstützung für eine Bearbeitungsseite unter Verwendung des Title-Benutzersteuerelements müssen wir die tatsächliche Bearbeitungsseite erstellen. Zusätzlich zum HTML-Code werden wir vier Methoden definieren:

• Page_Load

• UpdateBtn_Click

• DeleteBtn_Click

• CancelBtn_Click

Die Quelle für die DeleteBtn_Click-Methode und den damit in der Bearbeitungsseite verknüpften HTML-Code ist in Liste 3 dargestellt. Den Rest der Implementierung finden Sie in EditMilestones.aspx im Downloadpaket für die Milestone-Erweiterung.
Liste 3

<%@ Page Language="VB" %> 
<%@ Register TagPrefix="ASPNETPortal" TagName="Banner" Src="~/DesktopPortalBanner.ascx" %> 
<%@ Import Namespace="System.Data.SqlClient" %> 
<%@ Import Namespace=" ASPNET.StarterKit.Portal " %> 
<script runat="server"> 
 Private itemId As Integer = 0 
 Private moduleId As Integer = 0 
 Sub UpdateBtn_Click(ByVal sender As Object, ByVal e As EventArgs) 
  ' Only Update if the Entered Data is Valid 
  If Page.IsValid = True Then 
   ' Create an instance of the Milestone DB component 
   Dim milestones As New ASPNET.StarterKit.Portal.MilestonesDB() 
   If itemId = 0 Then 
 ' Add the milestone within the Milestones table 
 milestones.AddMilestone(moduleId, itemId, _ 
  Context.User.Identity.Name, TitleField.Text, _ 
  DateTime.Parse(CompleteDateField.Text), StatusField.Text) 
   Else 
 ' Update the milestone within the Milestones table 
 milestones.UpdateMilestone(moduleId, itemId, _ 
  Context.User.Identity.Name, TitleField.Text, _ 
  DateTime.Parse(CompleteDateField.Text), StatusField.Text) 
   End If 
   ' Redirect back to the portal home page 
   Response.Redirect(CType(ViewState("UrlReferrer"), String)) 
  End If 
 End Sub 
</script> 
<html> 
   <head> 
   <link rel="stylesheet"  
   href='<%= Request.ApplicationPath & "/ASPNETPortal.css" %>' type="text/css" /> 
   </head> 
   <body leftmargin="0" bottommargin="0" rightmargin="0" topmargin="0"  
   marginheight="0" marginwidth="0"> 
   <form runat="server"> 
   <table width="100%" cellspacing="0" cellpadding="0" border="0"> 
   <tr> 
   <td> 
   <br> 
   <table width="98%" cellspacing="0" cellpadding="4" > 
   <tr valign="top"> 
   <td width="100"> 
   &nbsp; 
   </td> 
   <td width="*"> 
   <p> 
   <asp:LinkButton  
   id="deleteButton"  
   Text="Delete this item"  
   CausesValidation="False"  
   runat="server"  
   class="CommandButton"  
   BorderStyle="none"  
   OnClick="DeleteBtn_Click" /> 
   </p> 
   </td> 
   </tr> 
   </table> 
   </td> 
   </tr> 
   </table> 
   </form> 
   </body> 
</html>

Hinzufügen des neuen Portalmoduls zum Framework

Das Meilenstein-Portalmodul ist jetzt vollständig. Der einzige noch auszuführende Schritt besteht im Hinzufügen des Moduls zum Portalframework unter Verwendung des Onlineadministrator-Abschnitts Moduldefinitionen. Klicken Sie in diesem Abschnitt auf Neuen Modultyp hinzufügen, um die in Abbildung 7 angezeigte Seite aufzurufen. Geben Sie die Informationen für das neue Modul ein, und klicken Sie auf Aktualisieren. Das Modul kann dann den verschiedenen Registerkarten hinzugefügt werden. Verwenden Sie dazu den Onlineadministrator-Abschnitt "Registerkartenname und -layout".

Abbildung 7. Modultypdefinition

Schlussbemerkung

Das Portal veranschaulicht die Schlüsseltechnologien zum Erstellen einer Portalwebanwendung unter Verwendung von ASP.NET. Neben den Möglichkeiten zur webbasierten Administration und zum Inhaltsmanagement ist das Portal extrem einfach erweiterbar. Ein Beispiel dafür ist das in diesem Whitepaper beschriebene Hinzufügen des Meilenstein-Moduls. Dieses Beispiel veranschaulicht auf überzeugende Weise die Möglichkeiten der .NET-Technologien sowie die Leistungsfähigkeit des Frameworks, das für Internet- oder Intranetportale verwendet werden kann.

Weitere Informationen

• Die gesamte Dokumentation und den vollständigen Quellcode finden Sie unter http://www.asp.net.

• Eine funktionsfähige Version der Site finden Sie unter http://www.asp.net.

• IBuySpy-Listserver: http://www.aspfriends.com/aspfriends/aspngibuyspy.asp.