Développement .NET par Cyril

Lorsque l'utilisateur est déconnecté (logged out) du site, il est encore possible de voir les pages privés qui ont été visité en faisant un simple "page précédente" (backward).

Pour éviter cela il suffit d'empécher la mis en cache des pages privées.

Code :

Private Sub Page_Load(ByVal sender As Object, ByVal e As System.EventArgs) Handles Me.Load
        If Not Page.IsPostBack Then
            Response.ExpiresAbsolute = Now()
            Response.Expires = 0
            Response.CacheControl = "no-cache"
            Response.Buffer = True
        End If
End Sub

Le serveur sera plus souvent sollicité mais c'est toujours mieux que d'avoir une faille de sécurité. Vous pouvez également mettre ce code sur la MasterPage de vos pages privées. Évitez de mettre ce code sur vos pages publics car cela sollicitera le serveur inutilement.

Le BackGroundWorker est un composant très performant qui permet de créer des Thread très simplement. Grâce au BackGroundWorker, vous pouvez rendre votre application très "fluide" et garder une interface toujours disponible pour l'utilisateur.

Dans l'exemple suivant, nous allons utiliser un BackGroundWorker pour accomplir une tâche simple d'incrémentation d'un compteur avec une pause entre chaque incrémentation.

Nous allons également utiliser un Delegate pour appeler une fonction qui se trouve en dehors du Thread.

Voici les différents éléments que nous allons utiliser pour cet exemple.

Les controls de notre WinForm :

• TextBox : tbCompteur
• TextBox : tbPause
• ProgressBar : pbBar
• Button : btnStart
• Label : lblCompte

Les classes :

• bgwArguments : permet de passer des paramètres au Thread
• bgwProgress : permet de passer des paramètres sur l'état de la progression du Thread

Les méthodes :

• startBgwCompte : Initialise et démarre le Thread
• bgwCompte_DoWork : Gère l'événement DoWork du BackGroundWorker. Cette méthode contient le code exécuté pendant le Thread.
• bgwCompte_RunWorkerCompleted : Gére l'événement RunWorkerCompleted du BackGroundWorker qui indique la fin du Thread.
• bgwCompte_ProgressChanged : Gère l'évènement ProgressChanged du BackGroundWorker. Cet événement se produit à chaque fois que l'on veut indiquer le changement d'état de la progression.
• Increment : Fonction qui incrémente le compteur
• btnStart_Click : Gère l'évènement Click du bouton btnStart
• OnBgwTermine : Gère l'event bgwTermine

Pour commencer, nous devons faire un "imports" des classes d'objets nécessaires :

Code :

Imports System.ComponentModel
Imports System.Threading

Nous allons ensuite déclarer notre BackGroundWorker, un Delegate qui nous permettra d'appeller notre fonction Increment à l'intérieur du Thread et un Event que nous lèverons à la fin du Thread.

Code :

Private WithEvents bgwCompte As BackgroundWorker
Private Delegate Function dIncrement(ByVal nbr As Integer) As Integer
Private Event bgwTermine(ByVal nbr As Integer)

Voici la méthode qui permet de lancer le Thread . On passe à l'aide de l'objet bgwArguments les 2 paramètres des TextBox qui représentent respectivement le total du compteur et le temps de pause du Thread.

Code :

Private Sub startBgwCompte(Optional ByVal nbr As Integer = 1)
        ' On remet la ProgressBarre à zéro
        With Me.pbBar
            .Minimum = 0
            .Maximum = 100
            .Value = 0
        End With

        bgwCompte = New BackgroundWorker

        ' le BackGroundWorker doit indiquer sa progression et accepter une possible annulation
        bgwCompte.WorkerReportsProgress = True
        bgwCompte.WorkerSupportsCancellation = True

       ' on utilise l'objet bgwArgument pour passer des paramètres au Thread

       bgwCompte.RunWorkerAsync(New bgwArguments(CInt(Me.tbCompteur.Text), CInt(Me.tbPause.Text)))
