8. Aplikacja [SimuPaie] – wersja 4 – ASP.NET / wiele widoków / jedna strona

---

Zalecane lektury: numer referencyjny [1], Tworzenie aplikacji WEB przy użyciu ASP.NET 1.1, akapity:

• Komponenty serwerowe i kontrolery aplikacji

• Przykłady aplikacji MVC z komponentami serwerowymi ASP

---

Obecnie analizujemy wersję pochodną trójwarstwowej aplikacji ASP.NET, którą omówiliśmy wcześniej, wzbogaconą o nowe funkcje. Architektura naszej aplikacji zmienia się w następujący sposób:

Przetwarzanie żądania klienta przebiega zgodnie z następującymi etapami:

1. klient wysyła żądanie do aplikacji.
2. aplikacja przetwarza to żądanie. W tym celu może potrzebować pomocy warstwy [métier], która z kolei może potrzebować warstwy [dao], jeśli konieczna jest wymiana danych z bazą danych. Aplikacja otrzymuje odpowiedź od warstwy [métier].
3. Na podstawie tej odpowiedzi wybiera (3) widok (= odpowiedź), który ma zostać wysłany do klienta, dostarczając mu (4) potrzebne informacje (szablon).
4. Odpowiedź jest wysyłana do klienta (5)

Mamy tu do czynienia z architekturą internetową zwaną MVC (Model – Widok – Kontroler):

• [Application] to kontroler. Przetwarza on wszystkie żądania od klienta.
• [Saisies, Simulation, Simulations, ...] to widoki. Widok w formacie .NET to standardowy kod ASP / HTML zawierający komponenty, które należy zainicjować. Wartości, które należy podać tym komponentom, tworzą model widoku.

W tym miejscu zaimplementujemy wzorzec projektowy (design pattern) MVC w następujący sposób:

• widoki będą komponentami [View] w ramach pojedynczej strony [Default.aspx]
• kontrolerem jest zatem kod [Default.aspx.cs] tej pojedynczej strony.

Tylko podstawowe aplikacje mogą obsługiwać tę implementację MVC. W rzeczywistości przy każdym żądaniu instancjonowane są wszystkie komponenty strony [Default.aspx], a więc wszystkie widoki. W momencie wysyłania odpowiedzi kod sterujący aplikacji wybiera jeden z nich, po prostu wyświetlając odpowiedni komponent o kodzie [View] i ukrywając pozostałe. Jeśli aplikacja ma wiele widoków, strona [Default.aspx] będzie zawierała wiele komponentów, a koszt ich instancjonowania może stać się zbyt wysoki. Ponadto strona [Design] może stać się niemożliwa do zarządzania z powodu zbyt dużej liczby widoków. Ten typ architektury nadaje się do aplikacji z niewielką liczbą widoków, tworzonych przez jedną osobę. Gdy można ją zastosować, pozwala na bardzo proste opracowanie architektury MVC. Właśnie temu przyjrzymy się w tej nowej wersji.

8.1. Widoki aplikacji

Użytkownikowi zostaną przedstawione następujące widoki:

• widok [VueSaisies], który przedstawia formularz symulacji

• widok [VueSimulation] służący do wyświetlania szczegółowych wyników symulacji:

• widok [VueSimulations], zawierający listę symulacji przeprowadzonych przez klienta

• widok [VueSimulationsVides], który wskazuje, że klient nie ma żadnych symulacji lub nie ma ich już:

• widok [VueErreurs], który wskazuje na jeden lub więcej błędów:

8.2. Projekt Visual Web Developer warstwy [web]

Projekt Visual Web Developer warstwy [web] wygląda następująco:

