• 20 heures
  • Moyenne

Ce cours est visible gratuitement en ligne.

Vous pouvez obtenir un certificat de réussite à l'issue de ce cours.

J'ai tout compris !

Mis à jour le 10/03/2017

Créez un projet bibliothèque de classes

Connectez-vous ou inscrivez-vous gratuitement pour bénéficier de toutes les fonctionnalités de ce cours !

Pour l'instant, nous n'avons créé que des projets de type application console. Il existe plein d'autres modèles de projet. Un des plus utiles est le projet permettant de créer des bibliothèques de classes.
Il s'agit d'un projet qui va permettre de contenir des classes que nous pourrons utiliser dans des applications. Exactement comme la bibliothèque de classes du framework .NET qui nous permet d'utiliser la classe Math ou les exceptions, ou plein d'autres choses…
Ce type de projet permet donc de créer une assembly sous la forme d'un fichier avec l'extension .dll. Ces assemblys sont donc des bibliothèques qui seront utilisables par n'importe quelle application utilisant un langage compatible avec le framework .NET.

Pourquoi créer une bibliothèque de classes ?

Globalement pour deux raisons que nous allons détailler :

  • Réutilisabilité

  • Architecture

Réutilisabilité

Comme indiqué en introduction, le projet de type bibliothèque de classes permet d’obtenir des assemblys avec l’extension .dll.
Nous pouvons y mettre tout le code C# que nous voulons, notamment des classes qui auront un intérêt à être utilisées à plusieurs endroits ou partagées par plusieurs applications. C’est le cas des assemblys du framework .NET. Elles possèdent plein de code très utile que nous aurons avantage à utiliser pour créer nos applications.

De la même façon, nous allons pouvoir créer des classes qui pourront être réutilisées à plusieurs endroits. Comme notre classe permettant de gérer les listes chainées. N’importe quel programme qui utilise des listes chainées aura intérêt à ne pas tout réinventer et à simplement réutiliser ce code prêt à l’emploi. Il suffira pour ce faire de réutiliser cette classe en référençant l’assembly, comme nous l’avons déjà vu.

Architecture :

L’autre avantage dans la création de bibliothèques de classes est de pouvoir architecturer son application de manière à faciliter sa mise en place, sa maintenabilité et l’évolutivité du code. L’architecture informatique c’est comme l’architecture d’une maison. Si nous mettons la douche au même endroit que le compteur électrique ou que la machine à laver est juste à côté de la chambre à coucher, cela peut poser des problèmes. De même, que penser d’un architecte s’il place les toilettes à côté du lit. Une maison mal architecturée est une maison où il ne fait pas bon vivre. De même qu’une application mal architecturée est une application où il ne fait pas bon faire la maintenance applicative ! :)

Architecturer son application est important surtout si l’application est grosse. Par exemple, une bonne pratique dans une application informatique est la décomposition en couches. Nous n’allons pas faire ici un cours d’architecture, mais le but est de séparer les composantes de l’application. Un grand nombre d’applications de gestions est composée d’une couche de présentation, d’une couche métier et d’une couche d’accès aux données, les couches communiquant entre-elles.
Le but est de limiter les modifications d’une couche lors de la modification d’une autre. Si toutes les couches étaient mélangées alors chaque modification impliquerait une série de modifications en chaine.
On peut faire une analogie avec un plat de lasagnes et un plat de spaghetti. Il est difficile de toucher à un spaghetti sans toucher les autres. Cependant, il pourrait être envisageable de toucher à la couche du dessus du plat de lasagnes pour rajouter un peu de fromage sans perturber ce qu’il y a dessous. Miam.

Il est donc intéressant d’avoir une bibliothèque de classes qui gère l’accès aux données, une autre qui gère les règles métier et une autre qui s’occupe d’afficher le tout.
Je m’arrête là sur l’architecture, vous aurez l’occasion de vous y confronter bien assez tôt :p .

Créer un projet de bibliothèque de classe

Pour créer une bibliothèque de classes, on utilise l’assistant de création de nouveau projet (Fichier > Nouveau > Nouveau projet), comme on l’a fait pour une application console sauf qu’ici, on utilisera le modèle « bibliothèque de classes ». Ne le faisons pas encore.

Le modèle de création d'un projet de bibliothèque de classes
Le modèle de création d'un projet de bibliothèque de classes

