Dateien erstellen, schreiben, Lesen (E/A-Fehler 32 & 103)

[Bounser]

Hallo ersteinmal.
Ich hoffe das ich hier im richtigen Bereich bin. Ich hab schon alles versucht, aber irgendwie finde ich den Fehler nicht:

Also ich möchte eine Datei bearbeiten:

Delphi-Quellcode:

var
  textf: TextFile;

procedure textOpen(Datei: string);
begin
  AssignFile(textf,Datei);
  Rewrite(textf); // an dieser Stelle gibt er E/A-Fehler 32 aus
end;

procedure TForm1.einfacherRechner1Click(Sender: TObject);
begin
        try
        textOpen('Einstellungen.txt');
        WriteLn(textf, '0');
        finally
        CloseFile(textf);
        end;
end;

procedure TForm1.wissenschaftlicherRechner1Click(Sender: TObject);
begin
        try
        textOpen('Einstellungen.txt');
        WriteLn(textf, '1');
        finally
        CloseFile(textf);// an dieser Stelle gibt er E/A-Fehler 103 aus
        end;
end;

procedure TForm1.FormCreate(Sender: TObject);
var settings: String;
begin
  try
  AssignFile(textf,'Einstellungen.txt');
  Reset(textf);
  Readln(textf,settings);
  case Strtoint(settings) of
    0: einfacherRechner1Click(Sender);
    1: wissenschaftlicherRechner1Click(Sender)
  else
        close;
  end;
  finally
  CloseFile(textf);// an dieser Stelle gibt er E/A-Fehler 103 aus
  end;

