8. Die Anwendung [SimuPaie] – Version 4 – ASP.NET / mehrere Ansichten / eine Seite

---

Empfohlene Lektüre: Referenz [1], Entwicklung WEB mit ASP.NET 1.1, Abschnitte:

• Serverkomponenten und Anwendungssteuerung

• Anwendungsbeispiele MVC mit Serverkomponenten ASP

---

Wir betrachten nun eine abgeleitete Version der zuvor untersuchten dreischichtigen Anwendung ASP.NET, die um neue Funktionen erweitert wurde. Die Architektur unserer Anwendung entwickelt sich wie folgt:

Die Bearbeitung einer Anfrage eines Kunden erfolgt in folgenden Schritten:

1. Der Kunde sendet eine Anfrage an die Anwendung.
2. Die Anwendung verarbeitet diese Anfrage. Dazu benötigt sie möglicherweise die Unterstützung der Schicht [métier], die ihrerseits die Schicht [dao] benötigen kann, falls Daten mit der Datenbank ausgetauscht werden müssen. Die Anwendung erhält eine Antwort von der Schicht [métier].
3. Anhand dieser Antwort wählt sie (3) die Ansicht (= die Antwort) aus, die an den Client gesendet werden soll, und stellt ihm (4) die benötigten Informationen (das Modell) zur Verfügung.
4. Die Antwort wird an den Client gesendet (5)

Hier handelt es sich um eine sogenannte MVC-Webarchitektur (Model – View – Controller):

• [Application] ist der Controller. Er empfängt alle Anfragen des Clients.
• [Saisies, Simulation, Simulations, ...] sind die Views. Ein View im Format .NET besteht aus Standardcode (ASP / HTML), der Komponenten enthält, die initialisiert werden müssen. Die Werte, die diesen Komponenten zugewiesen werden müssen, bilden das Modell der Ansicht.

Wir werden hier das Muster (Design Pattern) MVC wie folgt implementieren:

• Die Ansichten sind Komponenten vom Typ [View] innerhalb einer einzigen Seite vom Typ [Default.aspx]
• Der Controller ist dann der Code [Default.aspx.cs] dieser einzelnen Seite.

Nur einfache Anwendungen können diese Implementierung MVC unterstützen. Denn bei jeder Anfrage werden alle Komponenten der Seite [Default.aspx] instanziiert, also alle Ansichten. Beim Senden der Antwort wählt der Anwendungscode eine davon aus, indem er einfach die entsprechende Komponente [View] sichtbar macht und die anderen ausblendet. Verfügt die Anwendung über zahlreiche Ansichten, wird die Seite [Default.aspx] viele Komponenten enthalten, und die Kosten für deren Instanziierung können unerschwinglich werden. Zudem besteht die Gefahr, dass die Seite [Design] aufgrund der zu großen Anzahl an Ansichten unüberschaubar wird. Diese Art von Architektur eignet sich für Anwendungen mit wenigen Ansichten, die von einer einzigen Person entwickelt werden. Wenn sie eingesetzt werden kann, ermöglicht sie die sehr einfache Entwicklung einer MVC-Architektur. Genau das werden wir in dieser neuen Version betrachten.

8.1. Die Ansichten der Anwendung

Dem Benutzer werden folgende Ansichten angezeigt:

• die Ansicht [VueSaisies], die das Simulationsformular anzeigt

• die Ansicht [VueSimulation], die zur Anzeige des detaillierten Simulationsergebnisses dient:

• die Ansicht [VueSimulations], die die Liste der vom Kunden durchgeführten Simulationen anzeigt

• die Ansicht [VueSimulationsVides], die anzeigt, dass der Kunde keine oder keine Simulationen mehr hat:

• die Ansicht [VueErreurs], die einen oder mehrere Fehler anzeigt:

8.2. Das Visual Web Developer-Projekt der Ebene [web]

