MERISE

Exercice 1: 

   Une banque désire posséder un SGBD pour suivre ses clients. Elle désire ainsi stocker les coordonnées de chaque client (nom, prénom adresse), et les comptes dont elle dispose ainsi que leur solde (sachant par ailleurs que certains compte ont plusieurs bénéficiaires). On stockera également les opérations relatives à ces comptes (retrait et dépôt, avec leur date et le montant).

Questions :

1. Identifier les différentes entités et leurs propriétés pour cette gestion
2. Préciser les différentes associations entre les entités et ajouter les propriétés pour les associations porteuses de propriétés.
3. Préciser les cardinalités pour les différentes associations.  

********************************************************************************************************

Exercice 2:  «Gestion d'école»

Transformez le MCD suivant, qui représente «la gestion d'une école» en un MLD en respectant toutes les règles du passage MCD au MLD.

********************************************************************************************************

Exercice 3: 

    Le but est de construire un  système permettant de  gérer un magasin de vente de produit a des particuliers.

Les produits du magasin possèdent une référence (un code), un libelle et un prix unitaire.

Les clients ont une identité (nom, prénom, adresse).

Les clients passent des commandes de produits. On mémorise la date de la commande.

Pour chaque commande, le client précise une adresse de livraison.

La commande concerne un certain nombre de produits, en une quantité spécifiée pour chaque produit.

Questions :

1. Identifier les différentes entités et leurs propriétés pour cette gestion
2. Préciser les différentes associations entre les entités et ajouter les propriétés pour les associations porteuses de propriétés.
3. Préciser les cardinalités pour les différentes associations.  

********************************************************************************************************

Exercice 4:   «Gestion d'agence de location»

Transformez le MCD suivant, qui représente «la gestion d'une agence de location» en un MLD en respectant toutes les règles du passage MCD au MLD.

********************************************************************************************************

Exercice 5: 

      Une agence de location de maisons et d’appartements désire gérer sa liste de logements. Elle voudrait en effet connaître l’implantation de chaque logement (nom de la commune et du quartier) ainsi que les personnes qui les occupent (les signataires uniquement).

Le loyer dépend d’un logement, mais en fonction de son type (maison, studio, T1, T2...) l’agence facturera toujours en plus du loyer la même somme forfaitaire à ses clients. Par exemple, le prix d’un studio sera toujours égal au prix du loyer + 30 DH de charges forfaitaires par mois.

Pour chaque logement, on veut disposer également de l’adresse, de la superficie ainsi que du loyer.

Quant aux individus qui occupent les logements (les signataires du contrat uniquement), on se contentera de leurs noms, prénoms, date de naissance et numéro de téléphone.

Pour chaque commune, on désire connaître le nombre d’habitants ainsi que la distance séparant la commune de l’agence.

L’agence désire gérer l’historique de l’occupation des logements par les individus, pour chaque location, on enregistre la date de début et la date de fin.

On considèrera de plus qu’un individu peut être signataire de plusieurs contrats de location.

On précise aussi qu’un logement peut faire l’objet de plusieurs locations disjointes dans le temps.

L’unité géographique retenue pour la gestion des logements est le quartier et on considère que chaque commune possède au moins un quartier.

Questions :

1. Identifier les différentes entités et leurs propriétés pour cette gestion
2. Préciser les différentes associations entre les entités et ajouter les propriétés pour les associations porteuses de propriétés.
3. Préciser les cardinalités pour les différentes associations.  

********************************************************************************************************

Exercice 6:   « Club de vacances»

Transformez le MCD suivant, qui représente «la gestion d’un club de vacance» en un MLD en respectant toutes les règles du passage MCD au MLD.

********************************************************************************************************

Exercice 7:  (Gestion hôtelière) :

      Une Ecole d’Hôtellerie vous confie la réalisation d’un logiciel de gestion hôtelière.

Ce logiciel, destiné aux travaux pratique des étudiants, doit permettre la gestion centralisées de 8hôtels (N°Hôtel, NomH, AdresseH, CPH, TélH) de 80 chambres (N°Chambre, N°téléphone) au maximum chacun. Ces hôtels sont répartis en 4 classes(NbreEtoiles, Caractéristiques) (*, **, ***, ****). Pour chaque hôtel il y a au maximum 9 catégories (CodeCatégorie, Description) de chambres différentes. Cette gestion consiste en :