End Sub

C'est dans la méthode DoWork que ce trouve le code qui sera exécuté en arrière plan.

Code :

Private Sub bgwCompte_DoWork(ByVal sender As Object, ByVal e As System.ComponentModel.DoWorkEventArgs) Handles bgwCompte.DoWork
        ' on récupère les arguments
        Dim nbr As Integer = CType(e.Argument, bgwArguments).nbr
        Dim pause As Integer = CType(e.Argument, bgwArguments).pause

        Dim compteur As Integer = 0

        ' on utilise un Delegate pour faire appel à notre fonction Increment
        Dim delegateIncrement As dIncrement = AddressOf Increment

        Do
            ' on appelle notre Fonction à travers le Delegate
            compteur = delegateIncrement(compteur)

            ' on indique l'état de la progression
            bgwCompte.ReportProgress((compteur * 100) / nbr, New bgwProgress("Le compteur est à " & compteur.ToString))

            ' on vérifie si une demande d'annulation a été faite par l'utilisateur, si oui on sort de la boucle
            If Me.bgwCompte.CancellationPending = True Then
                e.Result = compteur
                Exit Do
            End If

           'on met le Thread en pause
            Thread.Sleep(pause)

        Loop Until compteur = nbr

        e.Result = compteur

    End Sub

 

Lorsque que le code de la méthode DoWork est terminé, l'évènement RunWorkerCompleted est géré par cette méthode.

Code :

Private Sub bgwCompte_RunWorkerCompleted(ByVal sender As Object, ByVal e As System.ComponentModel.RunWorkerCompletedEventArgs) Handles bgwCompte.RunWorkerCompleted

        ' on lève l'événement bgwTermine qui retourne la valeur du compteur
        RaiseEvent bgwTermine(CInt(e.Result))
End Sub

La méthode suivante gère le ReportProgress que l'on appelle dans la boucle de la méthode DoWork. Elle met à jour la valeur de la ProgressBar et le text du Label pour indiquer l'état de la progression.

Code :

Private Sub bgwCompte_ProgressChanged(ByVal sender As Object, ByVal e As System.ComponentModel.ProgressChangedEventArgs) Handles bgwCompte.ProgressChanged
        If e.ProgressPercentage <= 100 Then
            Me.pbBar.Value = e.ProgressPercentage
        Else
            Me.pbBar.Value = 100
        End If

        Me.lblCompte.Text = CType(e.UserState, bgwProgress).text
End Sub

La fonction suivante permet d'incrémenter le compteur. Biensur, le code de cette fonction aurait pu être mis directement dans la méthode DoWork, mais elle permet d'illustrer le faite que l'on peut appeller une méthode qui est en dehors du Thread en utilisant un Delegate.

Code :

Public Function Increment(ByVal nbr As Integer) As Integer
        nbr += 1
        Return nbr
End Function

L'événement Click du bouton btnStart est géré par cette méthode :

Code :

Private Sub btnStart_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles btnStart.Click
        If Me.btnStart.Text = "Stop" Then
           ' On vérifie que le Thread est bien en cours avant d'essayer de l'annuler
            If Me.bgwCompte.IsBusy Then
                Me.bgwCompte.CancelAsync()
            End If
            Me.btnStart.Text = "Start"
        Else
            If IsNumeric(Me.tbCompteur.Text) And IsNumeric(Me.tbPause.Text) Then
                'on vérifie que ce Thread n'est pas déjà en cours
                Me.startBgwCompte(CInt(Me.tbCompteur.Text))
                Me.btnStart.Text = "Stop"
            Else
                MsgBox("Les données saisies ne sont pas correctes.", MsgBoxStyle.Information)
        End If

        End If
    End Sub

Cette méthode gère l'évènement bgwTermine qui est levé à la fin du Thread :

Code :