Woran kann das liegen ? Ich weiß wirklich nicht. E/A-Fehler heißt doch, dass die Datei nicht geöffnet wird, aber wird das nicht mit Rewrite() ?
Ich hoffe ihr könnt mir helfen. Vielen Dank schonmal für die Antworten: :hi: :(

[Klaus01]

IO Error 32 -> bedeutet eine sharing violation
IO Error 103 -> bedeutet file not open

Ich vermute das File ist noch read only geöffnet.

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var settings: String;
begin
  try
  AssignFile(textf,'Einstellungen.txt');
  Reset(textf);                     // File readonly geöffnet
  Readln(textf,settings);
  case Strtoint(settings) of
    0: einfacherRechner1Click(Sender);  // hier wird versucht in das File etwas zu schreiben
    1: wissenschaftlicherRechner1Click(Sender)  // hier auch.
  else
        close;
  end;
  finally
  CloseFile(textf);// an dieser Stelle gibt er E/A-Fehler 103 aus
  end;

Du solltest an dem Design etwas ändern.

Grüße
Klaus

[Bounser]

Hallo Klaus

Vielen vielen Dank für deine Antwort. Jetzt seh ich es endlich. :oops: ich hatte wohl gleich zehn Wände/Bretter vorm Kopf. :wall: :wall: :-D Also vielen Danke ich weiß jetzt woran es liegt.
Ich wünsche noch einen schönen Abend.

Gruß Bounser

[himitsu]

dann sollte textf nicht global sein,
vorallem nicht, wenn du es überlappend von mehreren Dateioperationen verwendest.

vielleicht fällt dir so auf, was passiert :zwinker:

Code:

1+  AssignFile(textf,[color=#0000ff]'Einstellungen.txt'[/color]);
1+  Reset(textf);
1   Readln(textf,settings);
1   [color=#0000ff][b]case[/b][/color] Strtoint(settings) [color=#0000ff][b]of[/b][/color]
1     0: 
1       [color=#008000]{einfacherRechner1Click(Sender);}[/color]
12        [color=#008000]{textOpen('Einstellungen.txt');}[/color]
12+         AssignFile(textf,Datei);
12+         Rewrite(textf); [s][color=#008000]// an dieser Stelle gibt er E/A-Fehler 32 aus[/color][/s]
12        WriteLn(textf, [color=#0000ff]'0'[/color]);
12*       CloseFile(textf);
1     1: 
1       [color=#008000]{wissenschaftlicherRechner1Click(Sender)}[/color]
13        [color=#008000]{textOpen('Einstellungen.txt');}[/color]
13+         AssignFile(textf,Datei);
13+         Rewrite(textf); [color=#008000]// an dieser Stelle gibt er E/A-Fehler 32 aus[/color]
13        WriteLn(textf, [color=#0000ff]'1'[/color]);
13*       CloseFile(textf); [color=#008000]// an dieser Stelle gibt er E/A-Fehler 103 aus[/color]
1     [color=#0000ff][b]else[/b][/color]
1       close;
1   [color=#0000ff][b]end[/b][/color];
1*  CloseFile(textf); [color=#008000]// an dieser Stelle gibt er E/A-Fehler 103 aus[/color]

[Luckie]

Und da haben wir wieder die pösen globalen Variablen. ;)

[Bounser]

Guten Abend. :hi:
Also ich habe jetzt einfach CloseFile(textf); vor die case-Anweisung geschoben und alles Funktioniert, oder spricht etwas dagegen. Das Problem ist ja, dass ich textf über mehrere Proceduren bearbeite/verwende. Wie könnte man es denn besser machen, als mit globalen Variablen, oder habe ich das jetzt flasch verstanden? Denn wenn ich in der procedure textOpen KEINE globale Variable verwende, dann muss ich ja textf trotzdem zurückliefern, weil das doch sonst, nach Beendigung der Procedure, gelöscht wird, oder etwa nicht? Ich finde es am besten, wenn man dort eine globale Variable benutz, lasse mich aber gerne eines besseren belehren, wenn es nicht gut ist es so zu machen. :!:
Also wie gesagt habe jetzt CloseFile(textf); einfach vor die case-Anweisung verschoben.
Danke für die Antowrten. :balloon:

Gruß Bounser

[himitsu]

z.B.:

Delphi-Quellcode:

procedure textOpen(var textf: TextFile; Datei: string);
begin
  AssignFile(textf, Datei);
  Rewrite(textf); // an dieser Stelle gibt er E/A-Fehler 32 aus
end;

als Funktion mit Result=TextFile hätte es zwar auch gut ausgesehn, aber wegen des internen TextPuffers im TextFile-Record wäre dieses nicht so gut

[Bounser]

Hallo himitsu.

Also ist das so kein schlechter code, wie ich das jetzt habe. Bin noch Anfänger und daher sehr unerfahren. ;) Danke für die Hilfe, aber war das nur ein Beispiel, wie man es auch machen könnte, oder sollte man es so machen ? ich weiß tut mir leid, dass ich grad so viel poste. :oops:

Gruß Bounser

[himitsu]

Problem hierbei war erstmal die globale Variable,
denn wenn du den ablauf (siehe Beitrag #4) verfolgs, wirst du erkennen, daß diese Variable in einfacherRechner1Click und wissenschaftlicherRechner1Click überschrieben wurde und es somit zu Problemen kam.

Delphi-Quellcode:

procedure textOpen(var textf: TextFile; Datei: string);
begin
  AssignFile(textf, Datei);
  Rewrite(textf);
end;

procedure TForm1.einfacherRechner1Click(Sender: TObject);
var textf: TextFile;
begin
  textOpen(textf, 'Einstellungen.txt');
  try
    WriteLn(textf, '0');
  finally
    CloseFile(textf);
  end;
end;

procedure TForm1.wissenschaftlicherRechner1Click(Sender: TObject);
var textf: TextFile;
begin
  textOpen(textf, 'Einstellungen.txt');
  try
    WriteLn(textf, '1');
  finally
    CloseFile(textf);
  end;
end;

procedure TForm1.FormCreate(Sender: TObject);
var textf: TextFile;
  settings: String;
begin
  AssignFile(textf, 'Einstellungen.txt');
  Reset(textf);
  try
    ReadLn(textf, settings);
  finally
    CloseFile(textf);
  end;
  case Strtoint(settings) of
    0:   einfacherRechner1Click(Sender);
    1:   wissenschaftlicherRechner1Click(Sender)
    else close;
  end;
end;

zu StrToInt: schau dir mal StrToIntDef und TryStrToInt an.
zuletzt gab es auch 'nen Thread dazu: StrToIntDef TryStrToInt


PS: so wäre der Fehler auch am Fehlercode erkennbar gewesen :stupid:

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var textf: TextFile;
  settings: String;
begin
  AssignFile(textf,'Einstellungen.txt');
  Reset(textf);
  try
    Readln(textf,settings);
    case Strtoint(settings) of
      0:   einfacherRechner1Click(Sender);
      1:   wissenschaftlicherRechner1Click(Sender)
      else close;
    end;
  finally
    CloseFile(textf);
  end;
end;

PSS: eventuell schaust du dir auch noch die Ini's und die Registry an
z.B.: TIniFile, TRegistry

[Bounser]

ICh wusste nicht, dass es zu Problemen kommt, wenn man die Variable erneut belegt. :oops: Danke. Werde ich mir ansehen! :cheers:
Wünsche noch nen schönen Abend.

Gruß Max

[himitsu]

AssignFile speichert in dem Record (TextFile) nur den Dateinamen

Reset, Reweite und Append öffnen die Datei (über dem gespeicherten Namen) und speichen einen "Zeiger" auf die Datei ebenfalls in diesem TextFile-Record.

CloseFile schließt die Datei über den gespeicherten "Zeiger"


tja, nun hatest du erstmal den TextFileRecord überschrieben (heißt den Programm hat die geöffntete Datei aus FormCreate vergessen, aber Windows nicht und demnach ist die Datei immernoch geöffnet)

Rewrite und Reset vergeben keine Sharingrechte, also kann die datei nur einmal, zur selben Zeit, geöffnet sein ... drum schlägt dann der Aufruf von Rewrite mit Fehler 32 fehl.

CloseFile schließt die zulett geöffnete Datei ... da aber textf immernoch die Daten der letzten Datei hat, schlägt nun ein weiterer Aufruf vo CloseFile mit Fehler 103 fehl.


Lösung bezüglich des Überschreibens:
jeder Aufruf bekommt seine eigene TextFile-Variable (textf)

fehlende Rechte: Datei nur einmal zugleich öffnen, also rechtzeitig in FormCreate schließen

[Hansa]

Himitsu kann ich so nicht zustimmen. Es ist Blödsinn, das Textfile dauernd neu zu deklarieren. Deklariere es im Form-private-Teil und fertig.

[Bounser]

Das heißt ich speicher es als private Variable und muss nur darauf achten, dass die Variable nur einmal mit AssignFile einen Dateipfad zugewiesen bekommt. Das wäre nun eine gute Variante. Danke für die Antworten!

Gruß Bounser

[Luckie]

Zitat:

Zitat von Hansa

Himitsu kann ich so nicht zustimmen. Es ist Blödsinn, das Textfile dauernd neu zu deklarieren. Deklariere es im Form-private-Teil und fertig.

Zitat:

Zitat von Bounser

Das heißt ich speicher es als private Variable und muss nur darauf achten, dass die Variable nur einmal mit AssignFile einen Dateipfad zugewiesen bekommt. Das wäre nun eine gute Variante. Danke für die Antworten!

Gruß Bounser

Nein so würde ich es nicht machen. Denn wo das hinführt haben wir ja gesehen. Es gibt keinen Grund diese Variable global zu deklarieren und auch wenn sie im private-Abschnitt der Formklasse steht, ist sie aus der Sicht der Formklasse global. Grundsätzlich gilt, dass man die Sichtbarkeiten so gering wie möglich halten soll, um Fehler zu vermeiden. Ein Fehler besteht nämlich darin, dass man die Variable für die Textdatei benutzt mit Rewrite, aber die Datei noch offen oder noch nicht offen ist. Der Compiler meckert aber nicht, weil er sie ja kennt. Und wie wir gesehen haben, ist der Fehler schwer zu finden, weil man überall im Code überprüfen muss, welchen Zustand denn nun die Dasteivariable hat. Deklariert man sie konsequent lokal und nur da wo man sie braucht, kann dies nicht passieren, da der Fehler schon beim programmieren auffällt und wenn nicht, kann die Stelle mit dem Fehler genau auf eine Stelle im Code eingegrenzt werden , die man sehr leicht beim Debuggen findet. Es sollte also so aussehen:

Delphi-Quellcode:

procedure Foo;
var
  tf: TextFile;
begin
  try
    Assign(tf, '...');
    Rewrite(tf);
    Writeln(tf, '...');
    CloseFile(tf);
  except
    on E: EInOutError
  end;
end;

procedure Bar;
var
  tf: TextFile;
begin
  Assign(tf, '...');
  Rewrite(tf);
  Readln(tf, '...');
  CloseFile(tf);
end;

Noch zu beachten wäre die Fehlerbehandlung, die hier gänzlich fehlt. Und die man mit einer globalen Textdateivariable kaum sauber hinbekommen hätte:

Delphi-Quellcode:

procedure Foo;
var
  tf: TextFile;
begin
  Assign(tf, '...');
{$I-}  // automatische Fehlerbehandlung ausschalten, machen wir selber
  Rewrite(tf);
{$I+}
  if IOResult = 0 then  // auf Fehler prüfen
  begin
    Writeln(tf, '...';
    CloseFile(tf);
  else  // Fehler
    ShowMessage(SysErrorMessage(GetLastError));
end;

Alternativ kann man auch mit Exceptions arbeiten, da die Ein- und Ausgaberoutinen entsprechende Exceptions auslösen:

Delphi-Quellcode:

procedure Foo;
var
  tf: TextFile;
begin
  AssignFile(tf, '...');
  try
    Rewrite(tf);
    Writeln(tf, 'jhegfejhsd');
    CloseFile(tf);
  except
    CloseFile(tf);  // Mögliche offene Datei schliessen
    raise;  // Exception erneut auslösen, um sie an den Aufrufer hoch zu reichen
  end;
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  try
    Foo;
  except
    on E: EInOutError do  // Exception abfangen und behandlen
      ShowMessage(E.Message);
  end;
end;

[Bounser]

Das mit den globalen Variablen ist, wie es aussieht, ein Streitpunkt. Um nun das hier zu beenden: Ich habe es nun so, wie Luckie und himitsu gemacht und die Variablen lokal verwendet. Es funktioniert nun. Danke auch für den Tipp mit der Fehlerbehandlung. :mrgreen: Also ich werde nachher vielleicht nochmal den Code posten, aber es funktioniert nun alles wunderbar. Vielen Dank für die schnelle Hilfe. :hello:

Gruß Bounser

[Hansa]

Ihr wollt das wirklich so oft deklarieren ? :shock: Tja, dann macht eben. :mrgreen: Wenn IOResult benutzt werden soll, dann mus aber auch hier noch was deklariert werden :

Zitat:

Zitat von Luckie

Delphi-Quellcode:

procedure Foo;
var
  tf: TextFile;
begin
  Assign(tf, '...');
{$I-}  // automatische Fehlerbehandlung ausschalten, machen wir selber
  Rewrite(tf);
{$I+}
  if IOResult = 0 then  // auf Fehler prüfen
...

Man stelle sich mal so was vor :

Delphi-Quellcode:

procedure Foo;
{$I-}  // automatische Fehlerbehandlung ausschalten, machen wir selber
  Rewrite(tf);
{$I+}
  writeln (IOresult);
  if IOResult = 0 then  // auf Fehler prüfen
...

Da will jetzt einer wissen, was IOResult eigentlich anzeigt und zerschießt sich das ganze IOResult, weil das writeln auch eine I/O-Operation ist. Das Programm wird dann nicht laufen, wie gewünscht. Das weist man sofort einer Variablen zu und verwendet die ! Also so :

Delphi-Quellcode:

procedure Foo;
var
  tf: TextFile;
  io : integer;
begin
  Assign(tf, '...');
{$I-}  // automatische Fehlerbehandlung ausschalten, machen wir selber
  Rewrite(tf);
{$I+}
  io := IOResult;
writeln (io);
  if io = 0 then  // auf Fehler prüfen
...

Sieht relativ unwichtig aus, sollte man aber schon so machen.

[Luckie]

Zitat:

Zitat von Hansa

Ihr wollt das wirklich so oft deklarieren ? :shock: Tja, dann macht eben.

Was ist dagegen einzuwenden? Ich habe meine Entscheidung begründet.

Zitat:

Wenn IOResult benutzt werden soll, dann mus aber auch hier noch was deklariert werden :

Man stelle sich mal so was vor :

Delphi-Quellcode:

procedure Foo;
{$I-}  // automatische Fehlerbehandlung ausschalten, machen wir selber
  Rewrite(tf);
{$I+}
  writeln (IOresult);
  if IOResult = 0 then  // auf Fehler prüfen
...

Ist doch irgendwie etwas blöd, erst zu prüfen ob ein Fehler aufgetreten ist, wenn man vorher schon fröhlich weitergemacht hat. Guck dir mein Beispiel noch mal an. Ich prüfe ERST auf Fehler und dann schrieben ich in die Datei mit Writeln. Da wird nichts zerschossen.

[taaktaak]

Moin Luckie,
ist natürlich richtig und ich verwende das ebenfalls genau SO. Vielleicht ist Hansa aufgrund des fehlenden END in deinem Code etwas durcheinander gekommen :zwinker:

[Hansa]

Du verstehst aber, was ich meine ? :gruebel: Es geht um die unscheinbare Zeile : writeln (...); Die macht das IOResult komplett unbrauchbar. Roter Kasten ? :shock: Wenn ein end; fehlt, das ist egal. :mrgreen:

[taaktaak]

schon, schon...
aber warum sollte man VOR die Prüfung auf ioResult schon das writeln() verwenden? Das ist eben falsch. Man tut es nicht, wenn man diese Art der Fehlerüberprüfung wählt.