• w [1] znajduje się:
• plik konfiguracyjny aplikacji [Web.config] – jest identyczny jak w poprzedniej aplikacji.
• plik [Global.cs], który obsługuje zdarzenia aplikacji internetowej, w tym przypadku jej uruchomienie – jest identyczny z plikiem z poprzedniej aplikacji, z tą różnicą, że obsługuje również rozpoczęcie sesji użytkownika.
• Formularz aplikacji o nazwie [Default.aspx] – zawiera różne widoki aplikacji.

• W pliku [2] znajdują się odniesienia do projektu – są one identyczne jak w poprzedniej wersji

8.3. Plik [Global.cs]

Plik [Global.cs], który obsługuje zdarzenia aplikacji internetowej, jest identyczny z plikiem z poprzedniej aplikacji, z tą różnicą, że dodatkowo obsługuje uruchamianie sesji użytkownika:

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
    {

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

        // uruchomienie aplikacji
        public void Application_Start(object sender, EventArgs e)
        {
...
        }

        // uruchomienie sesji użytkownika 
        public void Session_Start(object sender, EventArgs e)
        {
            // do sesji dodawana jest pusta lista symulacji 
            Session["simulations"] = new List<Simulation>();
        } 

    }
}

• wiersze 27–34: obsługujemy rozpoczęcie sesji. Umieścimy w niej listę symulacji wykonanych przez użytkownika.
• wiersz 30: tworzona jest pusta lista symulacji. Symulacja to obiekt typu [Simulation], który omówimy szczegółowo w dalszej części.
• wiersz 31: lista symulacji jest umieszczana w sesji powiązanej z kluczem „simulations”

8.4. Klasa [Simulation]

Obiekt typu [Simulation] służy do enkapsulacji wiersza tablicy symulacji:

Jego kod jest następujący:

namespace Pam.Web
{

