Wieder generische Functions results

[QuickAndDirty]

Ich versuche sowas

Delphi-Quellcode:

class Function TWSClient.GetClient<T>(Addr: string):T
var RIO: THTTPRIO;
begin
  //Result := nil;// Das geht schonmal nicht aber ok
  RIO := GetLocalRio;
  try
    Result := (RIO as T);//[dcc32 Fehler] E2015 Operator ist auf diesen Operandentyp nicht anwendbar
    RIO.URL := Addr;
  finally
   // if (Result = nil) then // Das geht dann natürlich auch nicht
   //   RIO.Free;
  end;
End;

wie geht das?

[Neutral General]

Du kannst/musst angeben von welchem Typ "T" sein muss.
Du kannst da z.B. "class" verwenden oder einen Basistypen:

Delphi-Quellcode:

class Function GetClient<T: class>(Addr: string):T;
// oder
class Function GetClient<T: THTTPRIO>(Addr: string):T;

[mkinzler]

Das der Cast nach T funktionieren kann, müssen bestimmte Informationen über T vorliegen.

Haben die Typen einen gemeinsamen Vorfahr?

[QuickAndDirty]

Zitat:

Zitat von Neutral General (Beitrag 1432208)

Du kannst/musst angeben von welchem Typ "T" sein muss.
Du kannst da z.B. "class" verwenden oder einen Basistypen:

Delphi-Quellcode:

class Function GetClient<T: class>(Addr: string):T;
// oder
class Function GetClient<T: THTTPRIO>(Addr: string):T;

T soll IInvocable sein...also ein Interface typ

[QuickAndDirty]

Zitat:

Zitat von mkinzler (Beitrag 1432209)

Das der Cast nach T funktionieren kann, müssen bestimmte Informationen über T vorliegen.

Haben die Typen einen gemeinsamen Vorfahr?

Ja der gemeinsame Vorfahre von T ist IInvocable.

[QuickAndDirty]

in der Classe

Delphi-Quellcode:

interface
...
Type
....

Class Function GetClient<T: IInvokable>(Addr: string):T;

Delphi-Quellcode:

implementation
...
Class Function TWSClient.GetClient<T>(Addr: string):T;//Hier darf man nicht <T:IInvokable> schreiben...
var RIO: THTTPRIO;
begin
  //Result := nil;
  RIO := GetLocalRio;
  try
    Result := (RIO as T);//[dcc32 Fehler] E2015 Operator ist auf diesen Operandentyp nicht anwendbar
    RIO.URL := Addr;
  finally
    //if (Result = nil) then // Das geht dann natürlich auch nicht
    //  RIO.Free;
  end;
End;

meldet immer noch das selbe

Liegt das eventuell an der Referenzzählung? also können evtl. records, strings und interfaces generell keine Generics sein?

[QuickAndDirty]

Das hier compiliert

Delphi-Quellcode:

interface
...
Type
....

Class Function GetClient<T: IInterface>(Addr: string):T;

Delphi-Quellcode:

Class Function TWSClient.GetClient<T>(Addr: string):T;
var RIO: THTTPRIO;
begin
  Result := nil;
  RIO := GetLocalRio;
  try
    //Result := (RIO as T);//[dcc32 Fehler] E2015 Operator ist auf diesen Operandentyp nicht anwendbar
    Result := T(RIO);//Das geht
    RIO.URL := Addr;
  finally
    if (Result = nil) then // Das geht dann natürlich auch nicht
      RIO.Free;
  end;
End;

