Développer avec une architecture en Csharp

Cette couche se matérialise par les interfaces utilisateur (les fenêtres, boutons, les zones de texte). Dans la couche interface, nous ne ferons qu'instancier les méthodes des objets de la couche métier.

La couche métier contient des méthodes qui seront utilisées par les utilisateurs. Lorsqu'un utilisateur procède par exemple à une insertion ou une modification, ce sont ces méthodes créées dans la couche métier qui seront appelées. Elle permet de définir aussi les règles de validation de formulaire.

Cette couche se scinde en deux parties. Une première qui permet de décrire les entités de notre base de données (comme entité nous pourrons avoir des classes, des structs dont les propriétés devront être identiques à celles de vos tables au niveau de votre base de données) et une deuxième dans laquelle nous écrirons des méthodes qui sont relatives aux bases de données. Dans cette seconde couche, nous écrirons des fonctions qui porteront sur des opérations de base telles que l'insertion, la modification, la sélection et la suppression. L'écriture de ces méthodes dépendra du Système de Gestion de Base de Données. Étant donné que nous utiliserons le langage Csharp et une base de données SQL Server Express, nous utiliserons également des espaces de noms qui sont spécifiques à notre base de données. Pour une base de données SQL Server nous aurons System.Data, System.Data.SqlClient et MySql.Data, MySql.Data.MySqlClient pour une base de données MySQL et vice versa. Vos méthodes dépendront du SGBD que vous utiliserez. Cependant, sachez que les méthodes de la couche d'accès aux données sont créées en fonction des scripts que nous aurons écrits au niveau de notre base de données, la couche physique.

Elle contient les scripts de création de notre base de données et les opérations du CRUD (Create Read Update and Delete) et d'autres requêtes selon les fonctionnalités de l'application ou les besoins des utilisateurs. De façon plus simple, la couche physique c'est notre Système de Gestion de Base de Données (SGBD).

Nous allons donc créer nos procédures stockées, elles sont faites au niveau de notre SGBD, pour notre tutoriel, il s'agit de SQL Server Express.

VI-B-I. L'insertion▲

CREATE PROCEDURE InsertClient
(
/*Définition des paramètres 
en Transact-SQL les variables doivent être précédées du caractère @
*/
    @nom varchar(20),
    @prenom varchar(30),
    @tel varchar(15),
    @adresse varchar(50)
)
AS
INSERT INTO client(nom,prenom,tel,adresse) VALUES (@nom,@prenom,@tel,@adresse)

VI-B-II. La modification▲

CREATE PROCEDURE UpdateClient(
--Définition des paramètres de notre procédure
    @id int,
    @nom varchar(20),
    @prenom varchar(30),
    @tel varchar(15),
    @adresse varchar(50)
)
AS
UPDATE Client 
SET 
    nom=@nom,
    prenom=@prenom,
    tel=@tel,
    adresse=@adresse
WHERE(client.id=@id)

VI-B-III. La sélection▲

CREATE PROCEDURE SelectClient
AS
SELECT id,nom,prenom,tel,adresse from client;

VI-B-IV. La suppression▲

CREATE PROCEDURE DeleteClient
(
    @Id int
)
AS
DELETE FROM client
WHERE(client.id=@Id);

VI-B-V. La vérification▲

CREATE PROCEDURE VerifNumeroBeforeInsert
(
    @Numero varchar(15)
)
AS
SELECT COUNT(*) as 'Nombre' FROM client
WHERE(client.tel=@Numero);

Voici un exemple de la structure. Cette partie nous permettra de définir les objets que nous utiliserons dans notre application. Notez que ces objets sont créés en tenant compte des structures des tables de notre base de données. Pour notre minitutoriel, nous utiliserons des struct plutôt que des classes (Classes et structures).

Nous avons commencé par cette partie, car l'écriture des couches métier, les méthodes d'accès aux données en dépend.

