Beiträge von Bitnugger

Zitat von mirko2002

Hab mal in die Hilfe für die Funktion geschaut.... da bin ich ehrlich doch etwas mit überfordert, zumal die Hilfe für diese Funktion hier leider nur in Englisch zur Verfügung steht

Ok, das ist eine ehrliche Aussage.

Mit dieser Funktion kannst du dich von Windows benachrichtigen lassen, wenn sich etwas an oder in den zu überwachenden Verzeichnissen geändert hat.

Das hat den riesigen Vorteil, dass sich dadurch die Dateizugriffe in deinem Script drastisch reduzieren lassen.

Sage mir doch einfach mal, was du gerne an Änderungen überwachen würdest und ich schreibe dir dazu die passende Funktion.

Welches Verzeichnis (können auch mehrere sein) willst du überwachen (inkl. Unterverzeichnisse? (rekursiv)) und welche Dateien (oder Muster, z.B. *.txt oder Rechnung.*) sollen darin gemeldet werden, wenn sich was geändert hat?

Hier eine Liste aller Ereignisse, über die du benachrichtigt werden kannst... die für dich ganz sicher nicht relevanten habe ich mit einem * markiert - welche brauchst du davon?

$SHCNE_ALLEVENTS        * Alle Ereignisse sind aufgetreten.
$SHCNE_ASSOCCHANGED       Eine Dateitypzuordnung hat sich geändert.
$SHCNE_ATTRIBUTES         Die Attribute eines Elements oder Ordners haben sich geändert.
$SHCNE_CREATE             Es wurde ein Nicht-Ordnerelement erstellt.
$SHCNE_DELETE             Ein Nicht-Ordnerelement wurde gelöscht.
$SHCNE_DRIVEADD           Ein Laufwerk wurde hinzugefügt.
$SHCNE_DRIVEADDGUI      * Windows XP und höher: Wird nicht verwendet.
$SHCNE_DRIVEREMOVED       Ein Laufwerk wurde entfernt.
$SHCNE_EXTENDED_EVENT   * Derzeit nicht verwendet
$SHCNE_FREESPACE          Der freie Speicherplatz auf einem Laufwerk hat sich geändert.
$SHCNE_MEDIAINSERTED      Speichermedium wurde in ein Laufwerk eingelegt.
$SHCNE_MEDIAREMOVED       Speichermedien wurden aus einem Laufwerk entfernt.
$SHCNE_MKDIR              Ein Ordner wurde erstellt.
$SHCNE_NETSHARE           Ein Ordner auf dem lokalen Computer wird über das Netzwerk freigegeben.
$SHCNE_NETUNSHARE         Ein Ordner auf dem lokalen Computer wird nicht mehr über das Netzwerk freigegeben.
$SHCNE_RENAMEFOLDER       Der Name eines Ordners hat sich geändert.
$SHCNE_RENAMEITEM         Der Name eines Nicht-Ordnerelements wurde geändert.
$SHCNE_RMDIR              Ein Ordner wurde entfernt.
$SHCNE_SERVERDISCONNECT   Der Computer hat die Verbindung zu einem Server getrennt.
$SHCNE_UPDATEDIR          Der Inhalt eines vorhandenen Ordners hat sich geändert, der Ordner ist jedoch noch vorhanden und wurde nicht umbenannt.
$SHCNE_UPDATEIMAGE        Ein Bild in der Systemabbildliste wurde geändert.
$SHCNE_UPDATEITEM         Ein vorhandenes Element (ein Ordner oder ein Nichtordner) hat sich geändert, das Element ist jedoch noch vorhanden und wurde nicht umbenannt.
$SHCNE_DISKEVENTS       * Gibt eine Kombination aller Plattenereignis-IDs an.
$SHCNE_GLOBALEVENTS     * Gibt eine Kombination aller globalen Ereignisbezeichner an.
$SHCNE_INTERRUPT        * Das angegebene Ereignis ist infolge eines Systeminterrupts aufgetreten. Da dieser Wert andere Ereigniswerte ändert, kann er nicht alleine verwendet werden.

