Come si verifica una variabile di tipo generico per l'uguaglianza con Default (T) in Delphi?

Question

che sto cercando di scrivere un generico di accesso di proprietà nella cache come il seguente, ma sto ottenendo un errore di compilazione quando si cerca di verificare se la variabile di archiviazione contiene già un valore:

function TMyClass.GetProp<T>(var ADataValue: T; const ARetriever: TFunc<T>): T; 
begin 
    if ADataValue = Default(T) then // <-- compiler error on this line 
    ADataValue := ARetriever(); 
    Result := ADataValue; 
end; 

L'errore che sto ottenendo è " E2015 Operatore non applicabile a questo tipo di operando ".

Dovrei mettere un vincolo su T per farlo funzionare? Il file della guida dice che Default() accetta qualsiasi cosa tranne i tipi generici. Nel mio caso mi occupo principalmente di tipi semplici come String, Integer e TDateTime.

Oppure c'è qualche altra funzione di libreria per eseguire questo controllo particolare?

Sto utilizzando Delphi 2009 nel caso che importi.

---

PS: Nel caso in cui non è chiaro dal codice quello che sto cercando di fare: Nel mio caso la determinazione dei valori delle proprietà attuali potrebbe richiedere del tempo per vari motivi e qualche volta non potrebbe nemmeno bisogno loro affatto. D'altro canto, i valori sono costanti, quindi desidero solo chiamare il codice che determina il valore effettivo la prima volta che accede a questa proprietà e quindi archiviare il valore in un campo classe e al successivo accesso a questa proprietà restituisce il valore memorizzato nella cache direttamente. Ecco un esempio di come speravo di essere in grado di utilizzare quel codice:

type 
    TMyClass = class 
    private 
    FSomeProp: String; 
    function GetSomeProp: String; 

    function GetProp<T>(var ADataValue: T; const ARetriever: TFunc<T>): T; 
    public 
    property SomeProp read GetSomeProp; 
    end; 

function GetSomeProp: String; 
begin 
    Result := GetProp<String>(FSomeProp, 
          function: String 
          begin 
           Result := SomeSlowOrExpensiveCalculation; 
          end); 
end; 

(ovviamente, c'è più di una sola proprietà)

Answer 1

Dopo un suggerimento nei commenti da Binis e scavare intorno un po 'in Generics.Collections mi si avvicinò con la seguente, che sembra funzionare proprio come lo volevo :

function TMyClass.GetProp<T>(var ADataValue: T; const ARetriever: TFunc<T>): T; 
var 
    lComparer: IEqualityComparer<T>; 
begin 
    lComparer := TEqualityComparer<T>.Default; 
    if lComparer.Equals(ADataValue, Default(T)) then 
    ADataValue := ARetriever(); 
    Result := ADataValue; 
end; 

Answer 2

Il problema non è la funzione Default, ma l'operatore di uguaglianza = .

Si potrebbe limitare T-IEquatable e utilizzare il metodo Equals in questo modo:

TMyClass = class 
    function GetProp<T : IEquatable<T>>(var ADataValue: T; const ARetriever: 
end; 
... 
function TMyClass.GetProp<T>(var ADataValue: T; const ARetriever: TFunc<T>): T; 
begin 
if ADataValue.Equals (Default(T)) then 
    ADataValue := ARetriever(); 
Result := ADataValue; 
end; 

Answer 3

quanto ho capito le cose sembra che u vuole fare qualche tipo di funzionalità Memoize. Se questo è il caso appena letto questo articolo

http://blogs.teamb.com/craigstuntz/2008/10/01/37839/