•         L’enregistrement et la Consultation des disponibilités en vue des réservations immédiates,

•         L’enregistrement des arrhes (avances) confirmant les réservations effectuées plus de 8 jours avant l’arrivée prévue des clients,

•         L’enregistrement des diverses consommations ((N°Consommation, Date consommation Heure Consommation) durant le séjour d’un client.

•         L’établissement de la facture au départ du client; celle-ci regroupe le prix de la chambre et la quantité des prestations consommer pendant le séjour.

Modalités de réservation

Le client peut effectuer une réservation de deux façons :

•         sur Internet, en remplissant un formulaire de réservation

•         auprès d’une agence de réservation où il remplit un imprimé de réservation.

Le client indique (Nom,Prénom,Adresse,Ville, CP, Pays, Tél, Email)

… puis exprime son besoin en termes de catégorie de chambre, de période de séjour (date début et de fin) et de classe d’hôtel. Si la demande est soluble une réservation est établie (N°Réservation, DateDébut, DateFin, DatePayeArrhes, MontantArrhes…..]

Tarification :

-        Le prix de la  catégorie d’une chambre dépend de la classe d’hôtel.

-        Les prix des prestations (CodePrest,Désignation Pres) (exemple de prestation:  petit déjeuner, déjeuner,…) sont propres à chaque hôtel.

-        Le prix d’une chambre, dépend de la catégorie et de la classe de l’hôtel.

-        Une réservation ne concerne qu’une seule chambre.

-        Les prix des prestations dépendent de chaque hôtel.

-        Les consommations doivent être mémorisées.

Questions :

1. Identifier les différentes entités et leurs propriétés pour cette gestion
2. Préciser les différentes associations entre les entités et ajouter les propriétés pour les associations porteuses de propriétés.
3. Préciser les cardinalités pour les différentes associations.

                                         

********************************************************************************************************

Exercice 8:   « Chaine Hôtelière  »

Transformez le MCD suivant, qui représente «la gestion d’une chaine Hôtelière» en un MLD en respectant toutes les règles du passage MCD au MLD.

Cour Regular Expressions

Match: This program introduces the Regex class. We use its constructor and the Match method, and then handle the returned Match object.

Namespace:All these types are found in the System.Text.RegularExpressions namespace.

Pattern:The Regex uses a pattern that indicates one or more digits. The characters "55" match this pattern.

Success:The returned Match object has a bool property called Success. If it equals true, we found a match.

C# program that uses Match, Regex

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
 Regex regex = new Regex(@"\d+");
 Match match = regex.Match("Dot 55 Perls");
 if (match.Success)
 {
     Console.WriteLine(match.Value);
 }
    }
}

Output

55

*********************************************************************************


Static method:Here we match parts of a string (a file name in a directory path). We only accept ranges of characters and some punctuation. On Success, we access the group.

Static:We use the Regex.Match static method. It is also possible to call Match upon a Regex object.

Success:We test the result of Match with the Success property. When true, a Match occurred and we can access its Value or Groups.

Groups:This collection is indexed at 1, not zero—the first group is found at index 1. This is important to remember.

Groups

C# program that uses Regex.Match

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
 // First we see the input string.
 string input = "/content/alternate-1.aspx";

 // Here we call Regex.Match.
 Match match = Regex.Match(input, @"content/([A-Za-z0-9\-]+)\.aspx$",
     RegexOptions.IgnoreCase);

 // Here we check the Match instance.
 if (match.Success)
 {
     // Finally, we get the Group value and display it.
     string key = match.Groups[1].Value;
     Console.WriteLine(key);
 }
    }
}

Output

alternate-1

Pattern details

@"              This starts a verbatim string literal.
content/        The group must follow this string.
[A-Za-z0-9\-]+  One or more alphanumeric characters.
(...)           A separate group.
\.aspx          This must come after the group.
$               Matches the end of the string.

*********************************************************************************

NextMatch. More than one match may be found. We can call the NextMatch method to search for a match that comes after the current one in the text. NextMatch can be used in a loop.

Here:We match all the digits in the input string (4 and 5). Two matches occur, so we use NextMatch to get the second one.