Schau mal, evtl. kannst du es gebrauchen... weiß nicht mehr, wo ich das her habe...

Func EncodeUrl($src)
    Local $iCount = 1, $iStrLen = StringLen($src), $ch, $NewChr, $buff

    While ($iCount <= $iStrLen)
        ;Get byte code from string
        $ch = Asc(StringMid($src, $iCount, 1))

        ;Look for what bytes we have
        Switch $ch
            ;Looks ok here
            Case 45, 46, 48 To 57, 65 To 90, 95, 97 To 122, 126
                $buff &= Chr($ch)
            Case 32
                ;Space found
                $buff &= "+"
            Case Else
                ;Convert $ch to hexidecimal
                $buff &= "%" & Hex($ch, 2)
        EndSwitch
        ;INC Counter
        $iCount += 1
    WEnd

    Return $buff
EndFunc   ;==>EncodeUrl

Func DecodeUrl($src)
    Local $iCount = 1, $iStrLen = StringLen($src), $ch, $buff

    While ($iCount <= $iStrLen)
        $ch = StringMid($src, $iCount, 1)
        ;Correct spaces
        If ($ch = "+") Then $ch = " "

        ;Decode any hex values
        If ($ch = "%") Then
            $ch = Chr(Dec(StringMid($src, $iCount + 1, 2)))
            $iCount += 2
        EndIf
        ;Build buffer
        $buff &= $ch
        ;Inc Counter
        $iCount += 1
    WEnd

    Return $buff
EndFunc   ;==>DecodeUrl

In deinem aktuellen Example hast du für _BitAND64/_BitOR64/_BitXOR64 jetzt übrigens keine Beispiele mehr, die zeigen, wie es mit einem Array geht... die waren vorher drin und ich würde sie auch wieder hinzufügen.

In der Funktion _BitRotate64() hat sich ein Fehler eingeschlichen... denn wenn $iRotate = 0 ist, musst du $iValue1 und nicht $iRet zurückgeben!

Ich würde es so machen:

; A helper-function for "_BitROL64" and "_BitROR64"
; $iRotate = Number of bits to rotate to the right (negative numbers rotate left).
Func _BitRotate64($iValue1, $iRotate = 1)
    Return $iRotate = 0 ? $iValue1 : $iRotate > 0 ? _BitROR64($iValue1, $iRotate) : _BitROL64($iValue1, $iRotate)
EndFunc   ;==>_BitRotate64

Zitat von Oscar

Aber generell die Funktion "_Main" dafür zu verwenden, ist auch nicht gut.

Wenn Du das in mehreren UDFs machst, hast Du das Problem, dass es die Funktion doppelt gibt.

Selbstverständlich würde ich _Main() nicht in einer UDF verwenden, sondern nur in "normalen" Scripten und da ist das auch völlig ok.

Im Übrigen ist das OnAutoItExitRegister bzw. das If $__g_pBitOpASMCode[$i] > 0 Then wohl nicht zwingend nötig, da _MemVirtualFree($__g_pBitOpASMCode[$i], $__g_iBitOpMemSize[$i], $MEM_DECOMMIT) dann einfach ein False liefert, wenn $__g_pBitOpASMCode[$i] = "" ist. Konnte der Speicher freigegeben werden, liefert es True.... das allerdings traurigerweise auch, wenn man denselben Speicher mehrmals hintereinander freigibt.

Zitat von Musashi

Das wäre, bis auf ein Komma sogar wortwörtlich, auch meine Übersetzung !

Du meinst sicher das hinter Binärdaten... ja, das hätte ich mir sparen können.

Zitat von Musashi

Ein Grund warum das Projekt so schleppend vorankommt ist, dass Englisch- UND Fach- UND Grammatikkenntnisse zusammenkommen müssen.

