Blog de la rubrique Delphi

Un article de Laurent Dardenne    Pas de commentaires

J’ai ces derniers temps traduit quelques entrées de la FAQ C# vers la FAQ Delphi .NET et je me suis aperçus que les énumérations sous .NET qui me semblaient être un type de donnée différent, se manipule de la même manière qu’une énumération déclarée sous Delphi. Donc rien de transcendant en soit, il faut juste le savoir.

Type
  Couleurs = (Bleu,Blanc,Noir,Rouge,Vert);
 
  Conteneur= (Carton= 52, Valise= 137);  
 
  [FlagsAttribute]  
  DroitsFichier = (Aucun= 1,
                  Lecture = 2,
                  Ecriture= 4,
                  Effacement= 8,
                  All=15);
 
 //Alias, facilite l'écriture
 TEnvFolder = Environment.SpecialFolder;

Le type couleur est une énumération mappée sur System.Enum de type Byte.

Conteneur est aussi une énumération de type Byte, ici la modification de la valeur de 137 en 257 modifiera le type sous jacent en Integer. Il ne semble pas possible comme en C# de préciser le type de base de l’énumération en dehors de cette construction.

DroitsFichier est une énumération particuliére, l’ajout de l’attibut [FlagsAttribute] indique que cette énumération est traitée comme un champ de bits, c’est-à-dire un ensemble d’indicateurs. L’affectation se fait avec l’opérateur or :

 Resultat := Lecture or Ecriture;
 Writeln(TObject(Resultat));
 Writeln(Format('Resultat=%s',TObject(Resultat)));

Il est possible d’affecter une valeur en utilisant une chaîne de caractères, contenant des noms identiques au nom de valeur déclarée de l’énumération :

 NouveauDroit:='Ecriture,Effacement';
 Resultat:=DroitFichier(System.Enum.Parse(TypeOf(DroitFichier),NouveauDroit));
 Writeln(TObject(Resultat));

Les énumérations de FCL peuvent donc être manipulée directement :

 //Environment.SpecialFolder
 //Obtenir une chaîne à partir d'une valeur de type énumération
 Folder:=TEnvFolder.ApplicationData;
 Writeln(TObject(Folder));
 
 Write('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(TEnvFolder.ApplicationData)));
 Writeln(TObject(High(TEnvFolder.ApplicationData)));

Les itérateurs sont possibles sur les énumérations :

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

Il est égalemment possible, au travers de la classe EnumBuilder, de construire dynamiquement une énumération à l’intérieur d’un assembly dynamique.
Exemple :

 EnumCreate(Thread.GetDomain, AssemblyBuilderAccess.Run);

avec

procedure EnumCreate(myAppDomain : AppDomain ; access : AssemblyBuilderAccess );
var myAssemblyName  : AssemblyName;
    myFieldBuilder1,
    myFieldBuilder2 : FieldBuilder;
    valeur1,
    valeur2 : Integer;
 
begin
  // Affecte un nom pour l'assembly.
  myAssemblyName:=AssemblyName.Create;
  myAssemblyName.Name:='EmittedAssembly';
 
  // Crée l'assembly dynamique.
  myAssemblyBuilder:=myAppDomain.DefineDynamicAssembly(myAssemblyName,access);
 
  // Crée dynamiquement un module non-persistant (Run)
  // Définit et représente un module. Pour obtenir une instance de ModuleBuilder, appelez DefineDynamicModule.
  myModuleBuilder:= myAssemblyBuilder.DefineDynamicModule('EmittedModule','EmittedModule.mod');
 
  // Définit un type d'énumération qui est un type valeur avec un champ non statique unique appelé value__ du type spécifié.
  myEnumBuilder:= myModuleBuilder.DefineEnum('MyNamespace.MyEnum',TypeAttributes.Public, typeof(Integer));
 
  valeur1:=1;
  valeur2:=2;
 
  // Exception ArgumentException
  //" La constante ne correspond pas au type défini."
   // myFieldBuilder1:= myEnumBuilder.DefineLiteral('ChampUn', TObject(1));
   // myFieldBuilder2:= myEnumBuilder.DefineLiteral('ChampsDeux', TObject(2));
 
  myFieldBuilder1:= myEnumBuilder.DefineLiteral('ChampUn', TObject(Integer(1)));
  myFieldBuilder2:= myEnumBuilder.DefineLiteral('ChampsDeux', TObject(Integer(2)));
 
  { ou bien :
  myFieldBuilder1:= myEnumBuilder.DefineLiteral('ChampUn', TObject(valeur1));
  myFieldBuilder2:= myEnumBuilder.DefineLiteral('ChampsDeux', TObject(valeur2));
  }
  myEnumBuilder.CreateType;
end;

On peut donc sous .NET construire à la volée du code persistant ou non. Pratique !
La suite dans un prochain article …