Tuto POO en Vb.NET : La base

Le problème qu’on rencontre le plus souvent quand on souhaite apprendre un concept de programmation, c’est de trouver LE tuto qui montre tout ce qu’on doit savoir et surtout qui montre comment programmer sans avoir spécialement de grosses connaissances ou encore s’envahir l’esprit avec un vocabulaire trop pointu. Donc voici un tuto allégé sur la Programmation Orientée Objet en VB.NET.

Problématique

Alors pourquoi ne pas se satisfaire des tutos déjà présent sur internet ?

Pour le simple et bonne raison que je les trouve surchargés, sans réel intérêt dans le sens ou il explique des principes de base sans exemple très parlant. J’ai été amené à faire pas mal de recherche post-tuto pour savoir comment on faisait ceci ou cela, qui sont des principes de base, mais rien de simple à trouver. Donc je réalise ce tuto avec un exemple qui marche (puisque je l’utilise réellement en programmation).

La POO ?

La Programmation Orientée Objet est présente dans plusieurs langages de programmation et a pour objectif de faciliter le traitement des données. Elle présente pas mal d’avantages et peu d’inconvénient.

Actuellement en programmation, quand on veut obtenir une valeur à partir d’une base de données, on fait une requête est on traite les informations au cas par cas. Or un des principes de base est de ne jamais répéter plusieurs fois un code identique. Si on a besoin d’un même bout de code plusieurs fois, on créé une fonction pour le remplacer, ce qui facilite la maintenance du code.

L’idée de la POO est de centraliser la gestion des données et de faciliter leur exploitation grâce à une formulation plus explicite.

Si on compare l’avant et l’après POO :

  • Avant : Une multitude de boite qu’on doit ouvrir au pied de biche pour en modifier le contenu
  • Après : une commode avec une infinité de tiroir et une jolie clé toute simple pour modifier le contenu

Vocabulaire

Oui j’ai dit qu’on n’allait pas aborder de vocabulaire très poussé, mais il en faut un minimum.

  • La POO s’articule autour des Class. Pour faire simple, il s’agit d’une fonction en plus poussée (c’est notre commode).
  • Ensuite, chaque Class possède ses attributs qui ne sont que des variables avec une syntaxe particulière (ce sont nos tiroirs).
  • Les propriétés qui sont là pour accéder aux tiroirs attributs et les modifier (la clé du tiroir).
  • Et pour finir, les méthodes qui sont des sous-fonctions (c’est l’équivalent de la personne qui change le contenu des tiroirs).

Code

Déclaration de la Class

Avant toute chose, histoire d’avoir un code clair, on ouvre un nouveau module de Class et on la déclare. Cette syntaxe ne doit pas vous être étrangère car c’est de cette manière qu’est déclaré une UserForm.

Public Class MaClasse

End Class

Alors ça peut paraître très simple, mais c’est parce que ça l’est. Mais on va entrer tout de suite dans le vif du sujet avec une classe assez simple à propos qui contient les informations d’une société.

Ajout des attribus (propriétés)

Là on rajoute les attributs de la classe. Jusque là rien de bien compliqué puisqu’on utilise la même méthode pour déclarer une variable Public.

Public Class Societe
    Public Nom As String
    Public Adresse As String
    Public CP As String
    Public Ville As String

End Class

Jusque là ce ne sont que des choses déjà vu et connu mais qu’on ne remarque pas forcément (voir ci-dessous).

Le constructeur

Tout comme une fonction, une classe s’initialise quand on l’appelle. Alors tout l’intérêt de cet appel est qu’il peut intégrer des paramètres pour adapter les variables.

Public Class Societe
    Public Nom As String
    Public Adresse As String
    Public CP As String
    Public Ville As String

    Sub New(<paramètres comme="" n'importe="" quelle="" fonction="">)

    End Sub

End Class

Vous avez déjà vu ce genre de structure avant, quand vous utilisez une Form dans un projet et des variables Public.

Public Class Form1

    Public Stockage As String

    Private Sub MaSub()

    End Sub

End Class

Histoire de faire avancer le schmilblick, on va voir immédiatement comment utiliser le Constructeur en lui passant un paramètre. Ici, on va passer un identifiant unique de la société. On va également prévoir le cas où la base de donnée ne contient pas de société avec cet identifiant et utiliser des valeurs par défaut. Ça évite une erreur en cas d’utilisation d’une variable sans valeur.

Public Class Societe
    Public Id As Integer = 0
    Public Nom As String = ""
    Public Adresse As String = ""
    Public CP As String = ""
    Public Ville As String = ""

    Sub New(ByVal id_societe As String)
        'On transforme id_client en membre de la classe
        Id = id_client
        Dim Dr As OleDbDataReader
        Dim Command As OleDbCommand
        Connection.Open()
        Command = New OleDbCommand("SELECT * FROM SOCIETE WHERE id_societe = " & id_societe & ";", Connection)
        Dr = Command.ExecuteReader
        While Dr.Read()
            Nom = Dr("nom").ToString
            Adresse = Dr("adresse").ToString
            CP = Dr("code_postal").ToString
            Ville = Dr("ville").ToString
        End While
        Connection.Close()
    End Sub

End Class

 L’utilisation dans le code

Maintenant qu’on a vu comment ça fonctionne, on va voir comment exploiter ces résultats.

'Création d'une instance "client"
Dim client As New Societe(id_client)

Cette simple ligne permet d’instancié le client. Donc pour reprendre l’exemple de la commode à tiroir, client est notre commode. Donc comment utiliser ses tiroirs ? En fait c’est très simple.

'Création d'une instance "client"
Dim client As New Societe(id_client)

'On place le nom du client dans une TextBox
TextBox1.Text = client.Nom

'On change le contenu d'une valeur
client.Ville = TextBox2.Text

Vous comprenez maintenant ? C’est simple, propre, presque beau. Mais on peut encore allé bien plus loin en multipliant les instances. Si je souhaite avoir deux commodes, l’une étant un client l’autre un fournisseur…

'Création d'une instance "client"
Dim client As New Societe(id_client)

'Création d'une instance "fournisseur"
Dim fournisseur As New Societe(id_fournisseur)

Le client et le fournisseur étant deux sociétés, ils contiennent les mêmes informations : Nom de société, adresse, ville, code postal… Donc ma class société est en fait un archétype que je peux remplir.

Shared !

Le dernier point de ce tuto est l’utilisation de l’option Shared. Cette option permet d’utiliser la variable à laquelle elle a été rattachée sans avoir à instancié la class.

L’exemple ci-dessous devrait vous éclairer.

Public Class Societe
    Public Shared Nom As String
    Public Ville As String

    Sub New()
    End Sub

End Class

Sub Instance()
    'Initialise la class sans nom
    TextBox1.Text = Societe.Nom 'Fonctionne
    TextBox2.Text = Societe.Ville 'Ne Fonctionne Pas

    'Fonctionne
    Dim client As New Societe(id)
    TextBox2.Text = client.Ville
End Sub

Conclusion

C’est la fin de la première partie du tuto POO. Pour le moment vous savez déclarer une Class, l’initialiser via un constructeur et exploiter ses données.

Dans la prochaine partie, on verra les class imbriquées et les méthodes (si j’en ai parlé au début).

Leave a Reply