Private Sub OnBgwTermine(ByVal compteur As Integer) Handles Me.bgwTermine
        MsgBox("Le compteur c'est arrêté à " & compteur)
        Me.pbBar.Value = 0
        Me.lblCompte.Text = "Compteur arrêté"
End Sub

Cette classe permet de passer plusieurs paramètres au BackGroundWorker. Etant donné que vous pouvez passer n'importe quel objet en paramètre à un BackGroundWorker, les possibilités sont quasis illimitées !

Code :

Public Class bgwArguments
    Private _nbr As Integer
    Private _pause As Integer

    Public Sub New(ByVal nbrCompteur As Integer, ByVal pauseCompteur As Integer)
        _nbr = nbrCompteur
        _pause = pauseCompteur
    End Sub

    Public Property nbr() As Integer
        Get
            Return _nbr
        End Get
        Set(ByVal value As Integer)
            _nbr = value
        End Set
    End Property

    Public Property pause() As Integer
        Get
            Return _pause
        End Get
        Set(ByVal value As Integer)
            _pause = value
        End Set
    End Property
End Class

Cette classe permet de passer des paramètres sur l'état de la progression. Là aussi, n'importe quel objet peut être utilisé pour indiquer l'état de la progression.

Code :

Public Class bgwProgress
    Private _text As String

    Public Sub New(ByVal txt As String)
        _text = txt
    End Sub

    Public Property text() As String
        Get
            Return _text
        End Get
        Set(ByVal value As String)
            _text = value
        End Set
    End Property

End Class

Testons maintenant notre application. Dans le tbCompteur saisissez le chiffre 60 et dans le tbPause le chiffre 1000 (le temps de pause est en millisecondes) . Cliquez sur le bouton btnStart. Le texte du bouton va passer de "Start" à "Stop" et vous allez commencer à voir votre ProgressBar afficher la progression pendant que votre lblCompte vous indique la valeur du Compteur. Vous remarquerez que vous pouvez toujours agir sur les controls de votre WinForm et sur la fenêtre elle même. Lorsque vous cliquez sur "Stop", le thread s'arrête, et un message vous indique la valeur du compteur au moment de l'annulation du Thread.

Les règles à se rappeler sont les suivantes :

• Ne jamais faire appelle à une méthode directement dans le Thread. Utiliser un Delegate.
• Ne jamais agir sur l'interface de l'utilisateur depuis unThread. Par exemple, ne pas mettre dans le DoWork un tbMonText.Text="Hello".

Vous avez créé une base de donnée et vous voulez y créer des tables permettant la gestion des utilisateurs et des rôles.

Etape 1 :

• Utilisez l'utilitaire aspnet_regsql.exe pour créer les tables, les relations et les procédures stockées dans votre base de données.

Cet utilitaire se trouve généralement içi : C:\Windows\Microsoft.NET\Framework\v2.0.50727\aspnet_regsql.exe

Nous partirons du principe que votre base de donnée à une ConnectionString dans le Web.config se nommant "dbConStr".

Etape 2 :

• Insérez le code suivant dans votre Web.config pour le MemberShipProvider

Code :

<membership>
      <providers>
        <remove name ="AspNetSqlMembershipProvider" />
        <add name="AspNetSqlMembershipProvider"
                  type="System.Web.Security.SqlMembershipProvider, System.Web, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b03f5f7f11d50a3a"
                  connectionStringName="dbConStr"
                  enablePasswordRetrieval="false"
                  enablePasswordReset="true"
                  requiresQuestionAndAnswer="false"
                  applicationName="/"
                  requiresUniqueEmail="true"
                  minRequiredPasswordLength="6"
                  minRequiredNonalphanumericCharacters="0"
                  passwordFormat="Hashed"
                  maxInvalidPasswordAttempts="5"
                  passwordAttemptWindow="10"
                  passwordStrengthRegularExpression=""
              />
      </providers>
    </membership>

Vous pouvez biensur changer les paramètres.

• Insérez le code suivant dans votre Web.config pour le RoleProvider

Code :

