//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 renvoi 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>'

  //Classe générique 
 TGenericClass<C>=Class
  FData: T;
 End;

  //Record générique 
 TGenericEnregistrement<T>=Record
  Data: T;
 End;

type
 TGeneriqueArray<X> = array of X;
 TGeneriqueArray2D<X> = array of TGeneriqueArray<X>; // Equivalent à Array of Array of X

  //Tableau à une dimension contenant des chaînes de caractères
 TGtabString  = TGeneriqueArray<String>; 
  //Tableau à deux dimensions contenant des entiers  
 TGtab2DInt   = TGeneriqueArray2D<Integer>; 

  //Types compatibles
 TGtabInteger=TGeneriqueArray<Integer>;
 TGtabIntegerV2 = array of Integer;

type
  TProcedureGenerique<A> = procedure(Param1 : A);
  TProcObjetGenerique<B> = procedure(X,Y: B) of object; //Méthode d'objet
  TFonctionGenerique<T>  = Function : T;
  
  TMaClasse = class
    procedure UneMethode<T>(X, Y: T); // Même signature que le type TProcObjetGenerique<B>
    procedure TestMethode;
    procedure TestProcedure<UnType>(Prc:TProcedureGenerique<UnType>);
    procedure TestFonction<T>(fnct: TFonctionGenerique<T>);
  end;

  TMaClasse = class
    ...
    procedure TestProcedure(Prc:TProcedureGenerique<UnType>);
  end;

Procedure ProcedureGeneriqueInt(M:Integer);
begin
  Writeln(M);
end;

Procedure ProcedureGeneriqueString(M:String);
begin
  Writeln(M);
end;

..
  With TMaClasse.Create do
  begin
   TestProcedure<Integer>(ProcedureGeneriqueInt);

   //TestProcedure<Integer>(ProcedureGeneriqueString); //E2010 Types incompatibles : 'Integer' et 'string'
   //TestProcedure<String>(ProcedureGeneriqueInt); //E2010 Types incompatibles : 'string' et 'Integer'
   TestProcedure<String>(ProcedureGeneriqueString);
  end;

procedure TMaClasse.UneMethode<T>(X, Y: T);
begin
  Writeln(X.ToString,' , ',Y.ToString);
end;

procedure TMaClasse.TestMethode;
var
  P: TProcObjetGenerique<Boolean>; //Argument de type Boolean connu
begin
  UneMethode<String>('Hello', 'World'); //Argument de type String connu
  UneMethode('Hello', 'World');

  UneMethode<Integer>(10, 20); //Argument de type Integer connu
  UneMethode(10, 20);

  P:=UneMethode<Boolean>;
  P(False,True);
end;

procedure TMaClasse.TestProcedure<UnType>(Prc:TProcedureGenerique<UnType>);
var
  P: TProcedureGenerique<UnType>;
  Value: UnType;
begin
   //Le type est déterminé dans la signature, il est donc inconnu.
  Prc('Hello');
  P:=Prc;
  //Value:='Chaine'; //E2010 Types incompatibles : 'UnType' et 'string'
  Value:=Default(UnType);
    
  P(True);
  P(Default(UnType));
end;

 if assigned(TObject(Value)) //Le cast est obligatoire
   then writeln('Assigné.')
   else writeln('Non assigné.');

  UneMethode<String>('Hello', 'World');
  UneMethode('Hello', 'World');

  TGenericType<AnyType> = class
    FData: AnyType;
    function GetData: AnyType;

    procedure UneMethodeGenerique<AnyType>(Variable: AnyType);
    function UneFonctionGenerique<AnyType>: AnyType;

    procedure SetData(Value: AnyType);
    property Data: AnyType read GetData write SetData;
  end;

H2509 Identificateur 'AnyType' en conflit avec les paramètres type du type conteneur

  TGenericType<AnyType> = class
    FData: AnyType;
    function GetData: AnyType;

    procedure UneMethodeGenerique(Variable: AnyType);
    function UneFonctionGenerique: AnyType;

    procedure SetData(Value: AnyType);
    property Data: AnyType read GetData write SetData;
  end;

    procedure UneMethodeGenerique<T>(Variable: T);

    procedure UneMethodeGenerique(Variable: AnyType);Overlaod;
    procedure UneMethodeGenerique<R>(Variable: AnyType; Variable2: R);Overload;
    procedure UneMethodeGenerique<T,U>(Variable: U; Variable2: T);Overload;

