Dynamisches Array von DLL übergeben

[Eichhoernchen]

Zitat von DJ-SPM:

hm...

oder ich muss den schritt halt aufteilen: Die Funktion gibt mir lange Strings zurück, die ich in der Hauptanwendung in diese dann dort in Array packe. Finde ich zwar nicht so schön, aber so solls halt erstmal sein.

Danke euch.

Aber wenn's noch Vorschläge gibt, nehm ich sie gerne an!

Würde das nicht irgendwie dem Sinn der DLL widersprechen?

Ich meine du zerteilst erst etwas mit deiner Explode Funktion und dann bastelst du wieder einen String, den man um ihn in ein Array zu packen wieder mit einer Explode-artigen Funktion bearbeiten muss um das Ergebnis in ein Array zu speichern. Hört sich für mich Sinnlos an.

Kannst du nicht vielleicht einen Pointer übergeben, der auf eine Speicheradresse mit dem Array zeigt? Aber das würde wahrscheinlich nur bei konstanter Größe gehen richtig?

[TheMiller]

Pointer sind schon der richtige Weg - denke ich.

Mein Problem ist folgendes. Ich möchte einen Datensatz aus einer DB per PHP laden. Da habe ich dann verschiedene Felder (klar -> ist ja eine DB) diese Felder bzw. deren Werte sind durch einen Separator getrennt. Das Ende des Datensatzes hat einen anderen Separator. Jetzt möchte ich alle Datensätze in ein Record speichern.

Dazu muss ich doch erst die Werte zurückgeben lassen (die "Sep1" getrennt) und das Ende eines Datensatzes finden ("Sep2"). Jetzt muss ich erst nach Sep2 exploden und diese in ein Array speichern, sodass ich auf die einzelnen Datensätze zugreifen kann. Dann kann ich mich an die Werte machen ("Sep1") und kann diese Daten dann schön in mein Array speichern.

Soweit mein Vorhaben *g*

[gmc616]

Mit Pointer funktioniert das so nicht!

Das Arbeiten mit dynamischen Arrays zwischen DLL und Applikation ist, wie ich schmerzlich lernen mußte, nicht ohne weiteres möglich. Besonders dann nicht, wenn du ohne Speichermanager arbeiten willst.

Ich habe mir für diesen Fall eine "Krücke" gebastelt, in dem ich das Array in der DLL verwalten lasse und mir Export-Funktionen gebaut habe, die mir u.a. die Länge des DLL-Arrays zurück geben. Die einzelnen Array-Elemente lasse ich mir mit einer weiteren Export-Funktion(Index)Char zurück geben. Hierbei muss ich nur dafür sorgen, das ausreichend Speicher reserviert wird, sonst bekommt man nur ein Teil des String wieder zurück.

Quasi überträgt man nicht das Array komplett, sondern nur die einzelnen Elemente des Arrays.

Wenn du auf Applikationsseite die einzelen Elemente wieder in ein Array speicherst, dagegen spricht nix. Es ist halt nur nicht möglich das Array komplett per Parameter wieder zurück zubekommen. Zumindest nicht ohne Speichermanager.

Sorry, mit Beispielcode kann ich dir augenblicklich nicht dienen.

[Muetze1]

Frage an gmc616: Warum gibt die DLL nicht einfach zurück, wieviele Einträge es in dem Array gibt und eine weitere Funktion gibt die Adresse des ersten Eintrags an. Dies würde der Applikation doch schon reichen, schliesslich sind alle Arrays im Speicher fortlaufend und somit kann sie sich mit einem grossen CopyMemory() oder Move() Befehl den kompletten Array Inhalt kopieren ohne über jedes einzelne Element zu laufen.

[gmc616]

Hallo Muetze1,

Das habe ich schon probiert.

Ich lade meine DLL dynamisch. Das Kopieren per CopyMemory funktioniert auch ohne Probleme.
Wenn Ich allerdings die DLL mit FreeLibrary wieder entlade, bekomme ich eine Schutzverletzung bei Schreiben(!) an Adresse xy.

Vlt. liegt es daran, dass ich mit Array of Records arbeite. Vlt. muß ich auch irdendwo wieder Speicher freigeben, wüsste aber nicht welchen.
Oder es liegt daran, das es ohne Speichermanager einfach nicht funktioniert.

Ich weiß es nicht. Daher die Krücke.

Es wäre allerdings ne feine Sache, wenn das so einfach mit CopyMemory funktioniert täte / tun würde.

gmc

[Wormid]

Bekomme ich hier was nicht mit?

Man kann doch dynamische Arrays aus einer DLL zurückgeben...

Delphi-Quellcode:

library xyz;

uses
  ...

type
  TTestArray = array of ShortString;

function GetTestArray: TTestArray; stdcall;
begin
  SetLength(Result, 3);
  Result[0] := 'Hallo';
  Result[1] := 'Welt';
  Result[2] := '!';
