Stream an DLL übergeben

[sephraina]

Hallo Zusammen,

zuerst einmal bin ich mir nicht sicher ob das Thema im richtigen Forum platziert ist...

Mein Problem ist folgendes:
ein idhttp-client schickt einen Stream an den Server. Dieser zeigt ihn auch bei Aufruf des Arequestinfo.PostStream an.
Nur muss ich diesen aber noch in meine DLL bekommen, da von dort die Weiterverarbeitung läuft.

Meine Frage konkret: wie übergebe ich einen Stream an eine DLL?
(In dem gesendeten Stream ist ein xml-Dokument verpackt.)

Wenn der Client ein Get-Request macht hole ich so die Daten aus der DLL:

Delphi-Quellcode:

procedure TFServer.IdHTTPServer1CommandGet(AContext: TIdContext;
  ARequestInfo: TIdHTTPRequestInfo; AResponseInfo: TIdHTTPResponseInfo);
var s: TMemorystream;
    str : TStringstream;
    df: string;
    p: integer;
    Handle: THandle;
    Anzeigen: TAnzeigen;

begin
    s:= TMemorystream.Create;
    str:= TStringStream.Create;
    p := pos('/',ARequestInfo.URI);
    df := rightstr(ARequestInfo.URI, length(ARequestInfo.URI)-p);
    try
    handle := Loadlibrary(pchar('PServerDLL.dll'));
    if handle <> 0 then
       begin
           //*******************************GET********************************
           if ARequestInfo.Command ='GET'  then
              begin
                   @Anzeigen := GetProcAddress(Handle,PCHAR('DataOutputStr'));
                   if @Anzeigen <> nil then s := Anzeigen(df,xm);       //<<-- funktioniert, liefert ein Stream an den Client zurück mit Inhalt: xml-File welches angefordert wurde
              end
            //*******************************POST**********************************
             else if ARequestInfo.Command ='POST'  then
                  begin
                       showmessage('Post1');
                       //str.LoadFromStream(Arequestinfo.PostStream);
                       //showmessage('pServer: '+str.DataString);

                       @Anzeigen := GetProcAddress(Handle,PCHAR('DataInputStr'));  //<<-- 'DataInputStr' ist die procedure die den Stream in der DLL aufnehmen soll
                       if @Anzeigen <> nil then s := Anzeigen(df,xm);

                  end


       end;
    AResponseInfo.ContentStream := s;   //<<--- Zurück an Server

Hoffe jemand weiss zu helfen..

Update:
(function in der DLL ist: function DataInputStr(c: string; x: IXMLDocument): TMemoryStream; Also in die DLL komme ich, nur wenn ich den Stream-Inhalt abrufe, ist er leer.
Wenn ich das x des Xml-Dokumentes abfrage ist da nur das Dummy-xml drin und nicht das welches der client gesendet hat.

[Photoner]

Ich habe es leider noch nicht verstanden was du da genau vorhast, aber mir fällt folgendes auf:

Du erzeugst den MemoryStream zweimal

s := TMemoryStream.Create; und in der Dll vermutlich noch einmal:

function DataInputStr(c: string; x: IXMLDocument): TMemoryStream; Entweder den Stream als Parameter übergeben und sich auch ums Freigeben kümmern oder die Dll erzeugen lassen und dann nach dem Aufruf freigeben (finde ich nicht so toll).

[Sir Rufo]

Eine Klassen-Instanz tauscht man niemals über die Anwendungsgrenzen hinaus.

Was man austauschen kann ist ein Speicherbereich und bei einem Stream würde sich ja ein Byte-Array anbieten. Das liegt einfach so im Speicher und kann dann problemlos ausgetauscht werden. Ein IStream würde auch funktionieren.

[hoika]

Hallo,
da es sich um eine Xml-Datei handelt,
könntest du sie auch als String übergeben,
den StringStream hast du ja bereits.


Heiko

[frankyboy1974]

Hallo,


ein wenig OT:

Zitat:

Eine Klassen-Instanz tauscht man niemals über die Anwendungsgrenzen hinaus.

@Sir Rufo Was verstehts du unter Klassen-Instanz (=Object???) und seit wann überschreitet man Anwendungsgrenzen wenn man eine DLL dynamisch einbindet?

mfg

frank

[Sir Rufo]

Nun ich verstehe unter einer Klassen-Instanz das, was allgemein üblich als Klassen-Instanz verstanden wird:

Das ist eine Klasse:

Delphi-Quellcode:

type
  TMyClass = class
  end;

Das ist eine Instanz dieser Klasse:

Delphi-Quellcode:

var
  MyClassInstance: TMyClass;
begin
  MyClassInstance := TMyClass.Create; // Instanz erzeugen und die Referenz zu dieser Instanz in der Instanz-Referenz-Variablen ablegen
end;

Seit wann man die Anwendungsgrenzen überschreitet ... lass mich kurz überlegen ... seit schon immer?

Nachlesen kann man das zur Genüge hier im Forum, bei google, bei ...

Das Problem ist einfach, dass der Klassentyp TMyClass , wenn dieser der Anwendung und der DLL bekannt sind, trotzdem beide NICHT gleich sind, denn die DLL hat daraus einen eigenen Typen erstellt und die Anwendung auch. Die heißen gleich, sind aber nicht gleich.

Oder warum, denkst du, muss man sich beim Verwenden der Windows API immer mit diesen Struct und PChar herumschlagen?