Suche die TByteBuffer Klasse aus SysUtils ab XE 3 (?)

[jaenicke]

Einen TByteBuffer mit der Methode AddBytes gibt es weder irgendwo im Internet zu finden noch im Delphi Quelltext, das muss etwas eigenes sein.

Zudem sollte eine Schnittstellenbeschreibung eigentlich auf unterer Ebene passieren. Wenn ich das richtig verstehe, ist das nur ein Beispiel, oder? Dann kannst du das auch ohne diese Klasse machen. Einfacher ist es sicherlich, wenn du diese bekommst.

[ASM]

Eine Klasse TByteBuffer gab es schon: wurde 2010 innerhalb einer von Mike Heydon entwickelten und hier veröffentlichten Unit vorgestellt:

Delphi-Quellcode:

Type
  TByteBuffer = class(TObject) 
  strict private type 
    PByteArray = ^TByteArray; 
    TByteArray = array [0..0] of byte; 
  strict private 
    FBufLen : integer; 
    FBuffer : PByteArray; 
    function GetFAddress : pointer; 
    function GetFValue(AIndex : integer) : byte; 
    procedure SetFValue(AIndex : integer; AValue : byte); 
  public 
    constructor Create(ABufferSize : integer); 
    destructor Destroy; override; 
    procedure Assign(ABufferPointer : pointer); 
    procedure FillBytes(AValue : byte); 
    // Properties 
    property Address : pointer read GetFAddress; 
    property BufferSize : integer read FBufLen; 
    property Value[AIndex : integer] : byte read GetFValue write SetFValue; 
  end;

Kommentar des Autors (M.Heydon) in der Unit:
TByteBuffer - Creates a a simple static byte array buffer that can be used as pointers to API calls or I/O functions. The Delphi dynamic "TBytes : array of byte" does not always react in the way you think when passing it as a buffer to API or I/O calls.
TByteBuffer uses GetMem and FreeMem as opposed to SetLength(arr,x) and thus passes a TRUE pointer to the actual data. TBytes will sometimes act as a pointer to a pointer to the data.

Allerdings ist in seiner Klasse keine Methode AddBytes() deklariert. Zudem wird der Puffer in der Instanz von TByteBuffer als statisches Array angelegt. Jedoch ohne größeres Problem lässt sich die Klasse derart abändern und erweitern (cf. Methode AddBytes()), dass man eine dynamische Pufferverwaltung erreicht (was ja für ein AddBytes() zwingend erforderlich ist), ohne die im o.g. Kommmentar des Autors formulierten, besonderen Ziele zu verlieren.

Leider aber ist www.delphi3000.com (bereits spätestens seit 2012) nicht mehr im INet vorhanden. Insoweit die (ursprüngliche) Implementierung genau dieser Klasse TByteBuffer zur weiteren Modifizierung von Interesse wäre, könnte ich sie zur Verfügung stellen.

[Blup]

Einfach durch TMemoryStream ersetzen (ungetestet):

Delphi-Quellcode:

function SendRequest(var AData: string): boolean;
var
  len: integer;
  bytes: TBytes;
  temp_buffer: TByteArray;
  buffer: TMemoryStream;
begin
  Result := false;

  if AData <> '' then
  begin
    // FClient = ScktComp.TClientSocket;
    if FClient.Active then
    begin
      len := Length(AData);

      SetLength(bytes,Length(AData));

      bytes := BytesOf(AData);

      if FClient.Socket.SendBuf(bytes[0],Length(bytes)) = len then
      begin
        buffer := TMemoryStream.Create;

        try
          if not WaitForResponse(FClient.Socket,1) then
          begin
            len := FClient.Socket.ReceiveLength;

            // Nutzdaten übernehmen und zurückgeben
            if not WaitForResponse(FClient.Socket,len) then
            begin
              ZeroMemory(@temp_buffer,SizeOf(temp_buffer));

              AData := '';

              repeat
                len := FClient.Socket.ReceiveLength;

                if FClient.Socket.ReceiveBuf(temp_buffer,len) > 0 then
                begin
                  buffer.WriteBuffer(temp_buffer[0],len);
                  ZeroMemory(@temp_buffer,SizeOf(temp_buffer));
                  Delay(1);
                end;
              until (len = 0);

              ZeroMemory(@bytes,SizeOf(bytes));
              SetLength(bytes,buffer.Size);
              CopyMemory(@bytes[0],buffer.Memory,buffer.Size);
              AData := AData + TEncoding.Unicode.GetString(bytes);

              if AData <> '' then
              begin
                // In AData steht die Antwort
                Result := true;
              end;
            end;
          end;
        finally
          buffer.Free;
          Screen.Cursor := crDefault;
        end;
      end;
    end;
  end;
end;

[himitsu]

Zitat:

Delphi-Quellcode:

SetLength(bytes,Length(AData));
bytes := BytesOf(AData);

Das SetLength ist sinnlos, da BytesOf ein "vollständiges" dynamisches Array zurückgibt und damit das reservierte Array (der Speicher) von SetLength somit wieder freigegeben.

Beim TMemoryStream oder TBytesStream kann man auch direkt auf den Speicher zugreifen, weswegen man da eigentlich den temp_buffer weglassen könnte.

Delphi-Quellcode:

DataStream.Size := StreamLength;
StreamPosition  := 0;
//Received := Client.ReceiveBuf(DataStream.Memory^, StreamLength);  // ReceiveBuf wartet nicht bis alles eingetroffen ist, sondern bricht am Ende der Datenpackete ab.
while StreamPosition < StreamLength do begin
  Received := Client.ReceiveBuf(PByte(DataStream.Memory)[StreamPosition], StreamLength - StreamPosition);
  if Received = SOCKET_ERROR then
    Break;
  Inc(StreamPosition, Received);
end;

(aus http://www.delphipraxis.net/176863-b...ml#post1231969)

Statt StreamPosition kann man auch DataStream.Position verwenden, aber ihr wollt nicht wissen wie grauenhaft diesbezüglich der der TMemoryStream implementiert ist,
aber im Normalfall sollte es oftmals nicht groß auffallen.

Delphi-Quellcode:

DataStream.Size := ...;
DataStream.Position := 0;
while DataStream.Position < DataStream.Size do begin
  Received := Client.ReceiveBuf(PByte(DataStream.Memory)[DataStream.Position], DataStream.Size - DataStream.Position);
  if Received = SOCKET_ERROR then
    Break;
  DataStream.Position := DataStream.Position + Received;
end;

[jaenicke]

Zitat von himitsu:

Statt StreamPosition kann man auch DataStream.Position verwenden, aber ihr wollt nicht wissen wie grauenhaft diesbezüglich der der TMemoryStream implementiert ist,
aber im Normalfall sollte es oftmals nicht groß auffallen.

Was meinst du? Das sieht für mich eigentlich gut aus:

Delphi-Quellcode:

function TStream.GetPosition: Int64;
begin
  Result := Seek(0, soCurrent);
end;

function TCustomMemoryStream.Seek(const Offset: Int64; Origin: TSeekOrigin): Int64;
begin
  case Origin of
    soBeginning: FPosition := Offset;
    soCurrent: Inc(FPosition, Offset);
    soEnd: FPosition := FSize + Offset;
  end;
  Result := FPosition;
end;

Sprich für die Abfrage der Position wird die Position mit Inc um 0 erhöht (Seek weiß ja nicht, dass das unnötig ist), und dann die Position direkt zurückgeliefert. Wie sollte das sonst passieren, als auf diesem Standardweg für TStream-Nachfahren?