© Martin Korneffel, Stuttgart 2003 +++ email: trac@n.zgs.de +++ web: www.s-line.de/homepages/trac
Zugriff auf Konfigurationsdaten in ASP.NET mittels ASP.NET Ausdrücken
Physisches Verzeichnis zu einem virtuellen Verzeichnis abrufen
Einrichten der Konfigurationsdatenbank für Benutzer- und Rollenverwaltung (NET 2.0)
Benutzer und Rollenverwaltung mittels Konfigurationstool (Net 2.0)
|
Definition |
|
|---|---|
|
Webanwendung |
Stellt Inhalte, die auf Server gespeichert sind bzw. erzeugt werden, über das Internet durch das HTTP- Protokoll zu Verfügung. Der Client stellt die Inhalte durch Browser dar. |
Eine ASP.NET Webanwendung besteht aus folgenden Teilen:
|
Definition |
|
|---|---|
|
Webdienst |
Ist ein Dienst auf einem Server, der über HTTP und XML- basierten Protokollen wie SOAP im Internet abrufbar ist. |
ASP.NET ist eine Plattform zur Entwicklung von Webanwendungen, welche auf dem .NET – Framework basiert. Im Sinne von Microsoft umfasst ASP.NET folgende Komponenten und Dienste:
|
Visual Studio .NET Entwicklungswerkzeuge |
||
|
C#, VB.NET und HTML |
||
|
Server und HTML- und Serversteuerelemente |
ADO.NET |
Namespace System.Web |
|
IIS |
.NET Framework |
|
Hohe Ausführungsgeschwindugkeit durch Kompilation der ausführbaren Teile einer Webanwendung
Updates während des Betriebes
Eingebaute Sicherheitsmechanismen: Windows- Sicherheit oder formularbasierte Sicherheit
Beschleunigte Entwicklung durch Zugriff auf .NET Framework
Zugriff auf Datenbanken mittels ADO.NET
Programmierung in VB.NET, C#
Serversteuerelemente mit automatischer Statusverwaltung (Viewstate)
Entwicklung benutzerdefinierter Steuerelemente auf Basis der vordefinierten Serversteuerelemente
Unterstützung von CSS
Unterstützung von XML
Eingebaute Mechanismen zur Lokalisierung von Webseiten
Eingabaute Mechanismen zum Cachen von Webseiten
Zuerst muß eine Projektmappe angelegt werden. Dann kann im Projektmappen- Explorer das Kontextmenü vom Projektmappen- Knoten aufgerufen werden. In diesem ist unter dem Punkt Hinzufügen der Unterpunkt Neue Webseite vorhanden. Es öffnet sich ein Assistent der ASP.NET- Projektvorlagen anbietet
Visual Studio 2005 brach mit seinem Vorgänger 2003 in Punkto Webprojekte. In 2003 wurden Webprojekte analog den Windowsprojekten verwaltet: Es gab eine Projektdatei, die neben den Kompilereinstellungen auch die Verweise enthielt. VS2005 verwarf zunächst diesen Ansatz zugunsten der allgemein etablierten Struktur von Webprojekten: in 2005 waren Webprojekte nichts anderes als Unterverzeichnisse auf einem Server, die alle Dateien der Webanwendung enthielt. VS2005 kann solche Verzeichnisse im Projektmappenexplorer verwalten.
Nachteil dieser neuen Verfahrensweise war jedoch, daß ein Bruch zum Managment der restlichen Projekttypen entstand. Deshalb wurde mit dem Servicepack 1 ein neuer Projekttyp eingeführt, das Webanwendungsprojekt. Diese arbeitet wieder mit einer Projektdatei. Folglich können auch wieder alle Features der VS2005 Projekte genutzt werden, z.B. Verweise auf andere Webanwendungsprojekte oder Klassendiagramme.
ASP.NET Webseite
ASP.NET Ajax Enabled Website
ASP.NET Webdienst
ASP.NET Webanwendung (SP1)
ASP.NET Webdienstanwendung (SP1)
VS 2005 prüft mittels Intellisense validiert während der Eingabe gegen einen Voreingestellten HTML- Standard (z.B. HTML 4.0 Transistional). Dieser Standard kann geändert werden unter Extras/Optionen/Text-Editor/Html/Validierung (z.B. in XHTML 1.0 Transistional).
Die Konfiguration des .net Systems erfolgt über XML- basierte Dateien. .net Anwendungen sind aus Sicht der Verteilung der Programmdateien hierarchisch aufgebaut. Über diese Hierarchie gilt ein Vererbungsprinzip. Wird im Stammverzeichnis einer .net Anwendung eine Konfigurationsdatei angelegt, so wirken sich deren Definitionen auch auf die Komponenten in den Unterverzeichnissen aus. Einstellungen, die in config- Dateien der Unterverzeichnisse nicht definiert werden, werden aus den übergeordneten config- Dateien übernommen (Vererbungsprinzip)
Die Konfiguration von ASP.NET erfolgt nach dem Prinzip der Variation einer Grundkonfiguration. Die Grundkonfiguration wird durch die Datei machine.config gebildet. Diese Grundkonfiguration übernimmt jede ASP.NET Anwendung, solange in ihrem Verzeichnis keine web.config Datei eingerichtet wurde.
Mittels einer web.config Datei können einzelne Abschnitte aus der machine.config- Datei überschrieben werden. Die derart abgewandelte Konfiguration gilt für alle .NET Anwendungen im Heimverzeichnis
machine.config --> stammverz/web.config --> stammverz//unterverz/web.config
Achtung: pro Unterverzeichnis kann es max. 1 web.config geben.
Achtung: in der machine.config ist nach Installation von .net im Element processModel ein Fehler: das Attribut userName muß den Wert "System" haben. Dadurch werden führt der IIS aspx- Anwendungen unter einem allgemeienen Prozesskonto aus. Sonst ist die Anwendung nicht verfügbar. (.net- Hilfe: Konfigurieren von Anwendungen/Konfigurationsdateien/Computerkonfigurationsdateien)
Die Konfigurationsdateien sind reine XML Dateien. Groß/Kleinschreibung ist hier von Bedeutung (siehe XML).
<?xml version="1.0" encoding="UTF-8"?>
<configuration>
<configSections>
<!-- Deklaration der Handler -->
</configSection>
<!-- Abschnitte, die zu keiner Gruppe gehören -->
<!-- Abschnittsgruppen für ASP.NET – Konfiguration -->
<system.web>
<!-- ASP.NET Konfiguration -->
</system.web>
<!-- .NET Konfiguration -->
<system.net>
</system.net>
</confioguration>Das Debuggen einer Webform muß in der Web.config durch folgendes Element freigeschaltet werden:
<configuration xmlns="http://schemas.microsoft.com/.NetConfiguration/v2.0">
<system.web>
<compilation debug="true" defaultLanguage="c#" />
</system.web>
</configuration>Zur Fehlerfindung während der Laufzeit bietet .Net im Namespace System.Diagnostics die Klassen Debug und Trace an. Diese können in Asp.Net Webanwendungen eingesetzt werden. Insbesondere bei der Entwicklung ist die Klasse Debug- hilfreich, da die Meldungen ihrer Methoden wie gewohnt im Ausgabefenster von Visual Studio erscheinen.
Wird eine Webform auf einem Produktionsserver veröffentlicht, dann werden die Aufrufe der Debug- Methoden entfernt. Die Trace Meldungen sind auch nicht einfach in
Im Kontext einer Webseite wird über die Eigenschaft Trace ein Objekt der Klasse TraceContext angeboten. Mit diesem können zur Laufzeit Zustandsinformationen über den Code in Trace- Protokolle geschrieben werden. Diese Protokolle sind dann für jede Web- Anwendung über den speziellen HTTP- Handler trace.axd abrufbar.
using System.Diagnostics; namespace u02_Debug_Trace { public partial class _Default : System.Web.UI.Page { protected void Page_Load(object sender, EventArgs e) { // Instrumentieren einer Webanwendung Debug.WriteLine("Ausgabe einer Debug- Meldung"); System.Diagnostics.Trace.WriteLine("Ausgabe einer Trace- Meldung"); Debug.Assert(IsPostBack, "Es liegt kein Postback vor"); // Aufzeichnen im Asp.Net Logsystem Trace.Write("Eine Meldung im Asp.Net Trace ausgeben"); Trace.Warn("Eine Warnung im Asp.Net Trace ausgeben"); } } }
Die Methoden der System- Diagnostics- Klassen geben Asp.Net Webanwendungsprojekten ihre Meldungen im Ausgabefenster aus. Die Ausgabe der Methoden der Page.Trace Eigenschaft (TraceContext) hingegen sind per Default abgeschaltet.
Einschalten der Ausgaben von Page.Trace:
In der web.config folgendes Element in system.web hinzufügen:
<!-- mko: Asp.Net Tracing freischalten --> <trace enabled="true"/>
In der Page- Direktive der Webform folgenden zusätzliche Attribut hinzufügen:
<%@ Page ... Trace="true" %>
Um die Meldungen der System.Diagnostics- Klassen im Asp.Net- Trace erscheinen zu lassen, ist ein spezieller Listener hinzuzufügen in der Web.config:
<system.diagnostics>
<trace autoflush="true">
<!-- Trace- Klasse konfigurieren -->
<listeners>
<!-- Hinzufügen eines Listeners, der in das Asp.Net Protokoll schreibt:-->
<add name="WebPageTraceListener"
type="System.Web.WebPageTraceListener, System.Web, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"/>
</listeners>
</trace>
</system.diagnostics>Sollen die Meldungen des Asp.Net Trace- Systems in den Logdateien von System.Diagnostics landen, dann ist beim Freischalten des Asp.Net Tracing noch folgender Zusatz nötig:
<!-- mko: Asp.Net Tracing freischalten -->
<trace enabled="true" writeToDiagnosticsTrace="true"/>Wenn z.B. die Meldungen in einer Textdatei auf dem Server aufgezeichnet werden sollen, dann ist dem TextWriterTraceListener der voll qualifizierte Dateiname mitzuteilen. Dieser sollte möglichst auf eine Datei im Verzeichnis der Webanwendung verweisden, da sonst durch fehlende Berechtigungen Ausnahmen ausgelöst werden können. Beispiel:
<system.diagnostics>
<trace autoflush="true">
<!-- Trace- Klasse konfigurieren -->
<listeners>
<!-- Hinzufügen eines Listeners, der in eine Textdatei schreibt:-->
<add name="TxtTracer"
type="System.Diagnostics.TextWriterTraceListener, System, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089"
initializeData="C:\inetpub\wwwroot\u02\MyTrace.trc"/>
</listeners>
</trace>
</system.diagnostics>Asp-Dienst: aspnet_wp.exe (IIS 5.0) oder w3wp.exe (IIS 6.0)
In der Webconfig Datei können über das httpRuntime- Element der Http Request/Response- Zyklus konfigurert wie z.B. Timeout oder die maximale Größe eines Uploads:
<httpRuntime executionTimeout="110" -- Timeout eines Request maxRequestLength="4096" -- Max. Upload in KB requestLengthDiskThreshold="80" useFullyQualifiedRedirectUrl="false" minFreeThreads="8" minLocalRequestFreeThreads="4" appRequestQueueLimit="5000" enableKernelOutputCache="true" enableVersionHeader="true" requireRootedSaveAsPath="true" enable="true" shutdownTimeout="90" delayNotificationTimeout="5" waitChangeNotification="0" maxWaitChangeNotification="0" enableHeaderChecking="true" sendCacheControlHeader="true" apartmentThreading="false" />
Im Markup einer ASP.NET Seite kann mittels spezieller Ausdrücke direkt auf die Konfigurationsdaten einer Web.config Datei zugegriffen werden. Die Ausdrücke haben dabei folgende Syntax:
<%$ expression-Prefix: expression-Value %>
Expression- Prefix definiert den Konfigurationsabschnitt. Folgende Werte sind möglich:
|
Expression-Prefix |
Abschnitt |
|---|---|
|
AppSettings |
Zugriff auf den Abschnitt mit den Anwendungeinstellungen einer WebForm. expression-Value definiert den key der Einstellung, die ausgelesen werden soll. |
|
ConnectionStrings |
Zugriff auf Abschnitt mit den Verbindungszeichenfolgen. expression-Value definiert den Namen der Verbindungszeichenfolge, die durch den Ausdruck ausgelesen wird. |
Im Beispiel wird für ein Datenquellsteuerelement die Verbindungszeichenfolge des Attributes ConnectionString mittels eines ASP.NET- Ausdruckes definiert:
<asp:SqlDataSource ID="srcGetRecords" runat="server" ConnectionString="<%$ ConnectionStrings:dmsConnectionString %>" SelectCommand="select record_id, record from data.records"> </asp:SqlDataSource>
Web.config Dateien können auch sehr komfortabel auf dem IIS gewartet werden. Unter Einstellungen/ASP.NET/Konfiguration bearbeiten öffnet sich ein Konfigurationsdialog. Alle hier möglichen Einstellungen werden in der web.config- Datei im Stamm des virtuellen Verzeichnisses vorgenommen. Um z.B. die Seite mittels des VisualStudio 2005 Remote- Debugger zu debuggen ist unter Anwendung bei Debuggen aktivieren der Haken zu setzen.
ASP.NET 2.0 definiert eine feste Ordnerstruktur und damit ein einheitliches Datenmodell einer ASP.NET Anwendung:
|
Ordner |
Inhalt |
|---|---|
|
App_Code |
Hier können c# oder vb.net Dateien plaziert werden, die eine allgemeine Klassenbibliothek für die Anwendung bereitstellen. |
|
App_Data |
Zentraler Speicherort für Daten, die von der Anwendung verarbeitet werden wie Datenbankdateien, XML-Dateien etc. ASP.NET stellt sicher, das die Daten aus diesem Ordner nicht mittels eines HTTP- Requests direkt abgerufen werden können, wodurch die Datensicherheit der Anwendung erhöht wird. |
|
App_Themes |
Zentraler Speicherort für Dateien zur Definition von Layoutregeln wie CSS und sog. Skin- Dateien. Der wird in Unterordner unterteilt, genannt Designs. Jeder Design- Ordner enthält einen individuellen Satz von CSS- und Skin- Dateien. Durch Definition des Themes- Attribut in der <%Page ...%> Direktive einer ASPX- Seite kann ein Satz von Layoutregeln ausgewählt werden, der auf die Webform anzuwenden ist. |
|
App_GlobalResources |
Speicherort für Resourcendateien. Diese enthalten Tabellen, die Symbole Zeichenketten zuordnen. Anstelle den Text eines Label- Feldes fix im aspx- Markup zu codieren, kann er in eine Resourcendatei ausgelagert werden. Im ASP Markup kann auf die Resourcen zugegriffen werden mittels $ - Ausdrücke. Im Folgenden wird aus der Resourcendatei R1 die Zeichenkette, die unter dem Symbol R1 abgelegt ist, der Texteigenschaft von Label L1 zugewiesen. <asp:Label runat="server" ID="L1" Text="<%$ Resources:R1, String1 %>" /> Im c#- Quelltext sieht der Zugriff auf die Resourcen wie folgt aus: HttpContext.GetGlobalResourceObject("R1", "String1");
|
Um die Installation von Webseiten auf Servern zu vereinfachen, ist es notwendig, Dateipfade auf Resourcen in Serversteuerelementen an den jeweiligen Installationsort der Webseite anzupassen. ASP.NET bietet dazu den RootPath- Operator, welcher durch die Tilde(~) ausgedrückt wird.
~ // RootPath Operator: verweist auf Installationspfad der aktuellen Webanwendung
~/Images/My.gif // Absoluter Verweis auf die Gif Datei My.Gif im Image- Verzeichnis
// unterhalb des Installationsverzeichbnisses
/Images/My.gif // Relativer Verweis auf die Gif Datei My.gif im Image- Verzeichnis
// unterhalb des Speicherortes der aktuell aktiven WebformDie Position einer Webanwendung im Dateiverzeichnis eines Server kann mittels einer Methode der Klasse System.Web.HttpServerUtility bestimmt werden.
// phys. Pfad eines Unterverzeichnisses relativ zum Verzeichnis der akt. Webform
string physPfad = Server.MapPath("virtPath")
// phys. Pfad eines VErzeichnisses relativ zum Stammverzeichnis der Anwendung bestimmen
string RootWebApp = Server.MapPath("~/virtPath");
// phys. Pfad des Stammverzeichnisses bestimmen
string RootWebApp = Server.MapPath("~");In ASP.NET 2.0 wurde gegenüber ASP.NET 1.0 um eine konfigurierbare Benutzer und Rollenverwaltung erweitert. Das System basiert auf einen Satz Tabellen und gespeicherten Prozeduren für den SQL- Server 2005. Diese können in einer eigenständigen Datenbank (aspnetdb) oder in einer bereits existierenden Datenbank angelet werden mit dem Kommandozeilentool aspnet_regsql.
Sollen die Datenstrukturen für die Verwaltung einer Webanwendung in einer separaten Datenbank angelegt werden, dann kann diese auf einem SQLExpress- Server mit Windows- Authentifizierung ie folgt angelegt werden:
aspnet_regsql -S .\SqlExpress -E -A mr
aspnet_regsql -S .\SqlExpress -E -A mr -d datenbankname
Die Datenstrukturen können zur Verwaltung der Webseitenbenutzer und Rollen können auch wieder entfernt werden durch folgendes Kommando:
aspnet_regsql -S .\SqlExpress -E -R mr -d datenbankname
Die Benutzerverwaltung kann über die Webconfig- Datei gesteuert werden wie z.B. Name des ConnectionStrings der Datenbank mit den AspNetDb- Strukturen, Passwort- Struktur etc.. Im folgenden die Originaldaten aus der Machine.config Datei.
<system.web>
<membership>
<providers>
<add name="AspNetSqlMembershipProvider"
type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
connectionStringName="LocalSqlServer"
enablePasswordRetrieval="false"
enablePasswordReset="true"
requiresQuestionAndAnswer="true"
applicationName="/"
requiresUniqueEmail="false"
passwordFormat="Hashed"
maxInvalidPasswordAttempts="5"
minRequiredPasswordLength="7"
minRequiredNonalphanumericCharacters="1"
passwordAttemptWindow="10"
passwordStrengthRegularExpression="" />
</providers>
</membership>
</system.web> <membership>
<providers>
<clear/>
<add name="AspNetSqlMembershipProvider"
type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
connectionStringName="DmsConnectionString"
enablePasswordRetrieval="false"
enablePasswordReset="true"
requiresQuestionAndAnswer="false"
applicationName="/Web1"
requiresUniqueEmail="false"
passwordFormat="Hashed"
maxInvalidPasswordAttempts="5"
minRequiredPasswordLength="1"
minRequiredNonalphanumericCharacters="0"
passwordAttemptWindow="10"
passwordStrengthRegularExpression=".*" />
</providers>
</membership>Die Rollenverwaltung kann über die Webconfig- Datei gesteuert werden wie z.B. Name des ConnectionStrings der Datenbank mit den AspNetDb- Strukturen, Passwort- Struktur etc.. Im folgenden die Originaldaten aus der Machine.config Datei.
<roleManager>
<providers>
<add name="AspNetSqlRoleProvider"
connectionStringName="LocalSqlServer"
applicationName="/"
type="System.Web.Security.SqlRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
/>
<add name="AspNetWindowsTokenRoleProvider"
applicationName="/"
type="System.Web.Security.WindowsTokenRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
/>
</providers>
</roleManager> <!-- Konfiguration der ASP.NET 2.0 Rollenverwaltung -->
<roleManager enabled="true">
<providers>
<clear />
<add connectionStringName="DmsConnectionString"
applicationName="/Web1"
name="AspNetSqlRoleProvider"
type="System.Web.Security.SqlRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
<add applicationName="/Web1"
name="AspNetWindowsTokenRoleProvider"
type="System.Web.Security.WindowsTokenRoleProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a" />
</providers>
</roleManager> Wurden Membership und Rollenverwaltung erfolgreich konfiguriert, dann können Benutzer und Rollen komfortabel eingerichtet werden mittels des webbasierten Konfigurationstools. Dadurch ist es möglich, ohne eine aufwendig selbstprogrammierte Webforms einer Anwendung einen elementaren Satz von Benutzern und Rollen in der aspnetdb einzurichten.
Ein besonderes Merkmal von ASP.NET ist die Beschleunigung der Ausführungsgeschwindigkeit durch Kompilation der Sites. Es gibt drei Varianten der Kompilation:
dynamisches Kompilieren
Direktes Vorkompilieren
Vorkompilieren für die Bereitstellung
Dies ist die Standartoption. Die Webseiten werden unmittelbar vor dem ersten Abruf durch einen Benutzer vom System kompiliert. Erneute Abrufe der Webseiten greifen auf die Kompilate aus den vorausgegangenen Abrufen zurück. Somit ist der erste Abruf einer dynamisch kompilierten Webseite bezüglich der Ausführungszeit der ungünstigste, alle folgenden Abrufe sind in der Ausführungszeit deutlich verkürzt.
Vorteil der dynamischen kompilierung ist, das die Webseite jederzeit aktualisiert werden kann. Geänderte Webseiten werden automatisch neu kompiliert.
Bei dieser Option werden die Webseiten auf dem Host mittels des aspnet_compiler- Tools alle Kompiliert. Die Quelltextdateien verbeiben aber auf dem Server und können nachträglich geändert werden. Das System erkennt wie bei der dynamischen Kompilierung die geänderten Seiten und veranlasst für diese vor dem ersten Abruf wieder eine Kompilation.
Vorteil gegenüber der dynamischen Kompilierung ist eine deutlich bessere Performannce unmittelbar nach dem Vorkompilieren.
aspnet_compiler -v:VirtuellesVerzeichnisAufIIS
Bei dieser Option werden die Webseiten wie beim Direkten Vorkompilieren mittels des aspnet_compiler Tools übersetzt. Jedoch werden alle übersetzen Dateien in ein neues Verzeichnis kopiert. Die Quelltexte werden nicht in das neue Verzeichnis übernommen.
Vorteil gegenüber der direkten Kompilierung ist, daß Quelltexte nicht auf dem Server verteilt werden und so geistiges Eigentum besser geschützt werden kann.
aspnet_compiler -v:VirtuellesVerzeichnisAufIIS /targetpath
Das grundlegende Arbeitsprinzip eines Webservers ist der Request-Response Zyklus. Dabei fordert der Browser über das HTTP- Protokoll eine Webseite vom Server an, un dieser liefert als Antwort die Webseite zurück, falls sie im Zugriff des Webservers sich befindet.
|
Definition |
|
|---|---|
|
PostBack |
Ist ein HTTP- Request, bei dem die Eingaben in ein Formular mitgesendet werden. |
Ein wesentliches Merkmal von ASP.NET ist die Abbildung des Request/Response Zyklus auf ein ereignisgesteuertes Programmiermodell. Dabei werden zu bestimmten Zeitpunkten innerhalb des Seitenaufbaus Ereignisse ausgelöst, für die der Programmierer Ereignishandler registrieren, und so den Aufbau der Seite beeinflussen kann. Für Request, die durch Klicks auf Formularelemente im Browser ausgelöst wurden, werden beim Seitenaufbau ebenfalls Ereignisse ausgelößt, so daß Programmieren in ASP.NET große Ähnlichkeit mit der Programmierung einer Windows- Forms Anwendung erhält.
Wird in der <%@ Page ...> Direktive das Attribut AutoEventWireup="true" gesetzt, dann interpretiert der Compiler Methoden, die dem Namensschema Page_Ereignisname entsprechen als Ereignishandler, und bindet sie an die entsprechde Ereignisse.
Ist AutoEventWireup="false",dann müssen die Ereignisse des Seitenaufbaus manuell an die entsprechenden Eventhandler gebunden werden.
Steuerelemente, die in der *.aspx Datei durch Markup deklariert werden, werden an Eventhandler durch OnEreignisname="Name_des_Ereignishandlers" gebunden.
Für dynamisch erstellte Steuerelemente erfolgt die Bindung durch
Steuerelementobjekt.Event += DelegateEvent(Eventhandler)
Page ist die Basisklasse aller Eventhandler- Container in den Code- Behind Dateien.
Die ASP.NET Laufzeit verpackt die HTTP- Anfrage von einem Webbrowser in eine Instanz der Klasse HttpRequest.
Der Querystring liefert eine gesplittete Uri, die der Request des Browsers abgesendet hat. Die Uri wird in Wikipedia (http://de.wikipedia.org/wiki/Uniform_Resource_Identifier) erläutert.
Die Ausgabe an einen Webbrowser wird über eine Instanz der Klasse HttpResponse gesteuert:
Die Ereignisroutinen einer Anwendung werden in der Datei Global.asax definiert.
<@ Application Language="C#" ClassName="myApp" %>
<script language="VB" runat="server">
void Application_Start(Object sender, EventArgs e) {
// wird beim Starten der Applikation ausgeführt
}
void Session_Start(Object sender, EventArgs e) {
// wird beim Starten der Sitzung ausgeführt
}
void Session_End(Object sender, EventArgs e) {
// wird beim beenden einer Sitzung ausgeführt
}
void Application_End(Object sender, EventArgs e) {
// wird beim beenden einer Anwendung ausgeführt
}
</script>|
Definition |
|
|---|---|
|
Anwendungszustand |
Der Anwendungszustand ist ein gemeinsamer Speicherbereich, der allen Sitzungen bereitgestellt wird. Über den Anwendungszustand ist eine Kommunikation zwischen den Sitzungen möglich. |
Der Anwendungszustand ist eine Instanz der Klasse HttpApplication. Wie schon im klassischen ASP verhält sich diese wie ein Dictionary, das jede Zustandsvariable einem Zugriffsschlüssel zuordnet:
Eine Besonderheit in ASP.NET ist, das auch Klassenfelder (Felder mit dem Modifikator static in C# oder Shared in VB.NET) zum Anwendungszustand gehören. Folgende Deklaration erweitert den Anwendungszustand um eine Integervariable.
class C1 {
public static int x;
}Alle Sitzungen können über C1.x kommunizieren !
Alle Sitzungen haben Zugriff auf den Anwendungszustand. Deshalb ist eine Synchronisierung der konkuriererenden Zugriffe notwendig. Die Klasse Application bietet dazu die statischen Methoden Applikation.Lock() und Application.Unlock() an.
void Application_Start(object sender, EventArgs e) { // Code, der beim Starten der Anwendung ausgeführt wird. Application.Add("countSessions", 0); } void Session_Start(object sender, EventArgs e) { // Code, der beim Starten einer neuen Sitzung ausgeführt wird. // Auf die Tabelle im Anwendungszustand zugreifen Application.Lock(); // Synchronisieren des Zugriffs int countSessions = (int)Application["countSessions"]; countSessions++; Application["countSessions"] = countSessions; Application.UnLock(); }
Ähnlich wie der Anwendungszustand verhalten sich auch statische Variablen. Auch diese teilen sich alle Sitzungen, d.h. wird eine statische Membervariable wie folgt definiert, dann teilen sich alle Sitzungen den reservierten Speicherplatz. Auch hier ist Synchronisation erforderlich, z.B. mit Mutex- Objekten.
class MyClass { … // Alle Sitzungen haben Zugriff auf folgenden Variable. Konkurrierende Schreib- // und Lesezugriffe müssen synchronisiert werden ! public static int myStatikMember = 99; }
|
Definition |
|
|---|---|
|
Sitzungsstatus |
Ist eine Collection von Objekten, die den Zustand einer Sitzung widerspiegeln Deklaration: HttpSessionState Session; |
In C# müssen Anwendungsstatusvariablen initialisiert werden, bevor Operationen auf diesen ausgeführt werden !
Sessions können in einer web.config- Datei zentral, oder pro Seite an oder abgeschaltet werden.
<configuration>
<system.web>
<pages enableSessionState="true"/>
</system.web>
</configuration><%@ Page EnableSessionState="true|false" %>
Genaue
Infos finden Sie unter
ms-help://MS.NETFrameworkSDK.DE/cpguidenf/html/cpconcontrolexecutionlifecycle.htm
Bei einem Request werden mehrere Ereignisse ausgelößt, auf die durch die Ereignishandler eines Page- Objektes reagiert wird.
Das erste Ereignis bei einem Request ist Init. Im Ereignishandler Page_Init werden Serversteuerelemente instanziiert, und mit den Benutzereingaben aus dem aus dem Request initialisiert.
Das Page- Objekt einer ASP.NET- Seite besitzt einen Eventhandler, die Prozedur Page_Load(ByVal sender as Object, ByVal e as EventArgs). Diese wird vom Programmierer überschrieben. In ihr erfolgt die Verarbeitung der Benutzereingaben eines Requests, und als Antwort wird das Dom der Seite modifiziert oder neu aufgebaut.
Ähnlich wie der Zustand einer Sitzung definiert der Anzeigestatus den Zustand einer WebForm. Die Zustandsdaten werden in einem versteckten kodierten Feld abgelgt. Primär dient der Viewstate dazu, die Inhalte von Steuerelementen über die Request- Zyklen hin zu erhalten. Eigene Zustandsvariablen könne jedoch hinzugefügt werden.
if (ViewState["anz-req"] == null) ViewState["anz-req"] = 0; int wert = Convert.ToInt32(ViewState["anz-req"]); ViewState["anz-req"] = ++wert;
Jedes Steuerelement verfügt über die Eigenschaft enableViewState. Wird ihr der Wert false zugewiesen, dann erfolgt keine Speicherung des Steuerelementeinhaltes in ViewState. So kann das Transfervolumen eines Request/Response- Zyklus gemindert werden (insbesondere bei Berechneten Feldern sollte der ViewState abgeschaltet werden).
Werden in einer Webanwendung mehrere WebForms entwickelt, dann ist es oft wünschenswert, diesen ein einheitlichen Rahmen zu verpassen, welcher z.B. eine Kopfzeile mit dem Firmenlogo, und ein Menü enthält.
Die Bereitstellung eines solchen einheitlichen Rahmens erfolgt durch sog. Masterpages. Dabei wird der Html Code in einer Datei mit der Extension *.master abgelegt, und Serverseitiger Code in *.master.cs oder *.master.vb Dateien.
Eine Masterpage ist eine Datei mit der Extension *.master, und wird mit einer speziellen Direktive eingeleitet:
<%@ Master Language="C#" AutoEventWireup="true" CodeFile="DmsSearch.master.cs" Inherits="DmsSearch" %> <!-- Inhalt ist HTML- Markup der Masterpage sowie <asp:ContentPlaceHolder>- Elemente, durch welche Inhaltsseiten eingebette werden können -->
In ihr befindet sich das HTML- Markup der Masterpage. Der Code der Serversteuerelemente aus der Masterpage ist in einer C#- Datei mit der Extension *.master.cs enthalten. In dieser können auch die Eigenschaften des Masterpage- Objektes programmatisch gesetzt werden:
Die Basisklasse Page für Webforms wurde in NET 2.0 um Eigenschaften erweitert, mittels der sie ihre Masterpage definieren und deren Objekt referenzieren.
|
Achtung: Obwohl die Inhaltsseiten in den Masterseiten durch ContentPlaceHolder- Elemente eingebetet werden, ist die Beziehung im Objektmodell umgekehrt: Die Inhaltsseiten verweisen durch ihre Eigenschaft Master auf das Masterpage- Objekt. Die Unterordnung der Masterpage wird auch bei ihrer Funktion deutlich: Beim Response stellt das Markup vor dem Placeholder den Prolog beim Response der Inhaltseite, und das Markup nach dem Placeholder den Epilog dar. |
Um Stylesheets und Skin- Dateien der Webform, über die die Masterpagegelegt wird, auch auch die Masterpage wirken zu lassen, muß in deren Page- Direktive das Attribut EnableTheming auf true gesetzt werden:
EnableTheming="true"
Soll der Benutzer das Layout anpassen können, so kann er z.B. die MasterPageFile- Eigenschaft und damit die umrahmende Masterpage ändern. Allerdings ist die nur zum Zeitpunkt PreInit beim Aufbau einer Webform möglich, weshalb etwas umständlich mit zwischenspeicherung in Sessionvariablen und erneuten Seitenaufbau durch Response.Redirekt gearbeitet werden muß:
public partial class WebFormChangeMaster : System.Web.UI.Page
{
void Page_PreInit(Object sender, EventArgs e)
{
// Nur zu diesem Zeitpunkt am Beginn des Seitenaufbaus kann die
// MasterPageFile- Eigenschaft gesetzt werden
if(Session["Masterpage"] != null)
this.MasterPageFile = (string) Session["Masterpage"];
}
protected void Page_Load(object sender, EventArgs e)
{
}
protected void btnMasterA_Click(object sender, EventArgs e)
{
// Speichern des Pfades der Masterpage- Datei im Sitzungs-
// zustand, damit sie beim nächsten Seitenaufbau gesetzt
// werden kann
Session["Masterpage"] = "MP-A.master";
// Initiirung eines erneuten Seitenaufbaus
Response.Redirect(Request.Url.ToString());
}
protected void btnMasterB_Click(object sender, EventArgs e)
{
Session["Masterpage"] = "MP-B.master";
Response.Redirect(Request.Url.ToString());
}
}Mittels einer Multiview können die Steuerelemente einer Webform in Teilmengen aufgeteilt werden. Die Teilmengen werden durch View- Blöcke definiert. Immer nur eine View kann zur aktiven View werden. Die Steuerelemente innerhalb der aktiven View werden reendert und an den Server gesendet - die Steuerelemente aus den anderen Views sind dann unsichtbar.
Durch Auswählen einer neuen aktiven View wird eine andere Teilmenge der Steuerelemente sichbar gemacht.
Befinden
sich in Views an Datenquellsteuerelementen gebundene
Steuerelemente, so können vor dem umschalten die Daten neu
abgerufen werden, indem für die zu aktivierenden View die
DataBind()- Methode aufgerufen wird.
Analog dem DOM (Document Object Model) auf der Browserseite kann serverseitig das HTML- Dokument in einen Objektbaum umtransformiert.
In der Grundeinstellung wird der gesamte HTML- Quelltext durch einen einzigen Knoten vom Typ LiteralControl dargestellt. Über die Eigenschaft Text kann dann auf den gesamten Inhalt der HTML- Datei lesend und schreibend zugeriffen werden. Text stellt den gesamten Inhalt als String dar.
Wird einem HTML- Element das Attribut runat="server" hinzugefügt, dann erzeugt der Server für dieses im Dokumentenbaum einen weiteren Knoten, der einen von der Klasse HtmlControl abgeleiteten Typ hat.
Beispiel:
<html runat="server"> <head> <title>Server-Dom</title> </head> <body> <h1 runat="Server">DOM</h1> <form runat="server"> <input type="text" runat="server" size="20"/> <input type="button" runat="server" value="senden"/> </form> </body> </html>
Dieses Dokument führt zu folgendem Baum auf dem Server:
|
Name |
Typ |
Inhalt |
|---|---|---|
|
Text |
String |
Tags + Text eines HTML- Elementes, daß nicht durch das Attribut runat="server" als serverseitieger DOM- Knoten deklariert wurde. |
|
Controls |
ControlCollection |
Sind im Element weiter HTML- Elemente enthalten, die mittels runat="server" als serverseitige DOM- Knoten deklariert wurden, dann werden Referenzen vom Typ Control auf diese hier aufgelistet. |
|
Name |
Typ |
Inhalt |
|---|---|---|
|
TagName |
String |
Name des HTML- Tags |
|
ID |
String |
Wert des Attributes ID |
|
Controls |
ControlCollection |
Sind im Element weiter HTML- Elemente enthalten, die mittels runat="server" als serverseitige DOM- Knoten deklariert wurden, dann werden Referenzen vom Typ Control auf diese hier aufgelistet. |
Alle Steuerelemente in ASP.NET sind der gemeinsamen Basisklasse System.Web.UI.Control abgeleitet. Im Folgenden ihre wichtigsten Eigenschaften und Methoden:
ASP.NET bildet die gewöhnlichen HTML- Elemente serverseitig durch eine Klassenbibliothek ab, die im Namensraum System.Web.UI.HtmlControls definiert ist. Mittels dieser Klassen kann bei der Auslieferung einer WebForm auf dem Server programmatisch HTML- Markup generiert werden.
Vom Objekt HTMLControl leiten sich eine Menge von Wrapper- Klassen für HTML- Tags und Formularsteuerlemente ab:
|
Eigenschaft |
Typ |
Inhalt |
|---|---|---|
|
Attributes |
System.Web.UI.AttributeCollection |
Attribut-Wert-Paare eines Elementes |
|
Disabled |
Boolean |
bei true ist das Element deaktiviert |
|
Style |
System.Web.UI.CssStyleCollection |
Collection mit Style-Eigenschaften |
|
TagName |
String |
Name des Elementes |
|
Visible |
Boolean |
bei true ist das Steuerelement im Browser nicht sichtbar |
|
Eigenschaft |
Typ |
Inhalt |
|---|---|---|
|
Name |
String |
Eindeutiger Bezeichner für id und name- Attribut |
|
Value |
String |
Inhalt des Value- Attributes |
|
Type |
String |
Typ des Eingabenfeldes |
|
Definition |
|
|---|---|
|
ContainerControl |
Ein HTML- Element, das weitere Elemente enthalten kann, ist ein ContainerControl. |
Für eine Untermenge von HTML- Elementen wie Hyperlinks und Tabellen gibt es spezielle Klassen wie HtmlAchor und HtmlTable. Alle anderen Containerelemente werden durch die Klasse HtmlGenericControl erfasst.
Bis auf HtmlTable werden von allen ContainerControls folgende Eigenschaften unterstützt:
|
Eigenschaft |
Typ |
Inhalt |
|---|---|---|
|
InnerHtml |
String |
Inhalt zwischen öffnenden und schließenden Tag. Sonderzeichen wie < werden nicht in < konvertiert |
|
InnerText |
String |
Inhalt zwischen öffnenden und schließenden Tag. Sonderzeichen wie < werden werden in < konvertiert |
|
Eigenschaft |
Typ |
Inhalt |
|---|---|---|
|
Align |
String |
Ausrichtung des Bildes: left, center, right, top, middle, bottom |
|
Alt |
String |
Alternativtext für das Bild |
|
Border |
Integer |
Rahmenbreite in Pixeln |
|
Height |
Integer |
Höhe in Pixeln als Prozentangabe |
|
Src |
String |
URL der Bilddatei |
|
Width |
Integer |
Bildbreite in Pixeln oder als Prozentangabe |
HtmlControls dienen in erster Linie der Integration der klassischen HTML- Elemente in ASP.NRT. Für die serverseitig Verarbeitung sind die Webserversteuerelemente vorgesehen. Soll ein HtmlControl ebenfalls serverseitig verarbeitet werden, dann muß
das Attribut runat="server" gesetzt sein
Das Element ein id Attribut besitzen
In VisualStudio kann dies automatisiert erfolgen, in dem zum HtmlControl das Kontextmenü aufgerufen wird, und hier "Als Serversteuerung ausführen" angeklickt wird.
Buttons können durch das Attribut OnServerClick mit einer Ereignisprozedur verknüpft werden, indem der Name als Wert an das Attribut Übergeben wird:
: sub btnJa_Click(source as Object, e as EventArgs) ausgabe.innerText = "JA" end sub : <input runat="server" type="submit" id="btnJa" value="Ja" OnServerClick="btnJa_Click"/> :
Liste aller Steuerelemente unter : ms-help://MS.NETFrameworkSDK.DE/cpgenref/html/cpconaspsyntaxforwebcontrols.htm
Namensraum: System.Web.UI.WebControls.WebControl
Während HTMLControls als Wrapper für HTML dienen, stellen Webserversteuerelemente eine eigene Klassenbibliothek von GUI- Elementen dar, welche schließlich durch das Zusammenwirken von ASP.NET und HTML implementiert werden.
Achtung: Webserversteuerelemente setzten aktiviertes JavaScript im Browser voraus !
Folgende Darstellung der Hierarchie aus der .NET- 1.1 Doku von Microsoft:
<asp:Label runat="Server">bla bla</asp:Label>
<asp:TextBox
id = "eindeutige Id"
AutoPostBack = "true|false"
Columns = "Anzahl der Spalten"
Rows = "Anzahl Spalten"
MaxLength = "max. Anzahl Zeichen"
Text = "text"
TextMode = "SingleLine | Multiline | Password"
Wrap = "True|False"
OnTextChanged= "Ereignisroutine"
runat = "Server"
/>In ASP.NET bietet einen komfortablen Mechanismus für die Überprüfung von Benutzereingaben: Validierungssteuerelemente. Diese speziellen Webserversteuerelemente können Eingaben auf Vorhandensein, gegen Wertebereiche und gegen reguläre Ausdrücke abprüfen. Die Überprüfung kann Serverseitig als auch Clientseitig durch JavaScript Rountinen erfolgen.
Die Programmierung der Validierung wird auf die Wahl eines Validierungsbausteines und seiner Parametrieung beschränkt.
Q: ms-help://MS.NETFrameworkSDK.DE/cpref/html/frlrfSystemWebUIWebControlsBaseValidatorClassTopic.htm
|
Typ |
Funktion |
Beispiel |
|---|---|---|
|
RequiredFieldValidator |
Prüft das Vorhandensein einer Eingabe |
<input type="text" id="firstName"/>
<asp:RequiredFieldValidator
ControlToValidate="firstName"
runat="server">
Fehlermeldung hier eingeben
</asp:RequiredFieldValidator>
|
|
RangeValidator |
Prüft die Eingabe gengen einen Datentyp und gegen definierte Wertebereiche |
<input type="text" id="preisstufe"/>
<asp:RangeValidator
ControlToValidate="preisstufe"
Type="3"
MinimumValue="1"
MaximumValue="4"
runat="server">
Fehlermeldung hier eingeben
</asp:RangeValidator>
|
|
RegularExpressionValidator |
Prüft eine Eingabe gegen einen Regulären Ausdruck |
<input type="text" id="email"/>
<asp:RegularExpressionValidator
ControlToValidate="email"
ValidationExpression="^.+@.+\..{2,}"
runat="server">
Fehlermeldung hier eingeben
</asp:RegularExpression>
|
|
ValidationSummary |
Fasst Fehlermeldungen von Validierungssteuerelementen, die dort für die Attribute MessageText definiert wurden, der in einer gemeinsamen Ausgabe zusammen |
<input type="text" id="firstName"/>
<asp:RequiredFieldValidator
ControlToValidate="firstName"
MessageText="Eingabe erfoderlich"
runat="server"> *
</asp:RequiredFieldValidator>
<input type="text" id="email"/>
<asp:RegularExpressionValidator
ControlToValidate="email"
ValidationExpression="^.+@.+\..{2,}"
MessageText="keine Email"
runat="server"> *
</asp:RegularExpression>
<asp:ValidationSummary
HeaderText="Folgende Fehler traten auf:"
ShowSummary="true"
DisplayMode="BulletList"
/>
|
Im Script wird die Validierung nach einem PostBack zunächst mit der Funktion Page.Validate aufgerufen. Danach wird mittels IsValid abgeprüft, ob die Validierung Fehler meldete. In Abhägigkeit davon wird die Scriptausführung fortgesetzt oder vorzeitig beendet.
sub Page_Load(ByVal sender as Object, ByVal e as EventArgs)
if isPostBack then
Page.Validate
if IsValid then
' Weitere Verarbeitung der Benutzereingaben
end if
end if
end subDie Validierung kann Client, als auch Serverseitig erfolgen. Ist z.B. ein RequiredFieldValidator auf einer Seite aktiv, und der User möchte sich über einen Logoff- Button ohne etwas eingegeben zu haben ausloggen, dann hat er im Falle der Clientseitigen Validierung ein Problem: bevor sein Logoff an den Server geht blockt der in JavaScript realisierte Validator auf dem Browser den Request mit einer Fehlermeldung ab.
Stellen Sie den Validator auf serverseitige Validierung um:
<input type="text" id="firstName"/>
<asp:RequiredFieldValidator
EnableClientScript = "False"
ControlToValidate="firstName"
runat="server">
Fehlermeldung hier eingeben
</asp:RequiredFieldValidator>Deaktivieren Sie die Validierung für das betreffenden Webserversteuerelement
<asp:Button id="btnLogOff" runat="server" CausesVaidation="False" onClick="btnLogOff_click" text="Logoff"/>
Definieren eines Submitbuttons, welches beim Klick die Validierung abschaltet:
<input id="btnLogOff" onClick="Page_ValidationActive=false;" type="submit" value="Logoff"/>
Das Wizzard- Steuerelement hilft dem Anwender beim Erfassen von Daten oder Konfigurieren komplexer Systeme, indem es den Anwender schriweise durch eine Folge von Dialogen führt. Die Schritte werden durch eine Liste inder aspx- Seite definiert. Wizzard ist definiert in System.Web.UI.Controls.Wizzard:
<asp:Wizard ID="Wizard1" runat="server" ActiveStepIndex="0" Height="289px" Width="674px"
OnFinishButtonClick="Wizard1_FinishButtonClick">
<StartNavigationTemplate>
<asp:Button ID="StartNextButton" runat="server" CommandName="MoveNext" Text="Weiter" />
</StartNavigationTemplate>
<WizardSteps>
<asp:WizardStep stepType="Start" runat="server" Title="Ort und Zeit definieren">
<!-- Steuerelemente zum erfassen der Daten in Schritt 1 -->
</asp:WizardStep>
...
<asp:WizardStep stepType="Step" runat="server" Title="Inhalt definieren">
<!-- Steuerelemente zum erfassen der Daten in Schritt N -->
</asp:WizardStep>
<asp:WizardStep runat="server" StepType="Finish" Title="Suche starten">
<!-- Letzer Schritt -->
</asp:WizardStep>
</WizardSteps>
</asp:Wizard>|
Definition |
|
|---|---|
|
Datenbindung |
Datenbindung beschreibt die Zurodnung einer Datenquelle (z.B. Variable, Array oder DataSet) zu einer Eigenschaft eines Webserversteuerelementes |
Jede Eigenschaft eines Webserversteuerelementes ist an eine Datenquelle bindbar
Die Definition der Datenquelle erfolgt in der Deklaration des Webserversteuerelementes durch einen Bindungsausdruck.
<%# Datenbindungsausdruck %>
Der Bindungsausdruck muß ein gültiger C# Ausdruck sein, welcher zu einem String evaluiert wird. Beispiel:
<asp:Image id="img1" runat="server" ImageUrl="<%# bildersammlung_urls[3] %>" />
Eigenschaften und Methoden, die keine Strings zurückliefern, können durch Einsetzen in die statische Methode eval(Ausdruck) gebunden werden, welche den Ausdruck evaluiert und in einen String umwandelt.
Sollen Attribute bidirektional an Eigenschaften von ASP.NET Objekten gebunden werden, dann muß dies mittels der Methode Bind(Objekteigenschaft-get-set) erfolgen.
<asp:TextBox id="tbxArtikel" Text="<%#Bind(strTxt1)%>"/>
Der Ausdruck wird zur Laufzeit ausgewertet und sein Ergebnis an die Eigenschaft zugewiesen, wenn das DataBinding Ereignis des Webserversteuerelementes ausgelöst wird. Der Bindungsausdruck ist damit Teil einer Ereignisroutine, die an das DataBinding- Ereignis des Webserversteuerelementes gebunden ist.
Das DataBinding- Ereignis wird ausgelöst durch die Methode DataBind() des Webserversteuerelementes selbst, oder durch den Aufruf der Methode DataBind() eines Webserversteuerelements, in dem es eingebettet ist.
ASP.NET ermöglicht, die fast jede Eigenschaft eines Steuerlementes an das Feld eines Datensatzes zu binden.
Der Zugriff auf Datenbanken in .NET erfolgt über ADO.NET. ASP.NET unterstützt den Zugriff auf Datenbanken durch:
Binden von Steuerelementen an Datenquellen aus Datenbanken
Websteuerlementen für tabellarische Daten (DataGrid, DataList, Repeater)
Über Server- Explorer Vebindung zur Datenbank aufbauen
Tabelle, aus der Daten stammen, mit Maus in WebForm ziehen, die Daten verarbeiten soll - > es entsteht ein DataAdapter und ein Connection- Objekt
Aus DataAdapter ein DataSet generieren
z.B. DataGrid- Steuerelement in die Webform ziehen und über den Eigenschaftsgenerator an das DataSet binden
In der Page_Load- Ereignisroutine der Webform das DataSet mittels der Fill Methode des DataAdapters füllen und anschließend die DataBind- Methode des DataGrids aufrufen. (Effizentier ist es, die DataBind- Methode von Page aufzurufen. Dadurch werden die DataBind- Methoden aller Steuerelemente in der Page aufgerufen).
Werden Listboxen an Datasets gebunden, so muß neben der DataSource- Eigenschaft auch die DataTextField und DataValueField – Eigenschaft gesetzt werden.
DataTextField legt fest, welches Spalten aus dem DataSet an die ListItem.Text- Eigenschaft gebunden werden. Analog definiert DataValueField die Spalten, die an ListItem.Value zu binden sind.
Die
Bindung von Daten an ASP.NET Webseiten wurde in Version 2.0 mit
Klassen erweitert, die die prozedurale Programmierung des
Datenzugriffes mittels ADO.NET DataReader und Datasets durch ein
deklaratives Modell weitgehend ergänzen. Kern sind dabei
Klassen, die von System.Web.UI.DataSourceControl abgeleitet
sind. Über ihre Eigenschaften werden Datenbankverbindungen,
Abfragen und Bindungen an Steuerelemente definiert. Sie kapseln die
Zugriffsprozeduren.
Die GridView ermöglicht das interaktive Bearbeiten von Datensätzen über Auswählen, Bearbeiten und Löschen- Spalten. Auswählen liefert dabei in der Eigenschaft GridView.SelectedValue die Werte der Schlüsselspalten, wobei die Schlüsselspalten in GridView.DataKeysNames zuvor festgelgt werden mußten. Dieser Wert kann in einer SqlDataSource einem Select- Parameter zugewiesen werden, so daß das zurückgelieferte Resultset auf Datensätze mit diesen Schlüssel eingeschränkt werden (-> Anwendung der SqlDataSource für eine DetailView)
Soll ein, durch eine GridView visualiserter Datensatz gelöscht werden, dann muß die Insert- Anweisung der SqlDataSource, welche die Daten für das GridView liefert, Parameter besitzen, deren Namen identisch mit dem Namen der Schlüsselfelder in der Gridview sind. Die Namensgleichheit ist notwendig, da die SqlDataSource die Zuordnung der Schlüsselwerte an die Spalten über die Zurodnung der Spaltennamen an die Parameter steuert. Die Spaltennamen werden dabei automatisch zugeordnet nach der Regel Wert an Parameter wenn Spaltenname = Parametername.
Wird eine Zeile in einer GridView oder ein Datensatz in einer DetailView aktualisiert, dann müssen die Aktualisierungsmethoden für jedes editierbare Feld in der View einen Parameter besitzen, dessen Name gleich dem Name des Feldes ist. Zusätzlich müssen die Aktualiserungsmethoden für jede in der Eigenschaft [Grid/Detail]View.DataKeysNames verzeichnete Schlüsselfeld einen Parameter aufweisen dessen Name nach folgender Vorschrift gebildet wird:
original_<Feldname in der View>
Mittels der ObjectDatasource kann zwischen der Ebene der Datenbankabfragen (niedere) und Steuerelementen wie der GridView (höhere Ebene) eine Schicht geschoben werden, die weitere Kontrolle über den Datenzugriff ermöglicht. Diese Zwischenschicht wird auch als Menge der Geschäftsobjekte (engl. BusinessObjects) bezeichnet. Im Folgenden die Zusammenhänge:
Wird ein Steuerelement mit einer ObjectDatasource an eine Quelle gebunden, und enthält diese Quelle Felder vom Typ Single, Double oder Decimal, dann kann in einer Kulturumgebung es zu Konvertierungsfehlern kommen, die nicht en-US ist. Grund dafür ist wohl ein Bug bei er Implementierung der Datenbindung in der ObjectDatasource.
Es existiert glücklicherweise ein Workaround: Für die betroffene Update- Methode sind die Updateparameter explizit in der OpbjektDatasource zu beschreiben. Man beachte hierbei, dass die Definition der Update- Parameter in der ObjectDatasource keine Deklaration für die Signatur der Update- Methode ist. Vielmehr sind die Update- Parameter Metainformationen, die bei der Konvertierung und Datenbindung der Websteuerelement- Eingabefelder an die Parameter der Updatemethode hinzugezogen werden. Hat eine Update- Methode z.B. als Parameter eine Objektreferenz auf den Datensatz, dann beschreiben die Updateparameter der ObjectDatasource die die Typen der Eigenschaften, welche die Datensatzfelder abbilden. Durch die explizite Angabe wird das Fehleverhalten unterbunden.
Das DataGrid- Steuerelement dient zur tabelarischen Darstellung von Daten, die aus einer Datenquelle stammen. Die Datenquelle kann jedes Objekt sein, dessen Klasse die Schnittstellt IEnumerable unterstützt, z.B:
Arrays
DataSets
DataViews
Die Datenquelle wird über die DataSource - Eigenschaft an das DataGrid- Steuerelement angebunden. Ändern sich die Daten in der Datenquelle, dann muß der Inhalt des DataGrid druch die DataBind() - Methode aktualisiert werden.
// Ereignisroutinen für das Editieren im Datagrid
public void grdEdit(object sender, DataGridCommandEventArgs e)
{
dgrPetrinet.EditItemIndex = e.Item.ItemIndex;
}
public void grdUpdate(object sender, DataGridCommandEventArgs e)
{
dsPetrinet.PetrinetRow row = (dsPetrinet.PetrinetRow)
dsPetrinet1.Petrinet.Rows[e.Item.ItemIndex +
this.dgrPetrinet.CurrentPageIndex *
this.dgrPetrinet.PageSize];
TextBox tbx = (TextBox) e.Item.Cells[0].Controls[0];
row.name = tbx.Text;
tbx = (TextBox) e.Item.Cells[1].Controls[0];
row.description = tbx.Text;
dgrPetrinet.EditItemIndex = -1;
}
public void grdCancel(object sender, DataGridCommandEventArgs e)
{
dgrPetrinet.EditItemIndex = -1;
}
public void grdPageIndexChanged(Object sender, DataGridPageChangedEventArgs e)
{
this.dgrPetrinet.CurrentPageIndex = e.NewPageIndex;
}Das GridView - Steuerelement wird in ASP.NET 2.0 als Alternative zum DataGrid eingeführt. Es vereinfacht die Erstellung tabellarischer Datensichten indem prozedurale Programmierung der Datenbindung, des Paging und des Layouts durch Deklarationen mittels Asp- Markup ersetzt werden. Für den Datenzugriff nutzt GridView die von DataSource abgeleiteten Klassen wie SqlDataSource und XmlDataSource.
Die GrirdView stellt elementare Editierfunktionen wie Bearbeiten und Löschen einer Zeile bereit. Hierzu sind lediglich entsprechende CommanFields der Gridview hinzuzufügen. Für jede Zeile wird dann ein Bearbeiten/Aktualisieren bzw. ein Löschen - Button bereitgestellt. Es muß keine einzige Zeile Code geschrieben werden ! Die Editierfunktionen werden im hintergrund durch Interaktion der GridView mit den DataSource- Steuerelementen bereitgestellt.
Die integrierte Lösch- Funktion der Gridview bietet keine Rückfrage an, durch die der Anwender ein versehentliches Löschen verhindern kann. Hier kann man sich mit einem Allgemeinen Feature von ASP.NET behelfen, der Integration von ClientScripten in Steuerelementen. ASP- Buttons verfügen z.B. über ein Attribut namens OnClientClick. Diesem können JavaScript Anweisungen zugewiesen werden, die beim klicken auf die Schaltfläche gestartet werden. Mittels folgenden Scripts würde der Browser ein Popup- Fenster mit einer OK und einer Cancel - Schaltfläche anzeigen:
OnClientClick="return confirm('Wollen Sie den Benutzer tatsächlich löschen ?');"Gibt das Script den Wert true zurück, dann wird ein Roundtrip zum Server initiert, sonst nicht. Dies kann dierekt für die Integrierte Löschfunktion eines GridView genutzt werden. Zuvor muß das Löschen- CommandField in ein Template- Field umgewandelt werden, wodurch im Markup für die Spalte aus einem CommandField eine TemplateField mit einem ASP Button für das Löschen wird. Das Attribut CommandName muß den Wert "Delete" haben. Nun kann das Attribut OnClientClick mit dem Wert wie im Beispiel zugewiesen werden. Das Resultat ist dann eine durch ein Popup abgesicherte Löschfunktion.
Durch folgenden Trick können Zeilennummern beim Aufbau einer Gridview generiert werden:
<asp:GridView ID="grdTest" AutoGenerateColumns="false" runat="server"> <Columns> <asp:TemplateField HeaderText="Zeilennummer"> <ItemTemplate> Zeile Nr. <strong><%# Container.DataItemIndex +1 %></strong> </ItemTemplate> </asp:TemplateField> <asp:BoundField HeaderText="Schlüssel" DataField="Key" /> </Columns> </asp:GridView>