Return:NextMatch returns another Match object—it does not modify the current one. We assign a variable to it.

C# program that uses NextMatch

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
 string value = "4 AND 5";

 // Get first match.
 Match match = Regex.Match(value, @"\d");
 if (match.Success)
 {
     Console.WriteLine(match.Value);
 }

 // Get second match.
 match = match.NextMatch();
 if (match.Success)
 {
     Console.WriteLine(match.Value);
 }
    }
}

Output

4
5

*********************************************************************************

Preprocess. Sometimes we can preprocess strings before using Match() on them. This can be faster and clearer. Experiment. I found using ToLower to normalize chars was a good choice.ToLower

C# program that uses ToLower, Match

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
 // This is the input string.
 string input = "/content/alternate-1.aspx";

 // Here we lowercase our input first.
 input = input.ToLower();
 Match match = Regex.Match(input, @"content/([A-Za-z0-9\-]+)\.aspx$");
    }
}

*********************************************************************************
Static: Often a Regex instance object is faster than the static Regex.Match. For performance, we should usually use an instance object. It can be shared throughout an entire project.Static Regex

Sometimes:We only need to call Match once in a program's execution. A Regex object does not help here.

Class:Here a static class stores an instance Regex that can be used project-wide. We initialize it inline.

Static Class

C# program that uses static Regex

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
 // The input string again.
 string input = "/content/alternate-1.aspx";

 // This calls the static method specified.
 Console.WriteLine(RegexUtil.MatchKey(input));
    }
}

static class RegexUtil
{
    static Regex _regex = new Regex(@"/content/([a-z0-9\-]+)\.aspx$");
    /// <summary>
    /// This returns the key that is matched within the input.
    /// </summary>
    static public string MatchKey(string input)
    {
 Match match = _regex.Match(input.ToLower());
 if (match.Success)
 {
     return match.Groups[1].Value;
 }
 else
 {
     return null;
 }
    }
}

Output

alternate-1

*********************************************************************************
Numbers: A common requirement is extracting a number from a string. We can do this with Regex.Match. To get further numbers, consider Matches() or NextMatch.

Digits:We extract a group of digit characters and access the Value string representation of that number.

Parse:To parse the number, use int.Parse or int.TryParse on the Value here. This will convert it to an int.

Parse

C# program that matches numbers

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
 // ... Input string.
 string input = "Dot Net 100 Perls";

 // ... One or more digits.
 Match m = Regex.Match(input, @"\d+");

 // ... Write value.
 Console.WriteLine(m.Value);
    }
}

Output

100

*********************************************************************************
Value,length, index: A Match object,returned by Regex.Match has a Value, Length and Index. These describe the matched text (a substring of the input).

Value:This is the matched text, represented as a separate string. This is a substring of the original input.

Length:This is the length of the Value string. Here, the Length of "Axxxxy" is 6.

Index:The index where the matched text begins within the input string. The character "A" starts at index 4 here.

C# that shows value, length, index

using System;
using System.Text.RegularExpressions;

class Program
{
    static void Main()
    {
 Match m = Regex.Match("123 Axxxxy", @"A.*y");
 if (m.Success)
 {
     Console.WriteLine("Value  = " + m.Value);
     Console.WriteLine("Length = " + m.Length);
     Console.WriteLine("Index  = " + m.Index);
 }
    }
}

Output

Value  = Axxxxy
Length = 6
Index  = 4

*********************************************************************************

IsMatch: This method tests for a matching pattern. It does not capture groups from this pattern. It just sees if the pattern exists in a valid form in the input string.

Bool:IsMatch returns a bool value. Both overloads receive an input string that is searched for matches.

Bool Method

Internals:When we use the static Regex.IsMatch method, a new Regex is created. This is done in the same way as any instance Regex.

And:This instance is discarded at the end of the method. It will be cleaned up by the garbage collector.

C# that uses Regex.IsMatch method

using System;
using System.Text.RegularExpressions;

class Program
{
    /// <summary>
    /// Test string using Regex.IsMatch static method.
    /// </summary>
    static bool IsValid(string value)
    {
 return Regex.IsMatch(value, @"^[a-zA-Z0-9]*$");
    }

