//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; 

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

  TGenerique<T>  = class
   Champ: T
  end;

 THelperGenerique<T>=Class Helper for TGenerique<T>
 End;

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

  TGeneriqueInt=TGenerique<Integer>;
  THelperGeneriqueInt=Class Helper for TGeneriqueInt
   Procedure Test;
  End;

 TGenericType<T>

  TGenericType<T:TComponent>

  TGenericType<T:IMonInterface<T>>

  TGenericSansConstructeur<T> = class
  strict private
    FData: T;
    //Constructeur sans paramètre
    constructor Create; // inaccessible pour la contrainte :Constructor
  public
  ...
  end;
    
  TGenericAvecConstructeur<T> = class
  private
    FData: T;
  public
    //Constructeur sans paramètre  
    constructor Create;
  ...
  end;
  
 TGenericContraint<ClasseInstanciable:Constructor>=Class
  private
   MaClasse : ClasseInstanciable;
  public
   Constructor Create;
 end;

constructor TGenericContraint<ClasseInstanciable>.Create;
begin
 Inherited Create;
 MaClasse:=ClasseInstanciable.Create;
end;

 E2076 : Forme d'appel de méthode autorisée seulement pour méthodes de classe.

var  Z  : TGenericContraint<TGenericSansConstructeur<Integer>>;
     Z2 : TGenericContraint<TGenericAvecConstructeur<Integer>>;
begin
 try
  Z := TGenericContraint<TGenericSansConstructeur<Integer>>.Create;
  Z2:=TGenericContraint<TGenericAvecConstructeur<Integer>>.Create;
  WriteLn(Z2.MaClasse.ToString);

 E2513 : Le paramètre type 'ClassInstanciable' doit avoir un constructeur sans paramètre

Exception non gérée : System.TypeLoadException: GenericArguments[0], 'Contrainte
1.TGenericAvecConstructeur`1[System.Int32]', pour 'Contrainte1.TGenericContraint
`1[ClasseInstanciable]' ne respecte pas la contrainte du paramètre de type 'Clas
seInstanciable'....

  TGenericType<T:class>;

  Obj1 :TGenericType<TObject>;
  Obj2 :TGenericType<IMonInterface>;
  Obj3 :TGenericType<String>;
  Obj4 :TGenericType<Array of Integer>;    
  ...

 TGenericClass<R:record>=Class //Contrainte record sur une classe, attend un paramètre de type d'un type valeur.
  Champ: R;
 End;

 Obj5: TGenericClass<TEnregistrement>;
 Obj6: TGenericClass<Integer>;
 Obj7: TGenericClass<Couleurs>; // avec  Couleurs=(Rouge,Noir,Vert);

 TClassContrainteTypeNu<S,U>=Class
   type
     TClassImbriquee<T:U>=Class
      Valeur:S;
     End;
 End;

var
 Parent:TClassContrainteTypeNu<String,Integer>;
 Naked : TObject;

begin
   Parent:=TClassContrainteTypeNu<String,Integer>.Create;
   Naked:=TClassContrainteTypeNu<String,Integer>.TClassImbriquee<String>.Create;
...

 E2515 Le paramètre type 'T' n'est pas compatible avec le type 'Integer'

  TGenericType<T:Constructor,TMonItérateur,IEnumerable>=Class
   ...
  end;
  
  TGenericType<T,U:IEnumerable; S:record>=Class
   ...
  end;

 //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;

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;

 TClasseOperateur<T> = class
    Champ1: T;
    Procedure Test(const Value: TOperateur<T>);
    class operator Negative(const Value: TOperateur<T>): TOperateur<T>;
 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ètre 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'objet 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 construit sont-il égaux ? ', (t = construit));
  WriteLn('Les types génériques sont-il é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

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); //Transtypage obligatoire
  I:=Convert.ToInt32(intNull);

Writeln('Gestion d''une valeur null');
  //intnull:=Nil; //E2010 Types incompatibles : 'Nullable<System.Int32>' et 'Pointer'
  intnull:=Default(Nullable<integer>);
  I:=Integer(intnull);

 I:=intNull.GetValueOrDefault; 

procedure Addition;
var  I       : Integer;
     J       : System.Nullable<integer>;
     intNull : System.Nullable<integer>;

begin
  IntNull:=1;
  //intNull:=intNull+1; //E2015 Opérateur non applicable à ce type d'opérande
  //intNull:=intNull+System.Nullable<integer>(1); //Idem
  //inc(intNull); //Idem
  //inc(intNull.value); //E2064 La partie gauche n'est pas affectable

  IntNull:=Integer(intNull)+1;
  intNull:=intNull.value+1;
  with intNull do
   intNull:=value+1;

  //I:=intNull+5; //E2015 Opérateur non applicable à ce type d'opérande
  I:=Integer(intNull)+5;
  I:=intNull.value+5;
  I:=7;
  J:=12;
  intnull:=J;
  intnull:=8;

 //Addition de deux variable de type null
  //intnull:=intNull+J; //E2015 Opérateur non applicable à ce type d'opérande
  //intnull:=intNull.Value+J; //idem
  intnull:=intNull.Value+J.Value;
  //with intNull do
   // Value:=Value+J.Value;   //E2129 Affectation impossible à une propriété en lecture seule
end;

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;

 MonRecordInt=Record
   Data:Integer;
   Constructor Create (Value:Integer);
 End;
...
var RecNullable :System.Nullable<MonRecordInt>;
    Rec:MonRecordInt;

    RecNullable:=MonRecordInt.Create(852);
    Writeln(RecNullable.Value.Data);

    //RecNullable.Value:=10; //E2129 Affectation impossible à une propriété en lecture seule
    //RecNullable.Value.Data:=10; //E2064 La partie gauche n'est pas affectable
    Rec:=RecNullable.Value;
    Rec.Data:=10;

    RecNullable:=Rec;
    Writeln(RecNullable.Value.Data);

<code langage="delphinet">
 MonRecordInt=Record
   Data:Integer;
   Constructor Create (Value:Integer);
   class operator Implicit(a: Integer): MonRecordInt;
 End;
class operator MonRecordInt.Implicit(a: Integer): MonRecordInt;
begin
 Result.Data:=a;
end;

...
    RecNullable:=MonRecordInt(99);  //Appel implicit

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"