Natürlich auch deshalb... hauptsächlich aber, weil nur wenige User bereit sind, ihre Zeit dafür zu opfern - aber auch dann wäre es trotzdem noch ein langer und zäher Weg, bis die Umsetzung ihr gesegnetes Ende findet. Bestimmt ist sie trotz der enthaltenen Fehler aber eine Erleichterung für User, die eine Deutsche Hilfe bevorzugen.

Zitat von Musashi

(ich vermute mal, das war ursprünglich ein Bequemlichkeitsfeature, oder ? )

Ja, könnte man so nennen... und ist es immer noch...

Zitat von Musashi

in eine Funktion gepackt, wäre doch alles ok, oder ?

Ja, dann wäre alles klar!

Ich verwende dafür immer die Funktion _Main(), die es bei mir so gut wie immer gibt, damit solche Sachen nicht passieren.

Zitat von Musashi

Texte die voll von Tippfehlern sind, bringen das Projekt auch nicht wirklich weiter.

Die sind aber bei weitem nicht so schlimm, wie Übersetzungen (ohne Tippfehler), die den Sachverhalt falsch darstellen, denn die sind sogar kontraproduktiv.

Hier ein Beispiel: Übersetzung zu ConsoleWrite()

Remarks

EN: Binary data is written as-is. It will not be converted to a string. To print the hex representation of binary data, use the String() function to explicitly cast the data to a string.

DE: Die Binärdaten werden geschrieben, wie sie sind. Sie werden nicht in einen String gewandelt. Um den HEX-Wert der Binärdaten zu schreiben, muss die String() Funktion benutzt werden, damit die Daten explizit in einen String geschrieben werden.

Die Daten werden definitiv nicht in einen String geschrieben... sondern in einen String konvertiert.

So würde ich es übersetzen:

DE: Binärdaten werden so geschrieben, wie sie sind. Sie werden nicht in eine Zeichenfolge (String) konvertiert. Zum Schreiben der Hex-Darstellung von Binärdaten, muss die Funktion String() benutzt werden, um die Daten explizit in eine Zeichenfolge umzuwandeln.

Zitat von Oscar

Ok, das macht Sinn!

Ich hab's aber noch etwas anders gelöst (ohne Eval).

Soso, du magst Eval also nicht... so sah auch meine erste Lösung aus... mir hatte es aber nicht gefallen, nur zum Befüllen der Struktur ein Array zu erzeugen. Deshalb tendiere ich eher zu Eval. Unterm Strich aber völlig egal, weil ja beides funktioniert. Oder?

Eine Sache solltest du dir aber unbedingt abgewöhnen... For...Next-Schleifen im globalen Kontext!

Denn dadurch machst du die Count-Variable $i zu einer globalen Variable, was nicht nur unschön ist, sondern später auch mächtig Ärger machen kann, weil man innerhalb von Funktionen davon ausgeht, dass solche Lauf-Variablen eben nicht global sind.

Hier ein Beispiel:

#AutoIt3Wrapper_UseX64=y ; AutoIt 64-Bit-Modus

#include 'BitOperations64.au3'

_Test()

Func _Test()
    If IsDeclared('i') Then ConsoleWrite("@@ Debug line" & @TAB & @ScriptLineNumber & "   var: $i --> " & $i & ' IsDeclared("i") = ' & IsDeclared('i') & ' (1 = Global)' & @CRLF)
    Local $aDirList[0]
    If UBound($aDirList) Then
        For $i = 0 To UBound($aDirList) -1 Step 1
            If DirGetSize($aDirList[$i]) > 100000 Then ExitLoop
        Next
    EndIf
    If $i Then ConsoleWrite('! Mindestens ein Verzeichnis ist groesser als 100000!' & @CRLF) ; <<< Dieser Fehler ist sehr schwer zu finden, denn diese Zeile gehört vor das EndIf, weil $i sonst nicht lokal deklariert ist und das Script mit einer Fehlermeldung beendet wird - was aber nicht passiert, da $i ja wegen der For...Next-Schleife in BitOperations64.au3 als globale Variable existiert!