Pour notre exemple, nous n'avons que cinq méthodes, mais elles peuvent varier selon le projet sur lequel vous travaillerez. Nous allons donc créer nos méthodes, lesquelles serviront d'intermédiaire entre notre application et notre moteur de base de données. Ouvrez votre éditeur, ajoutez une classe au projet client_data que vous nommerez clientdata et nous ajouterons nos codes.

• L'insertion

public int insertclient(client notreclient)
        {
            SqlConnection cnx = new SqlConnection(connexion);
            cnx.Open();
            SqlCommand cmd = new SqlCommand("insertclient",cnx);
            cmd.CommandType = CommandType.StoredProcedure;
            SqlParameter prmnom = new SqlParameter("nom",SqlDbType.VarChar,20);
            prmnom.Value = notreclient.nom;
            cmd.Parameters.Add(prmnom);
            SqlParameter prmprenom = new SqlParameter("prenom", SqlDbType.VarChar, 20);
            prmprenom.Value = notreclient.prenom;
            cmd.Parameters.Add(prmprenom);
            SqlParameter prmtel = new SqlParameter("tel", SqlDbType.VarChar, 20);
            prmtel.Value = notreclient.tel;
            cmd.Parameters.Add(prmtel);
            SqlParameter prmadresse = new SqlParameter("adresse", SqlDbType.VarChar, 20);
            prmadresse.Value = notreclient.adresse;
            cmd.Parameters.Add(prmadresse);
            int resultat = Convert.ToInt32(cmd.ExecuteNonQuery());
            return resultat;
        }

• La mise à jour

  updateclient

  Sélectionnez

  public int updateclient(client notreclient)
          {
              SqlConnection cnx = new SqlConnection(connexion);
              cnx.Open();
              SqlCommand cmd = new SqlCommand("updateclient", cnx);
              cmd.CommandType = CommandType.StoredProcedure;
              SqlParameter prmid = new SqlParameter("id", SqlDbType.Int, 20);
              prmid.Value = notreclient.nom;
              cmd.Parameters.Add(prmid);
              SqlParameter prmnom = new SqlParameter("nom", SqlDbType.VarChar, 20);
              prmnom.Value = notreclient.nom;
              cmd.Parameters.Add(prmnom);
              SqlParameter prmprenom = new SqlParameter("prenom", SqlDbType.VarChar, 20);
              prmprenom.Value = notreclient.prenom;
              cmd.Parameters.Add(prmprenom);
              SqlParameter prmtel = new SqlParameter("tel", SqlDbType.VarChar, 20);
              prmtel.Value = notreclient.tel;
              cmd.Parameters.Add(prmtel);
  
              SqlParameter prmadresse = new SqlParameter("adresse", SqlDbType.VarChar, 20);
              prmadresse.Value = notreclient.adresse;
              cmd.Parameters.Add(prmadresse);
              int resultat = Convert.ToInt32(cmd.ExecuteNonQuery());
              return resultat;
          }

• La suppression

  deleteclient

  Sélectionnez

   public void deleteclient(int notreclient)
  //On passe l'identifiant du client en paramètre
          {
              SqlConnection cnx = new SqlConnection(connexion);
              cnx.Open();
              SqlCommand cmd = new SqlCommand("deleteclient", cnx);
              cmd.CommandType = CommandType.StoredProcedure;
  
              //Ajout des paramètres
              SqlParameter prmid = new SqlParameter("id", SqlDbType.Int, 0);
              prmid.Value = notreclient;
              cmd.Parameters.Add(prmid);
  
              //Exécution
              cmd.ExecuteNonQuery();
          }

• La sélection

  selectclient

  Sélectionnez

   public DataTable selectclient()
          {
              SqlConnection cnx = new SqlConnection(connexion); //Notre connexion à la base de données
              cnx.Open(); //Ouverture de la connexion
              SqlCommand cmd = new SqlCommand("selectclient", cnx); //Initialisation de la commande 
              cmd.CommandType = CommandType.StoredProcedure; //Ici nous précisons le type de notre commande qui est en fait une procédure stockée
  
              DataTable dt = new DataTable(); //Une table de données en mémoire
              SqlDataAdapter adaptater = new SqlDataAdapter(cmd); 
              adaptater.Fill(dt);
              return dt;
          }