Das Visual Web Developer-Projekt der Ebene [web] sieht wie folgt aus:

• In [1] findet man:
• Die Konfigurationsdatei [Web.config] der Anwendung – ist identisch mit der der vorherigen Anwendung.
• Die Datei [Global.cs], die die Ereignisse der Webanwendung verwaltet – hier deren Start – ist identisch mit der der vorherigen Anwendung, mit dem Unterschied, dass sie zusätzlich den Start der Benutzersitzung verwaltet.
• Das Formular [Default.aspx] der Anwendung – enthält die verschiedenen Ansichten der Anwendung.

• In der Datei [2] befinden sich die Projektreferenzen – sie sind identisch mit denen der vorherigen Version

8.3. Die Datei [Global.cs]

Die Datei [Global.cs], die die Ereignisse der Webanwendung verwaltet, ist identisch mit der der vorherigen Anwendung, mit dem Unterschied, dass sie zusätzlich den Start der Benutzersitzung verwaltet:

Global.cs

using System;
using System.Web;
using Pam.Dao.Entites;
using Pam.Metier.Service;
using Spring.Context.Support;
using System.Collections.Generic;
using istia.st.pam.web;

namespace pam_v4
{
    public class Global : HttpApplication
    {

        // --- statische Anwendungsdaten ---
        public static Employe[] Employes;
        public static string Msg = string.Empty;
        public static bool Erreur = false;
        public static IPamMetier PamMetier = null;

        // Start der Anwendung
        public void Application_Start(object sender, EventArgs e)
        {
...
        }

        // Start der Benutzersitzung 
        public void Session_Start(object sender, EventArgs e)
        {
            // Eine leere Simulationsliste wird in die Sitzung eingefügt 
            Session["simulations"] = new List<Simulation>();
        } 

    }
}

• Zeilen 27–34: Hier wird der Start der Sitzung verwaltet. In diese werden wir die Liste der vom Benutzer durchgeführten Simulationen aufnehmen.
• Zeile 30: Es wird eine leere Simulationsliste erstellt. Eine Simulation ist ein Objekt vom Typ [Simulation], auf das wir im Folgenden näher eingehen werden.
• Zeile 31: Die Simulationsliste wird in die Sitzung eingefügt, die dem Schlüssel „simulations“ zugeordnet ist.

8.4. Die Klasse [Simulation]

Ein Objekt vom Typ [Simulation] dient dazu, eine Zeile der Simulationstabelle zu kapseln:

Sein Code lautet wie folgt:

namespace Pam.Web
{

    public class Simulation
    {
        // Daten einer Simulation 
        public string Nom { get; set; }
        public string Prenom { get; set; }
        public double HeuresTravaillees { get; set; }
        public int JoursTravailles { get; set; }
        public double SalaireBase { get; set; }
        public double Indemnites { get; set; }
        public double CotisationsSociales { get; set; }
        public double SalaireNet { get; set; }

        // Konstruktoren 
        public Simulation()
        {

        }

        public Simulation(string nom, string prenom, double heuresTravailllees, int joursTravailles, double salaireBase, double indemnites, double cotisationsSociales, double salaireNet)
        {
            {
                this.Nom = nom;
                this.Prenom = prenom;
                this.HeuresTravaillees = heuresTravailllees;
                this.JoursTravailles = joursTravailles;
                this.SalaireBase = salaireBase;
                this.Indemnites = indemnites;
                this.CotisationsSociales = cotisationsSociales;
                this.SalaireNet = salaireNet;
            }
        }
    }
}

Die Felder der Klasse entsprechen den Spalten der Simulationstabelle.

8.5. Die Seite [Default.aspx]

8.5.1. Übersicht

Die Seite [Default.aspx] enthält mehrere Komponenten [View], eine für jede Ansicht. Ihr Grundgerüst sieht wie folgt aus:

