Les énumérations sous Delphi .NET

Date de publication : 01/07/2005 , Date de mise a jour : 01/07/2005

Par Laurent Dardenne (Contributions)
 

Les énumérations du framework .NET me semblaient être un type de donnée différent mais il n'en est rien, elles se manipulent de la même manière qu'une énumération déclarée sous Delphi .NET.

Vous trouverez dans ce tutoriel les manipulations de base sur les énumérations sous Delphi .NET ainsi qu'une approche de la technique d'injection de code CIL au travers de la classe EnumBuilder.

Je tiens à remercier Olivier Lance (Bestiol) pour ses corrections orthographiques et relectures attentives.

1. Public concerné

1-1. Les sources

2. Les bases

Les valeurs possibles d'un type scalaire forment un ensemble ordonné; à chaque valeur est associé un rang 
qui est une valeur entière.
La première valeur à le rang zéro et l'ordre est celui défini lors de la déclaration.
Les identificateurs d'une énumération sont considérés comme des constantes du type énuméré.

Type
  Couleurs = (Bleu,Blanc,Noir,Rouge,Vert);

Type
   // Enumération débutant à l'indice zéro
  Couleurs = (Bleu,Blanc,Noir,Rouge,Vert);

Function GetCouleur(EtatCourant : Couleurs):String;
// Affiche une string correspondant au contenu de la variable énumération EtatCourant
begin
 case EtatCourant of
   Bleu  : Result:='Bleu';
   Blanc : Result:='Blanc';
   Noir  : Result:='Noir';
   Rouge : Result:='Rouge';
   Vert  : Result:='Vert';
 end;
end;

Var uneCouleur : Couleurs;
    I: Byte;

begin
 Write('Affectation : ');
 uneCouleur:=Bleu;
 Writeln(GetCouleur(uneCouleur));

 Write('Valeur suivante : ');
 uneCouleur:=Succ(uneCouleur);
 Writeln(GetCouleur(uneCouleur));

 Write('Valeur précédente :');
 uneCouleur:=Pred(uneCouleur);
 Writeln(GetCouleur(uneCouleur));

 Writeln;
 Write('Affectation : ');
 uneCouleur:=Bleu;
 Writeln(GetCouleur(uneCouleur));

 Write('Incrémente : ');
 Inc(UneCouleur);
 Writeln(GetCouleur(uneCouleur));

 Write('Décrémente : ');
 Dec(UneCouleur);
 Writeln(GetCouleur(uneCouleur));

 Write('Obtient la valeur minimum : ');
 Writeln(GetCouleur(Low(Couleurs)));

 Write('Obtient la valeur maximum : ');
 Writeln(GetCouleur(High(Couleurs)));

 Writeln;
 Write('Accès par indice (3) : ');
 Writeln(GetCouleur(Couleurs(3)));  // Débute à zéro

 Write('Liste ordonnée des valeurs : ');
 For I:=byte(Low(Couleurs)) to Byte(High(Couleurs)) do
  begin
   Write(GetCouleur(Couleurs(I)));
   if I<>Byte(High(Couleurs))
    then Write(', ');
  end;
 Readln;
end.

 Write('Affectation : ');
 uneCouleur:=Bleu;
   // Transtypage obligatoire, Boxing
 Writeln(TObject(uneCouleur));

3. Une nouvelle approche

type
  Conteneur= (Carton= 52, Valise= 137); // La valeur détermine le type sous jacent.

 // Définit une énumération de type LONG
 enum Range :long {Max = 2147483648L, Min = 255L};

