Testé sous le framework .NET 1.1 et Delphi 2005.
Version 1.0

Concernant l'EDI de Delphi 2005 vous pouvez consulter l'article de SJRD : Prise en main de Delphi 2005.

Cet article contient des liens nommés Local. Ils pointent sur des URLs locales de la documentation de Delphi 2005 et de Microsoft. Leur utilisation nécessitera l'installation du SDK .NET v1.1 en français sur le poste.

Ils sont uniquement accessibles Offline, les liens 'ms-help' exécutent en local l'aide en ligne du SDK.

1-1. Les sources▲

Extrait du SDK :
"Le .NET Framework est une nouvelle plate-forme informatique qui simplifie le développement d'applications dans l'environnement fortement distribué d'Internet. Le .NET Framework est conçu pour remplir les objectifs suivants :

• Fournir un environnement cohérent de programmation orientée objet que le code objet soit stocké et exécuté localement, exécuté localement mais distribué sur Internet ou exécuté à distance.
• Fournir un environnement d'exécution de code qui minimise le déploiement de logiciel et de conflits de versioning.
• Fournir un environnement d'exécution de code qui garantit l'exécution sécurisée de code y compris le code créé par un tiers d'un niveau de confiance moyen ou un tiers inconnu.
• Fournir un environnement d'exécution de code qui élimine les problèmes de performance des environnements interprétés ou écrits en scripts.
• Fournir au développeur un environnement cohérent entre une grande variété de types d'applications comme les applications Windows et les applications Web.
• Générer toutes les communications à partir des normes d'industries pour s'assurer que le code basé sur le .NET Framework peut s'intégrer à n'importe quel autre code.

Le .NET Framework contient deux composants principaux : le Common Language Runtime et la bibliothèque de classes du .NET Framework. Le Common Language Runtime est la base du .Net Framework. Le runtime peut être considéré comme un agent qui manage le code au moment de l'exécution, fournit des services essentiels comme la gestion de la mémoire, la gestion des threads, et l'accès distant. Il applique également une stricte sécurité des types et d'autres formes d'exactitude du code qui garantissent un code sécurisé et robuste. En fait, le concept de gestion de code est un principe fondamental du runtime. Le code qui cible le runtime porte le nom de code managé, tandis que le code qui ne cible pas le runtime porte le nom de code non managé. La bibliothèque de classes, l'autre composant principal du .NET Framework, est une collection complète orientée objet, de types réutilisables que vous pouvez utiliser pour développer des applications allant des traditionnelles applications à ligne de commande ou à interface graphique utilisateur (GUI, Graphical User Interface) jusqu'à des applications qui exploitent les dernières innovations fournies par ASP.NET, comme les services Web XML et Web Forms.
..."
Lire la suite. Local.

2-1. Quelques détails sur le framework .NET▲

De nouvelles fonctionnalités ont été ajoutées au langage Delphi pour .NET afin de supporter des concepts et des fonctionnalités de programmation propre à la plate-forme .NET, et ce tout en respectant la CLS (Common Language Specification).

Cette adaptation pouvant laisser croire qu'il s'agit d'un nouveau langage alors qu'en fait ce qui est nouveau c'est la plate-forme .NET, c'est une évidence qu'il est bon de rappeler, votre premier objectif étant d'abandonner certaines pratiques et habitudes liées à la programmation sous Win32, qui à mon sens sont un frein à la compréhension de .NET. N'essayez donc pas de faire du WIN32 sous .NET, mais ceci est plus facile à dire qu'a faire ;-).

