Fehler E2250 Es gibt keine überladene Version von GetString ...

[pici]

Hallo liebe Community,

ich habe mich hier angemeldet, weil ich gerade bei einem schweren "Erbe" nicht weiterkomme. Wir haben ein paar Windows-Applikationen in Delphi, welche von einem Freiberufler für uns erstellt wurden. Leider ist der gute Mann plötzlich verstorben. :(

Meine Delphi-Kenntnisse bezeichne ich im Vergleich zu den Profis im Forum hier mit <10%. Eigentlich mache ich Software für Embedded Systems in C, also eine ganz andere Welt. Leider muss ich nun in einem der Projekte eine kleine Änderung machen die an sich kein Problem ist - mein Problem ist, dass sich das Projekt an sich nicht kompilieren lässt und an einem für mich kryptischem Fehler scheitert.

Es geht um diese Funktion hier:

Code:

function TCustomWSocket.SocketRead(Socket: TSocket; Flag: integer): string;
var
  Received, tRecvcount: longint;
  i: integer;
  tmpStr : String;
  tmpFReadBuffer: TReadBuffer;
begin
  Result:= '';
  tRecvcount:=0;
  Received:=0;

  if Received = SOCKET_ERROR then
    begin
      if WSAGetLastError <> WSAEWOULDBLOCK then
        SocketError(WSAGetLastError);
    end
  else
    if Received>0 then begin //05.11.10: Fix bei .SocketRead: bei Länge 0 gab es RangeError beim Zugriff auf Result[1]
      SetLength(Result, Received);
      Result := TEncoding.Default.GetString(FReadBuffer);
      tmpStr := StringOfChar('-', Length(FReadBuffer));
      for i := 1 to Received do
        tmpStr[i] := Char(FReadBuffer[i]);

      Result := tmpStr;

      SetLength(Result, Received);
      //Move(FReadBuffer, &Result[1], Received);
    end;
end;

Sie wirft den Fehler:

Code:

[dcc64 Fehler] WSockets.pas(846): E2250 Es gibt keine überladene Version von 'GetString', die man mit diesen Argumenten aufrufen kann

in der Zeile

Code:

Result := TEncoding.Default.GetString(FReadBuffer);

Die entsprechende Funktion scheint in einer Systembibliothek zu liegen "System.SysUtils", dahin verweist die Deklaration:

Code:

function TEncoding.GetString(const Bytes: TBytes): string;
begin
  Result := GetString(Bytes, 0, Length(Bytes));
end;

Die Definition von "FReadBuffer" im Programm an sich führt zu zwei Stellen:

Code:

    FReadBuffer: TReadBuffer;

sowie in einer "type"-Deklaration

Code:

  TReadBuffer = array[1..READ_BUFFER_SIZE] of byte;

Ich nerve ungerne in einem Forum mit "Anfängerfragen", aber leider brachte mich hier auch eine Stunde Googlen keinen Schritt weiter. Ich würde mich freuen, wenn jemand Licht ins Dunkel bringen könnte ...

Entwicklungsumgebung ist Delphi 10.1 Berlin.

Ich danke im Voraus :)

Marco

[Uwe Raabe]

Wie aus der Deklaration ersichtlich, erwartet GetString ein TBytes, also ein dynamisches Byte-Array. Dagegen ist TReadBuffer ein statisches Byte-Array.

Dein Code lässt sich auf folgendes reduzieren:

Delphi-Quellcode:

function TCustomWSocket.SocketRead(Socket: TSocket; Flag: integer): string;
var
  Received: longint;
  i: integer;
  bytes: TBytes;
begin
  Result:= '';
  Received:=0;

  if Received = SOCKET_ERROR then
    begin
      if WSAGetLastError <> WSAEWOULDBLOCK then
        SocketError(WSAGetLastError);
    end
  else
    if Received>0 then begin //05.11.10: Fix bei .SocketRead: bei Länge 0 gab es RangeError beim Zugriff auf Result[1]
      SetLength(bytes, Received);
      for i := 1 to Received do
        bytes[i-1] := FReadBuffer[i];
      Result := TEncoding.Default.GetString(bytes);
    end;
end;

Ich gehe mal davon aus, dass der eigentliche Receive-Code, der Received und FReadBuffer setzt, bewusst entfernt wurde.

[pici]

Hallo Uwe,

vielen Dank für Deine schnelle und kompetente Antwort. Mit Deiner Version lässt es sich einwandfrei kompilieren ... zum Testen der Funktion muss ich noch einen Aufbau der Umgebung machen.

Die anderen Funktionen habe ich nicht absichtlich entfernt, ich wollte den Beitrag nur nicht durch ellenlangen Code überladen. 8-)

Hier wird FReadBuffer meiner Meinung nach beschrieben:

Code:

RC:= recv(Socket, FReadBuffer, SizeOf(TReadBuffer), 0);

... oder hier passiert auch was damit:

Code:

function TCustomWSocket.SocketReadV2(Socket: TSocket; Flag: integer): String;
var
  Received, tRecvcount: longint;
  i: integer;
  tmpStr : String;
  tmpFReadBuffer: TReadBuffer;
begin
  Result:= '';
  tRecvcount:=0;
  Received:=0;
  //Received:= recv(Socket, FReadBuffer, SizeOf(TReadBuffer), Flag);
  repeat
  begin
    tRecvcount := recv(Socket, tmpFReadBuffer, SizeOf(TReadBuffer), Flag);

    for i := 1 to tRecvcount do
        FReadBuffer[Received + i]  := tmpFReadBuffer[i];

    Received := tRecvcount +   Received;
  end;
  until (tRecvcount <> SOCKET_ERROR);

  if Received = SOCKET_ERROR then
    begin
      if WSAGetLastError <> WSAEWOULDBLOCK then
        SocketError(WSAGetLastError);
    end
  else
    if Received>0 then begin //05.11.10: Fix bei .SocketRead: bei Länge 0 gab es RangeError beim Zugriff auf Result[1]
      SetLength(Result, Received);
      //Result := TEncoding.Default.GetString(FReadBuffer);

      tmpStr := StringOfChar('-', Length(FReadBuffer));
      for i := 1 to Received do
        tmpStr[i] := Char(FReadBuffer[i]);

      //for i := 1 to $ff do
      //     testBuf[i] := i;
      //for i := i to $ff do
      //     testStr[i] := Char(testBuf[i]);

      Result := tmpStr;

      SetLength(Result, Received);
      //Move(FReadBuffer, &Result[1], Received);
    end;
end;

Welchen Sinn macht es denn, das Array als statisches Array zu definieren? Würde das nicht auch funktionieren, wenn es ein dynamisches Array wäre? Nur um den Gedanken des Programmierers zu verstehen ...

[himitsu]

Der Parameter als "OpenArray", also

Delphi-Quellcode:

function GetString(const Bytes: array of Byte): string;

würde alle Arten von Byte-Arrays entgegennehmen, seien es dynamische Arrays, unterschiedlich große statische Arrays oder gar eine direkte Konstante/Variable ala

Delphi-Quellcode:

[1, 2, 3, 4, 5, EineByteVariable, OderEineKonstante, 6, 7, 8]

.

TBytes, so wie es früher mal deklariert war, und wie es im INDY auch immernoch Eines gibt, ala

Delphi-Quellcode:

TBytes = array of byte;

nimmt nur genau diesen Typen entgegen.
Aber

Delphi-Quellcode:

TBytes = TArray<Byte>;

dagegen nimmt alles an, was irgendwie von TArray<Byte> abgeleitet ist. (generische Deklaration verhalten sich da anders, als "normale" Deklarationen)