Les génériques sous Delphi .NET

   //Pile spécialisée afin de manipuler le type TCustomActionMenuBar;
  TMenuStack = class(TStack) 
  ...
function TMenuStack.GetBars(const Index: Integer): TCustomActionMenuBar;
begin
   //Transtypage obligatoire, car 
   //l'appel de TList.Get renvoie un objet.
  Result := TCustomActionMenuBar(List[Index]); 
end;

//La pile est construite autour d'une liste d'objet
function TList.Get(Index: Integer): TObject;
begin
  Result := FList[Index];
end;

 //FList étant déclarée ainsi :
 property List: System.Collections.ArrayList read FList;

type
  TGenericType<AnyType> = class
    FData: AnyType;
    function GetData: AnyType;
    procedure SetData(Value: AnyType);
    property Data: AnyType read GetData write SetData;
  end;

function TGenericType<AnyType>.GetData: AnyType;
begin
  Result := FData;
end;

procedure TGenericType<AnyType>.SetData(Value: AnyType);
begin
  FData := Value;
end;

type
  TGenericTypeInt = TGenericType<Integer>; //Déclare un type à partir d'une classe générique

type
  TGenericType<AnyType> = class
    FData: AnyType;
  end;

  TGenericType<ParametreDeType> = class //Erreur à la compilation
    FData: ParametreDeType;
  end;

  TGenericType<AnyType,N> = class //Surcharge Autorisée
    FData1: AnyType;
    FData2: N;
  end;

E2037 : La déclaration de 'TGenericType<AnyType>' diffère de la déclaration précédente

var
  I: TGenericType;

Identificateur non déclaré : ' TGenericType ' (E2003).

type
  TGenericTypeInt = TGenericType<Integer>; // La classe générique est paramétrée avec le type Integer

var
  I: TGenericTypeInt;
begin
  I := TGenericTypeInt.Create;

var X: TGenericType<Integer>;

begin
  X := TGenericType<Integer>.Create;
  X.Data := 100;

  With TGenericType<Integer>.Create do
   Data := 100;

type
  TGenericTypeString = TGenericType<string>;
var
  I: TGenericTypeInt;
  D: TGenericTypeString;
begin
  I := TGenericTypeInt.Create;
  I.Data := 100;
  WriteLn(I.Data);
 
  D := TGenericTypeString.Create;
  D.Data := 'Generic';
  WriteLn(D.Data);
  I:=D;  //Erreur à la compilation

E2010 Types incompatibles : 'TGenericType<System.Int32>' et 'TGenericType<System.String>'

TGenericType<T>

//Classe de base
  TClassDeBase=Class
   FData: integer;
  End;

   //Classe générique
  TGenerique<I>=Class
   FData: I;
  End;

   //Classe de base dérivée d'un type construit ouvert
  {TClassDeBaseDeriveDeGenerique=Class(TGenerique<I>) //E2003 Identificateur non déclaré : 'I'
   FData: integer;
  End;
  }
   //Classe de base dérivée d'un type construit fermé
  TClassDeBaseDeriveDeGenerique=Class(TGenerique<Integer>)
   FData: integer;
  End;

   //Classe générique dérivée d'une classe de base
  TGeneriqueDeriveeDeClass<I>=Class(TClassDeBase)
   FData: I;
  End;

   //Classe générique dérivée d'une classe générique
  TGeneriqueDeriveeDeGenerique<I,S>=Class(TGeneriqueDeriveeDeClass<I>)
   FData: I;
   Fitem: S;
  End;

   //Classe générique contrainte
  TGeneriqueContraint<I:constructor>=Class
   FData: I;
  End;

  //Classe générique dérivée d'une classe générique contrainte
   //dans ce cas les contraintes doivent être redéclarées.
  TGeneriqueDeriveeDeGeneriqueContraint<I:constructor;S>=Class(TGeneriqueContraint<I>)
   FData: I;
   Fitem: S;
  End;