    static void Main()
    {
 // Test the strings with the IsValid method.
 Console.WriteLine(IsValid("dotnetperls0123"));
 Console.WriteLine(IsValid("DotNetPerls"));
 Console.WriteLine(IsValid(":-)"));
 // Console.WriteLine(IsValid(null)); // Throws an exception
    }
}

Output

True
True
False

EFM Programmation orientée objet

Examens de fin de module : Programmation orientée objet Vb.Net, C#

Exercice : Gestion De Stock : 9 Pts
Soit à développer une application pour la gestion de stock. Un article est caractérisé par son numéro de référence, son nom, son prix d’achat et son prix de vente.

1. Créer la classe Article.
2. Ajouter un constructeur à la classe Article sans oublier l’exception PExeption si le prix de vente est inférieur à celui d’ achat.
3. Définir une méthode qui retourne une chaine de caractères représentant les différents attributs de l’objet Article. Pour gérer le stock du magasin, ce dernier se caractérise par son stock d’articles. Le stock est représenté par une collection d’objets Article.
4. Ecrire la classe Stock qui permet de réaliser les fonctionnalités suivantes :
         a. Ajouter un nouvel Article.
         b. Afficher tous les Articles du magasin.
         c. Rechercher un Article.
         d. Afficher les Articles dont les prix d’achat est supérieur à une valeur saisie.
         e. Supprimer un Article.
         f. Modifier un Article.

Exercice : Gestion Des Adhérents : 11 Pts
Soit à développer une application de gestion des adhérents qui sont inscrits dans une Médiathèque. Lorsqu’un adhérent est inscrit à la Médiathèque, on lui affecte automatiquement un numéro et on fixe sa cotisation. L’ adhèrent qui le souhaite peut ne plus appartenir à la médiathèque, il démissionne.

1. Créer la classe Adhérent.
2. Ajouter à la classe Adhérent les méthodes :
         a. ToString () : affichage des attributs de la classe Adhérent sous forme de chaine de caractères.
         b. Modifie (Double cotisation) : modification de la cotisation.
3. Ajouter un constructeur par défaut qui permet de créer un objet Adhérent dont le nom est « anonyme ».
4. Ajouter un constructeur qui permet de crée un objet adhèrent en générant un numéro aléatoire.
5. Ecrire le code permettant de saisir un adhèrent et prévoir les cas d’exception.
6. Ajouter une méthode de modification d’un adhèrent.
7. Ajouter une méthode d’affichage et de recherche et d’affichage d’un adhèrent.
8. Ajouter une méthode de suppression d’un adhérent.
9. Ajouter une méthode d’affichage de tous les adhérents.

Exercice : Gestion d’heures complémentaires : 7 Pts
Chaque enseignant de l’université effectue un certain nombre d’heures d’enseignement dans une année. Suivant le statut de l’enseignant, un certain nombre de ces heures peut être considéré comme complémentaire. Les heures omplémentaires sont payées séparément à l’enseignant. Les volumes horaires sont exprimés en heures entières et le prix d’une heure complémentaire est de 100DH.

          - Le nom et le nombre d’heures total d’un enseignant sont fixés à sa création, puis seul le nom peut être librement consulté (méthode getNom()).
          - D’autre part on veut pouvoir librement consulter un enseignant sur son volume d’heures complémentaires (méthode getHc()) et sur la rétribution correspondante (méthode getRetribution()).

Il y a deux types d’enseignants :
          - Les intervenants extérieurs : toutes les heures effectuées sont complémentaires.
          - Les enseignants de la fac : seules les heures assurées au delà d’une charge statutaire de 192h sont complémentaires.

Q1. Modéliser les enseignants : quelles sont les classes ? Ou sont implémentées les méthodes ? Lesquelles sont nouvelles, redéfinies?
Q2. Ecrire les classes.
Q3. Comment modifier le modèle pour y introduire les étudiants de troisième cycle qui assurent des enseignements: toutes les heures effectuées sont complémentaires mais dans la limite de 96 heures.
Q4. Cela pose-t-il un problème de prendre en compte le fait que les étudiants, n’ayant pas d’employeur, voient leur rétribution diminuée de 18% ?
Q5. Tester le programme.

