VB.NET

Tutoriel : Créer une classe ouverte en VB.NET

Dans ce tutoriel, nous allons explorer comment créer une classe ouverte en VB.NET. Une classe ouverte est une classe générique ou extensible, souvent utilisée pour travailler avec différents types de données tout en maintenant une structure commune.

Objectifs du tutoriel

Comprendre le concept de classes génériques.
Apprendre à créer une classe générique en VB.NET.
Illustrer l’utilisation d’une classe générique dans une application.

Prérequis

Avoir des connaissances de base en programmation VB.NET.
Avoir Visual Studio ou un autre environnement de développement intégré (IDE) pour écrire et tester le code.

Étape 1 : Comprendre les classes ouvertes

Une classe ouverte, ou classe générique, utilise des paramètres de type pour permettre à la classe de travailler avec différents types de données. Ces paramètres de type sont définis à l’aide de la syntaxe <T>.

Exemple :

Public Class GenericClass(Of T)
    Private _data As T

    Public Sub New(data As T)
        _data = data
    End Sub

    Public Function GetData() As T
        Return _data
    End Function

    Public Sub SetData(data As T)
        _data = data
    End Sub
End Class

Dans cet exemple, GenericClass peut fonctionner avec n’importe quel type de données grâce au paramètre générique <T>.

Étape 2 : Créer une classe générique en VB.NET

Voici les étapes pour créer une classe générique :

1. Déclaration de la classe

Utilisez Of pour indiquer un type générique.

Public Class OpenClass(Of T)
    ' Propriétés et méthodes génériques vont ici.
End Class

2. Ajouter des membres génériques

Vous pouvez ajouter des propriétés, des champs et des méthodes qui utilisent le type générique.

Exemple complet :

Public Class OpenClass(Of T)
    Private _items As New List(Of T)

    ' Ajouter un élément
    Public Sub AddItem(item As T)
        _items.Add(item)
    End Sub

    ' Obtenir tous les éléments
    Public Function GetAllItems() As List(Of T)
        Return _items
    End Function

    ' Obtenir un élément par index
    Public Function GetItem(index As Integer) As T
        If index >= 0 AndAlso index < _items.Count Then
            Return _items(index)
        Else
            Throw New IndexOutOfRangeException("Index invalide.")
        End If
    End Function
End Class

Étape 3 : Utiliser la classe générique dans une application

Exemple d’utilisation

Module Module1
    Sub Main()
        ' Créer une instance de classe pour des entiers
        Dim intList As New OpenClass(Of Integer)()

        ' Ajouter des entiers
        intList.AddItem(10)
        intList.AddItem(20)
        intList.AddItem(30)

        ' Obtenir et afficher les entiers
        Console.WriteLine("Liste des entiers:")
        For Each item In intList.GetAllItems()
            Console.WriteLine(item)
        Next

        ' Créer une instance de classe pour des chaînes
        Dim stringList As New OpenClass(Of String)()

        ' Ajouter des chaînes
        stringList.AddItem("VB.NET")
        stringList.AddItem("Tutoriel")
        stringList.AddItem("Classe ouverte")

        ' Obtenir et afficher les chaînes
        Console.WriteLine("Liste des chaînes:")
        For Each item In stringList.GetAllItems()
            Console.WriteLine(item)
        Next

        Console.ReadLine()
    End Sub
End Module

Étape 4 : Améliorer la classe avec des contraintes génériques

Les contraintes permettent de restreindre le type de données accepté par une classe générique. Par exemple :

Public Class OpenClass(Of T As Class) ' T doit être une classe.
    ' Membres de la classe ici.
End Class

Autres exemples de contraintes :

T As New: T doit avoir un constructeur sans paramètres.
T As IComparable: T doit implémenter une interface spécifique.

Créer une classe ouverte en VB.NET – Cas Pratiques

Dans cet article, nous allons explorer comment créer une classe ouverte (générique) en VB.NET et illustrer son utilisation dans des cas pratiques. Une classe générique est une classe qui utilise des paramètres de type pour gérer différents types de données de manière flexible et réutilisable.

Cas Pratique 1 : Gestion d’une liste générique

Nous allons créer une classe ouverte appelée GenericList pour gérer une liste d’éléments de n’importe quel type.

Code :

Public Class GenericList(Of T)
    Private _items As New List(Of T)

    ' Ajouter un élément à la liste
    Public Sub AddItem(item As T)
        _items.Add(item)
    End Sub

    ' Supprimer un élément de la liste
    Public Sub RemoveItem(item As T)
        _items.Remove(item)
    End Sub

    ' Obtenir tous les éléments de la liste
    Public Function GetAllItems() As List(Of T)
        Return _items
    End Function
End Class

' Exemple d'utilisation
Module Module1
    Sub Main()
        ' Liste d'entiers
        Dim intList As New GenericList(Of Integer)()
        intList.AddItem(1)
        intList.AddItem(2)
        intList.AddItem(3)

        Console.WriteLine("Liste d'entiers :")
        For Each num In intList.GetAllItems()
            Console.WriteLine(num)
        Next

        ' Liste de chaînes
        Dim stringList As New GenericList(Of String)()
        stringList.AddItem("VB.NET")
        stringList.AddItem("Tutoriel")

        Console.WriteLine("Liste de chaînes :")
        For Each str In stringList.GetAllItems()
            Console.WriteLine(str)
        Next
    End Sub
