Datei gegen Zugriff von anderer Seite sperren

DOheim

Ich habe zwei Programme, die auf die gleiche Datei zugreifen.Wenn das eine Programm die Datei geöffnet hat, soll das andere Programm, wenn es die Datei öffnen will, so lange warten bis das erste die Datei wieder geschlossen hat.FileOpen leistet das nicht.Wenn ich z. B. dieses Programm zweimal starte, können beide ungehindert mit der Datei parallel arbeiten.

Code

$h=FileOpen("Text.txt",2)
MsgBox(0,"","offen")
FileWriteLine($h,"yyy")
MsgBox(0,"","geschrieben")
FileClose($h)
MsgBox(0,"","geschlossen")

Was tun?

**Oscar**

Man kann mit einer "Semaphoren"-Datei arbeiten.
Programm 1 erstellt eine Datei (z.B. access.bin) und öffnet danach die eigentliche Textdatei, nimmt die Änderungen vor, schließt die Textdatei und löscht anschließend die "access.bin".
Wenn nun Programm 2 auf die Textdatei zugreifen will, dann prüft es erst, ob "access.bin" existiert, wenn ja, dann solange warten, bis "access.bin" von Programm 1 wieder gelöscht wurde.
Anschließend kann dann Programm 2 wie beschrieben auf die Textdatei zugreifen.

Edit: Hier mal ein Testscript:

AutoIt

$sSemaphoreFile = @ScriptDir & '\access.bin' ; Semaphorendatei (inkl. Pfad)
$sTextFile = @ScriptDir & '\test.txt' ; Textdatei (inkl. Pfad)


$iTimer = TimerInit() ; Timer initialisieren
$hSemaphore = -1 ; Dateihandle für die Semaphorendatei
Do
	If TimerDiff($iTimer) > 5000 Then ; hier habe ich ein Timeout von 5 sek. eingefügt
		MsgBox(0, 'Timeout', 'Zugriff verweigert')
		Exit
	EndIf
	If Not FileExists($sSemaphoreFile) Then ; wenn die Semaphorendatei nicht existiert, dann...
		$hSemaphore = FileOpen($sSemaphoreFile, 2) ; die Datei zum schreiben öffnen
	EndIf
Until $hSemaphore <> -1 ; warten, bis Semaphorendatei erfolgreich geöffnet wurde
FileClose($hSemaphore) ; die Semaphorendatei muss geschlossen werden, damit sie später gelöscht werden kann!
$hTextFile = FileOpen($sTextFile, 1) ; Textdatei zum hinzufügen öffnen
FileWriteLine($hTextFile, Random(1, 1000, 1)) ; Zeile mit Zufallszahl anhängen
Sleep(2000) ; etwas warten (simuliert weitere Dateizugriffe), dient nur zum testen!
FileClose($hTextFile) ; Textdatei wieder schließen, wichtig!
FileDelete($sSemaphoreFile) ; danach Semaphorendatei löschen, damit das andere Programm auf die Textdatei zugreifen kann

Alles anzeigen

**Andy**

Du könntest auch einfach ein Fileattribut setzen, welche(s) ist erstmal egal. https://autoit.de/onlinehilfe/functions/FileSetAttrib.htm
Die Programme dürfen nur auf die Datei zugreifen, wenn das "Hidden"-Flag nicht gesetzt ist.
Ist das "Hidden"-Flag gesetzt, wird vom ersten Programm, welches diesen Zustand bemerkt, das Hidden-Flag gesetzt ("Leseschutz eingeschaltet") und die Datei gelesen. Danach wird das Flag wieder zurückgesetzt.

**AspirinJunkie**

Wenn es wirklich den Zugriff von allen Seiten blockieren soll dann müsstest du direkt die Windows-Funktionen nutzen.
Hier mal ein Beispiel wie man eine Datei exklusiv öffnen kann:

AutoIt

#include <WinAPI.au3>


$s_FilePath = "H:\Temp\Test.tex"


$h_File = _WinAPI_OpenFile($s_FilePath, 0x10)


If @error Then _Fehler("WinAPIOpenFile", $s_FilePath)


; aus Datei lesen
$s_Text = _ReadNBytesFromFile($h_File, 20)
If @error Then _Fehler("_ReadNBytesFromFile", $s_Text)
ConsoleWrite($s_Text)


; Endlosschleife bis zur Taste q
HotKeySet("q", raus)
While Sleep(100)
WEnd








; etwas einfachere _WinAPI_ReadFile-Variante
Func _ReadNBytesFromFile(ByRef $h_File, $d_Bytes)
   Local $tBuffer = DllStructCreate("byte[" & $d_Bytes & "]")
   Local $d_Read
   $s_Ret = _WinAPI_ReadFile($h_File, $tBuffer, $d_Bytes, $d_Read)
   Local $er = @error, $ex = @extended


   Return SetError($er, $ex, BinaryToString(DllStructGetData($tBuffer, 1)))
EndFunc