Si nous faisons cela, Visual Studio Express va nous créer une nouvelle solution contenant le projet de bibliothèques de classes. C’est possible sauf qu’en général, on ajoute une bibliothèque de classes pour qu’elle serve dans le cadre d’une application. Cela veut dire que nous pouvons ajouter ce nouveau projet à notre solution actuelle.
Ainsi, celle-ci contiendra deux projets :

  • L’application console, qui sera exécutable par le système d’exploitation

  • La bibliothèque de classes, qui sera utilisée par l’application.

Pour ce faire, on peut faire un clic droit sur notre solution et faire Ajouter > Nouveau Projet.

Ajout d'un projet de bibliothèque de classes à la solution
Ajout d'un projet de bibliothèque de classes à la solution

Ici, on choisit le projet de type bibliothèque de classes, sans oublier de lui donner un nom, par exemple « MaBibliotheque ».

Nommer la bibliothèque de classes
Nommer la bibliothèque de classes

Visual Studio Express nous créé notre projet et l’ajoute à la solution, comme on peut le voir dans l’explorateur de solutions.

Deux projets dans la solution
Deux projets dans la solution

Il le génère avec un fichier Class1.cs que nous pouvons supprimer.

Nous pouvons voir que notre application console est en gras. Cela veut dire que c’est ce projet que Visual Studio Express va tenter de démarrer lorsque nous utiliserons ctrl + F5. Si ce n’est pas le cas, il peut tenter de démarrer la bibliothèque, ce qui n’a pas de sens vu qu’elle n’a pas de méthode Main(). Dans ce cas, vous pourrez le changer en faisant un clic droit sur le projet console et en choisissant « Définir comme projet de démarrage ».

Dans ce projet, nous pourrons désormais créer nos classes en ajoutant des nouvelles classes au projet, comme on l’a déjà fait avec l’application console.

Ajoutons par exemple la classe suivante :

namespace MaBibliotheque
{
    public class Bonjour
    {
        public void DireBonjour()
        {
            Console.WriteLine("Bonjour depuis la bibliothèque MaBibliotheque");
        }
    }
}

Propriétés de la bibliothèque de classe

Si nous ouvrons les propriétés de notre projet (bouton droit sur le projet, Propriétés) :

Afficher les propriétés du projet
Afficher les propriétés du projet

La fenêtre des propriétés s’affiche :

Affichage de la fenêtre de propriétés
Affichage de la fenêtre de propriétés

Nous pouvons voir différentes informations et notamment dans l’onglet Application que le projet possède un nom d’assembly, qui correspond ici au nom du projet ainsi qu’un espace de nom par défaut, qui correspond également au nom du projet. Le nom de l’assembly servira à identifier l’assembly, alors que l’espace de nom par défaut sera celui donné lorsque nous ajouterons une nouvelle classe (ou autre) à notre projet. Cet espace de nom pourra être changé, mais en général on garde un nom cohérent avec les arborescences de notre projet.

Notons au passage qu’il y a une option permettant d’indiquer la version du framework .NET que nous souhaitons utiliser. Ici, nous gardons la version 4,5.

Générer et utiliser une bibliothèque de classe

Nous pouvons alors compiler cette bibliothèque de classes, soit individuellement, soit en compilant tout le projet.