<roleManager enabled="true" defaultProvider ="AspNetSqlRoleProvider" >
      <providers>
        <remove name="AspNetSqlRoleProvider" />
        <remove name="AspNetWindowsTokenRoleProvider" />
        <add name="AspNetSqlRoleProvider"
             type="System.Web.Security.SqlRoleProvider"
             connectionStringName="dbConStr"
             applicationName="/" />
      </providers>
    </roleManager>

Vous n'avez plus qu'à ajouter les rôles et les utilisateurs en utilisant l'outils "Configuration ASP.NET" qui est intégré au volet "Explorateur de solution" de Visual studio 2005.

Ce comportement est un bug du Framework qu'il est facile de contourner. Voici comment procéder.

Tout d'abord nous allons ajouter une variable private de type control et une propriété public pour en changer la valeur.

Code :

Private _cmsSourceControl As System.Windows.Forms.Control

Public Property cmsSourceControl() As System.Windows.Forms.Control
        Get
            Return _cmsSourceControl
        End Get
        Set(ByVal value As System.Windows.Forms.Control)
            _cmsSourceControl = value
        End Set
End Property

 

Ensuite nous allons gérer l'événement Opened du ContextMenuStrip pour récupérer la valeur du SourceControl

Code :

Private Sub cms_Opened(ByVal sender As Object, ByVal e As System.EventArgs) Handles cms.Opened
        Me.cmsSourceControl = Me.cms.SourceControl

End Sub

Maintenant, quelque soit les circonstances, vous êtes sur de pouvoir connaitre le SourceControl du ContextMenuStrip en appellant la propriétée cmsSourceControl.

Lorsque l'on achète un ordinateur et qu'on l'allume pour la première fois, on se retrouve généralement sur une session utilisateur de type "Administrateur". La majorité des utilisateurs ne voit pas le besoin de créer un autre compte que celui par défaut.

Il n'est pas conseillé d'utiliser pour un usage courant un compte "Administrateur". De plus, ce compte n'a pas de mot de passe par défaut, ce qui rend l'ordinateur très vulnérable à des accès non autorisés.

Il est donc préférable de créer un autre compte de type "Standard" que l'utilisateur pourra utiliser pour le travail de tous les jours, et n'utiliser le compte "Administrateur" que pour installer un logiciel ou modifier certains paramètres de Windows.

Voici les étapes à suivre pour résoudre ce problème de sécurité.

Etape 1 : Mettre un mot de passe sur le compte "Administrateur"

• Allez dans le Panneau de configuration de Windows.
• Ouvrez Comptes d'utilisateurs
• Cliquez sur Changer votre mot de passe
• Saisissez les informations demandées et cliquez sur le bouton de confirmation

Je vous rappelle qu'un bon mot de passe doit êtres d'au moins 8 caractères et comporter au moins des chiffres et des lettres (exemple d'un très bon mot de passe : [(@.Le lièvre et la tortue.@)]639761).

A ce stade, le compte "Administrateur" que vous utilisez est maintenant protégé par un mot de passe. Il ne nous reste plus qu'à créer un nouveau compte de type "Standard" .

Etape 2 : Créer un nouveau compte "Standard"

• Allez dans le Panneau de configuration de Windows
• Ouvrez Comptes d'utilisateurs
• Cliquez sur Gérer un autre compte
• Cliquez sur Créer un nouveau compte
• Saisissez le nom que vous voulez pour ce compte
• Prenez soin de vérifier que Utilisateur standard est coché.
• Cliquez sur le bouton de confirmation pour créer le compte

Je vous conseille de mettre également un mot de passe sur le compte que vous venez de créer.

Remarque :

Lorsque l'on utilise un compte "Standard" sous Windows Vista et que l'on essaye d'accéder à des fonctionnalités qui sont réservées au compte "Administrateur", celui-ci nous demande le mot de passe du compte "Administrateur" pour y accéder. Il est donc tout à fait possible d'administrer Windows Vista à partir d'un compte utilisateur "Standard".