end;

exports
  GetTestArray;

end.

Delphi-Quellcode:

program test_xyz;

interface

type
  TTestArray = array of ShortString;

...
  var GetTestArray: function: TTestArray; stdcall;

implementation

procedure TestItOut;
var
  a: TTestArray;
  i: Integer;
  hDLL: THandle;
begin
  hDLL := LoadLibrary('xyz.dll');
  if hDLL <> 0 then
  begin
    GetTestArray := GetProcAddress(hDLL, 'GetTestArray');
    if GetTestArray <> nil then
    begin
      a := GetTestArray;
      ShowMessage(IntToStr(Length(a)));  // Eine schicke "3" erscheint als Meldung
      for i := Low(a) to High(a) do
        ShowMessage(a[i]);  // Hallo *click* Welt *click* ! *click*
      SetLength(a, 0);
      GetTestArray := nil;
    end;
    FreeLibrary(hDLL);
  end;
end;

*Edit: "Testprogramm" um dynamisches Einbinden der Funktion erweitert

[Muetze1]

Zitat von Wormid:

Bekomme ich hier was nicht mit?

Man kann doch dynamische Arrays aus einer DLL zurückgeben...

Nur wenn du ShareMem oder FastMM in beiden Projekten einbindest. (beides als erste Unit in beiden Projekten). Und genau diesen Fakt will er ja vermeiden.

Zitat von gmc616:

Wenn Ich allerdings die DLL mit FreeLibrary wieder entlade, bekomme ich eine Schutzverletzung bei Schreiben(!) an Adresse xy.

Vlt. liegt es daran, dass ich mit Array of Records arbeite. Vlt. muß ich auch irdendwo wieder Speicher freigeben, wüsste aber nicht welchen.

Da das Array kopiert wird, sollte es keine Probleme geben. Es kann aber Probleme geben, wenn die Funktion der DLL so deklariert ist, das gesamte Array zurück zu geben anstatt einen Zeiger auf den Record (welcher dann mit der Adresse des ersten Records befüllt wird beim Aufruf).

Ansonsten Speicher des Array freigeben? Naja, SetLength(Array, 0); - aber eigentlich nicht unbedingt von nöten.

Ich werde die Tage selber mal ein Beispielprojekt dazu aufbauen und das ganze nochmal im Detail versuchen nach zu vollziehen.

[TheMiller]

Hm...

hab mir dazu nochmal gedanken gemacht und getestet (hab mit Pointern noch nie was gemacht - lerne aber gerne dazu) und einiges rumprobiert.

hab zum Testen die Funktion myArray, die mir den zeiger zurückgeben soll. Eine weitere Funktion empfängt einen Zeiger und weist dementsprechend den Wert aus. Mein Programm fragt also nach einem Zeiger, empfängt ihn, sendet ihn an Funktion 2 und empfängt den String. Vom Prinzip her garnicht mal so übel (hoffe ich).

Doch ich denke, mein erster Fehler liegt schon in der ersten Funktion, da ich nicht weiß, welchen Rückgabewert ich benutzen muss. Ich denke, da Integer und Pointer so ziemlich gleich sind, kann ich den Pointer in einen Integer packen, gibt aber bei der Rückgabe im Programm nur Schrott aus. Weis nicht, wie ich auf einen Pointer zugreifen kann, um dessen Wert zu bekommen.:

Delphi-Quellcode:

function myArray: integer;
var
  testarr: array of byte;
  zeiger: ^integer;
begin
  SetLength(testarr, 2);
  randomize;
  testarr[0]:=random(9999);
  testarr[1]:=32;
  zeiger:=@testarr[0];
  result:=Integer(zeiger);
end;

Danke nochmal!

[himitsu]

Da die Array-Variable selber ein Pointer ist, kannst du auch direkt casten:
('s kommt aber darauf an, wie du es drüben verwenden willst)

Delphi-Quellcode:

function myArray: integer; 
var 
  testarr: array of byte; 
begin 
  SetLength(testarr, 2); 
  randomize; 
  testarr[0]:=random(9999); 
  testarr[1]:=32; 
  result:=Integer(testarr); 
end;

oder etwas schöner ... du gibst ja einen Zeiger zurück

Delphi-Quellcode:

function myArray: pointer; 
var 
  testarr: array of byte; 
begin 
  SetLength(testarr, 2); 
  randomize; 
  testarr[0]:=random(9999); 
  testarr[1]:=32; 
  result:=pointer(testarr); 
end;

und zurück dann z.B. so:
type Ttestarr = array of byte;

Ttestarr(myArray)

PS: randomize; nicht ständig aufrufen!

PSS:
SetLength(Arr, 0);
dat is schneller, da es direkt ClearArray aufruft ._.
Arr := nil;