È un oggetto o un'interfaccia? Devo liberarlo o no?

Question

Buona giornata! Funzione GetService crea un'istanza della classe THTTPRIO e la restituisce come IInvokable. Io uso questa interfaccia/oggetto in un'altra funzione. Devo liberarlo o no quando non ne ho più bisogno? Non è necessario liberare le interfacce, ma sono confuso dal fatto che RIO sia stato creato come oggetto della classe THTTPRIO.

function GetService(Addr: string): IInvokable; 
var 
    RIO: THTTPRIO; 
begin 
    RIO := THTTPRIO.Create(nil) 
    RIO.URL := Addr; 
    Result := (RIO as IInvokable); 
end; 

Dove:

IInvokable = interface(IInterface); 
THTTPRIO = class(TComponent, IInterface, IRIOAccess); 

Grazie in anticipo! Vojtech

Answer 1

Per rispondere alla domanda è necessario verificare come sono implementati IInterface._AddRef e IInterface._Release per questa classe. Sembrano così:

function TRIO._AddRef: Integer; 
begin 
    Result := TInterlocked.Increment(FRefCount); 
end; 

function TRIO._Release: Integer; 
begin 
    Result := TInterlocked.Decrement(FRefCount); 
    if (Result = 0) and not (Owner is TComponent) then 
    Destroy; 
end; 

Ciò significa che la durata dell'oggetto viene gestita dal conteggio dei riferimenti dell'interfaccia. Ciò significa che il tuo codice è corretto e non perde.

Si noti che se si era passato uno Owner nel costruttore, la durata sarebbe stata gestita da quel proprietario.

Il codice è ancora in qualche modo soggetto a perdite se l'impostazione di URL aumenta. Vorrei scrivere in questo modo:

function GetService(const Addr: string): IInvokable; 
begin 
    Result := THTTPRIO.Create(nil); 
    (Result as IRIOAccess).RIO.URL := Addr; 
end; 

Detto tutto questo, la classe THTTPRIO non supporta IInvokable quindi forse il codice attuale è leggermente diverso.