EndFunc

Zitat von Mars

Mir ist noch ein "Schönheitsfehler" aufgefallen, das OnAutoItExitRegister sollte erst nach _MemVirtualAlloc ausgeführt werden, da sonst (zumindest theoretisch) die Möglichkeit besteht, dass _MemVirtualFree aufgerufen wird bevor überhaupt Speicher reserviert wurde.

Ja, ok, das ist aber in der Tat nur ein Schönheitsfehler, denn er überprüft doch die Werte in dem Array, bevor _MemVirtualFree aufgerufen wird...

If $__g_pBitOpASMCode[$i] > 0 Then _MemVirtualFree($__g_pBitOpASMCode[$i], $__g_iBitOpMemSize[$i], $MEM_DECOMMIT)

Ich habe mir das alles mal umgestrickt und die wd_demo.au3 ein wenig erweitert (WebDriver-Demo.au3), sowie an einigen Stellen ein paar Korrekturen gemacht.

Mit der WebDriver-Demo.au3 wird nun automatisch der richtige geckodriver (für Chrome wird nur der aktuelle chromedriver) gedownloadet und entpackt, falls er noch nicht vorhanden ist.

Wollte euch das nicht vorenthalten... und wenn jemand Lust hat, kann er das ja noch weiter aufpeppen...

.\WEBDRIVER
│   chrome.log
│   WebDriver-Demo.au3
│
├───chromedriver
├───geckodriver
├───Includes
│       BinaryCall.au3
│       Json.au3
│       wd_core.au3
│       wd_helper.au3
│       WinHttp.au3
│       WinHttpConstants.au3
│       _BuildInZIP.au3
│       _GetFileVersionInfo.au3
│
├───WinHttp-1.6.4.1
│       WinHttp.chm
│       WinHttp.au3
│       WinHttp.au3.org
│       WinHttpConstants.au3
│
└───_Json-2018.12.16
        BinaryCall.au3
        Json.au3
        Json_Test.au3
        test.json

Zitat von autoiter

Ich möchte nur diese Aussage etwas korrigieren.

Danke mein Freund!

Zitat von Oscar

Bitnugger hatte bemängelt, dass die UDF bei AND, OR und XOR nur zwei Parameter zulässt. Aber anstatt alle 64-Bit-Zahlen in den Funktionsaufruf zu packen, finde ich es praktischer ein Array mit den Werten zu übergeben.

Außerdem ist es nicht angebracht, die Assemblerfunktion x-mal aufzurufen (die DllCallAdress-Aufrufe kosten Zeit). Lieber alle Werte in eine Struktur packen, den Pointer übergeben (sowie die Anzahl) und den Rest von Assembler aus erledigen.

Sehr schön... doch ein paar mehr als zwei Parameter sollten es meiner Meinung nach doch schon sein, bevor ich "genötigt" bin, vor dem Funktionsaufruf ein Array zu definieren.

Hier als Bsp. bei _BitAND64 (mit max. 8 Parametern), wie ich mir das gedacht habe...

Func _BitAND64($iValue1, $iValue2 = 0, $iValue3 = 0, $iValue4 = 0, $iValue5 = 0, $iValue6 = 0, $iValue7 = 0, $iValue8 = 0)
    #forceref $iValue2, $iValue3, $iValue4, $iValue5, $iValue6, $iValue7, $iValue8
    Local $iCount, $tData, $pData
    If IsArray($iValue1) Then
        $iCount = UBound($iValue1)
        $tData = DllStructCreate('uint64 value[' & $iCount & '];')
        For $i = 1 To $iCount
            DllStructSetData($tData, 1, $iValue1[$i - 1], $i)
        Next
    Else
        $iCount = @NumParams
        $tData = DllStructCreate('uint64 value['&$iCount&'];')
        For $i = 1 To $iCount Step 1
            DllStructSetData($tData, 1, Eval('iValue' & $i), $i)
        Next
    EndIf
    $pData = DllStructGetPtr($tData)
    Local $aRet = DllCallAddress('uint64:cdecl', $__g_pBitOpASMCode[0], 'ptr', $pData, 'uint64', $iCount)
    If @error Or Not IsArray($aRet) Then Return SetError(1, 0, 0)
    Return $aRet[0]
