hallo

ich mach grad folgendes:

zusammenfalten · markieren

Delphi-Quellcode:

var
  Form1: TForm1;
  Num : Array of byte;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);
var dat : file;
lokal : integer;
begin
AssignFile(dat,'I:\delphi\testContainer\test1.dat');
rewrite(dat);
for lokal:=0 to 127 do Blockwrite(dat,num[0],1);
closefile(dat);
end;

procedure TForm1.FormCreate(Sender: TObject);
var lokal : integer;
begin
SetLength(Num,128);
for lokal:=0 to 127 do begin
num[lokal]:=lokal;
end;
end;

was ich machen will ist klar:

ich will das dynamische array am anfang mit den werten 0 bis 127 füllen, und dann den 1. wert 128 mal abspeichern.


soweit so gut.

klappt auch ohne error.

doch nun will ich nicht immer nur den ersten sondern alle werte abspeichern.

dazu habe ich

for lokal:=0 to 127 do Blockwrite(dat,num[lokal],1); ausprobiert.

doch nun bekomme ich den E/A-Feherl 1784.

was soll den dass?

das array ist lang genug und eigendlich sollte es nix zu meckern geben.

Btw:

bei der 1. variante habe ich gemerkt, dass die datei, welche eigendlich grad mal 128byte groß sein sollte auf 14KB anwächst. nachdem ich mir die sache mit einem Hex-Viewer angeguggt habe stellte ich fest, dass 128byte packete mehrmals hintereinander in die datei geschrieben wurden.

Weis jemand weiter?

gruß snow

Wenn du byteweise schreibst müsste da glaub ich ein "rewrite(dat,1)" stehen

Der ganze übertragene Block belegt höchstens Count * RecSize Bytes. RecSize ist die beim Öffnen der Datei angegebene Blockgröße (oder 128, falls keine Größe angegeben wurde). Da steht aber ein SetLength von 128. Reicht das ?

Rewrite(..., 1); ist per Standard definiert, also wäre es egel,

aber sicher, daß du genau for lokal:=0 to 127 do Blockwrite(dat,num[lokal],1); geschrieben hast
oder steht im Programm etwas anderes?

Du könntest es ja mal so versuchen, auch wenn ich nicht wüßte was dieses ändern sollte

markieren

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var dat : file of byte;
lokal : integer;
begin
  AssignFile(dat,'I:\delphi\testContainer\test1.dat');
  rewrite(dat);
  for lokal:=0 to 127 do Blockwrite(dat,num[lokal],1);
  closefile(dat);
end;

markieren

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var dat : file of byte;
lokal : integer;
begin
  AssignFile(dat,'I:\delphi\testContainer\test1.dat');
  rewrite(dat);
  Blockwrite(dat,num[0],128);
  closefile(dat);
end;

Blos mal aus Interesse: was/wo ist denn da eine sehr große Datei?
(sehr groß fängt für mich so bei GB an)

Zitat von himitsu:

Rewrite(..., 1); ist per Standard definiert, also wäre es egel,

Wie kommst du darauf? Schau mal einen Post über dich!

hab den Post gesehn

var dat : file; da hier keine Größe angegeben ist, wird per Default 1 verwendet.

markieren

Code:

