[.NET] Un autre moyen de réaliser un « Dictionary » avec les classes sous .NET

Une classe peut-être vue comme un Dictionary<String, Object>. Pour rappel, Dictionary<TKey, TValue> est une collection contenant des paires clé/valeur, le premier paramètre de type étant le type de la clé, et le second le type des valeurs.Si on considère les propriétés comme une clé et la valeur de celle-ci comme une valeur, on peut donc se dire qu’une classe peut représenter un Dictionary<String, Object> statique.

Tout d’abord un exemple…

Voici un exemple d’une classe basique :

using System;

namespace Tourreau.Gilles.DotNet.ClasseDictionnary
{
    public class Personne
    {
        public string Nom
        {
            get;
            set;
        }
        public string Prénom
        {
            get;
            set;
        }
        public int Age
        {
            get;
            set;
        }
    }
}

Voici maintenant un exemple de l’utilisation de cette classe :

using System;

namespace Tourreau.Gilles.DotNet.ClasseDictionnary
{
    class Program
    {
        static void Main(string[] args)
        {
            Personne p1;

            p1 = new Personne()
            {
                Nom = "TOURREAU",
                Prénom = "Gilles",
                Age = 25
            };

            Console.WriteLine("Vous êtes : {0}, {1} agé de {2}",
                p1.Nom, p1.Prénom, p1.Age);
        }
    }
}

En prenant par exemple, l’instance « p1« , on peut considérer que cette instance est une instance d’un Dictionary<String, Object> contenant les paires clé/valeur suivantes :

  • Nom = TOURREAU
  • Prénom = Gilles
  • Age = 25

Si on devait utiliser un Dictionary<String, Object>, voilà ce que l’on écrirait à la place :

using System;
using System.Collections.Generic;

namespace Tourreau.Gilles.DotNet.ClasseDictionnary
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<string, object> p1;
            p1 = new Dictionary<string, object>();

            p1.Add("Nom", "TOURREAU");
            p1.Add("Prénom", "Gilles");
            p1.Add("Age", 25);
        }
    }
}

L’un des avantages de Dictionary est de pouvoir parcourir facilement les paires clé/valeur comme ceci :

foreach (KeyValuePair<string, object> paire in p1)
  Console.WriteLine("{0} = {1}", paire.Key, paire.Value);

Parcourir les différents ensembles de paire clé/valeur d’un objet

Il est tout à fait possible de parcourir notre classe précédente et de produire le même résultat que précédemment, pour cela on peut utiliser le mécanisme de Reflection de .NET, mais il existe une classe très utilisée qui (par Reflection aussi) permet de parcourir facilement les propriétés d’une classe. C’est la classe TypeDescriptor, cette dernière propose une méthode static permettant de récupérer toutes les propriétés (PropertyDescriptor) contenu dans la classe :

PropertyDescriptorCollection propriétés;
propriétés = TypeDescriptor.GetProperties(p1);

foreach (PropertyDescriptor propriété in propriétés)
    Console.WriteLine("{0} = {1}", propriété.Name, propriété.GetValue(p1));

Cela produira exactement le même résultat que précédemment avec un Dictionary<String, Object>. La question que vous devez certainement vous poser, qu’elles sont les avantages à utiliser une classe, comme la classe Personne précédente, par rapport à un objet Dictionary<String, Object> ?Il y a tout d’abord le typage fort, en effet en utilisant une classe, on est sûr que chaque propriétés sont de type correcte contrairement à un Dictionary<String, Object> dont le type des valeurs peut-être n’importe quel objet. Ensuite, l’utilisation d’un objet est beaucoup moins couteux en espace mémoire et plus performant contrairement à l’utilisation d’un Dictionary<String, Object>.Cependant il existe des inconvénients en ce qui l’utilisation d’une classe pour la représentation d’un ensemble de paires clé/valeur. La première est le problème d’ajout et de suppression à l’exécution de paire clé/valeur. Il est bien évident que l’on ne peut pas à l’exécution ajouter ou supprimer des propriétés d’une classe. L’autre inconvénient et le parcourt des valeurs des paires. Il est en effet possible de parcourir les valeurs d’un Dictionary<String, Object> via la propriété Values, ce qui n’est pas le cas avec une classe.Le but de cet article, était surtout de faire comprendre aux débutants l’utilisation des classes comme paire clé/valeur. On retrouve l’utilisation de ce genre de classes dans le modèle MVC ASP .NET. En particulier dans les méthodes d’extensions de la classe HtmlHelper :

<%= Html.ActionLink("Voir la tondeuse à gazon A80K", "VoirProduit", new { id = 5, type = "Tondeuse" }) %>

Comme vous le remarquez, pour donnez des paramètres à l’action d’un contrôleur dans le modèle MVC ASP .NET, on utilise une classe (anonyme) contenant des paires clé/valeur (propriétés/valeur). C’est ensuite en interne, que le moteur MVC d’ASP .NET récupèrera les différents ensembles de paire clé/valeur.

Conclusion

A travers cet article, j’ai voulu vous montrer qu’il était possible de considérer une classe comme un ensemble de paire clé/valeur statique, n’hésitez pas à utiliser ce concept si vous devez utiliser des ensembles de paire clé/valeur statique et fortement typé !

Publié dans la catégorie .NET Framework.
Tags : , , , . TrackBack URL.

Leave a comment