Beiträge von AspirinJunkie
-
-
OstseeBit
Du suchst doch immer nach auch den letzten Verbesserungen.
So sollte die sowieso schon schnelle Funktion von Eukalyptus noch nen Tick fixer arbeiten:Spoiler anzeigen
[autoit]Func _ArrayUnique_(ByRef $aA)
[/autoit]
Local Static $oD = ObjCreate('Scripting.Dictionary')
For $i In $aA
If Not $oD.Exists($i) Then $oD.Add($i, 0)
Next
Local $aR = $oD.Keys()
$oD.RemoveAll
Return $aR
EndFunc -
Window-Handles wären wohl besser als Fenstertitel: >>Klickmich<<
-
Warum taucht die PID in dem von ProcessList() erstelltem Array nicht auf?
Weil du ProcessList() schon VOR _INetMail() aufrufst welche erst das Mailprogramm startet?
-
Alternativer Vorschlag:
Linker oberer Rand vom Client bezüglich der Bildschirmkoordinaten sollte sein:- BlockInput damit die Maus stabil bleibt
- Unterschied = MouseGetPos bei Opt("MouseCoordMode", 0) - MouseGetPos bei Opt("MouseCoordMode", 2)
- Linker ober Rand des Clients absolut = WinGetPos() + Unterschied
Größe dann wie gehabt über WinGetClientSize
-
trotzdem hab ich auch schon hier im forum des öfteren gelesen dass man globale variablen vermeiden sollte.
Würde ich auch so mittragen.
Der Grund ist aber für mich weniger die Überschneidung mit lokalen Variablen (das kann man ja mit global und local entsprechend steuern) sondern eher die Effektivität.
Globale Variablen belegen solange Speicher wie das Programm läuft.
Oftmals benötigt man sie aber nur einen kurzen Moment im Programmverlauf.
Daher meine Meinung: Wenn man es effektiv vermeiden kann sollte man statt globalen Variablen lokale nehmen wenn es sinnvoll umsetzbar ist.
Das hat aber mit Dim und Global nichts tun da man mit Dim ja genauso globale Variablen erstellt wenn man es außerhalb von Funktionen einsetzt. -
Natürlich braucht man Globale Variablen.
In dem Fall ist es sogar egal ob du Global oder Dim nimmst - es macht hier keinen Unterschied.
Mal die AutoIt-Hilfe zitiert:ZitatDim = Wenn der Variablename nicht schon mit globalem Gültigleitsbereich existiert, hat die definiertr Variable einen lokalen Gültigkeitsbereich (falls die Variable schon global existiert, so wird die globale Variable verwendet!)
Global = Erzwingt globale Gültigkeit der Variablen
Local = Erzwingt lokale Gültigkeit der Variablen, bzw. innerhalb der FunktionMan sollte Local oder Global anstelle von Dim verwenden, um explizit den Gültigkeitsbereich für die Variable / Konstante / Array festzulegen.
Das heißt also in dem Fall wird die Variable $old_pos durch das Dim in seinem lokalen Gültigkeitsbereich als lokal definiert da es keine explizite globale Variable namens $old_pos gibt.
Da es sich hierbei allerdings um den "Außenrahmen" des Skriptes handelt ist sie überall verfügbar - also global.
Es macht hier also keinen Unterschied ob man hier Dim oder Global verwendet - die Variable ist auf jeden Fall global.
Allerdings sieht man bei Global gleich wie die Variable gedacht ist.globale variablen sind ja überall verfügbar. wenn du jetzt in einer funktion die gleiche variable hast und diese da bearbeitet oder überschrieben wird, dann haste auf einmal ziemlichen müll in deiner variable drinstehn.
Deswegen gibt es ja global und local, welche man auch entsprechend anwenden sollte so dass man problemlos einen Variablennamen in unterschiedlichen Gültigkeitsbereichen nutzen kann ohne das sie sich überschreiben:Spoiler anzeigen
[autoit]Global $Test = 10
[/autoit] [autoit][/autoit] [autoit]ConsoleWrite("Globale Variable $Test: " & $Test & @CRLF)
[/autoit] [autoit][/autoit] [autoit]
TestLocal()
ConsoleWrite("Globale Variable $Test nach Aufruf der Funktion Test(): " & $Test & @CRLF)
TestDim()
ConsoleWrite("Globale Variable $Test nach Aufruf der Funktion TestDim(): " & $Test & @CRLF)Func TestLocal()
[/autoit] [autoit][/autoit] [autoit]
Local $Test = 1
ConsoleWrite("Lokale Variable $Test: " & $Test & @CRLF)
EndFuncFunc TestDim()
[/autoit]
Dim $Test = 2
ConsoleWrite("Lokale Variable $Test: " & $Test & @CRLF)
EndFunc
Erst wenn man die Variablen mit Dim deklariert ist nicht mehr vorhersehbar was passiert und globale Variablen können in der Funktion überschrieben werden.
Also mit local und global ist man auf der sicheren Seite - Dim sollte vermieden werden. -
Zumindestens bei HTML und CSS handelt es sich nicht um Programmiersprachen sondern um Auszeichnungssprachen.
Sie haben lediglich beschreibenden Charakter. -
Kleine Ergänzung sonst gibts ne Fehlermeldung:
Bei der Deklaration von Arrays muss diese entsprechend als solche gekennzeichnet werden.
In dem Fall also je nach Kontext ein Global oder Local davor. -
Da brauchst du mit AutoIt nicht anzufangen - Office bringt alles nötige schon mit:
- >>Damit<< eine msp-Datei erstellen mit all deinen Einstellungen
- die erstellte msp-Datei in den Ordner "Updates" des Office-Setups kopieren.
- Setup starten
-
[autoit]
Func _SetState($Item, $State)
[/autoit]
GUICtrlSetState($Item, $State)
EndFunc
Meinste nich auch das zumindestens diese Funktion bisschen sinnfrei ist?...
Mehr als die Funktion GUICtrlSetState in _SetState "umbenennen" macht sie ja nicht. -
Willkommen im Forum.
[autoit]
Stichworte:FileGetTime
[/autoit]
If Then
Shutdown -
In vielen Anwendungsfällen entspricht die objektorientierte Programmierung eher dem "natürlichen Charakter" der Anwendung.
Beispielsweise soll man eine Bibliotheksverwaltung programmieren - da gibt es halt die Objekte Regale, dann Bücher usw.
Wie stellt man sich das prozedural stattdessen vor?
In diesen Fällen ist es logischer mit objektorientierter Programmierung.
Ansonsten wird es bei sehr großen Projekten echt schwer einen prozeduralen Code zu warten, zu ergänzen und überhaupt die Übersicht zu wahren.
Objektorientierte Programmierung ist hingegen deutlich modularer und damit übersichtlicher auch in großen Projekten.
Ich denke das sind die 2 entscheidenden Faktoren warum OO des öfteren der prozeduralen vorgezogen wird. -
Hat mir sehr viel spass gemacht wenn du oder jemand noch ideen hat dann immer her damit.

