Evenementielle Exercices

Exercice 1: (avec Corrigé): Evénementielle:

 

• Le clic sur le bouton Colorer permet de colorer le formulaire par la couleur choisie par l’utilisateur.
• Le clic sur le bouton Annuler permet de rétablir la couleur par défaut du formulaire et désélectionner le choix de utilisateur.

Corrigé:

private void Form1_Load(object sender, EventArgs e)
        {
            listBox_couleurs.Items.Add("Rouge");
            listBox_couleurs.Items.Add("Vert");
            listBox_couleurs.Items.Add("Bleu");
            listBox_couleurs.Items.Add("Jaune");
        }

private void button_Colorer(object sender, EventArgs e)
        {
            if (listBox_couleurs.SelectedIndex == -1)
                MessageBox.Show("Aucune couleur", "", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            else if (listBox_couleurs.SelectedIndex == 0)
                this.BackColor = Color.Red;
            else if (listBox_couleurs.SelectedIndex == 1)
                this.BackColor = Color.Green;
            else if (listBox_couleurs.SelectedIndex == 2)
                this.BackColor = Color.Blue;
            else
                this.BackColor = Color.Yellow;
        }

private void button_annuler(object sender, EventArgs e)
        {
            this.BackColor = DefaultBackColor;
            listBox_couleurs.SelectedIndex = -1;
        }

Exercice 2: (avec Corrigé): Evénementielle:





Le bouton Commander permet d’afficher un message contenant les plats du menu composé par l’utilisateur.
Le bouton Cocher tout (Décocher tout) permet de cocher (décocher) tous les plats proposés.
L'utilisateur pourra utiliser le clavier à la place des boutons "Commander" et "Quitter". La touche Entrée activera le bouton "Commander" et la touche "Echap" le bouton "Quitter". 





Corrigé:




private void Form1_Load(object sender, EventArgs e)
        {
            button_commander.Select();
            this.AcceptButton = button_commander;
            this.CancelButton = button_quitter;
        }





private void button_cocher_Click(object sender, EventArgs e)
        {
            //Méthode 1
            //checkBox1.Checked = true;
            //checkBox2.Checked = true;
            //checkBox3.Checked = true;
            //checkBox4.Checked = true;
            //checkBox5.Checked = true;
            //checkBox6.Checked = true;
            //checkBox7.Checked = true;
            //checkBox8.Checked = true;
            //checkBox9.Checked = true;
            //checkBox10.Checked = true;
 
            //Méthode 2
            foreach (CheckBox c in this.groupBox1.Controls)
            {
                c.Checked=true;
            }
        }



private void button_decocher_Click(object sender, EventArgs e)
        {
            //Méthode 1
            //checkBox1.Checked = false;
            //checkBox2.Checked = false;
            //checkBox3.Checked = false;
            //checkBox4.Checked = false;
            //checkBox5.Checked = false;
            //checkBox6.Checked = false;
            //checkBox7.Checked = false;
            //checkBox8.Checked = false;
            //checkBox9.Checked = false;
            //checkBox10.Checked = false;
 
            //Méthode 2
            foreach (CheckBox c in this.groupBox1.Controls)
            {
                c.Checked = false;
            }
        }



 private void button_commander_Click(object sender, EventArgs e)
        {
            string plat = "";
            
            //Méthode 1
            //if (checkBox1.Checked)
            //    plat +="-"+ checkBox1.Text + "\r\n";
            //if (checkBox2.Checked)
            //    plat += "-" + checkBox2.Text + "\r\n";
            //if (checkBox3.Checked)
            //    plat += "-" + checkBox3.Text + "\r\n";
            //if (checkBox4.Checked)
            //    plat += "-" + checkBox4.Text + "\r\n";
            //if (checkBox5.Checked)
            //    plat += "-" + checkBox5.Text + "\r\n";
            //if (checkBox6.Checked)
            //    plat += "-" + checkBox6.Text + "\r\n";
            //if (checkBox7.Checked)
            //    plat += "-" + checkBox7.Text + "\r\n";
            //if (checkBox8.Checked)
            //    plat += "-" + checkBox8.Text + "\r\n";
            //if (checkBox9.Checked)
            //    plat += "-" + checkBox9.Text + "\r\n";
            //if (checkBox10.Checked)
            //    plat += "-" + checkBox10.Text + "\r\n";
 
            //if(plat=="")
            //    MessageBox.Show("Vous n'avez rien commandé!!","commande",MessageBoxButtons.OK,MessageBoxIcon.Question);
            //else
            //MessageBox.Show("Votre plat contient :\r\n" + plat,"commande",MessageBoxButtons.OK,MessageBoxIcon.Information);
 
            //Méthode 2
            foreach (CheckBox c in this.groupBox1.Controls)
            {
                if(c.Checked)
                    plat += "-" + c.Text + "\r\n";
            }
            if (plat == "")
                MessageBox.Show("Vous n'avez rien commandé!!", "commande", MessageBoxButtons.OK, MessageBoxIcon.Question);
            else
                MessageBox.Show("Votre plat contient :\r\n" + plat, "commande", MessageBoxButtons.OK, MessageBoxIcon.Information);
        }


private void button_quitter_Click(object sender, EventArgs e)
        {
            this.Close();
        }

Exercice DataGridView

Exercice:

A.Créer une interface de Menu :

Créer une interface de menu comme suit :

Le menu « Fichier » contient les sous menus suivants :

• Connexion : permet d’affiche un formulaire d’authentification.
• Déconnexion : permet de désactiver le menu « Gestion »

Le menu « Gestion » contient les sous menus suivants :

• Gestion des clients
• Gestion des produits
• Gestion des commandes
• Consultation

Au démarrage du formulaire, le menu « Gestion » et l’option « Déconnexion » sont désactivés.

B.Interface d’authentification :

Réaliser l’interface d’authentification ci-dessous :

 

Si le login et le mot de passe de l’utilisateur sont corrects, activer le menu « Gestion » et l’option « Déconnexion » et désactiver l’option « Connexion ».

C.Interface de mise à jour des clients :

Créer une interface de mise à jour des clients en respectant les spécifications ci-dessous :

1. Nouveau: vider les champs de saisie.
2. Rechercher: rechercher un client par CIN et charger ses données dans les zones de texte correspondantes.
3. Ajouter : Ajouter un client à table client en vérifiant la contrainte de remplissage de tous les champs et l’unicité du CIN.
4. Modifier: Modifier les informations d'un client chargé.
5. Supprimer: supprimer un client à partir de son CIN.
6. Quitter : fermer le formulaire.

D.Interface de mise à jour des produits.

Créer une interface de mise à jour des produits en respectant les spécifications ci-dessous :

1. Au démarrage du formulaire, la liste catégorie doit se charger par les catégories déjà saisies.
2. Nouveau: vider les champs de saisie.
3. Rechercher: rechercher un produit par Référence et charger ses données dans les zones de texte correspondantes.
4. Ajouter : Ajouter un produit à la table Produit en vérifiant la contrainte de remplissage de tous les champs et l’unicité de la référence produit.
5. Modifier: Modifier les informations d'un produit chargé.
6. Supprimer: supprimer un produit à partir de sa référence.
7. Quitter : fermer le formulaire.

E.Interface de mise à jour des commandes et leurs détails :

Réaliser une interface de mise à jour des commandes et leurs détails en respectant les spécifications ci-dessous :

Au démarrage du formulaire, seule la zone « commande » est active, la zone « Détails » est désactivée.

Au démarrage du formulaire, charger la liste « CIN CLIENT » par les CIN des clients et la liste « REFERENCE » par les références des produits.

La zone « COMMANDES »

1. Le bouton « Nouveau » permet de vider les champs.
2. Le bouton « Rechercher » permet de rechercher une commande à partir de son numéro et charger ses données dans les contrôles correspondants.
3. Le bouton « Enregistrer » permet d’ajouter une commande à la table commande tout en vérifiant la contrainte de remplissage de tous les champs ainsi que l’unicité du numéro de la commande.
4. Le bouton « Modifier » permet de modifier les informations d’une commande chargée.
5. Le bouton « Supprimer » permet de supprimer une commande à partir de son numéro.
6. Le bouton « Détails » permet de désactiver la zone « Commande » et d’activer la zone « détails » tout en vérifiant d’abord qu’un numéro de commande existant est déjà saisi dans la zone de texte « Numéro » (Vous préparez l’interface pour la saisie des détails de la commande dont le numéro est dans la zone « numéro »), afficher ensuite les produits commandés de la commande en cours dans la grille de la zone « DÉTAILS ».

La zone « DÉTAILS »

1. Le bouton « Nouveau » permet de vider les champs.
2. Le bouton « Ajouter » permet d’ajouter un produit avec une quantité à la commande en cours.
3. Le bouton « Enlever » permet de supprimer le produit sélectionné de la commande en cours.
4. Au choix d’un produit dans liste, afficher sa quantité s’il est déjà commandé dans la commande en cours.
5. Le bouton « Modifier » permet de modifier la quantité du produit sélectionné dans la commande en cours.
6. Le bouton « Terminer » permet de vider et désactiver la zone « DÉTAILS » et activer la zone « COMMANDE ».
7. A chaque opération de mise à jour des détails de la commande en cours, actualiser et afficher le total de la commande.

F.Interface de consultation :

Réaliser une interface de consultation en respectant les spécifications ci-dessous :

 

1. Le bouton « OK » permet de rechercher le client à partir de son CIN, et afficher toutes ses commandes dans la gille « COMMANDE »
2. Au clic sur une commande, afficher ses détails dans la grille « DETAILS » ainsi que son total.

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