Hallo liebe Delphianer,

ich bin so gut wi neu hier, habe Euch durch Stöbern im Internet gefunden und auch schon hier im Forum ein wenig geblättert. Leider programmiere ich noch nicht allzu lange. Ich möchte es aber gerne lernen und da habe ich schon das erste Prorblem, das ich mir nicht erklären kann.

Ich habe diese Unit geschrieben.

zusammenfalten · markieren

Delphi-Quellcode:

unit UByteStream;

interface

uses
  Sysutils, Classes;


type
  PByteStream = ^TByteStream;
  TByteStream = Class(TObject)
  private
    FFile: File Of Byte;
    FFileName: String;
  public
    constructor Create(AFileName: String; Mode: Word);
    destructor Destroy; override;
    function ReadByte: Byte;
    function Read(var Buffer: array of byte; BufSize: Longint): Longint;
    procedure WriteByte(b: Byte);
    function Write(var Buffer: array of byte; BufSize: Longint): Longint;
    function Position: Longint;
    function Size: Longint;
    procedure Seek(APos: Longint; Flag: Word);
  End;


implementation


{ TByteStream }

constructor TByteStream.Create(AFileName: String; Mode: Word);
var IResult: Integer;
begin
  inherited Create;
  System.Assign(FFile, FFileName);
  {$I-}
  if (Mode=fmOpen) or (Mode=fmOpenRead) then
  begin
    System.Reset(FFile);
    IResult := System.IOResult;
    if IResult <> 0 then fail;
  end
  else
  if Mode = fmCreate then
  begin
    System.Rewrite(FFile);
    IResult := IOResult;
    if IResult <> 0 then fail;
  end;
  {$I+}
end;

destructor TByteStream.Destroy;
begin
  System.Close(FFile);
  inherited Done;
end;

function TByteStream.ReadByte: Byte;
var b: Byte;
begin
  System.Read(FFile, b);
  Result := b;
end;

function TByteStream.Read(var Buffer: array of byte; BufSize: Longint): Longint;
var Count,Current,BufStart,BufEnd,BufPos: Word;
begin
  BufStart := Low(Buffer);
  BufEnd := High(Buffer);
  BufPos := BufStart;
  Current := System.FilePos(FFile);
  Count := Current;
  while Count < Current + BufSize do
  begin
    System.Read(FFile, Buffer[BufPos]);
    inc(BufPos);
    inc(Count);
  end;
  Result := Count - Current;
end;

procedure TByteStream.WriteByte(b: Byte);
begin
  System.Write(FFile, b);
end;

function TByteStream.Write(var Buffer: array of byte; BufSize: Longint): Longint;
var Count,Current,BufStart,BufEnd,BufPos: Word; x: array[0..1023] of byte absolute Buffer;
begin
  BufStart := Low(Buffer);
  BufEnd := High(Buffer);
  BufPos := BufStart;
  Current := System.FilePos(FFile);
  Count := Current;
  while Count < Current + BufSize do
  begin
    System.Write(FFile, Buffer[BufPos]);
    inc(BufPos);
    inc(Count);
  end;
  Result := Count - Current;
end;

function TByteStream.Position: Longint;
begin
  Result := System.FilePos(FFile);
end;

function TByteStream.Size: Longint;
begin
  Result := System.FileSize(FFile);
end;

procedure TByteStream.Seek(APos: Longint; Flag: Word);
begin
  case Flag of
    soFromBeginning: System.Seek(FFile, APos);
    soFromCurrentPos: ;
    soFromEnd: ;
  end;
end;

end.

Bei Anwendung dieser Unit erhalte ich aber einen Fehler:

"Datei nicht geöffnet". Warum ist das so?

zusammenfalten · markieren

Delphi-Quellcode:

type
  TReader = class(TObject)
   private
    MeineBytes: TByteStream;
   public
    constructor Create(Filename: String);
    destructor Destroy; override;
    procedure ReadBytes;
  end;

implementation

constructor Create(Filename: String);
begin
  inherited Create;
  MeineBytes := TByteFile.Create(FileName, fmOpen);
end;

destructor Destroy;
begin
  MeineBytes.Free;
  inherited Destroy;
end;

procedure ReadBytes;
begin
  //hier sollten die Bytes aus der Datei nun gelesen werden
  //Aber die Datei ist nicht geöffnet
end;

end.

Entweder ich bin betriebsblind und habe was entscheidendes übersehen oder eine Datei kann in einer Klasse nicht geöffnet werden.

Wenn letzteres zutrifft, warum ist das so. Ich möchte die Zusammenhänge gerne verstehen.

Wer kann mir helfen?

AFileName wird übergeben aber nichts damit gemacht, stattdessen wird FFilename benutzt, das nirgends gesetzt wurde.

markieren

Delphi-Quellcode:

constructor TByteStream.Create(AFileName: String; Mode: Word);
var IResult: Integer;
begin
   inherited Create;
   System.Assign(FFile, FFileName);

Da ein Klassentyp eine Referenz( Zeiger-)typ ist, wird kein Zeigertyp benötigt
PByteStream = ^TByteStream;
Die Angabe der Superklasse TObject kann enfallen
TByteStream = Class(TObject) da beim Weglasen automatisch von TObject geerbt wird.

Ich würde hier aber direkt von TStream ableiten

Hallo,

danke erst mal für Eure wirklich schnellen Antworten.

@baumina:
Habe das geändert und jetzt wird die Datei geöffnet.

@mkinzler:

Ich werde in Zukunft auch von TStream ableiten. Aber vorher schau ich mir den Quelltext (Turbo Delphi) von TStream an. Da gibt es bereits jetzt jede Menge Fragen. Ich glaub, ich schau mir das in aller Ruhe erst mal an. Was ich bis jetzt gesehen habe, ist, das das Stream Objekt auch aus einer gewöhnlichen Datei liest. Bleibt die Frage, wie Objekte gelesen und geschrieben werden. Da werd ich wohl noch einige Zeit brauchen, um das zu verstehen. Will mich erst mal damit beschäftigen.

Mal so als Frage unter uns Kegelschwestern

Was unterscheidet deine Klasse jetzt von einem TFileStream?
(Abgesehen davon, dass TFileStream von TStream abgeleitet ist)

Oder was erwartest du von deiner Klasse, was nicht mit TFileStream erledigt werden könnte?

Oder ganz ketzerisch gefragt, was denkst du, was jemand erwartet, wenn er TByteStream liest?
Einen Stream wo Bytes drin sind? (das mit dem Dateinamen würde mich aber schon wieder überraschen - warum dann nicht TFileByteStream ?)

Ja was ist denn dann in einem TStream?
(auf jeden Fall keine Hasenköttel - ich dachte immer, da sind Bytes drin)

@Sir Rufo
vielleicht wollte er einfach mal üben?
"learning by doing"

Gruß
K-H