Wie wirkt sich hardcast vs softcast auf Android, Apple und windows aus wenn man eine Klasse hart in ein Interface castet?
EDIT:
hard Cast arbeitet nicht vernünftig mit der Referenzzählung zusammen...das Objekt ist einfach weg wenn man es so macht... :(

[jaenicke]

Benutze Supports um das Interface auf den richtigen Typ zu casten. Das funktioniert bei uns problemlos, wir machen etwas ähnliches.

// EDIT:
THTTPRIO implementiert doch IInvokable gar nicht.

[QuickAndDirty]

Zitat:

Zitat von jaenicke (Beitrag 1432246)

Benutze Supports um das Interface auf den richtigen Typ zu casten. Das funktioniert bei uns problemlos, wir machen etwas ähnliches.

// EDIT:
THTTPRIO implementiert doch IInvokable gar nicht.

Delphi generiert sowas für webservices

Delphi-Quellcode:

function GetWSClient(UseWSDL: Boolean; Addr: string; HTTPRIO: THTTPRIO): IWSClient;
const
  defWSDL = 'C:\IWSClient.xml';
  defURL  = 'http://localhost:80/soap/IWSClient';
  defSvc  = 'IWSClient';
  defPrt  = 'IWSClient_Port';
var
  RIO: THTTPRIO;
begin
  Result := nil;
  if (Addr = '') then
  begin
    if UseWSDL then
      Addr := defWSDL
    else
      Addr := defURL;
  end;
  if HTTPRIO = nil then
    RIO := THTTPRIO.Create(nil)
  else
    RIO := HTTPRIO;
  try
    Result := (RIO as IWSClient);
    if UseWSDL then
    begin
      RIO.WSDLLocation := Addr;
      RIO.Service := defSvc;
      RIO.Port := defPrt;
    end else
      RIO.URL := Addr;
  finally
    if (Result = nil) and (HTTPRIO = nil) then
      RIO.Free;
  end;
end;

Ich habe nur alles entfernt was ich nicht brauche und das interface durch <T> ersetzt
die Interfaces aus der generierten datei sind von IInvokable abgeleitet ...allerdings scheint das auch nur ein Alias für IInterface zu sein....

Ich versuche es mal mit supports und gebe feedback.

[QuickAndDirty]

Delphi-Quellcode:

//  deklaration
Class Function GetClient<T:IInterface>(Addr: string):T;

Das hier lässt sich nicht kompilieren :(

Delphi-Quellcode:

Class Function TWSClient.GetClient<T>(Addr: string):T;
var RIO: THTTPRIO;
begin
  Result := nil;
  RIO := GetLocalRio;
  try
    //Result := (RIO as T);//[dcc32 Fehler] E2015 Operator ist auf diesen Operandentyp nicht anwendbar
    //Result := T(RIO);//Das geht Aber es produziert zugriffsverletzungen... dank Refcount;
    if Supports(RIO,T,Result) then//[dcc32 Fehler] E2250 Es gibt keine überladene Version von 'Supports', die man mit diesen Argumenten aufrufen kann
      RIO.URL := Addr
    else
      Result := nil;
  finally
    if (Result = nil) then
      RIO.Free;
  end;
End;

[QuickAndDirty]

OK ich habs!
Kann man das irgendwie ohne RTTI hinbekommen?

Delphi-Quellcode:

Class Function TWSClient.GetClient<T>(Addr: string):T;
var RIO: THTTPRIO;
    aGuid:TGuid;
begin
  Result := nil;
  RIO := GetLocalRio;
  try
    //Result := (RIO as T);//[dcc32 Fehler] E2015 Operator ist auf diesen Operandentyp nicht anwendbar

    //Result := T(RIO);//Das geht Aber es produziert zugriffsverletzungen... dank Refcount;

    aGuid := TRttiInterfaceType(TRttiContext.Create.GetType(TypeInfo(T))).GUID ;

    if not Supports(RIO,aGuid,Result) then
      Result := nil;

    RIO.URL := Addr

  finally
    if (Result = nil) then
      RIO.Free;
  end;
End;

[Neutral General]

So kompilierts:

Edit: Oh du hast auch grad gepostet..
Ohne RTTI fällt mir auch keine Lösung ein...

Ist auch RTTI aber mit weniger overhead vielleicht?

Delphi-Quellcode:

uses
  TypInfo;

guid := PTypeInfo(TypeInfo(T))^.TypeData^.GUID;

Delphi-Quellcode:

uses
  System.RTTI;

class function TForm3.GetClient<T>(Addr: string): T;
var RIO: THTTPRIO;
    rtti: TRttiContext;
    intfType: TRttiInterfaceType;
begin
  Result := nil;
  RIO := nil;
  try
    rtti := TRttiContext.Create;
    try
      intfType := rtti.GetType(TypeInfo(T)) as TRttiInterfaceType;
      if Supports(RIO, intfType.GUID, Result) then
        RIO.URL := Addr
      else
        Result := nil;
    finally
      rtti.Free;
    end;
  finally
    if (Result = nil) then
      RIO.Free;
  end;
end;

[QuickAndDirty]

Ich fürchte einfach das die unit Typinfo irgendwann weg ist....
Aber danke für deine Lösung, das verschafft mir doch nochmal ein sicheres Gefühl das der Ansatz nicht zu unorthodox ist.

[Stevie]

Ich mag ja Generics aber das hier erscheint nen bisschen unnötig.

Warum nicht einfach:

Delphi-Quellcode:

function GetClient(Addr: string): IInterface;
var 
  RIO: THTTPRIO;
begin
  RIO := GetLocalRio;
  RIO.URL := Addr;
  Result := RIO;
end;

if Supports(GetClient('...'), IBlaBlubb, LBlaBlubb) then

Denn mit deiner Implementierung kommst du auch um einen Check nicht drumherum (obs Result von GetClient<T> assigned ist)

[Neutral General]

Zitat:

Zitat von QuickAndDirty (Beitrag 1432292)

Ich fürchte einfach das die unit Typinfo irgendwann weg ist....
Aber danke für deine Lösung, das verschafft mir doch nochmal ein sicheres Gefühl das der Ansatz nicht zu unorthodox ist.

System.RTTI und die Records/Klassen darin kapseln die System.TypInfo einfach nur.
Solange es die RTTI gibt, wird es auch die Unit TypInfo geben.