EndFunc   ;==>_BitAND64

Zitat von Friedhelm39

Was soll man mit dem Gecko-Treiber machen?

Gehen wir mal davon aus, du hast dir von autoiter das Archiv WebDriver Test.7z heruntergeladen und irgendwo entpackt.

In dem Demo-Script Deine Demo.au3 findest du eine Funktion mit Namen SetupGecko(), der als Parameter 'geckodriver.exe' übergeben wird. Wird der Parameter ohne Pfadangaben übergeben, muss die 'geckodriver.exe' im selben Verzeichnis sein, wie das Demo-Script. Die 'geckodriver.exe' wird benötigt, um mit Firefox zu kommunizieren.

Zitat von Friedhelm39

Zunächst habe ich Fehlermeldungen bekommen, weil der Zugriff mit include nicht klappte.

In der wd_core.au3 werden die Includes JSON.au3 und WinHttp.au3 geladen...

#include <JSON.au3> ; https://www.autoitscript.com/forum/topic/148114-a-non-strict-json-udf-jsmn

#include <WinHttp.au3> ; https://www.autoitscript.com/forum/topic/84133-winhttp-functions/

Da diese mit <JSON.au3> und <WinHttp.au3> angegeben wurden, werden sie zuerst im Include-Verzeichnis (normalerweise C:\Program Files\AutoIt3\Includes und falls in SciTE-Config angegeben, dem User-Include-Verzeichnis) gesucht... werden sie dort nicht gefunden, wird zusätzlich noch im Script-Verzeichnis danach gesucht. Wenn nun also Fehler auftreten, wurde höchstwahrscheinlich eine ältere/neuere/inkompatible Version von JSON.au3 bzw. WinHttp.au3 in deinem Include-Verzeichnis gefunden, die mit dieser Demo nicht richtig funktioniert.

Entweder du kopierst die beiden Includes aus dem Demo-Verzeichnis in dein Include-Verzeichnis (besser in das User-Include-Verzeichnis, weil sie dort bei einem Update nicht überschrieben werden), oder passt die beiden Include-Zeilen entsprechen an.

#include ".\WebDriver-0.1.0.13\JSON.au3" ; https://www.autoitscript.com/forum/topic/148114-a-non-strict-json-udf-jsmn

#include ".\1.6.4.1\WinHttp.au3" ; https://www.autoitscript.com/forum/topic/84133-winhttp-functions/

Evtl. musst du dann noch die für dich richtige 'geckodriver.exe' besorgen und die in dem Verzeichnis WebDriver-0.1.0.13 damit ersetzen.

Post #29: Binary.au3 jetzt auch mit max. 255 Params! Alles noch mal überarbeitet und optimiert.

@Musashi & Oscar - Vielen Dank!

Binary.au3 - habe ich auf die Schnelle ein wenig geändert, weil durch folgende Zeile (und die bleibt drin!) sonst Fehler ohne Ende angezeigt werden:

#AutoIt3Wrapper_AU3Check_Parameters=-q -d -w 1 -w 2 -w 3 -w- 4 -w 5 -w 6 -w- 7

BitOperations64.au3 - habe ich ein wenig geändert, weil bei _BitAND64, _BitOR64 und _BitXOR64 nur zwei Parameter akzeptiert wurden, nun dürfen es bis zu 255 sein.

Schöner wäre, wenn das auch mit X86-Mode geht...