var  UneBoite : Conteneur;
begin
  // Affiche le type sous-jacent d'une variable énumération
 Writeln('Type sous-jacent de l''énumération UneBoite : ');
    //Appel sur une variable énumération
 Writeln(Enum.GetUnderlyingType(TObject(UneBoite).GetType));
    // ou directement
 Writeln(Enum.GetUnderlyingType(TypeOf(UneBoite)));
    //Appel sur un type énumération
 Writeln(Enum.GetUnderlyingType(Typeof(Conteneur)));

  //Teste si la valeur spécifiée existe dans une énumération.
 If System.Enum.isDefined(TypeOf(Conteneur),TObject(1))
  then Writeln('la valeur 1 existe dans l''énumération Conteneur')
  else Writeln('la valeur 1 n''existe pas dans l''énumération Conteneur');

  // La recherche est 'case sensitive'
 If System.Enum.isDefined(TypeOf(Conteneur),'valise')
  then Writeln('la valeur valise existe dans l''énumération Conteneur')
  else Writeln('la valeur valise n''existe pas dans l''énumération Conteneur');

Attention cette méthode de recherche est case-sensitive.

var Chaine : String;
begin
 // Affiche les valeurs possibles de l'énumération
 // Récupère un tableau de chaînes de caractères
 for Chaine in Enum.GetNames(typeof(Couleurs)) do
  begin
   WriteLn(Chaine);
  end;

var UneBoite : Conteneur;
begin
   // Affiche les valeurs possibles de l'énumération
   // Récupére un tableau d'objets
  for UneBoite in Enum.GetValues(typeof(Couleurs)) do
  begin
   WriteLn(TObject(UneBoite));
  end;

4. Manipulation des énumérations du framework

Type
  //Alias, facilite l'écriture
 TEnvFolder = Environment.SpecialFolder;

Var  Chaine  : String;
     Folder : Environment.SpecialFolder;

begin

 //Environment.SpecialFolder
 Folder:=TEnvFolder.ApplicationData;
 Writeln(TObject(Folder));

 // Accès direct
 Writeln(TObject(TEnvFolder.ApplicationData));

 Writeln(Ord(TEnvFolder.ApplicationData));

 Writeln(TObject(Succ(TEnvFolder.ApplicationData)));
 Folder:=Succ(Succ(TEnvFolder.ApplicationData));
 Writeln(TObject(Folder));

 Folder:=Pred(Folder);
 Writeln(TObject(Folder));

 Writeln(TObject(Low(Environment.SpecialFolder)));
 Writeln(TObject(High(Environment.SpecialFolder)));

 Writeln(TObject(Environment.SpecialFolder(5))); // 5=Personnal
 Writeln;

 // Affiche les valeurs possibles de l'énumération
 for Chaine in Enum.GetNames(typeof(Environment.SpecialFolder)) do
  begin
   Write(Chaine+' , ');
  end;

  // Test de valeur
 if Folder=TEnvFolder.ApplicationData
  then WriteLn;

 readln;

 if ((flagAttr and FileAttributes.Archive) = FileAttributes.Archive)
  then Console.WriteLine(FileAttributes.Archive);

procedure GetFileAttributes(NomFichier : String) ;
//  Test : GetFileAttributes('C:\IO.SYS');
var flagAttr : FileAttributes;
    unAttr : System.IO.FileAttributes;

begin
 With System.IO.File do
  begin
   flagAttr := GetAttributes(NomFichier);

   for UnAttr in Enum.GetValues(TypeOf(System.IO.FileAttributes)) do
    if ( (flagAttr and unAttr) = UnAttr)
     then Console.WriteLine(UnAttr);
  end;
end;

5. Du nouveau : les champs de bits

  [FlagsAttribute]  
  DroitFichier = (Modification= 1,
                  Lecture = 2,
                  Ecriture= 4,
                  Effacement= 8,
                  All=15);