End Module

Points à retenir :

La classe GenericList(Of T) peut gérer n’importe quel type d’objet.
L’utilisation de paramètres génériques permet de réutiliser la même logique pour des types différents.

Cas Pratique 2 : Gestion d’un dictionnaire générique

Supposons que vous vouliez créer une classe pour gérer un dictionnaire clé-valeur.

Code :

Public Class GenericDictionary(Of TKey, TValue)
    Private _dictionary As New Dictionary(Of TKey, TValue)

    ' Ajouter une paire clé-valeur
    Public Sub AddItem(key As TKey, value As TValue)
        _dictionary(key) = value
    End Sub

    ' Obtenir une valeur par clé
    Public Function GetValue(key As TKey) As TValue
        If _dictionary.ContainsKey(key) Then
            Return _dictionary(key)
        Else
            Throw New KeyNotFoundException($"La clé '{key}' n'existe pas.")
        End If
    End Function

    ' Obtenir toutes les clés
    Public Function GetAllKeys() As List(Of TKey)
        Return _dictionary.Keys.ToList()
    End Function
End Class

' Exemple d'utilisation
Module Module2
    Sub Main()
        Dim phoneBook As New GenericDictionary(Of String, String)()
        phoneBook.AddItem("Alice", "123-456")
        phoneBook.AddItem("Bob", "789-012")

        Console.WriteLine("Numéro de téléphone d'Alice : " & phoneBook.GetValue("Alice"))

        Console.WriteLine("Clés dans le dictionnaire :")
        For Each key In phoneBook.GetAllKeys()
            Console.WriteLine(key)
        Next
    End Sub
End Module

Points à retenir :

La classe GenericDictionary(Of TKey, TValue) permet de gérer des paires clé-valeur avec n’importe quel type pour les clés et les valeurs.
Les méthodes comme AddItem et GetValue simplifient l’accès aux données.

Cas Pratique 3 : Gestion des contraintes avec des types spécifiques

Dans ce cas, nous allons créer une classe générique avec des contraintes pour accepter uniquement des objets héritant d’une classe de base ou implémentant une interface.

Code :

Public Interface ICanSpeak
    Sub Speak()
End Interface

Public Class Animal
    Public Property Name As String
    Public Sub New(name As String)
        Me.Name = name
    End Sub
End Class

Public Class Dog
    Inherits Animal
    Implements ICanSpeak

    Public Sub New(name As String)
        MyBase.New(name)
    End Sub

    Public Sub Speak() Implements ICanSpeak.Speak
        Console.WriteLine($"{Name} says: Woof!")
    End Sub
End Class

Public Class GenericAnimalHandler(Of T As {Animal, ICanSpeak})
    Private _animals As New List(Of T)

    ' Ajouter un animal
    Public Sub AddAnimal(animal As T)
        _animals.Add(animal)
    End Sub

    ' Faire parler tous les animaux
    Public Sub MakeAllSpeak()
        For Each animal In _animals
            animal.Speak()
        Next
    End Sub
End Class

' Exemple d'utilisation
Module Module3
    Sub Main()
        Dim dogHandler As New GenericAnimalHandler(Of Dog)()
        dogHandler.AddAnimal(New Dog("Buddy"))
        dogHandler.AddAnimal(New Dog("Max"))

        Console.WriteLine("Les chiens parlent :")
        dogHandler.MakeAllSpeak()
    End Sub
End Module

Points à retenir :

L’utilisation de contraintes génériques (Of T As {Animal, ICanSpeak}) permet de garantir que le type générique est compatible avec une classe ou une interface spécifique.
Le code devient plus robuste et moins sujet aux erreurs au moment de l’exécution.

Cas Pratique 4 : Gestion d’une pile (Stack) personnalisée

Une pile (stack) est une structure de données de type LIFO (Last In, First Out).

Code :

Public Class GenericStack(Of T)
    Private _stack As New List(Of T)

    ' Ajouter un élément à la pile
    Public Sub Push(item As T)
        _stack.Add(item)
    End Sub

    ' Retirer le dernier élément ajouté
    Public Function Pop() As T
        If _stack.Count = 0 Then
            Throw New InvalidOperationException("La pile est vide.")
        End If
        Dim item As T = _stack.Last()
        _stack.RemoveAt(_stack.Count - 1)
        Return item
    End Function

    ' Obtenir le dernier élément sans le retirer
    Public Function Peek() As T
        If _stack.Count = 0 Then
            Throw New InvalidOperationException("La pile est vide.")
        End If
        Return _stack.Last()
    End Function
End Class

' Exemple d'utilisation
Module Module4
    Sub Main()
        Dim intStack As New GenericStack(Of Integer)()
        intStack.Push(10)
        intStack.Push(20)
        intStack.Push(30)

        Console.WriteLine("Élément au sommet : " & intStack.Peek())
        Console.WriteLine("Élément retiré : " & intStack.Pop())
        Console.WriteLine("Nouveau sommet : " & intStack.Peek())
    End Sub
End Module