Perché non posso passare una TObjectList <S: T> a una funzione che si aspetta una TObjectList <T>?

Question

Ho un problema con il mio codice, che utilizza tipi generici. Perché il compilatore non sa che l'elenco passato (Result) è un TObjectList<TItem> (TItem è il tipo per T in TItems)?

Interfaccia:

type 
    TItem = class 
end; 

type 
    IItemsLoader = interface 
    procedure LoadAll(AList : TObjectList<TItem>); 
end; 

type 
    TItemsLoader = class(TInterfacedObject, IItemsLoader) 
public 
    procedure LoadAll(AList : TObjectList<TItem>); 
end; 

type 
    IItems<T : TItem> = interface 
    function LoadAll : TObjectList<T>; 
end; 

type 
    TItems<T : TItem> = class(TInterfacedObject, IItems<T>) 
    private 
    FItemsLoader : TItemsLoader; 
    public 
    constructor Create; 
    destructor Destroy; override; 
    function LoadAll : TObjectList<T>; 
end; 

Implementazione:

procedure TItemsLoader.LoadAll(AList: TObjectList<TItem>); 
begin 
    /// some stuff with AList 
end; 

{ TItems<T> } 

constructor TItems<T>.Create; 
begin 
    FItemsLoader := TItemsLoader.Create; 
end; 

destructor TItems<T>.Destroy; 
begin 
    FItemsLoader.Free; 
    inherited; 
end; 

function TItems<T>.LoadAll: TObjectList<T>; 
begin 
    Result := TObjectList<T>.Create(); 

    /// Error here 
    /// FItemsLoader.LoadAll(Result); 
end; 

Answer 1

Nella funzione con l'errore, Result è un TObjectList<T>, dove T è una certa sottoclasse di TItem, ma il compilatore non sa cosa classe specifica è. Il compilatore deve compilarlo in modo che sia sicuro di eseguire per qualsiasi valore di T. Questo potrebbe non essere compatibile con il tipo di argomento LoadAll, che richiede uno TObjectList<TItem>, quindi il compilatore rifiuta il codice.

Supponiamo che T sia TItemDescendant e che il compilatore consenta la compilazione e l'esecuzione del codice difettoso. Se LoadAll chiama AList.Add(TItem.Create), quindi AList finirà per contenere qualcosa che non è un TItemDescendant, anche se è un TObjectList<TItemDescendant>. Tiene un oggetto di un tipo diverso da quello che dice il parametro di tipo generico.

Solo perché S è un sottotipo di T non significa che X<S> è un sottotipo di X<T>.

Answer 2

è necessario utilizzare una versione generica del caricatore così:

type 
    TItem = class 
end; 

type 
    IItemsLoader<T: TItem> = interface 
    procedure LoadAll(AList : TObjectList<T>); 
end; 

type 
    TItemsLoader<T: TItem> = class(TInterfacedObject, IItemsLoader<T>) 
public 
    procedure LoadAll(AList : TObjectList<T>); 
end; 

type 
    IItems<T : TItem> = interface 
    function LoadAll : TObjectList<T>; 
end; 

type 
    TItems<T : TItem> = class(TInterfacedObject, IItems<T>) 
    private 
    FItemsLoader : TItemsLoader<T>; 
    public 
    constructor Create; 
    destructor Destroy; override; 
    function LoadAll : TObjectList<T>; 
end; 


implementation 

{$R *.dfm} 

procedure TItemsLoader<T>.LoadAll(AList: TObjectList<T>); 
begin 
    /// some stuff with AList 
end; 

{ TItems<T> } 

constructor TItems<T>.Create; 
begin 
    FItemsLoader := TItemsLoader<T>.Create; 
end; 

destructor TItems<T>.Destroy; 
begin 
    FItemsLoader.Free; 
    inherited; 
end; 

function TItems<T>.LoadAll: TObjectList<T>; 
begin 
    Result := TObjectList<T>.Create(); 

    /// Error here 
    FItemsLoader.LoadAll(Result); 
end;