<%@ Page Language="C#" AutoEventWireup="true" CodeFile="Default.aspx.cs" Inherits="pam_v4.PagePam" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head id="Head1" runat="server">
    <title>Simulateur de paie</title>
</head>
<body background="ressources/standard.jpg">
    <form id="form1" runat="server">
    <asp:ScriptManager ID="ScriptManager1" runat="server" EnablePartialRendering="true" />
    <asp:UpdatePanel runat="server" ID="UpdatePanelPam" UpdateMode="Conditional">
        <ContentTemplate>
            <table>
                <tr>
                    <td>
                        <h2>
                            Simulateur de calcul de paie</h2>
                    </td>
                    <td>
                        <label>
                            &nbsp;&nbsp;&nbsp</label>
                        <asp:UpdateProgress ID="UpdateProgress1" runat="server">
                            <ProgressTemplate>
                                <img src="images/indicator.gif" />
                                <asp:Label ID="Label5" runat="server" BackColor="#FF8000"
                                         EnableViewState="False" Text="Calcul en cours. Patientez ....">
                                        </asp:Label>
                            </ProgressTemplate>
                        </asp:UpdateProgress>
                    </td>
                    <td>
                       <asp:LinkButton ID="LinkButtonFaireSimulation" runat="server" 
                                CausesValidation="False" OnClick="LinkButtonFaireSimulation_Click">
                                    | Faire la simulation<br /></asp:LinkButton>
                       <asp:LinkButton ID="LinkButtonEffacerSimulation" runat="server"
                                     CausesValidation="False" OnClick="LinkButtonEffacerSimulation_Click">
                                    | Effacer la simulation<br /></asp:LinkButton>
                       <asp:LinkButton ID="LinkButtonVoirSimulations" runat="server" 
                                CausesValidation="False" OnClick="LinkButtonVoirSimulations_Click">
                                    | Voir les simulations<br /></asp:LinkButton>
                        <asp:LinkButton ID="LinkButtonFormulaireSimulation" runat="server"
                                CausesValidation="False" OnClick="LinkButtonFormulaireSimulation_Click">
                                | Retour au formulaire de simulation<br /></asp:LinkButton>
                        <asp:LinkButton ID="LinkButtonEnregistrerSimulation" runat="server"
                                CausesValidation="False" OnClick="LinkButtonEnregistrerSimulation_Click">
                                    | Enregistrer la simulation<br /></asp:LinkButton>
                        <asp:LinkButton ID="LinkButtonTerminerSession" runat="server"
                                CausesValidation="False" OnClick="LinkButtonTerminerSession_Click">
                                    | Terminer la session<br /></asp:LinkButton>
                    </td>
            </table>
            <hr />
            <asp:MultiView ID="Vues1" ActiveViewIndex="0" runat="server">
                <asp:View ID="VueSaisies" runat="server">
...
                </asp:View>
            </asp:MultiView>
            <asp:MultiView ID="Vues2" runat="server">
                <asp:View ID="VueSimulation" runat="server">
...
                </asp:View>
                <asp:View ID="VueSimulations" runat="server">
...
                </asp:View>
                <asp:View ID="VueSimulationsVides" runat="server">
...
                </asp:View>
                <asp:View ID="VueErreurs" runat="server">
...
                </asp:View>
            </asp:MultiView>
        </ContentTemplate>
    </asp:UpdatePanel>
    </form>
</body>
</html>