Exercice : Gestion De Comptes Bancaires : 13 Pts
On désir réaliser une application de gestion de comptes bancaires. Pour cela on a proposé d’organiser les objets de l’application en deux catégories (CompteSurCarnet et CompteSurCheque) et de les ranger dans une collection. Les classes CompteSurCarnet et CompteSurCheque ont des propriétés communes telles que Numéro et NomProprietaire et Solde qui donnent naissance à une troisième classe Compte considérée comme classe de base pour éviter les redondances. La classe CompteSurCarnet possède, en plus des propriétés communes, la propriété NuméroCanret. La classe CompteSurCheque est caractérisée par le NuméroChèque et le NuméroCarte ainsi que DateFinValiditéCarte.

1) Définir la classe abstraite AbstractCompte avec deux constructeurs (par défaut et d’initialisation) et les accesseurs.
         a. Ajouter deux méthodes abstraites créditer et Débiter qui prend en paramètre la somme à ajouter au compte ou à retirer du compte.

2) Définir la classe CompteSurCheque avec deux constructeurs (par défaut et d’initialisation) et les accesseurs.
         a. Redéfinir la méthode créditer qui prend en paramètre la somme à ajouter au compte.
         b. Redéfinir la méthode Débiter qui prend en paramètre la somme à déduire du compte qui ne doit pas dépasser le solde sinon une exception est générée avec le message : « Solde insuffisant ».

3) Définir la classe CompteSurCarnet avec deux constructeurs (par défaut et d’initialisation) et les accesseurs.
         a. Redéfinir la méthode créditer qui prend en paramètre la somme à ajouter au solde.
         b. redéfinir la méthode Débiter qui prend en paramètre la somme à retirer du compte qui ne doit pas dépasser le solde sinon une exception est générée avec le message : « Solde insuffisant », en plus la somme à retirer ne doit pas dépasser un plafond de 10000Dh sinon une exception est générée avec le message : « Plafond dépassé ».

4) Définir la classe Banque contenant une collection de comptes (CompteSurCheque et CompteSurCarnet) et ajouter les méthodes suivantes :
         a. rechercher : qui prend en paramètre un numéro et retourne l’indice du compte dans la collection ou -1 s’il n’existe pas.
         b. AjouterCompteCarnet : qui prend les paramètres nécessaires à la création d’un compte sur carnet et de l’ajouter à la collection (vérifier que le numéro n’existe pas déjà avant de l’ajouter).
         c. AjouterCompteCheque : qui prend les paramètres nécessaires à la création d’un compte sur chèque et de l’ajouter à la collection (vérifier que le numéro n’existe pas déjà avant de l’ajouter).
         d. Supprimer : qui prend en paramètre un numéro et supprime le compte correspondant.
         e. La propriété Elément : qui prend en paramètre un numéro et retourne le compte correspondant à ce numéro.

EFM Programmation événementielle

Examens de fin de module : Programmation événementielle Vb.Net & C#

Exercice : Pair | impair : 5 Pts
Construire une form conforme au modèle ci dessous permettent de démontrer si un nombre entier saisi est pair ou impair.

Placer deux contrôles label, un textbox et un bouton de commande L’idée de l'exercice est de saisir un nombre dans une zone de saisie et d’afficher le résultat dans un label après un click sur le Bouton.

Exercice : Gestion des stagiaires : 15 Pts
Une école de formation de la langue espagnole vous demande de développer une application qui permet de gérer ses stagiaires ainsi que les résultats qu’ils ont obtenus au cours du cursus de formation qui se découpe en 9 modules numérotés de 1 à 9.
On souhaite enregistrer pour chaque stagiaire, le numéro d’inscription, le nom, le prénom, le sexe, la date de naissance, le numéro de module et la note obtenue à ce module.
Toutes ces informations seront enregistrées en mémoire, à vous de choisir les structures de données qui conviennent à leur stockage. L’application que vous allez créer permettra la saisie des données et l’édition d’un certain nombre de résultats.
1) L’application doit comprendre le formulaire principal suivant :

