Wrapper für SOAP Aufrufe gesucht

[Sherlock]

Ich habe da ein kleines "Problem" Ich habe zur Kommunikation mit einem SOAP Server ca. 15 Methoden, die die eigentlichen SOAP-Calls die der Delphi-WSDL Assistent erzeugt aufruft. Da das multithreaded und auch plattformübergreifend gehen muss sehen diese Methoden weitgehend gleich aufgeblasen aus:

Delphi-Quellcode:

function TKommunikation.SendShutDown(aShutDownType: Integer): Boolean;
var
  ServerPort: DevicePortType;  // aus automatisch erzeugten SOAP.pas
begin
  Result := False;
{$IFDEF MSWINDOWS}
  CoInitialize(nil);
{$ENDIF MSWINDOWS}
  ServerPort := GetDevicePortType(False, fConfig.SoapServerAdress);
  if fConnectionOK then
  begin
  // Individuelles von hier
    Result := ServerPort.Shutdown(aShutDownType) = 'Done';
  // bis hier
  end;
{$IFDEF MSWINDOWS}
  CoUninitialize;
{$ENDIF MSWINDOWS}
end;

Es ergeben sich bei den Methoden nur marginale Unterschiede im als Individuell markierten Bereich. Ich habe nach einer langen Woche nur noch Bretter vor dem Kopf und komme nicht darauf, wie ich das 15 fache

Delphi-Quellcode:

var
  ServerPort: DevicePortType;  // aus automatisch erzeugten SOAP.pas
begin
  Result := False;
{$IFDEF MSWINDOWS}
  CoInitialize(nil);
{$ENDIF MSWINDOWS}
  ServerPort := GetDevicePortType(False, fConfig.SoapServerAdress);

nur noch einmal brauche. Ich hatte mich bis eben daran versucht den eigentlichen SOAP-Call als Parameter an eine einzelne Methode zu übergeben, die dann das ganze Brimborium drumherum klatscht. Aber das scheiterte an meinen Gehirnwindungen...bin ich auf dem Holzweg?

Delphi-Quellcode:

function TKommunikation.SOAPComWrapper(aFunc: TFunc<Integer, Boolean>): Boolean;
var
  ServerPort: DevicePortType;  // aus automatisch erzeugten SOAP.pas
begin
  Result := False;
{$IFDEF MSWINDOWS}
  CoInitialize(nil);
{$ENDIF MSWINDOWS}
  ServerPort := GetDevicePortType(False, fConfig.SoapServerAdress);
  if fConnectionOK then
  begin
    Result := aFunc;  // Das mag der Compiler nicht, es fehlen ja Parameter, aber die sollen 
                      // ja mit übergeben werden dachte ich...
  end;
{$IFDEF MSWINDOWS}
  CoUninitialize;
{$ENDIF MSWINDOWS}
end;

Ist das ein falscher Ansatz? Geht es anders leichter oder besser?

Sherlock

[DeddyH]

Wie wäre es mit einer Property vom Typ des Interfaces und Lazy Initialization?

Delphi-Quellcode:

type
  TKommunikation = class
  private
    FServerPort: DevicePortType;
    function GetServerPort: DevicePortType;
  public
    property ServerPort: DevicePortType read GetServerPort;
  end;

function TKommunikation.GetServerPort: DevicePortType;
begin
  if not Assigned(FServerPort) then
    begin
      {$IFDEF MSWINDOWS}
      CoInitialize(nil);
      {$ENDIF MSWINDOWS}
      FServerPort := GetDevicePortType(False, fConfig.SoapServerAdress);
    end;
  Result := FServerPort;
end;

[Fritzew]

Delphi-Quellcode:

function TKommunikation.SOAPComWrapper(aFunc: TFunc<Integer, Boolean>; intparam : integer; boolparam : boolean): Boolean;
var
  ServerPort: DevicePortType; // aus automatisch erzeugten SOAP.pas
begin
  Result := False;
{$IFDEF MSWINDOWS}
  CoInitialize(nil);
{$ENDIF MSWINDOWS}
  ServerPort := GetDevicePortType(False, fConfig.SoapServerAdress);
  if fConnectionOK then
  begin
    Result := aFunc(intparam, boolparam); // Das mag der Compiler nicht, es fehlen ja Parameter, aber die sollen 
                      // ja mit übergeben werden dachte ich...
  end;
{$IFDEF MSWINDOWS}
  CoUninitialize;
{$ENDIF MSWINDOWS}
end;

Das wäre eine Möglichkeit

[Fritzew]

Die andere Möglichkeit :

Delphi-Quellcode:

 TSoapCall = reference to function (): boolean  ;

function TMyClass.SOAPComWrapper(aFunc: TSoapCall): Boolean;
var
  ServerPort: DevicePortType; // aus automatisch erzeugten SOAP.pas
begin
  Result := False;
{$IFDEF MSWINDOWS}
  CoInitialize(nil);
{$ENDIF MSWINDOWS}
  ServerPort := GetDevicePortType(False, fConfig.SoapServerAdress);
  if fConnectionOK then
  begin
    Result := aFunc(); // Das mag der Compiler 
                     
  end;
{$IFDEF MSWINDOWS}
  CoUninitialize;
{$ENDIF MSWINDOWS}
end;

// Aufrufen
if SOAPComWrapper(function() : boolean
   begin
    result := myCall(1, false); // Hie den gewünschten Aufruf
   end

  ) then;

[Sherlock]

Oha! Das werde ich ausprobieren! Aber erst geh ich ins Wochenende
Montag berichte ich dann. Danke für die Hinweise!

Sherlock

[Sherlock]

Jaaa, das geht so nicht ganz. Weil, die gewrappte Methode ja eine Methode des ServerPort ist. Und ServerPort wird erst im Wrapper erzeugt.

Vermutlich lass ich den Code dann halt so aufgepustet...

Sherlock

[HolgerX]

Hmm..

Oder mach es so:

Delphi-Quellcode:

type
  TSOAPFunc = function( ServerPort: DevicePortType):boolean;

function TKommunikation.SOAPComWrapper(aFunc: TSOAPFunc): Boolean;
var
  ServerPort: DevicePortType; // aus automatisch erzeugten SOAP.pas
begin
  Result := False;
{$IFDEF MSWINDOWS}
  CoInitialize(nil);
{$ENDIF MSWINDOWS}
  ServerPort := GetDevicePortType(False, fConfig.SoapServerAdress);
  if fConnectionOK then
  begin
    Result := aFunc(ServerPort); // mit übergeben wird der ServerPort
  end;
{$IFDEF MSWINDOWS}
  CoUninitialize;
{$ENDIF MSWINDOWS}
end;

mit deiner Funtion für z.B. Shutdown:

Delphi-Quellcode:

function ServerShutdown(aServerPort: DevicePortType):boolean;
begin
  Result := aServerPort.Shutdown(aShutDownType) = 'Done';
end;

AUfruf mit:

// Aufrufen
if SOAPComWrapper(ServerShutdown) then ...;

[Mavarik]

Oder Du holst Dir über eine Class-Function ein Interface und setz CoInit und im Destructor der Interface-classe den CoUnInit.

Dann noch eine Procedure mit übergeben und schon hast Du alles was Du brauchst.

Delphi-Quellcode:

Procedure MyWebAufruf;
begin
  SOAP.Call(   // SOAP gibt ein IInterface zurück
    Procedure
      begin
        // Whatever
      end);
end;

Mavarik