Come memorizzare e localizzare più tipi di interfaccia all'interno di Delphi TInterfaceList

Question

Sto memorizzando piccole interfacce da un intervallo di oggetti in un unico "negozio" di TInterfaceList con l'intenzione di offrire un elenco di tipi di interfaccia specifici all'utente finale, quindi ogni l'interfaccia esporrà una funzione 'GetName' ma tutti gli altri metodi sono unici per quel tipo di interfaccia. Per esempio qui ci sono due interfacce:

IBase = interface 
    //---------------------------------------- 
    function GetName : string; 
    //---------------------------------------- 
    end; 

    IMeasureTemperature = interface(IBase) 
    //------------------------------------ 
    function MeasureTemperature : double; 
    //---------------------------------------- 
    end; 

    IMeasureHumidity = interface(IBase) 
    //---------------------------------------- 
    function MeasureHumidity: double; 
    //---------------------------------------- 
    end; 

ho messo alcune di queste interfacce in un unico TInterfaceList e poi mi piacerebbe scorrere la lista per un tipo di interfaccia specifica (ad esempio 'IMeasureTemperature') la costruzione di un altro elenco di puntatori agli oggetti che esportano tali interfacce. Non voglio fare supposizioni sulle posizioni di quegli oggetti, alcuni potrebbero esportare più di un tipo di interfaccia. So che potrei fare questo con una gerarchia di classi con qualcosa di simile:

If FList[I] is TMeasureTemperature then .. 

ma mi piacerebbe fare qualcosa simliar con un tipo di interfaccia, è possibile?

Answer 1

Immagino che potrebbe soddisfare le vostre esigenze.

function InterfaceRefIsInterface(Intf : IUnknown; ExpectedIntf : TGUID) : Boolean; 
var vReference : IUnknown; 
begin 
    if Supports(Intf, ExpectedIntf, vReference) then 
    Result := Intf = vReference 
    else 
    Result := False; 
end; 

io non sono sicuro di come la funzione si comporterà quando INTF e ExpectedIntf eredita gli uni dagli altri, ma questo restituisce true nel caso INTF è una corrispondenza esatta di ExpectedIntf.

Nell'esempio, IMeasureHumidity non restituirà true su IMeasureTemperature, ma non sono sicuro di come reagirà a IBase. Secondo i test preliminari, restituirà anche FALSE su IBase.

Answer 2

Proprio utilizzo di supporti, in questo modo:

var 
    oMTIntf: IMeasureTemperature; 
... 
    If Supports(FList[I], IMeasureTemperature, oMTIntf) then .. 

Answer 3

è possibile utilizzare la funzione di Supports in SysUtils, sono abbastanza sicuro (a meno che non li provi sulla memoria non inizializzate) e avete solo bisogno di una variabile di destinazione del esatto tipo di interfaccia si tenta di trasmettere a:

procedure DoSomethingInList(AList: IInterfaceList;); 
var 
    i: Integer; 
    liItem: IInterface; 
    liMeasureTemp: IMeasureTemperature; 
    liMeasureHumi: IMeasureHumidity; 
begin 
    AList.Lock; 
    try 
    for i := 0 to AList.Count - 1 do 
    begin 
     liItem := AList[i]; 
     if Supports(liItem, IMeasureTemperature, liMeasureTemp) then 
     //... liMeasureTemp.MeasureTemperature ... 
     else if Supports(liItem, IMeasureHumidity, liMeasureHumi) then 
     //... liMeasureHumi.MeasureHumidity ... 
     else 
     //... 
    end; 
    finally 
    AList.Unlock; 
    end; 
end;