2) Pour ajouter un nouveau stagiaire, on utilise l’option Ajouter du menu Stagiaires. La fenêtre ci-dessous doit apparaître pour permettre la saisie des informations. Un click sur le bouton OK permettra de valider les données et de fermer cette fenêtre. Le bouton Annuler permet d’abandonner l’opération. Prévoir un contrôle de saisie sachant que toutes les données sont obligatoires. Ajouter à ce formulaire une barre d’état qui indique le cas d’erreurs avec le message « Erreur de saisie » sinon affiche le message « Donnés valides ».
3) Ajouter à ce formulaire un menu contextuel permettant d’initialiser tous les contrôles.

4) Créer une fonction de recherche qui reçoit le numéro d’inscription d’un stagiaire et renvoie sa position dans la liste. La fonction doit renvoyer la valeur -1 quand le numéro recherché n’est pas trouvé.
5) Pour supprimer un stagiaire, on utilise l’option Supprimer du menu Stagiaire. La fenêtre ci-après apparaît. Elle permet de saisir le numéro d’inscription du stagiaire à supprimer. Quand il existe vous devez afficher un message de confirmation de la suppression avec la question « Voulez-vous vraiment supprimer ce stagiaire ? ». Si l’utilisateur répond par oui on procède à la suppression, sinon l’opération est annulée. Si le numéro d’inscription n’est pas trouvé, l’application affiche un message d’erreur.

6) La consultation des informations d’un stagiaire peut se faire avec l’option Consulter du menu Stagiaire. Pour ce faire, l’utilisateur doit commencer par saisir un numéro d’inscription, l’application répond soit par un message d’erreur lorsque le numéro est inexistant, soit par afficher les données du stagiaire recherché.

7) On peut consulter la liste des stagiaires en utilisant l’option Liste des Stagiaires du menu Edition. Utiliser une zone de liste pour afficher les données.

8) Liste des stagiaires par module : L’utilisateur choisit le numéro d’un module et l’application affiche la liste des stagiaires correspondants.

9) Ajouter une feuille d’authentification permettant de contrôler l’accès à l’application avec le compte suivant : (Login : TDI | Password : ISTA). Une fois authentifié, une Barre de progression s’affiche et le formulaire principal ne s’active qu’après 10 secondes.
10) On suppose maintenant qu’un stagiaire a le droit de s’inscrire dans tous les modules offerts, proposer une solution en réalisant un formulaire de saisie des données convenable.

Exercice : Mini Calculatrice :(7 points)

1) Dessiner l’interface précédente et personnaliser la propriété Name des contrôles (Objets graphiques).
2) Après avoir entré un nombre dans les zones de texte libellées 'Nombre1' et 'Nombre2' et sélectionné une des options du cadre 'Opérations' : Cliquer sur 'Calculer' déclenche le calcul et l'affichage du symbole de l’opération et du résultat. (Si on sélectionne l’opération sans saisir les nombres on affiche un message d’erreur).
3) Le bouton 'Remise à blanc' efface les trois zones et place le point d'insertion (curseur) dans la zone 'Nombre 1'.


Exercice : Application pour gérer les écritures dans un journal : (13 points)
Nous voulons mettre en oeuvre une application en vb.net ou en c# servant à gérer les écritures dans un journal. L’interface en cours d’exécution de cette application est donnée dans la figure suivante.

Un utilisateur saisi le montant de l’écriture et choisi le type de l’opération qui veut effectuer (crédit ou début). Il clique ensuite sur le bouton de propriété caption « Ecrire dans le journal » pour ajouter le montant saisi dans la liste des crédits si l’option crédit est choisie ou dans la liste des débits si l’autre option débit est choisi. Si l’écriture se fait dans la liste des crédits (respectivement, dans la liste des débits) l’item correspondant dans la liste des débits (respectivement, des crédits) est mis à 0. Après chaque écriture, les calculs du total crédit, débit et balance seront effectués. A tout moment, cette utilisateur peut annuler la dernière écriture effectuée en cliquant sur le bouton dont la propriété caption est « Annuler la dernière écriture ». L’annulation d’une écriture enlève des deux listes crédit et débit la ligne correspondante à la dernière écriture et mis à jour le total crédit, débit et balance. L’utilisateur peut également quitter l’application par un simple clique sur le bouton de propriété caption « Quitter l’application ».