• Zeile 10: das Tag zur Einbindung der Ajax-Erweiterungen
• Zeilen 11–73: der Container UpdatePanel, der durch Ajax-Aufrufe aktualisiert wird
• Zeilen 12–72: der Inhalt des Containers UpdatePanel
• Zeilen 13–52: Der Header, der in jeder Ansicht vorhanden sein wird. Er zeigt dem Benutzer die Liste der möglichen Aktionen in Form einer Liste von Links an.
• Zeile 33: Zu beachten ist das Attribut CausesValidation="False", das bewirkt, dass die Validatoren der Seite beim Anklicken des Links nicht implizit ausgeführt werden. Fehlt dieses Attribut, lautet sein Standardwert True. Die Validierung der Seite kann explizit im serverseitig ausgeführten Code mithilfe der Operation Page.Validate erfolgen.
• Zeilen 53–57: Eine Komponente [MultiView] mit einer einzigen Ansicht [VueSaisies]. Aus diesem Grund wurde in Zeile 53 die Nummer der anzuzeigenden Ansicht fest codiert: ActiveViewIndex="0"
• Zeilen 53–67: eine Komponente [MultiView] mit vier Ansichten: die Ansicht [VueSimulation] in den Zeilen 59–61, die Ansicht [VueSimulations] in den Zeilen 62–64, die Ansicht [VueSimulationsVides] in den Zeilen 65–67, die Ansicht [VueErreurs] in den Zeilen 68–70. Eine Komponente [MultiView] zeigt jeweils nur eine Ansicht an. Um die Ansicht Nr. i der Komponente Vues2 anzuzeigen, schreibt man folgenden Code:

Vues2.ActiveViewIndex=i

8.5.2. Die En -Kopfzeile

Der Header besteht aus folgenden Komponenten:

Nr.	Typ	Name	Rolle
1	LinkButton	LinkButtonFaireSimulation	Fordert die Berechnung der Simulation an
2	LinkButton	LinkButtonEffacerSimulation	Löscht das Eingabeformular
3	LinkButton	LinkButtonVoirSimulations	zeigt die Liste der bereits durchgeführten Simulationen an
4	LinkButton	LinkButtonFormulaireSimulation	kehrt zum Eingabeformular zurück
5	LinkButton	LinkButtonEnregistrerSimulation	speichert die aktuelle Simulation in der Simulationsliste
6	LinkButton	LinkButtonTerminerSession	Beendet die aktuelle Sitzung

8.5.3. Die Ansicht [Saisies]

Die Komponente [View] mit dem Namen [VueSaisies] lautet wie folgt:

Nr.	Typ	Name	Rolle
1	DropDownList	ComboBoxEmployes	Enthält die Liste der Namen der Mitarbeiter
2	TextBox	TextBoxHeures	Anzahl der geleisteten Arbeitsstunden – Ist-Zahl
3	TextBox	TextBoxJours	Anzahl der Arbeitstage – Ganzzahl
4	RequiredFieldValidator	RequiredFieldValidatorHeures	prüft, ob das Feld [2] [TextBoxHeures] nicht leer ist
5	RegularExpressionValidator	RegularExpressionValidatorHeures	Überprüft, ob das Feld [2] [TextBoxHeures] eine reelle Zahl >= 0 ist
6	RequiredFieldValidator	RequiredFieldValidatorJours	Prüft, ob das Feld [3] [TextBoxJours] nicht leer ist
7	RegularExpressionValidator	RegularExpressionValidatorJours	prüft, ob das Feld [3] [TextBoxJours] eine ganze Zahl >= 0 ist

8.5.4. Die Ansicht [Simulation]

Die Komponente [View] mit dem Namen [VueSimulation] lautet wie folgt:

Sie besteht ausschließlich aus Komponenten [Label], von denen die ID oben aufgeführt sind.

8.5.5. Die Ansicht [Simulations]

Die Komponente [View] mit dem Namen [VueSimulations] lautet wie folgt:

Nr.	Typ	Name	Rolle
1	GridView	GridViewSimulations	Enthält die Liste der Simulationen

Die Eigenschaften der Komponente [GridViewSimulations] wurden wie folgt definiert:

• in [1]: Rechtsklick auf [GridView] / Option [Mise en forme automatique]
• in [2]: Wählen Sie einen Anzeigetyp für [GridView]