Var Droits : DroitFichier;
begin
  // Champs de Bit
 Droits := Lecture;
 Writeln(TObject(Droits));

 Droits := Droits or Ecriture;
 Writeln(TObject(Droits));

  //Affichage au format String
 Writeln(TObject(Droits));
 Writeln(Format('Resultat=%s',TObject(Droits)));

  //Affichage au format numérique
 Writeln(Convert.ToInt32(Droits));
 Writeln(Format('Resultat=%d',TObject(Droits)));
 Writeln;

  //Affectation via une chaîne de caractères
 NouveauDroit:='Ecriture,Effacement';
 Droits:=DroitFichier(System.Enum.Parse(TypeOf(DroitFichier),NouveauDroit));
  // OU Resultat:=(System.Enum.Parse(TypeOf(DroitFichier),'Ecriture,Effacement')) as DroitFichier;
 Writeln(TObject(Droits));
 
  //Affectation via une valeur numérique
 DroitModifie:= DroitFichier(System.Enum.ToObject(TypeOf(DroitFichier),4));
 WriteLn(TObject(DroitModifie));
 
  //Ajout d'une valeur à une énumération existante
 NouveauDroit:=','+'Lecture';
 Droits:=DroitFichier(System.Enum.Parse(TypeOf(DroitFichier),Tobject(Droits).ToString+NouveauDroit));
 Writeln(TObject(Droits));

 NouveauDroit:=','+'Lecture';
 Droits:=DroitFichier(System.Enum.Parse(TypeOf(DroitFichier),TObject(Droits).ToString+NouveauDroit));
 Writeln(TObject(Droits));

  //Ajoute une valeur String à une énumération existante
 NouveauDroit:=','+'Lecture';
 Droits:=DroitFichier(System.Enum.Parse(TypeOf(DroitFichier),TObject(Droits).ToString+NouveauDroit));
 Writeln(TObject(Droits));

  //'Retire' une valeur Numérique de l'énumération
 I:=Convert.ToInt32(Droits) And not Convert.ToInt32(Ecriture);
 Writeln(Format('Resultat int=%d',TObject(I)));

  // Utilisation des fonctions de l'unité TypInfo.pas
 Chaine:=GetEnumName(TypeInfo(DroitFichier),4); // 4=Ecriture
 Writeln('Recherche par valeur : ',Chaine);
 
 I:=GetEnumValue(TypeInfo(DroitFichier),'Ecriture');
 Writeln('Recherche par nom de constante : ',I.ToString);
 
 Droits:=DroitFichier(GetEnumObject(TypeInfo(DroitFichier),'Ecriture'));
 Writeln('Utilisation de GetEnumObject ',TObject(Droits));

 Droits := Modification or Lecture or Ecriture or Effacement; // l'ensemble des valeurs est égal à All
 Writeln(TObject(Droits));
 Writeln(Format('Resultat =%s',TObject(Droits)));

 Resultat = All

for I:=0 to 512 do
 begin
  if TObject(Environment.SpecialFolder(I)).ToString<>I.ToString then
   Console.Writeline('{0} Value= {1}',[TObject(Environment.SpecialFolder(I)),I]);
 end;

L'appel de TObject(Environment.SpecialFolder(3)) affichera 3 étant donné que cette valeur n'est pas associée à une constante nommée dans l'énumération Environment.SpecialFolder.
Voir :
 Le code source de System.Enum, attention il s'agit d'une préversion du framework .NET datant de 2000.
 La classe Enum.

6. Construction dynamique d'une énumération avec EnumBuilder

Projet : ..\Enum\ExempleEnumBuilder

Le Framework .NET permet la génération de code à la volée appelé aussi injection de code CIL, il propose pour ce faire un ensemble de classes débutant par 'Builder'. Cette technique n'est pas détaillée dans ce tutoriel mais vous pouvez consulter ce lien sur le sujet ou mieux encore parcourir ce chapitre intitulé "La génération de code" issue du livre  .NET de Dick Lantim.

Extrait de ce chapitre :

Pour maîtriser la génération de code à la volée, il convient de bien connaître la structure d’un assemblage.
Pour rappel, un assemblage est constitué d’un ou de plusieurs modules (c’est-à-dire un assemblage de 
NetModules). Chaque module dispose d’une ou de plusieurs classes. Chaque classe dispose de données membres 
et de méthodes.

Cet exemple est simplifié. On peut par exemple spécifier une version, une langue et un couple de clés publique/privée pour protéger le code IL généré.

const cstAssemblage='AssemblyDynamique'; // Nom de l'assembly
      AssemblyAcces = AssemblyBuilderAccess.RunAndSave; // Type d'accès de l'assembly