    public class Simulation
    {
        // dane symulacji 
        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; }

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

Pola klasy odpowiadają kolumnom tabeli symulacji.

8.5. Strona [Default.aspx]

8.5.1. Przegląd

Strona [Default.aspx] zawiera kilka komponentów [View], po jednym dla każdego widoku. Jej szkielet wygląda następująco:

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

• wiersz 10: tag służący do umieszczenia rozszerzeń Ajax
• wiersze 11–73: kontener UpdatePanel aktualizowany przez wywołania Ajax
• wiersze 12–72: zawartość kontenera UpdatePanel
• wiersze 13–52: nagłówek, który będzie obecny w każdym widoku. Przedstawia on użytkownikowi listę możliwych działań w postaci listy linków.
• wiersz 33: należy zwrócić uwagę na atrybut CausesValidation="False", który powoduje, że walidatory strony nie będą uruchamiane domyślnie po kliknięciu linku. Gdy atrybut ten nie występuje, jego wartością domyślną jest True. Walidację strony można przeprowadzić jawnie w kodzie wykonywanym po stronie serwera za pomocą operacji Page.Validate.
• wiersze 53–57: komponent [MultiView] z jednym widokiem [VueSaisies]. Z tego powodu w wierszu 53 na stałe wpisano numer widoku do wyświetlenia: ActiveViewIndex="0"
• wiersze 53–67: komponent [MultiView] z czterema widokami: widok [VueSimulation] w wierszach 59–61, widok [VueSimulations] w wierszach 62–64, widok [VueSimulationsVides] w wierszach 65–67, widok [VueErreurs] w wierszach 68–70. Komponent [MultiView] wyświetla tylko jeden widok naraz. Aby wyświetlić widok nr i komponentu Vues2, należy wpisać następujący kod:

Vues2.ActiveViewIndex=i

8.5.2. Nagłówek

Nagłówek składa się z następujących komponentów:

Nr	Typ	Nazwa	Rola
1	LinkButton	LinkButtonFaireSimulation	prośba o obliczenie symulacji
2	LinkButton	LinkButtonEffacerSimulation	kasuje formularz wprowadzania danych
3	LinkButton	LinkButtonVoirSimulations	wyświetla listę już przeprowadzonych symulacji
4	LinkButton	LinkButtonFormulaireSimulation	powrót do formularza wprowadzania danych
5	LinkButton	LinkButtonEnregistrerSimulation	zapisuje bieżącą symulację na liście symulacji
6	LinkButton	LinkButtonTerminerSession	zamyka bieżącą sesję

8.5.3. Widok [Saisies]

Komponent o nazwie [View], oznaczony jako [VueSaisies], wygląda następująco:

Nr	Typ	Nazwa	Rola
1	DropDownList	ComboBoxEmployes	Zawiera listę nazwisk pracowników
2	TextBox	TextBoxHeures	Liczba przepracowanych godzin – rzeczywista
3	TextBox	TextBoxJours	Liczba przepracowanych dni – liczba całkowita
4	RequiredFieldValidator	RequiredFieldValidatorHeures	sprawdza, czy pole [2] [TextBoxHeures] nie jest puste
5	RegularExpressionValidator	RegularExpressionValidatorHeures	sprawdź, czy pole [2] [TextBoxHeures] jest liczbą rzeczywistą >=0
6	RequiredFieldValidator	RequiredFieldValidatorJours	sprawdza, czy pole [3] [TextBoxJours] nie jest puste
7	RegularExpressionValidator	RegularExpressionValidatorJours	sprawdza, czy pole [3] [TextBoxJours] jest liczbą całkowitą >=0

8.5.4. Widok [Simulation]

Komponent o nazwie [VueSimulation] o numerze [View] ma następującą postać:

Składa się wyłącznie z komponentów [Label], z których ID zostały wymienione powyżej.

8.5.5. Widok [Simulations]

Komponent o nazwie [View], oznaczony jako [VueSimulations], wygląda następująco:

Nr	Typ	Nazwa	Rola
1	GridView	GridViewSimulations	Zawiera listę symulacji

Właściwości komponentu [GridViewSimulations] zostały zdefiniowane w następujący sposób:

• w [1]: kliknij prawym przyciskiem myszy na [GridView] / opcja [Mise en forme automatique]
• na [2]: wybierz typ wyświetlania dla [GridView]

• w [3]: wybierz właściwości pliku [GridView]
• w [4]: edytuj kolumny w [GridView]
• w [5]: dodaj kolumnę typu [BoundField], która będzie powiązana (bound) z jedną z publicznych właściwości obiektu, który ma być wyświetlony w wierszu [GridView]. Wyświetlany tutaj obiekt będzie obiektem typu [Simulation].

• w [6]: podaj nazwę kolumny
• w [7]: podaj nazwę właściwości klasy [Simulation], która będzie powiązana z tą kolumną.
• [DataFormatString] określa sposób formatowania wartości wyświetlanych w kolumnie.

Kolumny komponentu [GridViewSimulations] mają następujące właściwości:

Nr	Właściwości
2	Typ: BoundField, HeaderText: Nazwa, DataField: Nazwa
3	Typ: BoundField, HeaderText: Nazwisko, DataField: Imię
4	Typ: BoundField, HeaderText: Przepracowane godziny, DataField: HeuresTravaillees
5	Typ: BoundField, HeaderText: Dni przepracowane, DataField: JoursTravailles
6	Typ: BoundField, HeaderText: Wynagrodzenie podstawowe, DataField: SalaireBase, DataFormatString: {0:C} (format walutowy, C = waluta) – wyświetli symbol euro.
7	Typ: BoundField, HeaderText: Dodatki, Pole danych: Indemnites, DataFormatString: {0:C}
8	Typ: BoundField, HeaderText: Składki na ubezpieczenie społeczne, DataField: CotisationsSociales, DataFormatString: {0:C}
9	Typ: BoundField, HeaderText: Wynagrodzenie netto, DataField: SalaireNet, DataFormatString: {0:C}

Należy zwrócić uwagę na fakt, że pole [DataField] musi odpowiadać istniejącej właściwości klasy [Simulation]. Po zakończeniu tej fazy utworzono wszystkie kolumny typu [BoundField]:

• w [1]: kolumny utworzone dla [GridView]
• w [2]: automatyczne generowanie kolumn musi zostać wyłączone, gdy to programista sam je definiuje, tak jak to właśnie zrobiliśmy.

Pozostaje nam jeszcze utworzyć kolumnę linków [Retirer]:

• w [1]: dodać kolumnę typu [CommandField / Supprimer]
• w [2]: ButtonType=Link, aby w kolumnie pojawił się link zamiast przycisku
• w [3]: CausesValidation=False – kliknięcie linku nie spowoduje wykonania kontroli poprawności, które mogą znajdować się na stronie. Usunięcie symulacji nie wymaga bowiem żadnej weryfikacji danych.
• w [4]: widoczny będzie tylko link do usunięcia.
• w [5]: tekst tego linku

8.5.6. Widok [SimulationsVides]

Komponent [View] o nazwie [VueSimulationsVides] zawiera po prostu tekst:

8.5.7. Widok [Erreurs]

Komponent [View] o nazwie [VueErreurs] wygląda następująco:

Nr	Typ	Nazwa	Rola
1	Repeater	RptErreurs	wyświetla listę komunikatów o błędach

Komponent [Repeater] umożliwia powtórzenie kodu ASP.NET / HTML dla każdego obiektu w źródle danych, zazwyczaj w postaci kolekcji. Kod ten jest zdefiniowany bezpośrednio w kodzie źródłowym ASP.NET na stronie:

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

• wiersz 2: <ItemTemplate> definiuje kod, który będzie powtarzany dla każdego elementu źródła danych.
• wiersz 4: wyświetla wartość wyrażenia Container.DataItem, które określa bieżący element źródła danych. Ponieważ element ten jest obiektem, to właśnie metoda ToString tego obiektu jest wykorzystywana do włączenia go do strumienia HTML na stronie. Nasza kolekcja obiektów będzie kolekcją typu List(Of String) zawierającą komunikaty o błędach. Wiersze 3–5 umieszczą sekwencje <li>Message</li> w strumieniu HTML strony.

8.6. Kontroler [Default.aspx.cs]

8.6.1. Przegląd

Wróćmy do architektury aplikacji MVC:

• [Default.aspx.cs], który jest kodem sterującym pojedynczą stroną, [Default.aspx] jest kontrolerem aplikacji.
• [Global] to obiekt typu [HttpApplication], który inicjuje aplikację i posiada odwołanie do warstwy [métier].

Szkielet kodu kontrolera [Default.aspx.cs] wygląda następująco:

using System.Collections.Generic;
...

public partial class PagePam : Page
{