• in [3]: Eigenschaften des [GridView] auswählen
• in [4]: Bearbeiten der Spalten des [GridView]
• in [5]: Fügen Sie eine Spalte vom Typ [BoundField] hinzu, die mit einer der öffentlichen Eigenschaften des Objekts verknüpft (gebunden) wird, das in der Zeile von [GridView] angezeigt werden soll. Das hier angezeigte Objekt ist ein Objekt vom Typ [Simulation].

• in [6]: Geben Sie den Spaltentitel an
• in [7]: Geben Sie den Namen der Eigenschaft der Klasse [Simulation] an, die dieser Spalte zugeordnet wird.
• [DataFormatString] gibt an, wie die in der Spalte angezeigten Werte formatiert werden sollen.

Die Spalten der Komponente [GridViewSimulations] weisen folgende Eigenschaften auf:

Nr.	Eigenschaften
2	Typ: BoundField, HeaderText: Name, DataField: Name
3	Typ: BoundField, HeaderText: Nachname, DataField: Vorname
4	Typ: BoundField, HeaderText: Geleistete Arbeitsstunden, DataField: HeuresTravaillees
5	Typ: BoundField, HeaderText: Arbeitstage, DataField: JoursTravailles
6	Typ: BoundField, HeaderText: Grundgehalt, DataField: SalaireBase, DataFormatString: {0:C} (Währungsformat, C = Währung) – zeigt das Euro-Symbol an.
7	Typ: BoundField, HeaderText: Zulagen, Datenfeld: Zulagen, DataFormatString: {0:C}
8	Typ: BoundField, HeaderText: Sozialabgaben, DataField: CotisationsSociales, DataFormatString: {0:C}
9	Typ: BoundField, HeaderText: Nettogehalt, DataField: SalaireNet, DataFormatString: {0:C}

Es ist zu beachten, dass das Feld [DataField] einer vorhandenen Eigenschaft der Klasse [Simulation] entsprechen muss. Am Ende dieser Phase wurden alle Spalten vom Typ [BoundField] angelegt:

• in [1]: die für [GridView] erstellten Spalten
• in [2]: Die automatische Generierung der Spalten muss unterbunden werden, wenn der Entwickler sie selbst definiert, wie wir es gerade getan haben.

Nun müssen wir noch die Spalte mit den Links [Retirer] erstellen:

• in [1]: Fügen Sie eine Spalte vom Typ [CommandField / Supprimer]
• in [2]: ButtonType=Link, um in der Spalte einen Link statt einer Schaltfläche zu erhalten
• in [3]: CausesValidation=False; ein Klick auf den Link löst keine Validierungsprüfungen aus, die sich möglicherweise auf der Seite befinden. Das Löschen einer Simulation erfordert nämlich keine Datenüberprüfung.
• in [4]: Es ist nur der Löschlink sichtbar.
• in [5]: Der Text dieses Links

8.5.6. Die Ansicht [SimulationsVides]

Die Komponente [View] mit dem Namen [VueSimulationsVides] enthält lediglich Text:

8.5.7. Die Ansicht [Erreurs]

Die Komponente [View] mit dem Namen [VueErreurs] sieht wie folgt aus:

Nr.	Typ	Name	Rolle
1	Repeater	RptErreurs	zeigt eine Liste von Fehlermeldungen an

Die Komponente [Repeater] ermöglicht es, einen Code ASP.NET / HTML für jedes Objekt einer Datenquelle, in der Regel einer Sammlung, zu wiederholen. Dieser Code ist direkt im Quellcode ASP.NET der Seite definiert:

                <asp:Repeater ID="RptErreurs" runat="server">
                    <ItemTemplate>
                        <li>
                            <%# Container.DataItem %>
                        </li>
                    </ItemTemplate>
</asp:Repeater>