; Wrapper für OpenFile (https://msdn.microsoft.com/en-us/library/windows/desktop/aa365430(v=vs.85).aspx)
Func _WinAPI_OpenFile($s_FilePath, $d_Style = 0)
	Local $tag_OFSTRUCT = "byte cBytes;byte fFixedDisk;ushort nErrCode;ushort Reserved1;ushort Reserved2;char szPathName[260]"
	Local $t_ReOpenBuff = DllStructCreate($tag_OFSTRUCT)


	$a_Ret = DllCall("Kernel32.dll", "HANDLE", "OpenFile", "str", $s_FilePath, "ptr", DllStructGetPtr($t_ReOpenBuff), "UINT", $d_Style)
	If @error Then Return SetError(1, @error, -1)


	If DllStructGetData($t_ReOpenBuff, 3) <> 0 Then Return SetError(2, DllStructGetData($t_ReOpenBuff, 3), -1)


	Return $a_Ret[0]
EndFunc   ;==>WINAPIOpenFile


Func raus()
   _WinAPI_CloseHandle($h_File)
   Exit
EndFunc




; kleine Funktion zum besseren Debugging
Func _Fehler(Const $s_Text, Const $Ret = Default, Const $b_Exit = True, Const $Error = @error, Const $Extended = @extended, $ScriptLine = @ScriptLineNumber)
   ; by AspirinJunkie
    #forcedef $d_SCRIPTLINEOFFSET, $d_SCRIPTLINEOFFSET_OFFSET


	Local $a_DllRet = DllCall("kernel32.dll", "dword", "GetLastError")
	Local $d_APIError = @error ? 0 : $a_DllRet[0]
	Local $a_DllRet = DllCall("Wininet.dll", 'bool', 'InternetGetLastResponseInfoW', 'dword*', 0, 'wstr', "", 'dword*', 4096)
	Local $s_InetError = @error ? 0 : $a_DllRet[1]
	Local $s_InetErrorMsg = @error ? "" : $a_DllRet[2]
	Local $a_DllRet = DllCall("kernel32.dll", "dword", "FormatMessageW", _
			"dword", 0x1100, _      ; Flags
			"ptr", 0, _             ; Source (hier unwichtig)
			"dword", $d_APIError, _ ; Error-Code
			"dword", 1031, _        ; Language-ID (per _WinAPI_MAKELANGID ermittelbar)
			"wstr*", "", _          ; Buffer für Ausgabestring
			"DWORD", 0, _           ; Buffersize (hier automatisch durch entsprechendes Flag)
			"ptr", 0)
	Local $s_APIMessage = @error Or $d_APIError == 0 ? "" : $a_DllRet[5]


	If IsDeclared("d_SCRIPTLINEOFFSET") Then $ScriptLine -= $d_SCRIPTLINEOFFSET + $d_SCRIPTLINEOFFSET_OFFSET


	Local $s_Out = '"' & $s_Text & '"' & @CRLF & @CRLF & _
			"Line: " & $ScriptLine & @CRLF & _
			"@error: " & $Error & @CRLF & _
			"@extended: " & $Extended & _
			($Ret = Default ? "" : @CRLF & "Return value: " & $Ret) & _
			($d_APIError = 0 ? "": "API-Error: " & $d_APIError & " - " & $s_APIMessage & @CRLF) & _
			($s_InetError = 0 ? "": "WinINet-Error: " & $s_InetError & " - " & $s_InetErrorMsg)


	MsgBox(48, "Fehler", $s_Out)
	If $b_Exit Then Exit
EndFunc   ;==>_Fehler

Alles anzeigen

Dort kannst du dann aber mit den AutoIt-Funktionen zum lesen und schreiben nicht weiter sondern musst die entsprechenden _WinAPI_XXX-Funktionen nutzen (fürs lesen ist ein Beispiel enthalten).

DOheim

Recht vielen Dank für Eure Antworten.
Ich muss sie mir nun erst einmal zu Gemüte ziehen.
Der Vorschlag von Oscar erscheint mir insofern problematisch, dass wenn das Programm aus irgendeinem Grund abbricht bevor die Semaphorendatei geschlossen wird, dann bleibt sie "hängen" und blockiert alles weitere. Es kommt dann zwar
MsgBox(0, 'Timeout', 'Zugriff verweigert'). Aber schön ist das auch nicht.
Gruß Dieter

Espyre

Zitat von DOheim

Der Vorschlag von Oscar erscheint mir insofern problematisch, dass wenn das Programm aus irgendeinem Grund abbricht bevor die Semaphorendatei geschlossen wird, dann bleibt sie "hängen" und blockiert alles weitere.

Schau dir mal "OnAutoItExitRegister" an

**AspirinJunkie**

Um es bisschen einfacher zu machen hat schonmal jemand ein UDF dafür geschrieben: >>LockFile<<

DOheim

OnAutoItExitRegister ist ja eine prima Funktion. Die ist mir bisher noch nicht über den Weg gelaufen. Bzw. habe ich sie beim Durcharbeiten der AutoIt-Hilfe nicht im Kopf behalten.
Jetzt habe ich mehrere Lösungsmöglichkeiten und die Qual der Wahl.
Vielen Dank Euch allen.

**Bitnugger**

Das sollte hiermit doch auch gehen...

#include <WinAPIFiles.au3>

; Locks the specified file for exclusive access by the calling process
_WinAPI_LockFile ( $hFile, $iOffset, $iLength )

; Unlocks a region in an open file
_WinAPI_UnlockFile ( $hFile, $iOffset, $iLength )

DOheim

Was es alles gibt. Das ist wohl die einfachste Lösung. Vielen Dank!

DOheim

Der Hinweis von AspirinJunkie war ja Gold wert.

>>LockFile<<