    private void setVues(bool boolVues1, bool boolVues2, int index)
    {
        // wyświetlane są żądane widoki 
        // boolVues1: true, jeśli widok zbiorczy Widoki1 ma być widoczny 
        // boolVues1: true, jeśli zestaw widoków „Vues2” ma być widoczny 
        // index: indeks widoku z zestawu Vues2, który ma zostać wyświetlony 
...
    }

    private void setMenu(bool boolFaireSimulation, bool boolEnregistrerSimulation, bool boolEffacerSimulation, bool boolFormulaireSimulation, bool boolVoirSimulations, bool boolTerminerSession)
    {
        // ustawiamy opcje menu 
        // każda wartość logiczna jest przypisywana do właściwości „Visible” odpowiedniego linku 
...
    }

    // ładowanie strony 
    protected void Page_Load(object sender, System.EventArgs e)
    {
        // przetwarzanie żądania początkowego 
        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)
    {
...
    }
}

W przypadku pierwszego żądania (GET) użytkownika przetwarzane jest wyłącznie zdarzenie Load z wierszy 24–31. W przypadku kolejnych żądań (POST) wysyłanych za pośrednictwem linków w menu przetwarzane są dwa zdarzenia:

1. zdarzenie Load (24–31), ale wynik testu wartości logicznej Page.IsPostback (wiersz 27) powoduje, że nie zostanie wykonana żadna akcja.
2. zdarzenie związane z klikniętym linkiem:

• wiersze 33–36: obsługują kliknięcie linku [1]
• wiersze 38–41: obsługują kliknięcie linku [2]
• wiersze 43–46: obsługują kliknięcie linku [3]
• wiersze 58–61: obsługują kliknięcie linku [4]
• wiersze 48–51: obsługują kliknięcie linku [5]
• wiersze 53–56: obsługują kliknięcie linku [6]

W celu wyodrębnienia często powtarzających się sekwencji kodu utworzono dwie metody wewnętrzne:

• setVues, wiersze 7–14: określa widok lub widoki do wyświetlenia
• setMenu, wiersze 16–21: określa opcje menu, które mają być wyświetlane

8.6.2. Zdarzenie Load

---

Warto przeczytać: dokumentacja [1], Programowanie WEB z wykorzystaniem ASP.NET 1.1:

• akapit „Komponent [Repeater] i powiązania danych”.

---

Pierwszym widokiem wyświetlanym użytkownikowi jest pusty formularz:

Inicjalizacja aplikacji wymaga dostępu do źródła danych, co może zakończyć się niepowodzeniem. W takim przypadku pierwszą wyświetlaną stroną jest strona błędów:

Zdarzenie [Load] jest obsługiwane analogicznie do poprzednich wersji ASP.NET:

    // ładowanie strony 
    protected void Page_Load(object sender, System.EventArgs e)
    {
        // przetwarzanie żądania początkowego 
        if (!IsPostBack)
        {
            // błędy inicjalizacji? 
            if (Global.Erreur)
            {
                // wyświetlanie widoku [erreurs] 
...
                // pozycjonowanie menu 
                ...
                return;
            }
            // ładowanie nazwisk pracowników do listy rozwijanej 
...
            // pozycjonowanie menu 
...
            // wyświetlanie widoku [saisie] 
 ...
        }
}

---

Zadanie: uzupełnij powyższy kod

---

8.6.3. Czynność: Przeprowadź symulację

Poniżej ekran oznaczony numerem (1) przedstawia zapytanie użytkownika, a ekran oznaczony numerem (2) – odpowiedź wysłaną do niego przez aplikację internetową. Z ekranu głównego użytkownik może rozpocząć symulację:

- (1): użytkownik wysyła żądanie przeprowadzenia symulacji

- (2): wynik symulacji

Procedura obsługująca tę akcję mogłaby wyglądać następująco:

    protected void LinkButtonFaireSimulation_Click(object sender, System.EventArgs e)
    {
        // obliczanie wynagrodzenia 
        // czy strona jest poprawna? 
        Page.Validate();
        if (!Page.IsValid)
        {
            // wyświetlanie widoku [saisie] 
            ...
            return;
        }
        // strona jest poprawna – pobierane są wprowadzone dane 
        double HeuresTravaillées = ...;
        int JoursTravaillés = ...;
        // obliczamy wynagrodzenie pracownika 
        FeuilleSalaire feuillesalaire;
        try
        {
            feuillesalaire = ...
        }
        catch (PamException ex)
        {
            // wyświetlanie widoku [erreurs] 
...
            return;
        }
        // zapisywanie wyniku w sesji 
        Session["simulation"] = ...
        // wyświetlanie wyników 
...
        // wyświetlanie widoków [saisie, employe, salaire] 
        ...
        // wyświetlanie menu 
        ...
}

---

Zadanie: uzupełnij powyższy kod

---

8.6.4. Akcja: Zapisz symulację

Po zakończeniu symulacji użytkownik może poprosić o jej zapisanie:

- (1): prośba o zapisanie bieżącej symulacji

- (2): symulacja została zapisana i wyświetlona jest lista przeprowadzonych symulacji

Procedura obsługująca tę akcję mogłaby wyglądać następująco:

    protected void LinkButtonEnregistrerSimulation_Click(object sender, System.EventArgs e)
    {
        // zapisuje bieżącą symulację na liście symulacji dostępnej w sesji 
        ...
        // wyświetla się widok [simulations] 
        ...
}

---

Zadanie: uzupełnij powyższy kod

---

8.6.5. Akcja: Powrót do formularza symulacji

---

Warto przeczytać: odniesienie [1], [Développement WEB avec ASP.NET 1.1 ]: rola ukrytego pola _VIEWSTATE

---

Po wyświetleniu listy symulacji użytkownik może poprosić o powrót do formularza symulacji:

Należy zauważyć, że ekran (2) przedstawia formularz w takiej postaci, w jakiej został wypełniony. Należy pamiętać, że te różne widoki należą do tej samej strony. Pomiędzy poszczególnymi żądaniami wartości komponentów są zachowywane dzięki mechanizmowi ViewState, o ile właściwości tych komponentów mają wartości od EnableViewState do true.

Procedura obsługująca tę akcję mogłaby wyglądać następująco:

    protected void LinkButtonFormulaireSimulation_Click(object sender, System.EventArgs e)
    {
        // wyświetlanie widoku [saisie] 
        ...
        // pozycjonowanie menu 
        ...
}

---

Pytanie: uzupełnij powyższy kod

---

8.6.6. Czynność: Usuń symulację

Po powrocie do formularza symulacji użytkownik może poprosić o usunięcie obecnych wpisów:

Procedura obsługująca tę akcję mogłaby wyglądać następująco:

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

---

Zadanie: uzupełnij powyższy kod

---

8.6.7. Akcja: Wyświetl symulacje

Użytkownik może poprosić o wyświetlenie symulacji, które już wykonał:

Procedura obsługująca tę akcję mogłaby wyglądać następująco:

protected void LinkButtonVoirSimulations_Click(object sender, System.EventArgs e)
    {
        // pobieranie symulacji z sesji
        ...
        // czy są jakieś symulacje? 
        if (...)
        {
            // widok [simulations] widoczny 
...
        }
        else
        {
            // widok [SimulationsVides] 
            ...
        }
        // ustawiamy menu 
        ...
    }

---

Zadanie: uzupełnij powyższy kod

---

8.6.8. Akcja: Usuń symulację

Użytkownik może złożyć wniosek o usunięcie symulacji:

Procedura [GridViewSimulations_RowDeleting ], która obsługuje tę akcję, mogłaby wyglądać następująco:

    protected void GridViewSimulations_RowDeleting(object sender, GridViewDeleteEventArgs e)
    {
        // pobieramy symulacje z sesji
        ...
        // usuwa się wskazaną symulację (e.RowIndex to numer usuwanej linii)
        ...
        // czy pozostały jeszcze jakieś symulacje? 
        if (...)
        {
            // wypełnia się plik GridView 
 ...
        }
        else
        {
            // widok [SimulationsVides] 
            ...
        }
}

---

Pytanie: uzupełnij powyższy kod

---

8.6.9. Akcja: Zakończ sesję

Użytkownik może poprosić o zakończenie swojej sesji symulacji. Spowoduje to utratę zawartości sesji i wyświetlenie pustego formularza:

Procedura obsługująca tę akcję mogłaby wyglądać następująco:

    protected void LinkButtonTerminerSession_Click(object sender, System.EventArgs e)
    {
        // zamyka się sesję 
        ...
        // wyświetl widok [saisies] 
        ...
        // pozycjonowanie menu 
        ...
}

---

Pytanie: uzupełnij powyższy kod

---

Zadanie praktyczne: wdroż poprzednią aplikację internetową na komputerze. Dodaj do niej obsługę Ajax.