Rendons nous dans le répertoire où nous avons sauvegardé notre bibliothèque, nous voyons dans le répertoire de sortie (chez moi : C:\Users\Nico\Documents\Visual Studio 2013\Projects\C#\MaPremiereApplication\MaBibliotheque\bin\Release) qu’il y a un fichier du nom de notre projet dont l’extension est .dll.
C’est notre bibliothèque de classes (même s’il n’y a qu’une classe dedans !). Elle possède le même nom que celui que nous avons vu dans les propriétés du projet.

J’en profite pour vous faire remarquer qu’à son côté, il y a également un fichier du même nom avec l’extension .pdb. Je peux enfin vous révéler de quoi il s’agit. Ce fichier contient les informations de débogages, utiles lorsque nous déboguons notre application. Sans ce fichier, impossible de déboguer à l’intérieur du code de notre classe.

Revenons à l’assembly générée. C’est cette dll qu’il faudra référencer dans notre projet, comme nous avons vu au chapitre sur le référencement d’assemblys. Si vous avez un doute, n’hésitez pas à retourner le consulter. Ainsi, nous serons en mesure d’utiliser la classe de notre bibliothèque.
Rappelez-vous, pour référencer une assembly, nous faisons un clic droit sur les références du projet et sélectionnons « Ajouter une référence ». Nous pourrons référencer notre bibliothèque soit en utilisant l’onglet Parcourir, qui va nous permettre de pointer directement le fichier dll contenant nos classes :

Ajout d'une référence directe à l'assembly
Ajout d'une référence directe à l'assembly

soit en référençant directement le projet de bibliothèque de classes qui se trouve dans notre solution en utilisant l’onglet Solution :

Ajout d'une référence à un projet de la solution
Ajout d'une référence à un projet de la solution

C’est ce choix qui doit être privilégié lorsque notre solution contient les projets à référencer.
Généralement, vos bibliothèques vont évoluer en même temps que votre programme, donc il est judicieux de les avoir dans la même solution que son application. Nous pourrons donc faire des références projet.
Si cependant les bibliothèques sont stables et ne sont pas sujettes à évoluer, alors vous pourrez les référencer directement à partir des dll, vous y gagnerez en temps de compilation.
Utilisons désormais notre classe avec le code suivant :

MaBibliotheque.Bonjour bonjour = new MaBibliotheque.Bonjour();
bonjour.DireBonjour();

Vous pouvez aussi bien sûr inclure l’espace de nom MaBibliotheque pour éviter d’avoir à préfixer notre classe. En général, l’espace de nom d’une bibliothèque est différent de celui de l’application.
Notez que pour qu’une classe, comme la classe Bonjour, puisse être utilisée par une application référençant son assembly, elle doit être déclarée en public afin qu’elle soit visible par tout le monde.

Le mot-clé internal

Nous avons déjà vu ce mot-clé lorsque nous parlions de visibilité avec notamment les autres mots-clés public, private et protected.
C’est avec les assemblys que le mot-clé internal prend tout son sens. Il permet d’indiquer qu’une classe, méthode ou propriété ne sera accessible qu’à l’intérieur d’une assembly.
Cela permet par exemple qu’une classe soit utilisable par toutes les autres classes de cette assembly mais qu’elle ne puisse pas être utilisée par une application référençant l’assembly.

Par exemple créons dans notre bibliothèque de classes les trois classes suivantes :

public class Client
{
    private string login;
    public string Login
    {
        get { return login; }
    }

    private string motDePasse;
    public string MotDePasse
    {
        get { return motDePasse.Crypte(); }
    }

    public Client(string loginClient, string motDePasseClient)
    {
        login = loginClient;
        motDePasse = motDePasseClient;
    }
}

public static class Generateur
{
    public static string ObtenirIdentifiantUnique()
    {
        Random r = new Random();
        string chaine = string.Empty;
        for (int i = 0; i < 10; i++)
        {
            chaine += r.Next(0, 100);
        }
        return chaine.Crypte();
    }
}

internal static class Encodage
{
    internal static string Crypte(this string chaine)
    {
        return Convert.ToBase64String(Encoding.Default.GetBytes(chaine));
    }

    internal static string Decrypte(this string chaine)
    {
        return Encoding.Default.GetString(Convert.FromBase64String(chaine));
    }
}

Les deux premières sont des classes publiques qui peuvent être utilisées depuis n’importe où, comme depuis notre programme principal :

class Program
{
    static void Main(string[] args)
    {
        Client client = new Client("Nico", "12345");
        Console.WriteLine(client.MotDePasse);

        Console.WriteLine(Generateur.ObtenirIdentifiantUnique());
    }
}

Par contre, la classe Encodage n’est accessible que pour les deux autres classes, car elles sont dans la même assembly. Cela veut dire que si nous tentons de l’utiliser depuis notre méthode Main() :

static void Main(string[] args)
{
    string chaine = "12345".Crypte();

    Encodage.Crypte("12345");
}

Nous aurons des erreurs de compilation.
Cet exemple permet d’illustrer l’intérêt pas toujours évident du mot-clé internal.

À noter qu’il existe enfin le mot-clé protected internal qui permet d’indiquer que des éléments sont accessibles à un niveau internal pour les classes d’une même assembly mais protected pour les autres assemblys, ce qui permet d’appliquer les principes de substitutions ou d’héritage.

Voilà, vous avez vu comment créer une bibliothèque de classes. N’hésitez pas à créer ce genre de projet afin d’y mettre toutes les classes qui peuvent être utilisées par plusieurs applications. Comme ça, il suffit d’une simple référence pour accéder au code qui y est contenu.
Vous vous en servirez également pour mieux architecturer vos applications, le code s’en trouvera plus clair et plus maintenable.

En résumé
  • Un projet de bibliothèque de classes permet de regrouper des classes pouvant être utilisées entre plusieurs applications.

  • Les bibliothèques de classes génèrent des assemblys avec l'extension .dll.

  • Elles permettent également de mieux architecturer un projet.

Exemple de certificat de réussite
Exemple de certificat de réussite