TTest=Class
   FData: integer;
  End;
  //Surcharge générique
  TTest<I>=Class
   FData: I;
  End;

  {
  TTest<I:constructor>=Class //E2037 La déclaration de 'TTest<I>' diffère de la déclaration précédente
   FData: I;
  End;
  }

  TTest<I,S>=Class
   FData: I;
   Fitem: S;
  End;

  //Surcharge générique à partir d'une autre surcharge générique de la même classe
      TGeneric<A,B>=Class
       FData: A;
       Fitem: B;
      End;

  TGeneric<A>=Class(TGeneric<A,String>)
   FData: A;
  End;

  //Surcharge générique à partir d'une autre surcharge générique d'une autre classe
  TGenericTest<R,U>=Class(TGeneric<R>)
   FData: R;
  End;

{$APPTYPE CONSOLE}
type
  TFoo<T> = class
    class var FCount: Integer;
    constructor Create;
  end;

constructor TFoo T>.Create;
begin
  inherited Create;
  Inc(FCount);
end;

procedure Test;
var FI: TFoo<Integer>;
begin
  FI := TFoo<Integer>.Create;
  FI.Free;
end;

var
  FI: TFoo<Integer>;
  FS: TFoo<String>;

begin
  FI := TFoo<Integer>.Create;
  FI.Free;
  FS := TFoo<String>.Create;
  FS.Free;
  Test;
  WriteLn(TFoo<Integer>.FCount); // renvoie 2
  WriteLn(TFoo<String>.FCount);  // renvoie 1
end;

Procedure TConteneur.Main;
var t,
    generique,
    construit : System.Type;
    typeArgs    : Array of System.Type;

begin
 try
  WriteLn('Crée un type construit à partir du type générique Dictionary.',  Environment.NewLine);
   {Crée un type objet représentant le type générique Dictionary,
   en omettant le type arguments (mais en gardant la virgule qui les sépare,
   ainsi le compilateur peut déduire le nombre de paramètres de type).}
  generique:= typeof(Dictionary<,>);
  AfficheInformationDeType(generique);

   {Crée un tableau de type pour remplacer les paramètres de type de Dictionary.
   le paramètre 'Key' est de type String, et le type à contenir dans Dictionary est TConteneur}
  typeArgs:= TArrayType.Create(typeof(string), typeof(Self));

  {Crée un type objet représentant le type générique construit.}
  construit:= generique.MakeGenericType(typeArgs);
  AfficheInformationDeType(construit);

  {Compare les types d'objets obtenus ci-dessus aux types objet obtenus
  en utilisant les méthodes typeof et GetGenericTypeDefinition.}
  WriteLn(Environment.NewLine,'Compare les types obtenus par les différentes méthodes :');

  //t:= typeof(System.Collections.Generic.Dictionary<String, Self>);   //E2003 Identificateur non déclaré : 'Dictionary'
  t:= typeof(TGenDictionary);
  WriteLn('Les types construits sont-ils égaux ? ', (t = construit));
  WriteLn('Les types génériques sont-ils égaux ? ',(t.GetGenericTypeDefinition = generique));
  except
    on E:Exception do
      Writeln(E.Classname, ': ', E.Message);
  end;
end;

type
 EContrainteArgumentException=Class(ArgumentException);

 MaClasse<T>=Class
   UnChamp : T;
   S       : String;
   Constructor Create;
   Class Constructor CreateClass;
  end;
...
var Objet : MaClasse<Integer> ;
    Objet2 : MaClasse<String>;
    Objet21 : MaClasse<TObject>;
    Objet3,Objet4 : MaClasse<Double>;
    Objet5 : MaClasse<Byte>;