var dat : file of [color=#ff0000]type[/color];

aber hier ist es per Default SizeOf(type)

markieren

Delphi-Quellcode:

type TNum : Array[0..127] of byte;

var dat : file of TNum;

also "nur" so wären es 128

[edit]grad getestet

zusammenfalten · markieren

Delphi-Quellcode:

function GetFileSize: Integer;
var F: File of Byte;
begin
  AssignFile(F, 'test1.dat');
  Reset(F);
    Result := FileSize(F);
  CloseFile(F);
end;

type TTest = array[0..31] of Byte;
  PFileRec = ^TFileRec;

var F1: File;
  F2: TextFile;
  F3: File of TTest;
  F4: File of Byte;
  F5: File;
  i, i1, i2, i3, i4, i5: Integer;
  l1a, l3a, l4a, l5a: Integer;
  l1b, l4b, l5b: Integer;
  Num: Array of Byte;

begin
  SetLength(Num, 32);

  //AssignFile(F1, 'test1.dat');
  //Rewrite(F1);
  // i1 := PFileRec(@F1)^.RecSize;
  //CloseFile(F1);
  AssignFile(F1, 'test1.dat');
  Rewrite(F1);
    i1 := PFileRec(@F1)^.RecSize;
    Blockwrite(F1, num[0], 1{32? o.O});
  CloseFile(F1);
  l1a := GetFileSize;
  Rewrite(F1);
    for i := 0 to 31 do
      Blockwrite(F1, num[i], 1);
  CloseFile(F1);
  l1b := GetFileSize;

  //AssignFile(F2, 'test1.dat');
  //Rewrite(F2);
  // i2 := PTextRec(@F2)^.RecSize;
  //CloseFile(F2);
  AssignFile(F2, 'test1.dat');
  Rewrite(F2);
    i2 := PFileRec(@F2)^.RecSize; //i2 := PTextRec(@F2)^.RecSize;
  CloseFile(F2);

  //AssignFile(F3, 'test1.dat');
  //Rewrite(F3);
  // i3 := PFileRec(@F3)^.RecSize;
  //CloseFile(F3);
  AssignFile(F3, 'test1.dat');
  Rewrite(F3);
    i3 := PFileRec(@F3)^.RecSize;
    Blockwrite(F3, num[0], 1{1*TTest});
  CloseFile(F3);
  l3a := GetFileSize;

  //AssignFile(F4, 'test1.dat');
  //Rewrite(F4);
  // i4 := PFileRec(@F4)^.RecSize;
  //CloseFile(F4);
  AssignFile(F4, 'test1.dat');
  Rewrite(F4);
    i4 := PFileRec(@F4)^.RecSize;
    Blockwrite(F4, num[0], 32);
  CloseFile(F4);
  l4a := GetFileSize;
  Rewrite(F4);
    for i := 0 to 31 do
      Blockwrite(F4, num[i], 1);
  CloseFile(F4);
  l4b := GetFileSize;

  //AssignFile(F5, 'test1.dat');
  //Rewrite(F5);
  // i5 := PFileRec(@F5)^.RecSize;
  //CloseFile(F5);
  AssignFile(F5, 'test1.dat');
  Rewrite(F5, 1);
    i5 := PFileRec(@F5)^.RecSize;
    Blockwrite(F5, num[0], 32);
  CloseFile(F5);
  l5a := GetFileSize;
  Rewrite(F5, 1);
    for i := 0 to 31 do
      Blockwrite(F5, num[i], 1);
  CloseFile(F5);
  l5b := GetFileSize;

  Application.MessageBox(PChar(Format(
      'F1: File = %d > %d %d'#13#10
    + 'F2: TextFile = %d > - -'#13#10
    + 'F3: File of TTest = %d > %d -'#13#10
    + 'F4: File of Byte = %d > %d %d'#13#10
    + 'F5: File(1) = %d > %d %d', [i1, l1a,
    l1b, i2, i3, l3a, i4, l4a, l4b, i5, l5a, l5b])), '');
end;

Zitat von Ergebnis:

---------------------------

---------------------------
F1: File * * * * * * * = 128 > 128 4096
F2: TextFile * * * *= 128 > * * - * * * *-
F3: File of TTest = * 32 > * 32 * * * -
F4: File of Byte * = * * 1 > * 32 * * 32
F5: File(1) * * * * * = * * 1 > * 32 * * 32
---------------------------
OK
---------------------------

Variante = RecSize > Size_1x32 Size_32x1

aber, egal wie es da aussieht, sollte doch BlockWrite dennoch nur das schreiben, was man angegeben hat?
(kein Wunder daß ich da lieber mit der WinAPI arbeite)
nja, mal wieder eines der Probleme an den alten Pascal-Funktionen.
PS: es wird wohl nicht ohne Grund von "allen" empfohlen diese nicht mehr zu verwenden.
(viele empfehlen TFileStream und andere wenden sich direkt an Windows)

Aber meine Vermutung/Erklärung warum es 128 sind:
es liegt nicht an dem 128 Byte großem Array, dann davon weiß AssignFile definitiv überhaupt nichts.
die 128 kommen wohl daher, daß Delphi File indirekt wie TextFile mit einem Puffer ausstattet ist, welcher nunmal "rein zufällig" eine Größe von 128 Byte hat.
TTextBuf = array[0..127] of Char; (drum hab ich bei obrigem Code/Test 32 Byte und nicht 128 verwendet, damit man den Unterschied sieht)

hab's aber grad selber nochma in der OH gefunden

Zitat von OH:

Hinweis:
Wenn die Datei untypisiert deklariert ist und Sie beim Aufrufen von Reset keine Datenblockgröße angeben, nimmt FileSize eine Größe von 128 Bytes an. FileSize gibt also die Anzahl der Bytes geteilt durch 128 zurück.

ich würde dieses Verhalten ganz einfach als Fehler in Delphi ansehn, da hier 1 logischer gewesen wäre.

Der Fehler muss woanders liegen, denn das hier funktioniert:

zusammenfalten · markieren

Delphi-Quellcode:

Var
  dat: File;
  lokal: integer;
  Num : Array of byte;

Begin
  AssignFile(dat, 'C:\test1.dat');
  rewrite(dat);
  SEtLength (Num,128);
  For lokal := 0 To 127 Do
    Blockwrite(dat, num[lokal], 1);
  closefile(dat);
End;

Zitat von himitsu:

ich würde dieses Verhalten ganz einfach als Fehler in Delphi ansehn, da hier 1 logischer gewesen wäre.

Es ist nicht gleich ein Fehler in Delphi, nur weil Du es als unlogisch ansiehst. Das BlockWrite ist älter als Du. Die 128 standen schon in der ersten Pascalversion, mit der ich gearbeitet habe (UCSD Pascal 1.0). Ob das in der Wirth'schen DEfinition auch schon enthalten ist, weiss ich nicht.
Soweit ich das beurteilen kann, stammen die 128 Bytes von der Sektorgröße damaliger Speicher (Tontafeln oder ? ). Das waren nun mal 'Blöcke' und mit diesem Superbefehl konnte man direkt auf die Tontafeln a.k.a. Floppies/Bänder schreiben! Also *hardwarenah* und supersauschnell!

Ich glaube, der Fragesteller hat uns noch nicht Alles verraten.

@snow: Reduziere dein Projekt mal auf die relevanten und fehlerhaften Zeilen und stelle es hier rein.

Das BlockWrite, AssignFile und Co. sowas von uralt sind, seh ich schon ein
und nicht die 128 Byte "Cache" hab ich als Fehler angesehn,
sondern die tatsache daß bei Nichtangabe einer Größe diese 128 genommen werden.

Wenn nichts angegeben wird und Delphi oder damals Pascal dann eine 1 nehmen würden, dann würden solche Fehler hier nicht auftreten.

Zitat von alzaimar:

Der Fehler muss woanders liegen, denn das hier funktioniert

sein Code entspricht F1 aus meinem Test und auch im Test kommt nirgends eine 32 Byte-Datei raus.

Wie es schon Vorgeschlagen wurde, muß er also nur bei Reset/Rewrite die 1 angeben oder mit File of Byte arbeiten ... also F4 oder F5.
und schon geht's.
Oder er steigt einfach auf FileStream's um (mit der WinAPI muß er sich ja nicht unbedingt überfordern ).

Ich hatte (als ich noch diese Funktionen nutzte) wohl einfach nur Glück, da ich nie mit "File" arbeitete und dafür zufällig nur typisierte Dateien (File of) und Textdateien (TextFile) nutzte.

Ahoi himitsu san,
Das

Zitat von snow:

doch nun bekomme ich den E/A-Fehler 1784.

hat mich stutzig gemacht. Und dieser Fehler tritt im Code von 'snow' so nicht auf. Da gibt es ein Problem mit dem 'Userbuffer'.

Ansonsten gilt wie immer (nicht für Dich): RTFM. Fehler dieser Art macht man genau deswegen, weil man eben nicht TFM liest. Ich habe BlockRead/Write ausschließlich für Dateikopierfunktionen verwendet (und als ich einmal eine kleine DB geschrieben habe).

Zitat von himitsu:

sein Code entspricht F1 aus meinem Test und auch im Test kommt nirgends eine 32 Byte-Datei raus.

Wieso sollte eine 32 Byte Datei rauskommen? Ich würde eine 128 x 128 Byte große Datei annehmen, und genau das passiert. Denn in der OH steht es so beschrieben: Der optionale dritte Parameter gibt die Anzahl der *Records* an, die geschrieben werden.

Zitat von alzaimar:

Ahoi himitsu san,
Das

Zitat von snow:

doch nun bekomme ich den E/A-Fehler 1784.

hat mich stutzig gemacht. Und dieser Fehler tritt im Code von 'snow' so nicht auf. Da gibt es ein Problem mit dem 'Userbuffer'.

jupp ... drum hab ich bei F3 auch keine 2 "Messwerte", da ich dort wegen diesem Fehler einfach das Nichtfunktioniernde weggelassen hab.

32 ... nja, er hat eine 128 Byte-Array und das ist rein zufällig genausogroß wie der Datei-Puffer.
also nahm ich einfach irgendeinen anderen Wert (32 is doch 'ne nette Zahl ), damit man nicht mit den 128-Byte des Puffers und den 128 Byte des Arrays durcheinander kommt.

denn wie soll man denn da wissen wovon die gemessenen 128 Byte nun stammen (Puffer oder Array).

[s]

Zitat von alzaimar:

Der optionale dritte Parameter gibt die Anzahl der *Records* an, die geschrieben werden.

Größe eines Records [s/]

nja und wenn man nichts angibt, dann hätte sich als Default eigentlich die kleines Einheit (also 1 Byte) gut gemacht ... und nicht 'ne willkürliche 128

tja und da sein Array 128 Byte groß ist, hat e wohl das Problem aus meiner F3 bei sich vorliegen (obwohl er wohl nach F1 geschrieben hat ... bei 128 stimmt F1 mit F3 zufällig überein )