Hat definitiv Spaß gemacht aber weitere Ideen hab ich erstmal nicht mehr.
Wir haben aber nun viele verschiedene Ansätze für Teilprobleme welche man sich nun selbst frei zusammenbauen kann:- Auslesen der Dateien:
- FileFind...File
- dir-Kommandozeilenbefehl
- Shell-Objekt
- Datenstruktur zum Aufbau der Dateiliste:
- ausreichend groß vordimensioniertes Array
- Array mit kontinuierlichem ReDim
- String
- .Net-Strukturen (Stack, Queue, ArrayList)
- Vorgehensweise beim durchgehen der Unterordner:
- rekursiv
- iterativ mit .Net Strukturen als Zwischenspeicher für Unterordner
- iterativ mit String als Zwischenspeicher für Unterordner
Hinzu kommen dann noch diverse Anpassungen wie z.B. Filtermöglichkeiten.
Interessant wird es erst dann wieder wenn andere Ansätze hinzukommen.
Mir persönlich fällt erstmal keiner dazu ein aber vielleicht dir.
- Auslesen der Dateien:
-
-
Hab grad kein XP zur Hand aber das wär echt merkwürdig wenn der dir kein PID liefert.
Teste in dem Fall mal was ProcessExists zurück gibt.
Ansonsten wär eine Möglichkeit folgende Funktion:Spoiler anzeigen
[autoit];by Manko (http://www.autoitscript.com/forum/index.ph…ndpost&p=633581)
[/autoit]
Func _WinAPI_GetCommandLineFromPID($PID)
$ret1=DllCall("kernel32.dll", 'int', 'OpenProcess', 'int', $PROCESS_VM_READ+$PROCESS_QUERY_INFORMATION, 'int', False, 'int', $PID)
$tag_PROCESS_BASIC_INFORMATION = "int ExitStatus;" & _
"ptr PebBaseAddress;" & _
"ptr AffinityMask;" & _
"ptr BasePriority;" & _
"ulong UniqueProcessId;" & _
"ulong InheritedFromUniqueProcessId;"
$PBI=DllStructCreate($tag_PROCESS_BASIC_INFORMATION)
DllCall("ntdll.dll", "int", "ZwQueryInformationProcess", "hwnd", $ret1[0], "int", 0, "ptr", DllStructGetPtr($PBI), "int", _
DllStructGetSize($PBI), "int",0)
$dw=DllStructCreate("ptr")
DllCall("kernel32.dll", "int", "ReadProcessMemory", "hwnd", $ret1[0], _
"ptr", DllStructGetData($PBI,2)+0x10, _ ; PebBaseAddress+16 bytes <-- ptr _PROCESS_PARAMETERS
"ptr", DllStructGetPtr($dw), "int", 4, "ptr", 0)
$unicode_string = DllStructCreate("ushort Length;ushort MaxLength;ptr String")
DllCall("kernel32.dll", "int", "ReadProcessMemory", "hwnd", $ret1[0], _
"ptr", DllStructGetData($dw, 1)+0x40, _ ; _PROCESS_PARAMETERS+64 bytes <-- ptr CommandLine Offset (UNICODE_STRING struct) - Win XP / Vista.
"ptr", DllStructGetPtr($unicode_string), "int", DllStructGetSize($unicode_string), "ptr", 0)
$ret=DllCall("kernel32.dll", "int", "ReadProcessMemory", "hwnd", $ret1[0], _
"ptr", DllStructGetData($unicode_string, "String"), _ ; <-- ptr Commandline Unicode String
"wstr", 0, "int", DllStructGetData($unicode_string, "Length") + 2, "int*", 0) ; read Length + terminating NULL (2 bytes in unicode)
DllCall("kernel32.dll", 'int', 'CloseHandle', "hwnd", $ret1[0])
If $ret[5] Then Return $ret[3] ; If bytes returned, return commandline...
Return "" ; Getting empty string is correct behaviour when there is no commandline to be had...
EndFuncOder der (langsamere) Weg über WMI:
Spoiler anzeigen
[autoit]Global $Prozessname = "javaw.exe"
[/autoit] [autoit][/autoit] [autoit]Global $oWMI = ObjGet("winmgmts:\\localhost\root\CIMV2")
[/autoit] [autoit][/autoit] [autoit]For $oProc In $oWMI.ExecQuery('SELECT CommandLine, Name FROM Win32_Process WHERE Name="' & $Prozessname & '"', "WQL", 48)
[/autoit]
MsgBox(0,"", $oProc.Name & ':' & @TAB & $oProc.CommandLine)
Next
$oWMI = 0 -
Eigentlich suchst du nur eine Funktion welche die Startparameter von einem Prozess ausliest.
Hier ist ein Beispiel dafür:Spoiler anzeigen
[autoit]$aProc = ProcessList("javaw.exe")
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]
For $i = 1 To $aProc[0][0]
ConsoleWrite($aProc[$i][0] & ':' & @TAB & _WinAPI_GetCommandLineFromPID($aProc[$i][1]) & @CRLF)
Next; by trancexx (http://www.autoitscript.com/forum/index.ph…ndpost&p=780861)
[/autoit] [autoit][/autoit] [autoit]
Func _WinAPI_GetCommandLineFromPID($iPID)
Local $aCall = DllCall("kernel32.dll", "handle", "OpenProcess", _
"dword", 1040, _ ; PROCESS_VM_READ | PROCESS_QUERY_INFORMATION
"bool", 0, _
"dword", $iPID)If @error Or Not $aCall[0] Then
[/autoit] [autoit][/autoit] [autoit]
Return SetError(1, 0, "")
EndIf
Local $hProcess = $aCall[0]
Local $tPROCESS_BASIC_INFORMATION = DllStructCreate("dword_ptr ExitStatus;" & _
"ptr PebBaseAddress;" & _
"dword_ptr AffinityMask;" & _
"dword_ptr BasePriority;" & _
"dword_ptr UniqueProcessId;" & _
"dword_ptr InheritedFromUniqueProcessId")
$aCall = DllCall("ntdll.dll", "int", "NtQueryInformationProcess", _
"handle", $hProcess, _
"dword", 0, _ ; ProcessBasicInformation
"ptr", DllStructGetPtr($tPROCESS_BASIC_INFORMATION), _
"dword", DllStructGetSize($tPROCESS_BASIC_INFORMATION), _
"dword*", 0)
If @error Then
DllCall("kernel32.dll", "bool", "CloseHandle", "handle", $hProcess)
Return SetError(2, 0, "")
EndIfLocal $tPEB = DllStructCreate("byte InheritedAddressSpace;" & _
[/autoit] [autoit][/autoit] [autoit]
"byte ReadImageFileExecOptions;" & _
"byte BeingDebugged;" & _
"byte Spare;" & _
"ptr Mutant;" & _
"ptr ImageBaseAddress;" & _
"ptr LoaderData;" & _
"ptr ProcessParameters;" & _
"ptr SubSystemData;" & _
"ptr ProcessHeap;" & _
"ptr FastPebLock;" & _
"ptr FastPebLockRoutine;" & _
"ptr FastPebUnlockRoutine;" & _
"dword EnvironmentUpdateCount;" & _
"ptr KernelCallbackTable;" & _
"ptr EventLogSection;" & _
"ptr EventLog;" & _
"ptr FreeList;" & _
"dword TlsExpansionCounter;" & _
"ptr TlsBitmap;" & _
"dword TlsBitmapBits[2];" & _
"ptr ReadOnlySharedMemoryBase;" & _
"ptr ReadOnlySharedMemoryHeap;" & _
"ptr ReadOnlyStaticServerData;" & _
"ptr AnsiCodePageData;" & _
"ptr OemCodePageData;" & _
"ptr UnicodeCaseTableData;" & _
"dword NumberOfProcessors;" & _
"dword NtGlobalFlag;" & _
"ubyte Spare2[4];" & _
"int64 CriticalSectionTimeout;" & _
"dword HeapSegmentReserve;" & _
"dword HeapSegmentCommit;" & _
"dword HeapDeCommitTotalFreeThreshold;" & _
"dword HeapDeCommitFreeBlockThreshold;" & _
"dword NumberOfHeaps;" & _
"dword MaximumNumberOfHeaps;" & _
"ptr ProcessHeaps;" & _
"ptr GdiSharedHandleTable;" & _
"ptr ProcessStarterHelper;" & _
"ptr GdiDCAttributeList;" & _
"ptr LoaderLock;" & _
"dword OSMajorVersion;" & _
"dword OSMinorVersion;" & _
"dword OSBuildNumber;" & _
"dword OSPlatformId;" & _
"dword ImageSubSystem;" & _
"dword ImageSubSystemMajorVersion;" & _
"dword ImageSubSystemMinorVersion;" & _
"dword GdiHandleBuffer[34];" & _
"dword PostProcessInitRoutine;" & _
"dword TlsExpansionBitmap;" & _
"byte TlsExpansionBitmapBits[128];" & _
"dword SessionId")$aCall = DllCall("kernel32.dll", "bool", "ReadProcessMemory", _
[/autoit] [autoit][/autoit] [autoit]
"ptr", $hProcess, _
"ptr", DllStructGetData($tPROCESS_BASIC_INFORMATION, "PebBaseAddress"), _
"ptr", DllStructGetPtr($tPEB), _
"dword", DllStructGetSize($tPEB), _
"dword*", 0)If @error Or Not $aCall[0] Then
[/autoit] [autoit][/autoit] [autoit]
DllCall("kernel32.dll", "bool", "CloseHandle", "handle", $hProcess)
Return SetError(3, 0, "")
EndIfLocal $tPROCESS_PARAMETERS = DllStructCreate("dword AllocationSize;" & _
[/autoit] [autoit][/autoit] [autoit]
"dword ActualSize;" & _
"dword Flags;" & _
"dword Unknown1;" & _
"word LengthUnknown2;" & _
"word MaxLengthUnknown2;" & _
"ptr Unknown2;" & _
"handle InputHandle;" & _
"handle OutputHandle;" & _
"handle ErrorHandle;" & _
"word LengthCurrentDirectory;" & _
"word MaxLengthCurrentDirectory;" & _
"ptr CurrentDirectory;" & _
"handle CurrentDirectoryHandle;" & _
"word LengthSearchPaths;" & _
"word MaxLengthSearchPaths;" & _
"ptr SearchPaths;" & _
"word LengthApplicationName;" & _
"word MaxLengthApplicationName;" & _
"ptr ApplicationName;" & _
"word LengthCommandLine;" & _
"word MaxLengthCommandLine;" & _
"ptr CommandLine;" & _
"ptr EnvironmentBlock;" & _
"dword Unknown[9];" & _
"word LengthUnknown3;" & _
"word MaxLengthUnknown3;" & _
"ptr Unknown3;" & _
"word LengthUnknown4;" & _
"word MaxLengthUnknown4;" & _
"ptr Unknown4;" & _
"word LengthUnknown5;" & _
"word MaxLengthUnknown5;" & _
"ptr Unknown5;")$aCall = DllCall("kernel32.dll", "bool", "ReadProcessMemory", _
[/autoit] [autoit][/autoit] [autoit]
"ptr", $hProcess, _
"ptr", DllStructGetData($tPEB, "ProcessParameters"), _
"ptr", DllStructGetPtr($tPROCESS_PARAMETERS), _
"dword", DllStructGetSize($tPROCESS_PARAMETERS), _
"dword*", 0)If @error Or Not $aCall[0] Then
[/autoit] [autoit][/autoit] [autoit]
DllCall("kernel32.dll", "bool", "CloseHandle", "handle", $hProcess)
Return SetError(4, 0, "")
EndIf$aCall = DllCall("kernel32.dll", "bool", "ReadProcessMemory", _
[/autoit]
"ptr", $hProcess, _
"ptr", DllStructGetData($tPROCESS_PARAMETERS, "CommandLine"), _
"wstr", "", _
"dword", DllStructGetData($tPROCESS_PARAMETERS, "MaxLengthCommandLine"), _
"dword*", 0)
If @error Or Not $aCall[0] Then
DllCall("kernel32.dll", "bool", "CloseHandle", "handle", $hProcess)
Return SetError(5, 0, "")
EndIf
DllCall("kernel32.dll", "bool", "CloseHandle", "handle", $hProcess)
Return $aCall[3]
EndFunc -
Mein Ansatz aus dem zitierten Thread hat dich wohl doch nicht so weiter gebracht?
Nun dann mal einen wirklich großen Ansatz mit vielen Kommentaren.
ProcessClose hab ich nicht eingebaut - das kannst du dir dann sicherlich selbst machen:Spoiler anzeigen
[autoit]#include <Crypt.au3> ;Wird für die Funktion _Crypt_HashFile benötigt
[/autoit] [autoit][/autoit] [autoit]Global $aProc, $sPath, $iHash ;Deklariere später genutzte Variablen - nicht unbedingt nötig - aber sauberer Programmierstil
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]
Global $iBlockHash = "0x2626FC9755BE22F805D3CFA0CE3EE727" ;Beispielhashwert meiner Explorer.exeWhile 1 ; Endlosschleife da das Programm ja die ganze Zeit laufen soll
[/autoit] [autoit][/autoit] [autoit]
$aProc = ProcessList() ;Liest alle derzeit laufenden Prozesse in ein ArrayFor $i = 1 To $aProc[0][0] ;Schleife um das eben erstellte Array durchzugehen
[/autoit] [autoit][/autoit] [autoit]
$sPath = _ProcessGetPath($aProc[$i][1]) ;Ermittelt den Pfad des Prozesses an der derzeitigen Arrayposition und schreibt ihn in die Variable $sPathIf StringLen($sPath) > 3 Then ;Systemprogramme und Dienste geben keinen vernünftigen Pfad zurück - deswegen muss dieser Fall abgefragt werden
[/autoit] [autoit][/autoit] [autoit]
$iHash = _Crypt_HashFile($sPath, $CALG_MD5) ;Ermittelt den Hashwert der Datei deren Pfad in $sPath steht mit dem MD5-AlgorithmusIf $iHash = $iBlockHash Then ; Frage ab ob die ermittelte Hash der zu blockenden entspricht.
[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]
MsgBox(0, "Gefunden", "Der Prozess wurde gefunden - seine PID für z.B. Processclose() lautet: " & $aProc[$i][1])
EndIf
EndIf
Next
Sleep(500) ; Kleine Atempause für den Rechner
WEnd; Funktion welche den Dateipfad eines Prozesses ausliest:
[/autoit]
Func _ProcessGetPath($PID)
If IsString($PID) Then $PID = ProcessExists($PID)
$Path = DllStructCreate("char[1000]")
$dll = DllOpen("Kernel32.dll")
$handle = DllCall($dll, "int", "OpenProcess", "dword", 0x0400 + 0x0010, "int", 0, "dword", $PID)
$ret = DllCall("Psapi.dll", "long", "GetModuleFileNameEx", "long", $handle[0], "int", 0, "ptr", DllStructGetPtr($Path), "long", DllStructGetSize($Path))
$ret = DllCall($dll, "int", "CloseHandle", "hwnd", $handle[0])
DllClose($dll)
Return DllStructGetData($Path, 1)
EndFunc ;==>_ProcessGetPath -
PS: Wenn du progandy und meine func antreten llassen willst dann bitte auf gleicher bassis denn in unser Func ist noche ein zusatz, bei progandy ( __FLTAEx_FileIsSymlink) und bei mir ( _F_L_) das
ist eine Func zum prüfen von Symlink die eine Schleife verursacht.
Hab die REPARSE_POINT-Abfrage noch mit in meine Funktionen eingebaut und deine Funktion aktualisiert und das Ergebnis sieht nun so aus:Spoiler anzeigen
[autoit]-------------------- _FL2Arr ---------------------
[/autoit] [autoit][/autoit] [autoit]
Dauer: 15466 ms
--------------------------------------------------------------------- _FileListToArrayEx ---------------------
[/autoit] [autoit][/autoit] [autoit]
Dauer: 6744 ms
--------------------------------------------------------------------- FLwStr ---------------------
[/autoit] [autoit][/autoit] [autoit]
Dauer: 6697 ms
--------------------------------------------------------------------- FLwStrRek ---------------------
[/autoit] [autoit][/autoit] [autoit]
Dauer: 6857 ms
--------------------------------------------------------------------- _File_List_Rekursiv ---------------------
[/autoit] [autoit][/autoit] [autoit]
Dauer: 5665 ms
--------------------------------------------------------------------- FileListCmd ---------------------
[/autoit] [autoit][/autoit] [autoit]
Dauer: 7765 ms
--------------------------------------------------------------------- _GetFilesFolder_Rekursiv ---------------------
[/autoit]
Dauer: 104729 ms
-------------------------------------------------
Die _File_List_Rekursiv ist nun natürlich die schnellste von allen da sie die Suche nach einer dynamischen Datenstruktur komplett ignoriert in dem dort einfach ein Array mit 10066329 Elementen im Arbeitsspeicher erstellt wird.
Alle anderen Funktionen versuchen hingegen nur soviel Speicher zu belegen wie sie tatsächlich benötigen, sei es über ein String, eine Queue oder ein kontinuierliches ReDim des Arrays.
Das kostet natürlich Zeit, ist aber sauberer. -
Nein den gibt es nicht - den musst du dir selber schreiben.
Deswegen hab ich dir die dazu nötigen Funktionen und eine mögliche Vorgehensweise genannt.