Delphi 2009 problème de compilation de génériques

Question

Je vérifie l'essai Delphi 2009, mais j'ai rencontré des problèmes avec les génériques tout de suite.

Le code suivant ne compile pas, et je n'ai pas la moindre idée pourquoi il me donne E2015 pour la méthode equals():

type 
    TPrimaryKey<T> = class(TObject) 
    strict private 
    fValue: T; 
    public 
    constructor Create(AValue: T); 
    function Equals(Obj: TObject): boolean; override; 
    function GetValue: T; 
    end; 

constructor TPrimaryKey<T>.Create(AValue: T); 
begin 
    inherited Create; 
    fValue := AValue; 
end; 

function TPrimaryKey<T>.Equals(Obj: TObject): boolean; 
begin 
    Result := (Obj <> nil) and (Obj is TPrimaryKey<T>) 
    and (TPrimaryKey<T>(Obj).GetValue = fValue); 
end; 

function TPrimaryKey<T>.GetValue: T; 
begin 
    Result := fValue; 
end; 

Pourquoi pense que le compilateur qui fValue et le résultat de GetValue() ne peut pas être comparé?

Answer 1

si T est une chaîne? Et si c'est un disque TSize?

Sans contrainte T (par exemple avec < T: class>), vous ne pouvez pas être sûr que la comparaison sera significative.

Si, au contraire, que vous vouliez comparer deux valeurs de type T, vous pouvez utiliser l'unité et de l'utilisation Generics.Defaults:

TEqualityComparer<T>.Default.Equals(x, y) 

pour comparer les valeurs x et y de type T.

Answer 2

Vous ne pouvez pas utiliser d'opérateurs avec des génériques non typés. Voir here pour une discussion.

Il compile si vous modifiez à:

TPrimaryKey<T: class> = class(TObject) 

Answer 3

Je pense que l'affiche originale tente de créer une enveloppe d'objet autour de types simples (entier, double etc etc), ce qui limite donc T à la classe serait peut-être pas travaille pour ce qu'il veut.

Answer 4

Le compilateur a du mal à déterminer si les deux "T" sont identiques. Mais avec un petit truc, vous pouvez le faire fonctionner:

type 
    TPrimaryKey<T> = class(TObject) 
    public 
    type 
     TCompare<T1> = reference to function(const A1, A2: TPrimaryKey<T1>): Boolean; 
    private 
    fValue: T; 
    fCompare : TCompare<T>; 
    public 
    constructor Create(AValue: T; ACompare: TCompare<T>); 
    function Equals(Obj: TPrimaryKey<T>): Boolean; reintroduce; 
    function GetValue: T; 
    function CreateNew(const AValue: T): TPrimaryKey<T>; 

    end; 

constructor TPrimaryKey<T>.Create(AValue: T; ACompare: TCompare<T>); 
begin 
    inherited Create; 
    fValue := AValue; 
    fCompare := ACompare; 
end; 

function TPrimaryKey<T>.Equals(Obj: TPrimaryKey<T>): Boolean; 
begin 
    Result := FCompare(self, Obj); 
end; 

function TPrimaryKey<T>.GetValue: T; 
begin 
    Result := fValue; 
end; 

function TPrimaryKey<T>.CreateNew(const AValue: T): TPrimaryKey<T>; 
begin 
    Result := TPrimaryKey<T>.Create(AValue, FCompare); 
end; 

instanciation avec:

var 
    p1, p2 : TPrimaryKey<Integer>; 
begin 
    p1 := TPrimaryKey<Integer>.Create(10, 
    function(const A1, A2: TPrimaryKey<Integer>): Boolean 
    begin 
     Result := (A1<>nil) and (A2<>nil) and (A1.GetValue=A2.GetValue); 
    end); 
    p2 := p1.CreateNew(10); 

    p1.Equals(p2); 
end;