• Zeile 2: <ItemTemplate> definiert den Code, der für jedes Element der Datenquelle wiederholt wird.
• Zeile 4: Zeigt den Wert des Ausdrucks Container.DataItem an, der das aktuelle Element der Datenquelle bezeichnet. Da es sich bei diesem Element um ein Objekt handelt, wird die Methode ToString dieses Objekts verwendet, um es in den Datenstrom HTML der Seite einzubinden. Unsere Objektsammlung wird eine List(Of String)-Sammlung sein, die Fehlermeldungen enthält. Die Zeilen 3–5 fügen <li>Message</li>-Sequenzen in den Datenstrom HTML der Seite ein.

8.6. Der Controller [Default.aspx.cs]

8.6.1. Übersicht

Kehren wir zur Architektur MVC der Anwendung zurück:

• [Default.aspx.cs], der den Steuerungscode der einzelnen Seite enthält, ist der Controller der Anwendung.
• [Global] ist das Objekt vom Typ [HttpApplication], das die Anwendung initialisiert und über eine Referenz auf die Schicht [métier] verfügt.

Das Code-Gerüst des Controllers [Default.aspx.cs] sieht wie folgt aus:

using System.Collections.Generic;
...

public partial class PagePam : Page
{

    private void setVues(bool boolVues1, bool boolVues2, int index)
    {
        // Die angeforderten Ansichten werden angezeigt 
        // boolVues1: true, wenn die Mehrfachansicht „Ansichten1“ sichtbar sein soll 
        // boolVues1: true, wenn die Mehrfachansicht „Ansichten2“ sichtbar sein soll 
        // index: Index der anzuzeigenden Ansicht von „Ansichten2“ 
...
    }

    private void setMenu(bool boolFaireSimulation, bool boolEnregistrerSimulation, bool boolEffacerSimulation, bool boolFormulaireSimulation, bool boolVoirSimulations, bool boolTerminerSession)
    {
        // Hier werden die Menüoptionen festgelegt 
        // Jeder boolesche Wert wird der Eigenschaft „Visible“ des entsprechenden Links zugewiesen 
...
    }

    // Laden der Seite 
    protected void Page_Load(object sender, System.EventArgs e)
    {
        // Verarbeitung der ersten Anfrage 
        if (!IsPostBack)
        {
...
        }
    }

    protected void LinkButtonFaireSimulation_Click(object sender, System.EventArgs e)
    {
...
    }

    protected void LinkButtonEffacerSimulation_Click(object sender, System.EventArgs e)
    {
....
    }

    protected void LinkButtonVoirSimulations_Click(object sender, System.EventArgs e)
    {
...
    }

    protected void LinkButtonEnregistrerSimulation_Click(object sender, System.EventArgs e)
    {
...
    }

    protected void LinkButtonTerminerSession_Click(object sender, System.EventArgs e)
    {
...
    }

    protected void LinkButtonFormulaireSimulation_Click(object sender, System.EventArgs e)
    {
...
    }


    protected void GridViewSimulations_RowDeleting(object sender, GridViewDeleteEventArgs e)
    {
...
    }
}

Bei der ersten Anfrage (GET) des Benutzers wird nur das Ereignis Load in den Zeilen 24–31 verarbeitet. Bei den folgenden Anfragen (POST), die über die Menü-Links erfolgen, werden zwei Ereignisse verarbeitet:

1. das Ereignis Load (24–31), doch aufgrund der Überprüfung des Booleschen Werts Page.IsPostback (Zeile 27) wird keine Aktion ausgeführt.
2. das Ereignis, das mit dem angeklickten Link verbunden ist:

• Zeilen 33–36: Verarbeiten den Klick auf den Link [1]
• Zeilen 38–41: Verarbeiten den Klick auf den Link [2]
• Zeilen 43–46: Verarbeiten den Klick auf den Link [3]
• Zeilen 58–61: Verarbeiten den Klick auf den Link [4]
• Zeilen 48–51: Verarbeiten den Klick auf den Link [5]
• Zeilen 53–56: Verarbeiten den Klick auf den Link [6]

Um häufig wiederkehrende Codeabschnitte zu abstrahieren, wurden zwei interne Methoden erstellt:

• setVues, Zeilen 7–14: Legt die anzuzeigende(n) Ansicht(en) fest
• setMenu, Zeilen 16–21: Legt die anzuzeigenden Menüoptionen fest

8.6.2. Das Load-Ereignis

---

Empfohlene Lektüre: Referenz [1], Entwicklung WEB mit ASP.NET 1.1:

• Abschnitt „Komponente [Repeater] und Datenverknüpfung“.

---

Die erste Ansicht, die dem Benutzer angezeigt wird, ist die des leeren Formulars:

Die Initialisierung der Anwendung erfordert den Zugriff auf eine Datenquelle, was fehlschlagen kann. In diesem Fall wird eine Fehlerseite angezeigt:

Das Ereignis [Load] wird analog zu den vorherigen Versionen ASP.NET verarbeitet:

    // Laden der Seite 
    protected void Page_Load(object sender, System.EventArgs e)
    {
        // Verarbeitung der ersten Anfrage 
        if (!IsPostBack)
        {
            // Initialisierungsfehler? 
            if (Global.Erreur)
            {
                // Anzeige der Ansicht [erreurs] 
...
                // Menüpositionierung 
                ...
                return;
            }
            // Laden der Mitarbeiternamen in das Kombinationsfeld 
...
            // Menüpositionierung 
...
            // Anzeige der Ansicht [saisie] 
 ...
        }
}

---

Aufgabe: Vervollständigen Sie den obigen Code

---

8.6.3. Aktion: Simulation durchführen

Im Folgenden bezeichnet die mit (1) gekennzeichnete Seite die Anfrage des Benutzers, die mit (2) gekennzeichnete Seite die Antwort, die ihm von der Webanwendung gesendet wird. Von der Startseite aus kann der Benutzer eine Simulation starten:

- (1): Der Benutzer fordert eine Simulation an

- (2): Ergebnis der Simulation

Die Prozedur, die diese Aktion verarbeitet, könnte wie folgt aussehen:

    protected void LinkButtonFaireSimulation_Click(object sender, System.EventArgs e)
    {
        // Lohnberechnung 
        // Seite gültig? 
        Page.Validate();
        if (!Page.IsValid)
        {
            // Anzeige der Ansicht [saisie] 
            ...
            return;
        }
        // Die Seite ist gültig – die Eingaben werden übernommen 
        double HeuresTravaillées = ...;
        int JoursTravaillés = ...;
        // Das Gehalt des Mitarbeiters wird berechnet 
        FeuilleSalaire feuillesalaire;
        try
        {
            feuillesalaire = ...
        }
        catch (PamException ex)
        {
            // Anzeige der Ansicht [erreurs] 
...
            return;
        }
        // Das Ergebnis wird in die Sitzung geschrieben 
        Session["simulation"] = ...
        // Anzeige der Ergebnisse 
...
        // Anzeige der Ansichten [saisie, employe, salaire] 
        ...
        // Menü anzeigen 
        ...
}

---

Frage: Vervollständigen Sie den obigen Code

---

8.6.4. Aktion: Simulation speichern

Sobald die Simulation abgeschlossen ist, kann der Benutzer deren Speicherung anfordern:

- (1): Antrag auf Speicherung der aktuellen Simulation

- (2): Die Simulation wird gespeichert und die Liste der durchgeführten Simulationen wird angezeigt

Die Prozedur, die diese Aktion verarbeitet, könnte wie folgt aussehen:

    protected void LinkButtonEnregistrerSimulation_Click(object sender, System.EventArgs e)
    {
        // Die aktuelle Simulation wird in der Simulationsliste der Sitzung gespeichert 
        ...
        // Die Ansicht [simulations] wird angezeigt 
        ...
}

---

Frage: Vervollständigen Sie den obigen Code

---

8.6.5. Aktion: Zurück zum Simulationsformular

---