type
  IMonInterface<T>= interface
    procedure set_Valeur(const AValeur: T);
    function get_Valeur: T;
    property Valeur: T read get_Valeur write set_Valeur;
  end;

  IMonInterfaceDerivee<T>= interface(IMonInterface<T>)
   Procedure Multiplier(AMulplicateur:T);
  end;

Procedure TClasseTest<T>.Multiplier(AMulplicateur:T);
begin
 //E2015 Opérateur non applicable à ce type d'opérande
 FCompteur:=FCompteur * AMulplicateur;  
end;

 Ensemble<T>=Set of T; //Erreur

 TTestNullableHelper<T:Record>=Class Helper for TTestNullable<T:Record>
 End;

 Erreur : E2508 Les paramètres de type ne sont pas autorisés sur ce type

 TGenericType<T>

  TGenericType<T:TComponent>

  TGenericType<T:IMonInterface<T>>

 TTestNullable<T:record>=Class
   procedure Inverser(Arg:System.Nullable<T>; Valeur:System.Nullable<T>);
 End;

  TGenericType<T:Constructor,TMonItérateur,IEnumérable>;
  
  TGenericType<T,U:IEnumérable>;

 //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 générique ouvert
  {TClassDeBaseDeriveDeGenerique=Class(TGenerique<I>) //E2003 Identificateur non déclaré : 'I'
   FData: integer;
  End;
  }
   //Classe de base dérivée d'un type générique 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
   //E2513 Le paramètre type 'I' doit avoir un constructeur sans paramètre
   //TGeneriqueDeriveeDeGeneriqueContraint<I,S>=Class(TGeneriqueContraint<I>)
  TGeneriqueDeriveeDeGeneriqueContraint<I,S>=Class(TGeneriqueContraint<I:constructor>)
   FData: I;
   Fitem: S;
  End

Type
   TParent<T> = class
     X: T;
   end;

   TEnfant<S> = class(TParent<S>)
     Y: T;  // Erreur! Identifieur inconnu "T" 
   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 type paramètres).}
  generique:= typeof(Dictionary<,>);
  AfficheInformationDeType(generique);

   {Crée un tableau de type pour remplacer les paramètres de type 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éez un type objet représentant le type générique construit.}
  construit:= generique.MakeGenericType(typeArgs);
  AfficheInformationDeType(construit);

  {Compare les types d'objet obtenus ci-dessus aux types objet obtenu
  en utilisant les methode 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 construit sont-il égaux ? ', (t = construit));
WriteLn('Les type génériques sont-il égaux ? ',(t.GetGenericTypeDefinition = generique));
  except
    on E:Exception do
      Writeln(E.Classname, ': ', E.Message);
  end;
end;

 public struct Nullable<T> where T : struct

var
    intNull : System.Nullable<integer>;
    dblNull : System.Nullable<Double>;

 TTestNullable<T:record>=Class
   procedure Inverser(Arg:System.Nullable<T>; Valeur:System.Nullable<T>);
 End;

procedure Assignation;
var  I:Integer;
     intNull:System.Nullable<integer>;
begin
  intnull:=52;
  //I:=intNull;  //E2010 Types incompatibles : 'Integer' et 'Nullable<System.Int32>'
  I:=Integer(intNull);
  I:=Convert.ToInt32(intNull);
Writeln('Gestion d''une valeur null');
  intnull:=Default(Nullable<integer>);

  intnull:=Default(Nullable<integer>);

procedure Test(Arg:System.Nullable<integer>);
begin
  if Arg.HasValue
   then writeln('La variable n''est pas à null')
   else writeln('La variable est à null')
end;

procedure Test2(Arg:System.Nullable<integer>);
begin
 try
  Writeln('Valeur du type nullable =',Arg.Value);
  Except
    //l'accés à la propriété Value déclenche une exception si son contenu est Null
   On E:InvalidOperationException do
    Writeln('La variable est à null')
 end;
end;