var NomAssembly : AssemblyName;
	MonDomain   : AppDomain
begin
  MonDomain:=Thread.GetDomain;
  // Affecte un nom pour l'assembly.
  NomAssembly:=AssemblyName.Create;
  NomAssembly.Name:=cstAssemblage;

Var  ConstructeurAssembly : AssemblyBuilder; // Définit et représente un assembly dynamique
begin
  ...
 ConstructeurAssembly:=MonDomain.DefineDynamicAssembly(NomAssembly,access);

Var  ConstructeurModule : ModuleBuilder; // Définit et représente un module. Module Dynamique
begin
  ...
   // Créer un module dynamique persistant
  case Access of
    // si l'assembly est persistant nécessite un nom de module et un nom de fichier.
   AssemblyBuilderAccess.Save,
   AssemblyBuilderAccess.RunAndSave : 
     ConstructeurModule:= ConstructeurAssembly.DefineDynamicModule('ModuleDynamique','ModuleDynamique.mod');

    // si l'assembly n'est pas persistant nécessite uniquement un nom de module.
   AssemblyBuilderAccess.Run : 
     ConstructeurModule:= ConstructeurAssembly.DefineDynamicModule('ModuleDynamique');
  end;

Var  ContructeurEnum : EnumBuilder; // Décrit et représente un type d'énumération
begin
  ...
  ContructeurEnum:= ConstructeurModule.DefineEnum('Enumeration.EnumerationDynamique',TypeAttributes.Public, typeof(Integer));

var myFieldBuilder1,
    myFieldBuilder2 : FieldBuilder;
    valeur1,
    valeur2 : Integer;
Begin
 ...
  valeur1:=1;
  valeur2:=2;
   // Le double transtypage est nécessaire
   //Définit le champ statique nommé d'un type d'énumération à l'aide de la valeur de constante spécifiée.
  myFieldBuilder1:= ContructeurEnum.DefineLiteral('Premier', TObject(Integer(1)));
  myFieldBuilder2:= ContructeurEnum.DefineLiteral('Deuxieme', TObject(Integer(2)));

   // Il est possible d'utiliser des variables :
    // myFieldBuilder1:= ContructeurEnum.DefineLiteral('Premier', TObject(valeur1));
    // myFieldBuilder2:= ContructeurEnum.DefineLiteral('Deuxieme', TObject(valeur2));

 myFieldBuilder1:= ContructeurEnum.DefineLiteral('Premier', TObject(1));
 myFieldBuilder2:= ContructeurEnum.DefineLiteral('Deuxieme', TObject(2));

"La constante ne correspond pas au type défini."

var TypeDynEnum : System.Type;
begin
  ...
  TypeDynEnum:=ContructeurEnum.CreateType;
end;

 If Not (AssemblyAcces=AssemblyBuilderAccess.Run) // L'assembly doit pouvoir être enregistré (persistant)
   then ConstructeurAssembly.Save(cstAssemblage+'.dll');

var  I        : Integer;
     MonEnum,
     UneEnum  : System.Enum;
begin
 ...
  // Manipule l'enumération créée
  If Not (AssemblyAcces=AssemblyBuilderAccess.Save) // L'assembly doit pouvoir être exécuté
   then
    begin
     MonEnum:=System.Enum(Activator.CreateInstance(TypeDynEnum));

     Writeln('Contenu de l''énumération crée :');
     for UneEnum in Enum.GetValues(typeof(MonEnum)) do
      begin
       WriteLn(TObject(UneEnum));
      end;
      // Ou pour ce contexte, directement
    { for UneEnum in Enum.GetValues(TypeDynEnum) do
    }
   end
  else 
   Writeln('L''énumération dynamique ne peut être instanciée avec le mode d''accès : ',TObject(AssemblyAcces));

A partir du moment où "Les identificateurs d'une énumération sont considérés comme des constantes du type énuméré", les instructions Ord, Succ, Pred, Low, High ne pourront être utilisées sur des 'constantes' d'une énumération dynamique pour la simple raison qu'elles sont inconnues du compilateur.