begin
try
 Writeln('Début d''exécution du code.');
 Objet2:=nil;
  // Partage de code IL pour tous les types références
 Objet2:=MaClasse<String>.Create; //Appel du constructeur de classe, le type n'existe pas encore

 Objet21:=nil;
 Objet21:=MaClasse<TObject>.Create; //Appel du constructeur de classe, le type n'existe pas encore

  // Création de code pour chaque type valeur
 Objet3:=nil;
 Objet3:=MaClasse<Double>.Create; //Appel du constructeur de classe, le type n'existe pas encore

 Objet4:=nil;
 Objet4:=MaClasse<Double>.Create; //Pas d'appel du constructeur de classe, le type existe déjà

 Objet5:=nil;
 Objet5:=MaClasse<Byte>.Create; //Appel du constructeur de classe, le type n'existe pas encore
..

Class Constructor MaClasse<T>.CreateClass;
var UnEntier:Integer;
    VarGeneric :T;
begin
 Writeln(#9+#9+'Appel du constructeur de classe MaClasse.CreateClass<',Typeof(T),'>');
 VarGeneric:=default(T);

  //Est-ce un type valeur et le paramètre de type est-il un integer ?
 if (assigned(TObject(VarGeneric))=true) and (TObject(UnEntier) is T) then
  Raise EContrainteArgumentException.Create('L''utilisation du type Integer n''est pas autorisé pour la Classe MaClasse<T>');
end;

  //Appel du constructeur de classe, le paramètre de type Integer est interdit.
 Objet:=nil;
 Objet:=MaClasse<Integer>.Create;

 except
    //Déclenchée par le constructeur de la classe générique fermé MaClasse<Integer>
   on E:TypeInitializationException do
    If E.InnerException is EContrainteArgumentException
     then Writeln(E.InnerException.Classname, ': ', E.InnerException.Message)
     else Raise;

public struct Nullable<T> where T : struct

type
 MaClasse<T>=class
  unchamp:T;
  procedure Test<X>;
  procedure Test2<X>;
 end;

 NullInteger = System.Nullable<Integer>;

procedure MaClasse<T>.Test<X>;
var Variable:X;
begin
 Writeln;
 Write(#9+'Le test sur X<',Typeof(X),'> is T<',typeof(T),'> est ' );
 if TObject(Variable) is T
  then writeln('Vrai')
  else writeln('Faux');
  if assigned(TObject(Variable))
   then writeln(#9+'assigned(Variable) =Vrai')
   else writeln(#9+'assigned(Variable)=Faux');
end;

procedure Test(Resultat:Boolean);
begin
 if Resultat
  then writeln('Vrai')
  else writeln('Faux');
end;

var Classe1: MaClasse<TObject>;
    Classe2: MaClasse<System.Nullable<Integer>>;
    Classe3: MaClasse<Integer>;
    VarNull: NullInteger;
    Objet  : TObject;
    int    : Integer;

//If T is a nullable type, the result is true if D is the underlying type of T.
 Writeln('test pour la variable Classe2 MaClasse<System.Nullable<Integer>>');
 Classe2:=MaClasse<NullInteger>.Create;
 Classe2.Test<Double>;
 Classe2.Test<String>;
 Classe2.Test<integer>;
 Classe2.Test<NullInteger>;

test pour la variable Classe2 MaClasse<System.Nullable<Integer>>

        Le test sur X<System.Double> is T<System.Nullable`1[System.Int32]> est Faux
        assigned(Variable) =Vrai

        Le test sur X<System.String> is T<System.Nullable`1[System.Int32]> est Faux
        assigned(Variable)=Faux

        Le test sur X<System.Int32> is T<System.Nullable`1[System.Int32]> est Vrai
        assigned(Variable) =Vrai

        Le test sur X<System.Nullable`1[System.Int32]> is T<System.Nullable`1[System.Int32]> est Faux
        assigned(Variable)=Faux

Function MaClasse.Contraint<X>(AValue: TObject):X;
begin
 Result:=AValue as X;
end;

Mise à niveau du projet ..\RAD Studio\Projets\Delegues\VCL\Delegues.bdsproj
Numéro de version de la personnalité "1.0" mis à jour vers "3.0"