Hier mal die bei mir benötigten Zeiten für die Scripts _ProcessSetAffinityMask2 (Binary.au3).au3 und _ProcessSetAffinityMask3 (BitOperations64.au3).au3:

Binary.au3 (Ward, max. 20 Params)            : Benötigte Zeit: 00:00:01:133:1685

Binary.au3 (Ward, max. 255 Params)           : Benötigte Zeit: 00:00:01:249:1656

BitOperations64.au3 (Oscar, max.  20 Params) : Benötigte Zeit: 00:00:01:080:7824

BitOperations64.au3 (Oscar, max. 255 Params) : Benötigte Zeit: 00:00:01:181:7813

Ich habe das einfach mal alles in ein Archiv reingelegt, damit Ovik sich eine Version aussuchen kann...

_ProcessSetAffinityMask2 (Binary.au3).au3           9.436 Bytes
_ProcessSetAffinityMask3 (BitOperations64.au3).au3  9.593 Bytes
Binary.au3                                         43.300 Bytes
Binary (Ward, max.  20 Params).au3                 27.559 Bytes
Binary (Ward, max. 255 Params).au3                 43.300 Bytes
BinaryExample.au3                                   5.753 Bytes
BinarySpeedTest.au3                                 2.162 Bytes
BitOperations64.au3                                25.299 Bytes
BitOperations64 (Oscar, max.  20 Params).au3        9.558 Bytes
BitOperations64 (Oscar, max. 255 Params).au3       25.299 Bytes
BitOperations64_example.au3                         2.812 Bytes

Die Ausgabe sieht dann bei mir so aus:

Ausgabe.png

Zitat von Ovik

Mir ist nun auch klar, warum die Prozessoren 32-35 nicht ansprechbar sind (Maske hat ja nur 32 Bits).

Hihi, fast richtig!

Schau mal hier...

; Was in deiner Ausgabe angezeigt wird:
$aLogicalProcessors[35] = 0x00000000 BitMask --> 000000000000000000000000000000000000

; Die Stellen der BitMask sind so schwer zu zählen... deshalb machen wir es mal etwas übersichtlicher...
;                                                [ 32-35  ] [ 24-31  ] [ 16-23  ] [  8-15  ] [  0-7   ]
$aLogicalProcessors[35] = 0x00000000 BitMask -->      0000   00000000   00000000   00000000   00000000

; Wie du nun sehen kannst, sind es mehr als 32 Bit, die hier angezeigt werden:
;                                                [ 32-35  ] [ 24-31  ] [ 16-23  ] [  8-15  ] [  0-7   ]
$aLogicalProcessors[35] = 0x00000000 BitMask -->      1000   00000000   00000000   00000000   00000000
; Hier sollte bei dir aber eine 1 stehen..............^

; *************************************************************************************************************************************
; Die 1-Million-Dollar-Frage ist nun: Warum ist dies bei dir aber nicht der Fall?
; *************************************************************************************************************************************

; #####################################################################################################################################
; 1. Fehler)
; #####################################################################################################################################
$g_aLogicalProcessors[$i] = '0x' & Hex(Int(2^$i), 8) ; Hex(2^$i, 8) geht nicht, weil Hex(2^0) fälschlicherweise 0x3FF0000000000000 ist, und nicht 0x0000000000000001!
;  Hier darf nicht Hex(Int(2^$i), 8) stehen, weil wir ja mit mehr als 32 Bits hantieren müssen, uns aber mit Hex(expression, 8) aber auf 32 Bits beschränken.

; Richtig wäre also:
$g_aLogicalProcessors[$i] = '0x' & Hex(Int(2^$i), 16) ; Hex(2^$i, 16) geht nicht, weil Hex(2^0) fälschlicherweise 0x3FF0000000000000 ist, und nicht 0x0000000000000001!