• La vérification

/*Cette méthode permettra de vérifier l'existence d'un numéro
          C'est-à-dire que lorsque nous ajouterons un nouveau client, nous allons 
         nous assurer que ce numéro n'est pas déjà utilisé par quelqu'un d'autre*/
        public DataTable verifclientbeforeinsert(string paramNumero)
{
            SqlConnection cnx = new SqlConnection(connexion); //Notre connexion à la base de données
            cnx.Open(); //Ouverture de la connexion
            SqlCommand cmd = new SqlCommand("VerifNumeroBeforeInsert", cnx); //Initialisation de la commande 
            cmd.CommandType = CommandType.StoredProcedure; //Ici nous précisons le type de notre commande qui est en fait une procédure stockée
            DataTable dt = new DataTable(); //Une table de données en mémoire
            SqlDataAdapter adaptater = new SqlDataAdapter(cmd);
            adaptater.Fill(dt);
            return dt;
        }

En ce qui concerne l'insertion, nous devons nous assurer que le numéro entré n'est utilisé par aucun client. Avec le code l'explication sera beaucoup plus facile.

public void insertclient(string numero, string nom, string prenom, string adresse)
        {
            unclient = new clientmetier();
            int verif = unclient.VerifNumero(numero); //Méthode vérification des numéros avant insertion que nous avons écrite dans la couche métier
            if (verif == 0) //Si vrai alors le numéro n'existe pas
            {
                //Assignation
                unclient.nom = nom;
                unclient.prenom = prenom;
                unclient.tel = numero;
                unclient.adresse = adresse;

                //Insertion
                unclient.Insertclient(); //Méthode d'insertion 
                cleanfields(); //Cette méthode vide le contenu des champs
            }
            else
            {
                //Sinon on affiche un message d'erreur à l'utilisateur
                MessageBox.Show("Ce numéro existe déjà", "Erreur", MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }

Et pour finir, la méthode d'insertion est appelée derrière le bouton comme suit

 private void button1_Click(object sender, EventArgs e)
        {
            insertclient(txttel.Text,txtnom.Text,txtprenom.Text,txtadresse.Text);
            cleanfields();
            loaddata(); //Méthode d'affichage des données.
        }

Pour effectuer une sélection, cela est possible grâce à un espace de noms qui est le system.Data. C'est pourquoi nous avons cette ligne.

using System.Data;

Voici la méthode sélection

 public void loaddata()
        {
            AllClient = new System.Data.DataTable(); 
            unclient = new clientmetier();
            AllClient = unclient.Selectclient();//Notre méthode écrite dans la couche d'accès aux données retourne un DataTable
            listView1.Items.Clear(); //Suppression de la liste avant d'y afficher les données
            foreach (DataRow dtr in AllClient.Rows)
            {
                //Le DataRow nous permet de parcourir chaque ligne du DataTable(qui est une table de données en mémoire)
                int id =0;
                string nom = null;
                string prenom = null;
                string tel = null;
                string adresse = null;
                //Nous recueillons les valeurs en fonction du nom des colonnes et nous procédons à l'assignation
                id = (int)dtr["id"];
                nom = (string)dtr["nom"].ToString();
                prenom = (string)dtr["prenom"].ToString();
                adresse = (string)dtr["adresse"].ToString();
                tel = (string)dtr["tel"].ToString();
                //Fin assignation
                ListViewItem itm = listView1.Items.Add(nom);
                itm.SubItems.Add(prenom);
                itm.SubItems.Add(tel);
                itm.SubItems.Add(adresse);
                itm.Tag = id;
            }
        }