Selon moi, un des points important est qu'étant donné que sous .NET tout est objet vous devez 'penser' objet, plus encore que sous Win32.
Bien évidemment les problématiques telles que la gestion des threads ne changent pas ( .NET s'appuyant sur WIN32 ), seule leur implémentation diffère.

J'aborderais ici ces nouveautés du langage ainsi que les différences de comportement les plus sensibles. Ces quelques informations permettront aux débutants sous Delphi pour .NET, d'appréhender au mieux les bases de .NET et du langage Delphi pour .NET. Pour simplifier, j'ai principalement utilisé des applications console dans les exemples proposés.
Cette introduction n'aborde pas les problématiques de migration de code Win32 vers .NET, consultez à ce sujet l'ouvrage d'Olivier Dahan ou les articles appropriés sur le site de Borland US.

De nombreuses informations issues du SDK .NET émailleront cet article, autant puiser à la source.

Sous Dot Net la manipulation d'adresse n'est plus possible dans du code managé étant donné que l'organisation de la mémoire est désormais du domaine exclusif du Garbage Collector (ramasse-miettes) et plus du programmeur.
Cette prise en charge de la mémoire par le Garbage Collector implique une réorganisation périodique de la mémoire, on ne peut donc plus avoir de référence fixe sur des zones mémoire.

La manipulation de pointeur reste possible mais dans ce cas votre code est considéré comme unsafe, non sécurisé. Ceci pouvant avoir comme conséquence de limiter ou d'interdire l'intégration de ce code dans d'autres applications .NET.

Voir aussi
Garbage Collector : Le GC est un sous-ensemble de la CLR. Local.

Le Common Language Runtime (CLR) gère la mémoire, l'exécution des threads, l'exécution du code, la vérification de la sécurité du code, la compilation et d'autres services du système. Ces fonctionnalités font partie intégrante du code managé qui s'exécute sous le Common Language Runtime. Local.

L'article sur les pointeurs sous .NET par Nono40.

Certains liens peuvent ne pas s'afficher directement, dans ce cas valider à nouveau l'URL dans votre browser.

Les types primitifs sous .NET sont Boolean, Byte, SByte, Int16, UInt16, Int32, UInt32, Int64, UInt64, Char, Double et Single.
Ils correspondent directement aux types qui existent dans le Framework .NET

Les allocations de blocs de données, par exemple, se font désormais soit dans la pile soit sur le tas (Managed Heap). Si on ne manipule plus d'adresse comment dans ce cas passer en paramètre un objet sans avoir à recopier l'intégralité de son contenu sur la pile ?

Sous .Net les données sont de deux types :

1. Type valeur
   Les types valeur contiennent directement leurs données; les instances de types valeur sont allouées sur la pile.
2. Type référence
   Les types référence stockent une référence à l'adresse mémoire de la valeur et sont alloués sur le tas managé.

Je tiens à remercier Emerica qui m'a proposé ce graphique, m'évitant ainsi des explications des plus hasardeuses sur le sujet et confirmant par là même qu'un dessin vaut mieux qu'un long discours.

Les variables de type valeur stockent des données alors que les variables de type référence stockent les références aux données. Les types référence sont également considérés comme des objets comme on peut le voir sur le schéma précédent.

On voit donc que la notion d'indirection persiste sous .Net mais n'a plus à rien à voir avec les pointeurs présent sous Win32, Win16 ou MS-DOS. La possibilité d'interpréter des données pointées, c'est à dire la possibilité de transtyper des données, est également affectée. On retrouve donc la notion de typage fort, chère au Pascalien.

Il faut savoir que sous .NET tout est objet. La classe System.Object prend en charge toutes les classes de la hiérarchie des classes du .NET Framework et fournit des services de bas niveau aux classes dérivées. Il s'agit de la classe de base fondamentale parmi toutes les classes du .NET Framework. Elle constitue la racine de la hiérarchie des types.

Voir Aussi
Vue d'ensemble du système de type commun. Local.
Qu'est-ce que la spécification CLS (Common Language Specification) ? Local.

6-1. Principales fonctionnalités des types valeur▲

6-2. Un peu de pratique▲

Type
 monRecord=Record
  A :Integer ;
  B :Integer ;
  Constructor Create(p1,p2:integer);
 end ;

 Constructor monRecord.Create(p1,p2:integer);
  begin
   A:=p1;
   B:=p2;
  end;

var
   RInstance1, RInstance2 : monRecord;

Begin
 RInstance1:= monRecord.Create(5, 3) ; // Création d'un objet.
                                       // L'assignation directe des champs par RInstance1.A 9 est possible.
 RInstance2:= RInstance1; // Recopie de l'objet RInstance1 dans RInstance2
 RInstance1.A:= 7; //  Le champ RInstance2.A reste égale à 2.

 Writeln('RInstance1.A=',RInstance1.A);
 Writeln('RInstance2.A=',Rinstance2.A);
 Readln;
End;

Type
 maClasse=Class
  A :Integer ;
  B :Integer ;
  Constructor Create(p1,p2:integer);
 end ;

Constructor maClasse.Create(p1,p2:integer);
  begin
   inherited Create;
   A:=p1;
   B:=p2;
  end;

var
   CInstance1, CInstance2 : maClasse;

Begin

 CInstance1:= maClasse.Create(2, 9) ; // Création d'un objet
 CInstance2:= CInstance1; // copie la référence d'Instance1 dans CInstance2
 CInstance1.A:= 1; //  Le champ Instance2.A dans ce cas est aussi égal à 1.

 Console.Writeline; // Appel d'une classe du Framework .NET 
					// Alias FCL ( Framework Classe Library)
 Writeln('CInstance1.A=',CInstance1.A);
 Writeln('CInstance2.A=',Cinstance2.A);
 Console.readline;
End;

var
   OTemp: TObject;

 OTemp:=RInstance1;     // Récupére une référence sur RInstance1
 RInstance1.A:=20;      // Modifie la variable référencée
 Writeln('OTemp.A transtypé en monRecord, référence RInstance1.A=',monRecord(OTemp).A);
 Writeln('RInstance1.A référencé par OTemp=',RInstance1.A);
 Writeln;
 Readln;

 Writeln('Assignation d''un type valeur avec une variable de type référence'+#13#10);
 RInstance1:=MonRecord(OTemp);
 Writeln('RInstance1.A est réassigné avec OTemp=',RInstance1.A);
 Writeln('OTemp.A=',MonRecord(OTemp).A);
 Writeln;
 Readln;

try
  OTemp:=Rinstance1;
  CInstance1:=maClasse(OTemp); 
  Writeln('Test de bricolage ',CInstance1.A);
  Console.readline;
 except
  On E: NullReferenceException do
   Console.WriteLine('Erreur d''exécution la variable CInstance1 contient une référence nulle !');
  end;
 end;

Certaines traductions d'ouvrage sur .NET associent le terme boxing à une notion de compartiment.

7-1. Boxing ▲

var VarTypeValeur : integer;     // Type valeur
    VarTypeReference : TObject;  // Type objet ( référence )

Begin
  VarTypeValeur:= 123;
  VarTypeReference:=TObject(VarTypeValeur);  // Boxing explicite
  VarTypeValeur:= 456;                       // Change le contenu de i

  Writeln('Valeur de VarTypeValeur de type valeur = ', VarTypeValeur);
  Writeln('Valeur de VarTypeReference de type object (référence ) = ', VarTypeReference);

  VarTypeReference:=TObject.Create; // L'appel de GetType nécessite l'appel du constructeur

   // Gettype renvoie une valeur de type System.Type
  Writeln('Nom complet du type de VarTypeValeur= ', VarTypeValeur.GetType);
  Writeln('Nom complet du type de VarTypeReference= ', VarTypeReference.GetType);

Nom complet du type de VarTypeValeur= System.Int32
Nom complet du type de VarTypeReference= System.Object

Nom complet du type de VarTypeValeur= System.Int32
Nom complet du type de VarTypeReference= System.Int32

 VarTypeReference:=TObject(321.1);

var w : Word;    // Type valeur
    i : integer; // Type valeur
    o : TObject; // Type objet ( référence )

Begin
  i:= 123;
  o:=i;
  ...

  o := TObject(I);

7-2. UnBoxing▲

var j,i : integer;
    box : TObject;

begin
  i:=312;            // Un type valeur
  box:=TObject(i);   // Boxing explicite
  j:=integer(box);   // Unboxing explicite

var
    h   : byte;
    j,i : integer;
    box : TObject;

begin
  ...
  H:=byte(box);
  Writeln('Nom complet du type de K= ', H.GetType);
  Writeln('Valeur de h, de type valeur, = ', h);

var h   : Byte;
    box : TObject;
    K   : Double;

begin
  ...
  H:=byte(integer(box)); 
  ...


  K:=3.12;
  box:=TObject(K);   // Boxing explicite
  h:=byte(Trunc(Double(box)));     // Transtypage des types réels en entiers nécessite Trunc

7-3. L'allocation mémoire▲

//AllocationArrayList
uses
  System.Collections;

Type
  Data=Record
   X,Y : Integer;
  end;

var D   : Data;
    Tab : Arraylist;
    i   : Integer;

begin
  Tab:=Arraylist.Create;

  For i:=0 to 10 do
  begin
   D.X:=i;
   D.Y:=D.X*5;
   Tab.Add(D); // Ajout d'un record dans la liste,
               // ne nécessite pas d'allocation mémoire pour les multiples instances de D.
               // Box implicite
  end;

  For i:=0 to 10 do
   Writeln('X= '+Data(Tab[i]).X.ToString+' Y= '+Data(Tab[i]).Y.ToString);

  Readln;
end.

Projet : ..\Passage_Parametre\Parametre

Les type valeur et type référence se comportent différemment dans un appel de méthode selon qu'il sont passés soit en paramètre par valeur soit en paramètre par référence.

L'utilisation de var ou out permet de spécifier le passage de paramètre par référence, le mot-clé out permettant de passer en paramètre une valeur qui n'a pas été initialisée.
L'utilisation de const ou l'absence de mot-clé permet de spécifier le passage de paramètre par valeur.

Le tableau suivant récapitule les cas :

1. Passage de types valeur par valeur.
   Les modifications intervenant au sein de la méthode n'affectent en rien la valeur d'origine de la variable.
   
   
2. Passage de types valeur par référence.
   La valeur du paramètre est modifiée après l'appel de la méthode.
   
   
3. Permutation de types valeur (deux entiers).
   Vous devez passer les paramètres à la méthode Swap par référence
   
   
4. Passage de types référence par valeur.
   La tentative de réassignation du paramètre à un emplacement de mémoire différent s'effectue uniquement au sein de la méthode et n'affecte pas la variable d'origine
   
   
5. Passage de types référence par référence.
   Toutes les modifications qui interviennent dans la méthode affecteront les variables d'origine dans le programme appelant.
   
   
6. Permutation de types référence (deux chaînes).
   La permutation de chaînes est un bon exemple de passage de paramètres de type référence par référence. Les deux chaînes sont permutées au sein de la méthode, ainsi que dans l'appelant.

On voit donc que l'initialisation d'une variable globale, si toutefois cette notion a encore un sens sous .NET, se fera ainsi :

Procedure Init_Variable( Out uneRéference: unType);

8-1. Paramètre sans type▲

procedure PrcAvecParametreSansType(var X);
begin
 Writeln('Type de la variable X : '+TypeOf(x).ToString);
end;

Vous pouvez consulter l'article suivant concernant les déclarations de type imbriqués.

9-1. Visibilité des types imbriqués. ▲

type 
  TForm1 = class(TForm) //Déclaration de classe qui héberge une déclaration de classe imbriqué.
  private 
    { Déclarations privées} 
  public 
    Type 
      TSousClasse = Class (Tobject) // Classe imbriquée
      Private 
        MembrePrivé : Integer; 
      Public 
        MembrePublic : Integer; 
      End; 
    { Déclarations publiques} 
  public 
    SousClasse : TSousClasse; 
  end;

procedure TForm2.Button1Click(Sender: TObject); 
Var i:Integer; 
begin 
  i:=Form1.SousClasse.MembrePublic; // Compile 
  i:=Form1.SousClasse.MembrePrivé; // Ne compile pas 
end;

Projet : ..\Type\Type_type

Delphi permettait déjà de créer des alias de type tels que

type TMaString = string;

autorisant la déclaration de variable suivante :

 var 
  Chaine1: TMaString;
  Chaine2: string;

Ici Chaine1 et Chaine2 sont du même type.
Si on souhaite distinguer le type exact de ces 2 variables cela n'est pas possible car TMaString est un nom de type différent de string mais si on veut créer un autre type, vu comme tel par le compilateur, il faut utiliser la syntaxe suivante :

type TMaString = type string;

Dans ce cas le passage en paramètre par référence d'une variable de ce type provoquera une erreur de compilation :

type
  TMaString1 = string;
  TMaString2 = type string;

 var
  Chaine: string;
  Chaine1: TMaString1;
  Chaine2: TMaString2;

  procedure Affiche(S:TMaString2);
  begin
  end;

  procedure Affiche_Var(Var S:TMaString2);
  begin
  end;

begin
 Chaine:='Type Chaine classique';
 Chaine1:=Chaine;
  // l'affectation ne pose pas de problème
 Chaine2:=Chaine;

  // Le passage en paramètre à une procédure const ou par valeur ne pose pas de problème
 Affiche(Chaine1);


  // Le passage en paramètre à une procédure var, provoque l'erreur (E2033) :
  // Les types des paramètres var originaux et formels doivent être identiques.
  Affiche_Var(Chaine1);

Le code précédent provoque l'erreur suivante :

E2033 : Les types des paramètres var originaux et formels doivent être identiques.

Texte issu de la documentation de DELPHI 2005 :

Lors de la programmation avec Delphi pour .NET, il se peut que vous rencontriez des identificateurs CLR (c'est-à-dire des types ou des méthodes de classe) de même nom qu'un mot-clé Delphi. Par exemple, une classe peut posséder une méthode appelée begin. La classe CLR Type de l'espace de nommage System constitue un autre exemple. Type est un mot-clé du langage Delphi qui ne peut être utilisé comme nom d'identificateur.

En revanche, vous pouvez sans problème qualifier l'identificateur à l'aide de sa spécification complète de l'espace de nommage. Pour utiliser la classe Type, par exemple, vous devez utiliser son nom complet :

var
 TMyType : System.Type; // L'utilisation de l'espace de nommage qualifié
                        // évite toute ambiguïté avec le mot-clé Delphi.

Comme alternative abrégée, Delphi pour .NET propose l'opérateur perluète (&) afin de résoudre les ambiguïtés entre identificateurs CLR et mots-clé du langage Delphi. Si vous rencontrez une méthode ou un type portant le même nom qu'un mot-clé Delphi alors que vous avez indiqué le signe & au début de l'identificateur, vous pouvez omettre la spécification de l'espace de nommage.

Par exemple, le code suivant utilise un "et commercial" pour distinguer la classe CLR Type du mot-clé Delphi type.

var
   TMyType : &Type; // Le mot commence par '&' ce qui le distingue du mot-clé.

Un autre exemple dans un contexte de conversion de code C# vers Delphi.

Vous pouvez consulter l'article suivant concernant les itérateurs.

var I, odd, even : integer;
  arr  : Array[] of integer;

Begin
 odd:= 0;
 even:=0;
 arr:= New(array[] of integer,(0,1,2,5,7,8,11));

 For I in arr Do
 begin
  WriteLn('I= '+ intToStr(I));
  if (I mod 2 = 0)
   then
    begin
    inc(even);
    WriteLn('Trouvé '+ intToStr(even)+' '+intToStr(I));
    end
   else inc(odd);
 end;
 WriteLn('Trouvé '+ intToStr(odd)+' chiffre impair et '+intToStr(even)+' chiffre pair.') ;
 Readln;

Attention ce qui différencie une boucle classique d'un itérateur est qu'on manipule via la variable d'indice I le contenu de la collection.
La variable I ne contient pas le nombre d'itération.
Cette syntaxe peut prêter à confusion dans les premiers temps.

Rappel des différentes possibilités :

 // Tableau
const
  MyArr : Array[0..3] of char = ('1','2','3','4');
var
  C : Char;
  S : String;
begin
  for C in MyArr do
    S := S + C;
  ShowMessage(S);
end;


 // Ensemble
const
  MySet: set of char = ['1','2','3','4'];
var
  C : Char;
  S : String;
begin
  for C in MySet do
    S := S + C;
  ShowMessage(S);
end;


 // Chaîne de caractère (Strings)
const
  S : String = 'C''est une chaine intéressante';
var
  C : Char;
  cnt: Integer;
begin
  cnt := 0;
  for C in S do
    if C = 'e' then
      Inc (cnt);
  ShowMessage(Format('Votre chaîne contient %d lettres "e"',[cnt]));
end;

 // Collection prédéfinie TStringLists 
var
  S : String;
begin
  for S in Memo1.Lines do
    ListBox1.Items.Add(S);
end;

Projet : ..\class-iterateur\class_iterateur

L'itération sur une classe demande un peu plus de code :

type
 TPeopleEnumerator = class; // Forward déclaration

   // Objet manipulé
  TPerson = class
    Name: String;
    DateOfBirth: TDateTime;
    Gender : Char;
    constructor Create (AName: String; ADateOfBirth: TDateTime; AGender: Char);
  end;

   // Liste d'objets, conteneur pour le type TPerson
  TPeopleList = class
  strict private
    List : TList;
    function GetCount: Integer;
    function GetPerson(idx: Integer): TPerson;
    procedure SetPerson(idx: Integer; const Value: TPerson);
  public
    Constructor Create;
    function Add (Person: TPerson): Integer;
    procedure Delete (idx: Integer);
    property Person [idx: Integer] : TPerson read GetPerson write SetPerson; default;
    property Count: Integer read GetCount;
          //Méthode nécessaire pour la prise en charge de l'itération
    Function GetEnumerator: TPeopleEnumerator;
  end;

   // Afin que la collection soit énumérable, elle doit implémenter une suite de méthodes
   // comme indiqué ci dessous.

   // Enumérateur pour la classe conteneur.
  TPeopleEnumerator = class
  strict private
    CurrentPos: Integer;
    PeopleList : TPeopleList;
  public
    constructor Create (AList : TPeopleList);
    function GetCurrent: TPerson;
     //Membre de classse nécessaire pour la prise en charge de l'itération
    function MoveNext :Boolean;    // Méthode publique
    property Current : TPerson read GetCurrent; // Propriété en Read Only
  end;

Une fois les méthodes implémentées, l'itération de la classe devient possible :

 //Exemple d'énumération de la classe TPeopleList
 // Le membre PeopleList appartient à la Forme principale
Procedure TForm1.Button1Click(Sender: TObject);
var Person : TPerson; // Doit être une variable locale
begin
  // Ajout d'élément
 PeopleList.Add(TPerson.Create('Daniel',StrToDate('15/03/1973'),'M'));
 PeopleList.Add(TPerson.Create('Monique',StrToDate('05/05/1973'),'F'));

  // Itération sur la classe
 for Person in PeopleList do
  ListBox1.Items.Add(Person.Name);
end;

La variable utilisée pour l'itération doit être de même type que celle déclarée dans la classe cible et cette variable doit être locale à la méthode ou à la procédure.

Vous pouvez consulter l'article suivant concernant les nouvelles directives.

13-1. Autobox▲

{$AUTOBOX ON}

13-2. Experimental▲

unit Borland.Vcl.NetControl platform experimental;

Un nouveau commutateur, debugger=[borwin32|bordonet], vous permet de sélectionner le débogueur Win32 de Borland ou le débogueur .NET en ligne de commande du SDK, lorsque vous déboguez à partir de la ligne de commande.


Lors de l'utilisation du commutateur -LU sur la plate-forme .NET, vous pouvez faire une référence au package avec ou sans l'extension .dll.
Si vous omettez l'extension .dll, le compilateur recherchera le package sur le chemin de recherche de l'unité et sur le chemin de recherche du package. Néanmoins, si la spécification de package contient une lettre de lecteur ou le caractère séparateur de chemin, le compilateur suppose alors que le nom de package est le nom de fichier complet (y compris l'extension .dll). Dans le dernier cas, si vous spécifiez un chemin relatif ou complet, mais omettez l'extension .dll, le compilateur ne sera pas capable de localiser le package.

Voir aussi

Il n'est plus possible, dans du code managé, d'utiliser les déclarations ou procédures suivantes :
pointeurs, type procédure, exitproc, absolute, @, les types pchar et variants...

Pour la manipulation de délégués l'opérateur @ reste possible mais c'est une exception.

Les procédures de manipulation de mémoire : move, fillchar, getmem, freemem...
Et bien évidemment la directive asm, l'accès aux registres du micro-processeur n'est plus possible dans du code managé ( .NET ou JAVA ).

Et ceci pour la simple raison qu'ils sont considérés comme type ou code non sécurisé ( unsafe ).
Les types pointeur et pointeur de fonction ne sont pas conformes CLS. Certains types de données ne sont plus supportés et sont soit émulés soit remplacés par d'autres types natifs de .NET.

Le tableau suivant montre la correspondance entre les types réels fondamentaux et les types .NET Framework.
Mappage des types réels .NET fondamentaux

Si votre composant doit être entièrement utilisable par des composants écrits dans d'autres langages, les types exportés de votre composant doivent exposer uniquement les fonctionnalités de langage qui font partie de la spécification CLS (Common Language Specification).

Voir aussi
Deprecated Language Features
Aide de delphi 2005 :Portage d'applications VCL vers Delphi 2005

Projet : ..\Delegues\Delegate1

Un délégué en Delphi .NET est similaire à un pointeur de fonction ou de procédure en WIN32. Avec un délégué, vous pouvez encapsuler une référence à une méthode à l'intérieur d'un objet delegate. Ce dernier peut ensuite être transmis au code, qui peut appeler la méthode référencée sans savoir, au moment de la compilation, quelle méthode sera appelée. Toutefois, à la différence des pointeurs de procédure ou de fonctions, les délégués sont orientés objet, indépendants des types et sécurisés.
Une de leur utilisation concerne les fonctions de rappel (Callback).

En Delphi .NET les types procédure sont donc implémentés comme des types délégués. Leur déclaration se fait par l'ajout de of object au nom de type. Exemple :

  TMonDelegue= Procedure(AClient:TClient) of Object;

Les déclarations suivantes sont toutes compilées comme des délégués :

Type
  TMonDelegue  = Procedure of Object;
  TMonDelegue2 = Procedure;
  TMonDelegueF = Function:Boolean;
var
   unDelegue : procedure(L :integer);

L'utilisation se fait ensuite de la manière suivante :

  TCompte=Class
   Clients:Array[1..5] of TClient;
   Constructor Create;
    // Déclaration
   procedure Callback(UnDelegue:TMonDelegue);
  end;
...
 // Implémentation
procedure TCompte.Callback(UnDelegue:TMonDelegue);
var i: integer;
begin
 For i:=1 to 5 do
    //Callback
   UnDelegue(Clients[i]);
end;
...
// Main  
Procedure AfficheClient(UnClient:TClient);
begin
 Writeln('Procédure de callback appelée pour le client nommé : ',UnClient.Nom);
end;

begin
 UnCompte:=TCompte.Create;
  // Appel
 UnCompte.Callback(AfficheClient);

Il est tout à fait possible de manipuler ce délégué par l'intermédiaire d'une variable typée :

Var TestDelegue:TMonDelegue;
..
  // Autre construction possible
 TestDelegue:=AfficheClient;
 UnCompte.Callback(TestDelegue);

Projet : ..\Delegues\Delegate2

Ensuite il est possible de visualiser la différence qui ne semble pas évidente entre une déclaration d'un type procédure sous Win32 et d'un délégué sous Delphi .NET:

  // Assignation obligatoire, sinon exception NullReferenceException lors de l'appel de GetType
 TestDelegue:=AfficheClient;
 Writeln('Ancêtre de TestDelegue = ',typeof(TestDelegue).BaseType);

L'instruction suivante provoque l'erreur de compilation suivante :

Pas assez de paramètres originaux (E2035)

La syntaxe correcte ici se fait par l'utilisation de l'opérateur @ qui semblait déconseillé. Il s'agit ici de la seule exception.
Il permet d'obtenir l'adresse du délégué. Si vous n'employez pas cette syntaxe, le compilateur pensera que vous essayez d'appeler le délégué, d'où l'erreur précédente.

 Writeln('Ancêtre de TestDelegue = ',typeof(@TestDelegue).BaseType);

 // Ici le compilateur reconnaît un accès à un membre de classe.
 Writeln('Type de TestDelegue = ',TestDelegue.GetType);

L'affichage de la classe ancêtre de TestDelegue nous renvoie System.MultiCastDelegate qui est elle-même dérivée de la classe System.Delegate.
En quoi notre procédure est-elle à diffusion multiple (multi-cast) ?

17-1. La diffusion multiple▲

Property MonDelegue:TMonDelegue read FMonDelegue write FMonDelegue;

Property MonDelegue:TMonDelegue add FMonDelegue remove FMonDelegue;

  TCompte=Class
   Clients:Array[1..5] of TClient;
    // Pour le multicast doit être une propriété :
   FMonDelegue:TMonDelegue;
   Constructor Create;
   procedure Callback;
    // la syntaxe : Property MonDelegue:TMonDelegue read FMonDelegue write FMonDelegue;
    // ne permet pas le composition de délégué. Il n'y a qu'un seul appel qui est le dernier déclaré
   Property MonDelegue:TMonDelegue add FMonDelegue remove FMonDelegue;
  end;

procedure TCompte.Callback;
var i: integer;
begin
 if assigned(FMonDelegue) then
  For i:=1 to 5 do
    FMonDelegue(Clients[i]);
end;

 Include(UnCompte.MonDelegue,@Traite);
 Include(UnCompte.MonDelegue,@AfficheClient);
 UnCompte.Callback;

 Exclude(UnCompte.MonDelegue,@Traite);
 Exclude(UnCompte.MonDelegue,@AfficheClient);
 Include(UnCompte.MonDelegue,@Fin);
 UnCompte.Callback;

 UnCompte.FMonDelegue:=Traite;
 UnCompte.Callback;

  // Identique à System.Delegate.RemoveAll(System.Delegate(@FMultiEvent), Nil);
 UnCompte.FMonDelegue:=Nil;   
 UnCompte.Callback;

17-2. Gestionnaire d'événements sous la VCL▲

type
   //Tableau Dynamique de Délégués
  TDelegateDynArray = array of System.Delegate;
...

procedure TForm1.Button1Click(Sender: TObject);
var TabDelegue : TDelegateDynArray;
    unDelegue  : System.Delegate;
    
begin
  if Not assigned(FMultiEvent)
  then
   begin
    Log.Lines.Add('La liste des délégués est vide');
    Exit;
   end;
 TabDelegue:=System.Delegate(@FMultiEvent).GetInvocationList;
 For unDelegue in TabDelegue do
  begin
   // Obtient le type du Delegué, ici : TNotifyEvent
   //  log.Lines.Add('Array :'+Deleg.ToString);
  Log.Lines.Add('Array :'+' '+unDelegue.Target.ToString+'.'+unDelegue.Method.Name);
 end;
end;

17-3. Gestionnaire d'événements sous Windows Form▲

unit Borland.Vcl.NetControlWrapper platform experimental;
...
 TNetEventHandler = procedure (Sender: System.Object; AArgs: System.EventArgs);
...

type
 MyEventArgs=Class(EventArgs)

 UserPrintPageEventArgs = class(EventArgs)
  Public
   MySpecialValue :String;
 end;

 TSampleEventHandler = procedure(Sender: TObject; Args: MyEventArgs);

Texte issu de la documentation de DELPHI 2005
Une assistance de classe est un type qui, lorsqu'il est associé à une autre classe, introduit des méthodes et propriétés supplémentaires qui peuvent être utilisées dans le contexte de la classe associée (ou ses descendants). Les assistances de classes permettent d'étendre une classe sans avoir recours à l'héritage.

Les assistances de classes permettent d'étendre une classe, mais elles ne doivent pas être considérées comme un outil de conception à utiliser pour développer un nouveau code. Elles ne doivent être utilisées que pour la liaison entre le langage et la RTL de la plate-forme.

On peut voir ci dessous l'utilisation parcimonieuse des class Helper dans les sources du runtime de Delphi 2005 .NET.

...\Borland\BDS\3.0\source\dotNet\rtl\
Borland.Delphi.System.pas :   TObjectHelper = class helper for TObject
Borland.Vcl.Classes.pas)  :   TPersistentHelper = class helper (TObjectHelper) for TPersistent
Borland.Vcl.Classes.pas   :   TComponentHelper = class helper (TPersistentHelper) for TComponent
Borland.Vcl.SysUtils.pas  :   ExceptionHelper = class helper (TObjectHelper) for Exception
Borland.Vcl.TypInfo.pas   :   TTypeInfoHelper = class helper for TTypeInfo
Borland.Vcl.TypInfo.pas   :   TPropInfoHelper = class helper for TPropInfo
Borland.Vcl.Variants.pas  :   VariantHelper = class helper for Variant
Borland.Vcl.Variants.pas  :   OleVariantHelper = class helper for OleVariant

Toutes les classes concernées sont des classes spécifiques à Delphi et mappées sur les classes correspondantes du Framework .NET. Par contre ces classes du Framework ne déclarent pas certains membres présents dans la classe Delphi.

Le class Helper permet donc ici d'ajouter ces membres manquants afin de préserver la compatibilité du code existant.

 ExceptionHelper = class helper (TObjectHelper) for Exception
  private
    class function CreateMsg(const Msg: string): Exception;
    function GetHelpContext: Integer;
    procedure SetHelpContext(AHelpContext: Integer);
  public
    /// Doc: The help context return zero(0) if exception's helplink property cannot be parsed into an integer.
    property HelpContext: Integer read GetHelpContext write SetHelpContext;

    // constructor Create(const Msg: string) is provided by the CLR class
    class function CreateFmt(const Msg: string; const Args: array of const): Exception;
    class function CreateHelp(const Msg: string; AHelpContext: Integer): Exception;
    class function CreateFmtHelp(const Msg: string; const Args: array of const;
      AHelpContext: Integer): Exception;

    // System.Exception.HResult is protected.  This helper exposes
    // the HResult for read-only access by non-descendents
    function HResult: Integer;
  end;
  ExceptionClass = class of Exception;