; Korrigieren wir diesen Fehler, sollte die Ausgabe bei dir so aussehen:
$aLogicalProcessors[35] = 0x0000000080000000 BitMask --> 100000000000000000000000000000000000
; Doch auch jetzt hast du hier keine 1 stehen............^

; #####################################################################################################################################
; 2. Fehler) Das BitOR in der Funktion _Example und das BitAND in der Funktion _UsedLogicalProcessorsToBinaryString
; #####################################################################################################################################
; Das BitOR in der Funktion _Example:
If UBound($aLogicalProcessors) >= 32 Then _SetProcessAffinityMask(@AutoItPID, BitOR($aLogicalProcessors[11], $aLogicalProcessors[12], $aLogicalProcessors[31]))

; Das BitAND in der Funktion _UsedLogicalProcessorsToBinaryString:
$bAffinityMask &= BitAND($iUsedLogicalProcessors, 2^$i) ? '1' : '0'

; Erklärung... der für $aLogicalProcessors[35] gespeicherte Wert ist nach der ersten Korrektur: '0x' & Hex(2^35, 16) --> 0x0000000800000000 - entspricht Integer --> 34359738368.

; Wenn $i also 35 ist... und wir nun die entsprechenden Werte anstelle der Variablen einsetzen, sähe das so aus...
$bAffinityMask &= BitAND(34359738368, 2^35) ? '1' : '0' ; hier liefert BitAND aber den Wert 0 und das Ergebnis in der BitMask ist somit auch eine '0'
; DAS funktioniert so nicht... weil... wie in der AutoIt-Hilfe zu BitAND auch steht: >>>Bit operations are performed as 32-bit integers.<<<
; BitAND(34359738368, 34359738368)                             = 0
; BitAND(0x800000000, 0x800000000)                             = 0
; BitAND(0x0000000800000000, 0x0000000800000000)               = 0

; *************************************************************************************************************************************
; Wir haben ab $aLogicalProcessors[32] also einen Wert, der mehr als 32 Bits benötigt... derselbe Fehler tritt ergo auch bei BitOR auf!
; *************************************************************************************************************************************

; Und nu?
; Wir brauchen ein BitOR/BitAND, dass mit mehr als 32 Bit funktioniert... ist in Arbeit... aber heute nicht mehr!

; Vielleicht hat ja einer der User hier eine fertige Lösung parat? - oder ich bin mal wieder mächtig auf dem Holzweg. ;-)

Zitat von mirko2002

Damit ich nicht im Sekundentakt die Ansicht aktualisieren lasse habe ich ne Abfrage auf 5 Minuten gesetzt - es muss halt zwingend die Dateiansicht aktuell sein, geht leider nicht anders.

Schau dir doch mal die Funktion _WinAPI_ShellChangeNotifyRegister an...

Schau mal ob dir das hilft...

;~ #include <WinAPI.au3>     ; AutoIt Version <= 3.3.14.2
#include <WinAPIConv.au3> ; AutoIt Version >= 3.3.14.3

ConsoleWrite('> @AutoItVersion = ' & @AutoItVersion & '   @AutoItPID = ' & @AutoItPID & @CRLF & @CRLF)

ConsoleWrite('! ...schließen...' & @CRLF)

;~ _WinAPI_WideCharToMultiByte ( $vUnicode [, $iCodePage = 0 [, $bRetNoStruct = True [, $bRetBinary = False]]] )
ConsoleWrite(_WinAPI_WideCharToMultiByte('> ...schließen...', 65001) & @CRLF)

Zitat von alpines

Man gibt hier beiden CPUs sehr schlechte Voraussetzungen um die Aufgabe optimal zu lösen ...

Ja, ich denke mal, damit liegst du richtig... und somit zeigt sich wieder mal, dass die Realität nicht immer so ist, wie einem die Werbung weismachen will. Ich hätte es jedenfalls niemals für möglich gehalten, dass ein antiker Dual-Core einem beinahe aktuellen Quad-Core zeigt, wo der Hammer hängt!

Danke für eure Antworten...