Travail demandé :
1. Réalisez une interface conforme à celle proposée ci-dessous (voir l’interface en mode création). N’oubliez pas de bien nommer vos contrôles.
2. Initialisez les valeurs du total crédit, débit et balance et déclarez les variables globales nécessaires pour votre application.
3. Programmez ensuite les boutons des trois boutons de commandes « Ecrire dans le journal », « Annuler la dernière écriture » et « Quitter l’application » comme définis dans l’énoncé.
4. Vérifiez que le montant saisi par l’utilisateur est bien un réel et ne peut être vide. Affichez les messages d’erreurs à l’aide d’un contrôle MsgBox.
5. Vérifiez aussi que un clique sur le bouton « Annuler la dernière écriture » ne peut pas être possible si aucune écriture n’est présente dans la liste crédit et débit (les deux listes débit et crédit son vides).

Link

Regular expressions

Regular Expressions

Regex:

Ancres ^ Début de la chaîne, ou début de la ligne dans le modèle multi-ligne \UNE Début de la chaîne $ Fin de la chaîne, ou à la fin de la ligne dans le modèle multi-ligne \ Z Fin de la chaîne \ b limite Word \ B Pas limite de mot \ < Début du mot \> Fin du mot Classes de caractères \ c Caractère de contrôle \ s L'espace blanc \ S Pas d'espace blanc \ré Chiffre \RÉ Non chiffres \ w Mot \ W Non mot \X chiffres hexadécimaux \ O octal chiffres POSIX [:plus haut:] Lettres capitales [:inférieur:] Minuscules [:alpha:] Toutes les lettres [: Alnum:] Digits et lettres [:chiffre:] Digits [Xdigit:] Les chiffres hexadécimaux [Punct:] Ponctuation [:blanc:] Espace et onglet [:espace:] caractères blancs [: Cntrl:] Les caractères de commande [:graphique:] Les caractères imprimés [:impression:] caractères et espaces imprimés [:mot:] Digits, des lettres et de soulignement assertions ? = Lookahead assertion ?! négatif préanalyse <? = assertion arrière ?! = Ou <?! lookbehind négatif ?> Une fois seule Sous-expression ? () Condition [if then] ? () | Condition [if then else] ? # Commentaire

quantificateurs

*	0 ou plus	{3}	Exactement 3
+	1 ou plus	{3}	3 ou plus
?	0 ou 1	{3,5}	3, 4 ou 5

Ajouter un ? à un quantificateur pour le rendre ungreedy.

Groupes et plages

.	Tout caractère sauf nouvelle ligne (\ n)
(A | b)	a ou b
(...)	Groupe
(?: ...)	groupe passif (non-capture)
[abc]	Range (a ou b ou c)
[^ Abc]	Non (a ou b ou c)
[Aq]	lettre minuscule de a à q
[AQ]	lettre majuscule de A à Q
[0-7]	Digit 0-7
\X	Groupe / nombre subpattern "x"

Les gammes sont inclus.

Modificateurs Pattern

g	correspondance globale
je *	Insensible à la casse
m *	Plusieurs lignes
s *	traite la chaîne comme une seule ligne
X *	Autoriser les commentaires et les espaces dans le profil
e *	Évaluer le remplacement
U *	motif Ungreedy

* PCRE modificateur

Chaîne de remplacement

$ n	groupe non passive nième
2 $	"Xyz" dans / ^ (abc (xyz)) $ /
1 $	"Xyz" dans / ^ (?: abc) (xyz) $ /
`$	Avant chaîne correspondante
$ '	Après chaîne correspondante
$ +	Dernière chaîne correspondante
$ &	Tout string assorti

Certaines implémentations utilisent regex \ au lieu de $.

séquences d'échappement

\	Caractère d'échappement suivant
\ Q	Commencez séquence littérale
\ E	Fin séquence littérale

«Échapper» est une façon de traiter les caractères qui ont une signification particulière dans les expressions régulières littéralement, plutôt que comme des caractères spéciaux.

métacaractères communs

^	[	.	$
{	*	(	\
+	)	|	?
<	>

Le caractère d'échappement est généralement \

Caractères spéciaux

\ n	Nouvelle ligne
\ r	Retour chariot
\ t	Languette
\ v	onglet Vertical
\F	Saut
\ xxx	xxx caractère Octal
\ xhh	hh de caractères Hex