Empfohlene Lektüre: Referenz [1], [Développement WEB avec ASP.NET 1.1 ]: Die Rolle des versteckten Feldes _VIEWSTATE

---

Sobald die Liste der Simulationen angezeigt wird, kann der Benutzer die Rückkehr zum Simulationsformular anfordern:

Es ist zu beachten, dass der Bildschirm (2) das Formular so anzeigt, wie es eingegeben wurde. Dabei ist zu beachten, dass diese verschiedenen Ansichten zu derselben Seite gehören. Zwischen den verschiedenen Abfragen werden die Werte der Komponenten durch den Mechanismus von ViewState beibehalten, sofern diese Komponenten die Eigenschaften EnableViewState bis true aufweisen.

Die Prozedur, die diese Aktion verarbeitet, könnte wie folgt aussehen:

    protected void LinkButtonFormulaireSimulation_Click(object sender, System.EventArgs e)
    {
        // Ansicht anzeigen [saisie] 
        ...
        // Menüpositionierung 
        ...
}

---

Frage: Vervollständigen Sie den obigen Code

---

8.6.6. Aktion: Simulation löschen

Sobald der Benutzer zum Simulationsformular zurückgekehrt ist, kann er das Löschen der vorhandenen Eingaben anfordern:

Die Prozedur, die diese Aktion verarbeitet, könnte wie folgt aussehen:

    protected void LinkButtonEffacerSimulation_Click(object sender, System.EventArgs e)
    {
        // RAZ des Formulars 
        ...
}

---

Frage: Vervollständigen Sie den obigen Code

---

8.6.7. Aktion: Simulationen anzeigen

Der Benutzer kann die bereits durchgeführten Simulationen anzeigen lassen:

Die Prozedur, die diese Aktion verarbeitet, könnte wie folgt aussehen:

protected void LinkButtonVoirSimulations_Click(object sender, System.EventArgs e)
    {
        // Die Simulationen werden in der Sitzung abgerufen
        ...
        // Gibt es Simulationen? 
        if (...)
        {
            // Ansicht [simulations] sichtbar 
...
        }
        else
        {
            // Ansicht [SimulationsVides] 
            ...
        }
        // Das Menü wird festgelegt 
        ...
    }

---

Aufgabe: Vervollständigen Sie den obigen Code

---

8.6.8. Aktion: Eine Simulation löschen

Der Benutzer kann das Löschen einer Simulation anfordern:

Die Prozedur [GridViewSimulations_RowDeleting ], die diese Aktion verarbeitet, könnte wie folgt aussehen:

    protected void GridViewSimulations_RowDeleting(object sender, GridViewDeleteEventArgs e)
    {
        // Simulationen werden in die Sitzung geladen
        ...
        // die angegebene Simulation wird gelöscht (e.RowIndex ist die Nummer der gelöschten Zeile)
        ...
        // Sind noch Simulationen vorhanden? 
        if (...)
        {
            // Das Feld GridView wird ausgefüllt 
 ...
        }
        else
        {
            // Ansicht [SimulationsVides] 
            ...
        }
}

---

Frage: Vervollständigen Sie den obigen Code

---

8.6.9. Aktion: Sitzung beenden

Der Benutzer kann das Beenden seiner Simulationssitzung anfordern. Dadurch wird der Inhalt seiner Sitzung verworfen und ein leeres Formular angezeigt:

Die Prozedur, die diese Aktion verarbeitet, könnte wie folgt aussehen:

    protected void LinkButtonTerminerSession_Click(object sender, System.EventArgs e)
    {
        // Die Sitzung wird beendet 
        ...
        // Ansicht anzeigen: [saisies] 
        ...
        // Menüpositionierung 
        ...
}

---

Frage: Vervollständigen Sie den obigen Code

---

Praxisaufgabe: Implementieren Sie die vorherige Webanwendung auf einem Rechner. Fügen Sie ihr Ajax-Funktionalität hinzu.