Beiträge von Runa

Misterspeed: Da machst du es dir aus Sicherheitsgründen meines Erachtens viel zu restriktiv...

Folgende Funktion macht das gleiche wie "Execute" lässt dabei aber nur Strings und AutoIt-Makros zu.

$s_Au3String = '"Das ist ein Test." & @CRLF & @TAB & "Weiter geht es." & @CRLF'
ConsoleWrite(_SaveExecute($s_Au3String))


Func _SaveExecute($sExecute)
	Local $aElements = StringSplit($sExecute, "&")
	Local $sSaveExecute = ""
	Local $fSave = False
	For $i = 1 To $aElements[0]
		$fSave = False
		$aElements[$i] = StringStripWS($aElements[$i], 3)
		If StringRegExp($aElements[$i], '^"', 0) Then $fSave = True	;Strings Version 1
		If StringRegExp($aElements[$i], "^'", 0) Then $fSave = True	;Strings Version 2
		If StringRegExp($aElements[$i], "^@", 0) Then $fSave = True	;AutoIt Makro
		If $fSave Then $sSaveExecute &= $aElements[$i] & "&"
	Next
	If StringRight($sSaveExecute, 1) = "&" Then $sSaveExecute = StringTrimRight($sSaveExecute, 1)
	Return Execute($sSaveExecute)
EndFunc

Natürlich ist die Funktion noch nicht zu 100% funktional (kleinere Probleme hat sie noch...), aber sie beseitigt schon mal die meisten Versuche, die man darauf loslässt.

Gerade aus einem alten (~5 Jahre alt) Script ausgegraben... vielleicht kann es hier ja noch wer gebrauchen.

Func __Levenshtein($s, $t)
	Local $m, $n, $iMaxM, $iMaxN
	$n = StringLen($s)
	$m = StringLen($t)
	$ss = StringSplit($s, "")
	$tt = StringSplit($t, "")
	$iMaxN = $n + 1
	$iMaxM = $m + 1
	Dim $d[$iMaxN + 1][$iMaxM + 1]
	$d[0][0] = 0
	If $n = 0 Then
		Return $m
	ElseIf $m = 0 Then
		Return $n
	EndIf
	For $i = 1 To $n
		$d[$i][0] = $d[$i - 1][0] + 1
	Next
	For $j = 1 To $m
		$d[0][$j] = $d[0][$j - 1] + 1
	Next
	For $i = 1 To $n
		For $j = 1 To $m
			$jj = $j - 1
			$ii = $i - 1
			Local $cost
			If (StringMid($s, $i, 1) = StringMid($t, $j, 1)) Then
				$cost = 0
			Else
				$cost = 1
			EndIf
			$d[$i][$j] = __Min(__Min($d[$ii][$j] + 1, $d[$i][$jj] + 1), $d[$ii][$jj] + $cost)
		Next
	Next
	Return $d[$n][$m]
EndFunc
Func __Min($iNum1, $iNum2)
	Return (Number($iNum1) > Number($iNum2)) ? Number($iNum2) : Number($iNum1)
EndFunc

Hinweis: Nicht sicher, ob damals selbst geschrieben oder eine modifizierte Fassung eines anderen Nutzers. Lob sollte daher an den unbekannten Nutzer gehen.

AutoMit:

Das stimmt, allerdings nur solange, bis in der Ini ein kleiner Buchstabendreher oder ähnliches vorkommt.

GUICtrlSetData($Combo1, $DropDownListe) -> DropDownList wird um $DropDownListe ergänzt
GUICtrlSetData($Combo1, $DropDownListe, $DropDownListe) -> DropDownList wird um $DropDownListe ergänzt und dieses ausgewählt

Ich glaube, dass das nicht geplant ist: Daher hier mal dein Code ergänzt um eine Funktion die ich mal verwendet habe...

#include <ComboConstants.au3>
#include <GUIConstantsEx.au3>
#include <WindowsConstants.au3>
;Neuer Include
#include <GuiComboBox.au3>


Local $Form_01 = GUICreate("Form_01", 262, 151, 1022, 155)
Local $Combo1 = GUICtrlCreateCombo("", 32, 24, 193, 25, BitOR($CBS_DROPDOWNLIST,$CBS_AUTOHSCROLL))
GUICtrlSetData(-1, "Kiwi|Apfel|Weintraube")
GUISetState(@SW_SHOW)




;Ein "falsch geschriebener Ini-Wert"
$DropDownListe = "Ai"


;Kleine Funktion zum Setzen des Wertes nach Ähnlichkeit
_GUICtrlSetData_Combo($Combo1, $DropDownListe)


While 1
	$nMsg = GUIGetMsg()
	Switch $nMsg
		Case $GUI_EVENT_CLOSE
			Exit


	EndSwitch
WEnd


;Neue Funktionen
Func _GUICtrlSetData_Combo($hCombo, $sData)
	Local $iMin = 5000
	Local $sTemp = ""
	Local $aRead = _GUICtrlComboBox_GetListArray($hCombo)


	For $i = 1 To $aRead[0]
		$iDis = __Levenshtein($sData, $aRead[$i])
		If $iDis < $iMin Then
			$iMin = $iDis
			$sTemp = $aRead[$i]
		EndIf
	Next


	GUICtrlSetData($Combo1, $sTemp, $sTemp)
EndFunc


;Berechnet die Levenshtein-Distanz von zwei Worten
Func __Levenshtein($s, $t)
	Local $m, $n, $iMaxM, $iMaxN


	$n = StringLen($s)
	$m = StringLen($t)
	$ss = StringSplit($s, "")
	$tt = StringSplit($t, "")
	$iMaxN = $n + 1
	$iMaxM = $m + 1
	Dim $d[$iMaxN + 1][$iMaxM + 1]
	$d[0][0] = 0


	If $n = 0 Then
		Return $m
		ElseIf $m = 0 Then
		Return $n
	EndIf


	For $i = 1 To $n
		$d[$i][0] = $d[$i - 1][0] + 1
	Next
	For $j = 1 To $m
		$d[0][$j] = $d[0][$j - 1] + 1
	Next


	For $i = 1 To $n
		For $j = 1 To $m
			$jj = $j - 1
			$ii = $i - 1
			Local $cost
			If (StringMid($s, $i, 1) = StringMid($t, $j, 1)) Then
				$cost = 0
			Else
				$cost = 1
			EndIf
			$d[$i][$j] = __Min(__Min($d[$ii][$j] + 1, $d[$i][$jj] + 1), $d[$ii][$jj] + $cost)
		Next
	Next
	Return $d[$n][$m]
EndFunc


;Gibt die kleinere Zahl aus
Func __Min($iNum1, $iNum2)
	Return (Number($iNum1) > Number($iNum2)) ? Number($iNum2) : Number($iNum1)
EndFunc

Evtl. hilft dir das ja

Kurze Antwort: Ja.

Ausführlicher: Ich empfehle den "Recorder" nur sehr sehr eingeschränkt. Ändert sich der Titel des Fensters nur leicht -> Läuft nicht. Verändert sich die Position des Fensters -> Läuft nicht. Soll das Script im Hintergrund laufen können. -> Is nicht.

Für deinen "Job" empfiehlt es sich, die IE.au3 zu verwenden und direkt im Webbrowser zu automatisieren, statt diesen von außen anzusteuern. Tutorials, Tipps und Anleitungen dazu gibt es im WWW in Massen.

Wenn es wirklich so viel ist, wie hier angedeutet wird, wäre eine Fragmentierung wohl der sinnigste Weg.

$OrdAngAlt ließt du nur ganz am Anfang aus ... bedeutet so viel wie: Du kannst aus dem Input ein Label machen, weil du ohnehin nie wieder ausließt, was drin steht. EGAL was der Nutzer da rein schreibt, es bleibt immer das, was es initial war.


Stand "14" drin, bleibt es "14" für die gesamte Laufzeit des Scripts. Steht eben "" drin, bleibt es "" für die gesamte Laufzeit des Scripts.

Dein Script würde den Ordner also finden, wenn es den Ordner "G:\D....\KIen....\ANGEBOT 20\" gäbe. Tut es aber vermutlich nicht.

Gleiches Problem hast du übrigens auch bei OrdAufAlt und OrdAltAA.

Zitat von Kanashius

Int($zahl/1)->Ohne Kommastellen
Round($zahl,2)->2 Nachkommastellen
$InputString=StringReplace($InputString,",",".")->Kommas im Input erlauben

Round($zahl, 0) -> Ohne Kommastellen - selbes Ergebnis, nur weniger "Kuddelmuddel" mit unterschiedlichsten Funktionen.

Michl: Es fehlt die Information wo genau du jetzt KEIN Komma brauchst, und wo du ZWEI Kommata benötigst. Faktisch hast du nur eine einzige Rechnung, deren Ergebnis du in ein Input schreiben lässt, welches du bisher nie wieder ausließt.

Nehmen wir mal an, dass du den Nenner deiner Rechnung (derzeit alles Strich-Rechnungen) ohne Komma brauchst, während du das Endergebnis gerne mit zwei Kommata hättest. Dann bräuchtest du diesen Ansatz:

Funktion(Funktion($Zahl1 + $Zahl2 + $Zahl3 + $Zahl4 - $Zahl6 - $Zahl7 - $Zahl8 - $Zahl9) / $Zahl5)

Für Funktion musst du dann die Funktion einsetzen, die du benötigst.

Floor - Rundet immer auf die niedrigere Ganzzahl ab.
Round - Rundet kaufmännisch korrekt.
Ceiling - Rundet immer auf die höhere Ganzzahl auf.

Solltest du bei den Funktionen Floor oder Ceiling Nachkommastellen brauchen, könntest du folgende Funktion von mir verwenden:

Func __Round($vNumber, $iDecimalplaces = 0, $sFunction = "Round")
	If $iDecimalplaces = 0 Then Return Execute($sFunction & "($vNumber)")
	$iMult = 1
	For $i = 1 To $iDecimalplaces
		$iMult *= 10
	Next
	$vNumber = Execute($sFunction & "($vNumber * $iMult)") / $iMult
	Return $vNumber
EndFunc

Falls das zu verwirrend ist, hast du hier noch drei Hilfsfunktionen:

Func _Round($vNumber, $iDecimalplaces)
	Return __Round($vNumber, $iDecimalplaces, "Round")
EndFunc


Func _Floor($vNumber, $iDecimalplaces)
	Return __Round($vNumber, $iDecimalplaces, "Floor")
EndFunc


Func _Ceilling($vNumber, $iDecimalplaces)
	Return __Round($vNumber, $iDecimalplaces, "Ceilling")
EndFunc


Func __Round($vNumber, $iDecimalplaces = 0, $sFunction = "Round")
	If $iDecimalplaces = 0 Then Return Execute($sFunction & "($vNumber)")


	$iMult = 1
	For $i = 1 To $iDecimalplaces
		$iMult *= 10
	Next
	$vNumber = Execute($sFunction & "($vNumber * $iMult)") / $iMult
	Return $vNumber
EndFunc

Schreibe bitte nicht so etwas wie "brauch das Ergebnis ohne Komma stellen und später dann bräucht ich ein Ergebnis mit 2 Kommastellen" sondern ein konkretes Problem. Hier nur mal vier Interpretationsansätze für das vorher genannte Problem. Jeder Interpretationsansatz benötigt einen anderen Lösungsweg:

Interpretation 1: Die Strich-Rechnungen des Scripts sollen auf null Nachkommastellen gerundet werden (Floor? Ceiling? Round?). Das Endergebnis der Rechnung soll dann mit maximal zwei Kommastellen angezeigt werden.
Interpretation 2: Ziemlich genau wie Interpretation 1. Es sollen aber *immer* 2 Nachkommastellen beim Endergebnis angezeigt werden (bsp.: 25.00)
Interpretation 3: Das Endergebnis soll in der GUI ohne Nachkommastellen angezeigt werden, allerdings für eine spätere Rechnung auf zwei Kommastellen gerundet wieder bereit stehen.
Interpretation 4: Das Endergebnis soll auf 0 Nachkommastellen gerundet werden, in der GUI soll es allerdings dennoch mit zwei Nachkommastellen angezeigt werden. (Ergebnis: 24.98 -> Round: 25 -> GUI: 25.00)

... und die Liste lässt sich noch weiter führen. Ich möchte dir auch nicht auf den Schlips treten, aber es ist schwierig dir zu helfen, wenn ich nicht einmal dein Problem kenne. Denn ich kann dir nicht in den Kopf gucken um zu wissen, was jetzt "das Ergebnis" ist, und was "ein Ergebnis". Um weiter helfen zu können wäre es sinnvoll zu wissen, was genau das Problem ist. Solange wir uns hier sprichwörtlich mit der Kristallkugel hinsetzen müssen, ist es schwierig dir bei deinem individuellen Problem zu helfen. Solange die Formulierungen nicht eindeutig sind, werde ich persönlich keinen Beitrag mehr in diesem Thread leisten, da es nicht nur dir nicht wirklich hilft, wenn ich hier im Nebel stochere, sondern zudem auch meine Zeit frisst, die ich damit hätte verbringen können jemandem zu helfen.

HotKeySet("{NumpadDiv}", "_Key")
HotKeySet("{NumpadMult}", "_Key")
HotKeySet("{NumpadSub}", "_Key")
HotKeySet("{NumpadAdd}", "_Key")
HotKeySet("{NumpadDot}", "_Key")


While 1
WEnd


Func _Key()
	ConsoleWrite(@HotKeyPressed & @CRLF)
EndFunc

Numpad-Enter kann nicht als Hotkey gesetzt werden.

Alina: Mir ist es nicht gelungen einen ungültigen SQL-Befehl hinzubekommen mit meinem Tool x'D

Das Script ist hoffentlich nicht dein aktuelles, da das nur mit einer Fehlermeldung starten kann, da du die Funktion "Button2" nicht definiert hast. Zum anderen vermischst du OnEvent Code mit anderem. On Event ist dabei ausgeschaltet.

1. Wie mach ich das jetzt genau, wenn ich durch 2 divitiere bekomm ich das selbe Ergebnis als wenn ich durch 2,5 divitieren würde.

Also, wenn als Divident dort 2.5 angegeben werden würde, willst du dennoch durch 2 teilen? Erscheint mir unlogisch, daher der sinnvollste Ansatz... den Inhalt des Feldes direkt abrunden zu lassen, sobald das Feld verlassen wird.

2. Beispiel beim Runden: Ergebnis 2,3333333 rauskommen dann soll er mir auf 2,3 runden. Ergebnis 2,55555555 runden auf 2,6

Dazu musst du die Round-Funktion verwenden und ihr sagen, dass du eine Nachkommastelle brauchst.

Hier mal dein Code in aufgeräumt ... Bitte verwende zukünftig beim Posten von Scripts das Code-Tag. Das findest du direkt links neben dem Spoiler, welches du bereits erfolgreich verwendest.

#include <ButtonConstants.au3>
#include <EditConstants.au3>
#include <GUIConstantsEx.au3>
#include <StaticConstants.au3>
#include <WindowsConstants.au3>
#include <IE.au3>


GUICreate("Rechner", 280, 400, 494, 262)
$button1 = GUICtrlCreateButton("Start", 55, 10, 74, 27)
$button2 = GUICtrlCreateButton("Pause", 160, 10, 74, 27)
$input3 = GUICtrlCreateInput("2", 55, 105, 40, 15)
$input4 = GUICtrlCreateInput("3", 55, 130, 40, 15)
$input5 = GUICtrlCreateInput("2", 55, 155, 40, 15)
$input6 = GUICtrlCreateInput("4", 55, 180, 40, 15)
$input7 = GUICtrlCreateInput("8", 55, 205, 40, 15)
$input8 = GUICtrlCreateInput("2", 160, 130, 40, 15)
$input9 = GUICtrlCreateInput("3", 160, 155, 40, 15)
$input10 = GUICtrlCreateInput("4", 160, 180, 40, 15)
$input11 = GUICtrlCreateInput("2", 160, 205, 40, 15)
$input12 = GUICtrlCreateInput("", 55, 230, 100, 15)
$label3 = GUICtrlCreateLabel("z1", 10, 130, 30, 15)
$label4 = GUICtrlCreateLabel("z2", 10, 155, 30, 15)
$label5 = GUICtrlCreateLabel("z3", 10, 180, 30, 15)
$label6 = GUICtrlCreateLabel("z4", 10, 205, 30, 15)
$label7 = GUICtrlCreateLabel("Erg", 10, 230, 30, 15)
$label8 = GUICtrlCreateLabel("z5", 110, 130, 40, 15)
$label9 = GUICtrlCreateLabel("z6", 110, 155, 40, 15)
$label10 = GUICtrlCreateLabel("z7", 110, 180, 40, 15)
$label11 = GUICtrlCreateLabel("z8", 110, 205, 40, 15)
$label12 = GUICtrlCreateLabel("divitieren", 10, 105, 30, 15)
GUISetState(@SW_SHOW)


While 1
	$msg = GUIGetMsg()
	Switch $msg
		Case -3
			Exit
		Case $button1
			button1()
		Case $input3
			If GUICtrlRead($Input3) <> "" Then
				GUICtrlSetData($input3, Floor(GUICtrlRead($Input3)))
			EndIf
	EndSwitch
WEnd


Func button1()
	$Zahl1 = GUICtrlRead($input4)
	$Zahl2 = GUICtrlRead($input5)
	$Zahl3 = GUICtrlRead($input6)
	$Zahl4 = GUICtrlRead($input7)
	$Zahl5 = GUICtrlRead($input3)
	$Zahl6 = GUICtrlRead($input8)
	$Zahl7 = GUICtrlRead($input9)
	$Zahl8 = GUICtrlRead($input10)
	$Zahl9 = GUICtrlRead($input11)
	$Ergebnis = ($Zahl1 + $Zahl2 + $Zahl3 + $Zahl4 - $Zahl6 - $Zahl7 - $Zahl8 - $Zahl9) / $Zahl5
	$Ergebnis = Round($Ergebnis, 1)
	GUICtrlSetData($input12, $Ergebnis)
EndFunc   ;==>button1


Func End()
	Exit
EndFunc   ;==>End

Guck mal auf deine Funktion. An welcher Stelle rundest du denn? Die Antwort ist: An keiner. Die rundest weder auf noch ab noch kaufmännisch.

Was deine Problembeschreibung betrifft: Keine Ahnung was du damit ausdrücken wolltest, zumal ich dein Script nicht habe und die Funktion einem da nicht sonderlich weiterhilft. Kann deinen Rechen-Durchlauf nur mit irgendwelchen Beispieldaten durchgehen:

Zahl 1 - 13 (außer 5) = 1, Zahl 5 = 7.5

(1+1+1+1+1+1+1+1) / 7.5 = 8 / 7.5 = 1,066

Die anderen Rechnungen:

1 / 7.5 = 0,133

Wüsste nicht, warum der deine Zahlen da runden sollte (zumal du an keiner Stelle rundest), aber wenn er dies tun würde, würde er dir folgende Ergebnisse geben:

Rechnung 1: 1,142
Rechnung 2: 0,142

Wenn ich nun wüsste, WAS dein Problem genau ist, WANN es auftritt, WIE es sich auswirkt, etc. pp - dann könnte ich dir helfen. So kann ich dir nur die drei Rundungsfunktionen von AutoIt zeigen.

$dHigh	= 4.7
$iExact = 4
$dLow	= 4.2


;Es soll immer auf die nächste gerade Ganzzahl aufgerundet werden
MsgBox(64, "Ceiling(4.7)", Ceiling($dHigh))
MsgBox(64, "Ceiling(4)", Ceiling($iExact))
MsgBox(64, "Ceiling(4.2)", Ceiling($dLow))


;Es soll immer auf die nächste gerade Ganzzahl abgerundet werden
MsgBox(64, "Floor(4.7)", Floor($dHigh))
MsgBox(64, "Floor(4)", Floor($iExact))
MsgBox(64, "Floor(4.2)", Floor($dLow))


;Es soll immer kaufmännisch korrekt auf die nächste gerade Ganzzahl gerundet werden
MsgBox(64, "Round(4.7)", Round($dHigh))
MsgBox(64, "Round(4)", Round($iExact))
MsgBox(64, "Round(4.2)", Round($dLow))

Angenommen, ich verstehe das richtig ... du möchtest einfach nur prüfen, welche URL momentan geöffnet ist ... also im IE um zu wissen, ob die Person ausgeloggt ist ... hier mal ganz minimalistisch ...

#include <IE.au3>


$oIE = _IECreate("http://www.autoit.de/")


While Sleep(250)
	$sTool = _IEPropertyGet($oIE,"locationurl")
	If @error Then Exit
	ToolTip($sTool, 0, 0, "URL")
WEnd

10 Jahre schon. Und es wird leider relativ still um diese Domain.

Es ist ein Forum, welches mir durch diverse Nutzer mit denen ich gerne Zeit verbracht habe, aber auch ein Forum, welches mir durch diverse Nutzer mit denen ich auch weiterhin wenn überhaupt nur sehr distanziert Kontakt halten möchte, aber in beiden Fällen bereue ich keine Sekunde hier.

Auf das AutoIt.de auch noch weitere 10 Jahre - mindestens - aktiv weiter bestehen wird.

Zitat von Mokkaschnitte

Runa: ist mir nicht ganz klar - das Skript schläft doch immer 1 Minute zwischendurch, wie sollte es zu den vielen Schreibzyklen kommen?

Ich habe genau eine Bedingung überlesen gehabt, die wirklich dazu führt dass in der Regel eine Minute geschlafen wird. Alles gut.

@peter S. Taler: Muss man dich darauf hinweisen, dass dein Post ziemlich deutlich aussagt, dass du entweder meinen letzten Post nicht gelesen hast, oder ihn schlicht nicht verstanden hast?

Zitat von BugFix

Hmm, soll ich mir jetzt Sorgen machen, dass 1 Skript seit 2 Jahren und 3 Monaten (da wurde der PC zuletzt neu gestartet) ohne Murren als Dienst 24/7 arbeitet? Auch ein neuer Dienst, installiert Anfang August, weigert sich bisher beharrlich Schwierigkeiten zu machen.

Ich denke, man sollte nicht pauschal urteilen. Mir persönlich ist es noch nie passiert, dass ein (endgültig fertiggestelltes) Skript den Overflow-Tod gestorben ist.

Ich urteile nicht pauschal. Ich sage bloß, dass es sehr schnell passieren kann. Es kommt ja auch an, welche Funktionen man verwendet. Das mit dem Overflow hatte ich zum Beispiel bei häufigen FileWrites. Und das obwohl ich Handles verwendet habe und die immer wieder geschlossen habe... Es kann schnell passieren, muss es aber nicht. Man sollte es aus meiner Sicht dennoch nicht schlicht ignorieren. Natürlich kenne ich meine "Pappenheimer" mittlerweile auch. Es ist schnell klar, welche Funktionen da so bescheuert sind.

@Mokkaschnitte: Gehe ich zu Hause noch mal drauf ein. Von unterwegs ist das sehr nervig.

Zitat von misterspeed

Was Bioshade uns mit seiner Kritik zur Windows Aufgabenplannung sagen wollte ist mir nicht wirklich klar. Wenn die Software voll mit Bugs ist und abstürzt kann Windows da auch nichts dafür. Das passiert genauso wenn das Script im Kontext des angemeldeten Benutzers läuft, nur dass der Benutzer den Absturz der Software dann halt mitbekommt und mit der Nase drauf gestossen wird, dass hier irgendwas diletantisch programmiertes unsichtbar im Hintergrund läuft/lief.

Bioshade hat in ihrer Kritik zur Windows Aufgabenplanung zu bedenken geben wollen, dass AutoIt bei weitem nicht die stabilste Scriptsprache ist, wenn es um einen pseudo 24/7-Betrieb geht. Teilweise hast du dann das Problem, dass das Script einfach mal eben "hung" ist, oder einfach abgeschmiert ist oder sonst etwas. Jeder, der hier im Forum bereits einmal einen Windows-Service in AutoIt geschrieben hat weiß ganz genau: Egal wie simpel das Programm gehalten ist ... man hat ganz schnell einen Memory-Overflow erschaffen oder das Programm läuft - wie bereits erwähnt in eine Exception.

Was du an ihrer Kritik allerdings nicht verstanden hast ist die Tatsache, dass es nicht darum geht, ob das Script im Nutzerkontext oder in dem eines anderen Benutzers beispielsweise über die Aufgabenplanung gestartet wird. Es geht rein darum die Ausführungszeit des Scriptes so minimal wie möglich zu halten. Alles andere ist unzuverlässig, egal ob nun Aufgabenplanung oder in Form eines Dienstes. Bei den oben beschriebenen 60 Minuten mag das noch nicht - oder nicht häufig - zu einem Problem werden, was Dinge wie den Memory Overflow betrifft. Bei häufigen Interaktionen mit empfindlichen Ressourcen und schlechter Weiterverarbeitung würde sich in den 60 Minuten maximal ein Overflow von 150 MB ergeben - erfahrungsgemäß. Das killt einen Rechner noch nicht, aber je weiter man die Zeit skaliert, desto problematischer wird das Ganze.

RegWrite ("HKEY_CURRENT_USER\Software\timer", "Datum", "REG_SZ", @YEAR & "-" & @MON & "-" & @MDAY)

Das ist eine vermeidbare drastische Reduzierung der Lebenszeit der SSD ... Diese Zeile wird komplett ohne Bedingungen immer wieder in die Registry geschrieben. Bei 0.5 Sekunden pro Schleifendurchlauf sind das stolze 7200 Schreibaktionen, die nicht notwendig sind...

Also ich hätte ja eine versteckte Systemdatei verwendet, statt die Datei einfach offen hinzulegen, das zum einen. Zum anderen ist Aufgabenplanung weder sonderlich sinnvoll für sowas, noch extrem zuverlässig, da hier - wie auch bei Diensten - nur eine minimale Prüfung stattfindet, ob dein Script überhaupt noch läuft oder in eine Exception gelaufen ist. Die einzige sinnvolle Möglichkeit über die Aufgabenplanung ist aus meiner Sicht das Prüf-Script minimal zu halten und es nur "durchlaufen" zu lassen und es wieder - z.B. nach 5 Minuten - neu aufrufen zu lassen. Das andere Script, welches den Login-Zeitpunkt ausließt hingegen ist an einer der AutoStart-Locations. Vorzugsweise natürlich in der Registry.

Problem hättest du nur mit dem Logout, den du ja mitnehmen wolltest. Den bekommst du eigentlich nur vernünftig, wenn du die Zeit in der Textdatei durchgehend aktualisierst. Aber egal wie gut die versteckt ist, man wird sie problemlos finden, wenn sie derart häufig aufgerufen wird - außer, die Datei hat zusätzlich zu ihren Attributen noch einen Namen der nach Systemdatei klingt...

mhm... den habe ich zum Testen gerade nicht da ... eventuell klappt es aber mit der Lösung für den Adobe Acrobat Reader DC ... müsstest du mal testen:

#include <String.au3>
;// Datei die eingelesen wird
$sFile = 'O:\C# Tutorial - Uni Trier.pdf'
;// Reader-Spezifische Variablen
$sAdobeClass = "AcrobatSDIWindow"
$sAdobeEdit_Class = "Edit"
$iAdobeEdit_Instance = "2"
;// Öffnen der PDF-Datei im Reader
ShellExecute($sFile)
;// Warten bis das Fenster aktiv ist
WinWaitActive("[CLASS:" & $sAdobeClass & "]")
;// Ende an das Fenster senden
Send("{END}")
;// Liest die aktuelle Seite aus dem Adobe Reader DC aus
$iActualPage = ControlGetText("[CLASS:" & $sAdobeClass & "]", "", "[CLASS:" & $sAdobeEdit_Class & "; INSTANCE:" & $iAdobeEdit_Instance& "]")
;// Ausgabe ob letzte Seite oder nicht
If $iActualPage = ReadFile($sFile) Then
	MsgBox(64, "", "Letzte Seite")
Else
	MsgBox(16, "", "Nicht die letzte Seite")
EndIf
;// Gibt die Anzahl der Seiten innerhalb der PDF-Datei zurück - je größer die Datei, desto länger dauert es.
Func ReadFile($file)
	ToolTip("Reading amount of pages...")
	Local $xCtPg = 0
	$fsz = FileGetSize($file)
	$fileHd = FileOpen($file, 16)
	$Fch = FileRead($fileHd, $fsz)
	FileClose($fileHd)
	$objNr = GetObj($Fch, "/Root")
	$objCon = ReadObj($Fch, $objNr)
	If StringInStr($objCon, "/Pages") > 0 Then
		$xon = GetObj(_StringToHex($objCon), "/Pages")
		$xoc = ReadObj($Fch, $xon) ;$xon)
		$xCtPg = GetCount($xoc)
	EndIf
	ToolTip("")
	Return $xCtPg
EndFunc   ;==>ReadFile
Func GetObj($fc, $type)
	$typeh = _StringToHex($type)
	$x = StringMid($fc, StringInStr($fc, $typeh), 80)
	$x = _HexToString($x)
	$xct = StringLen($type)
	$xon = StringMid($x, $xct + 2, StringInStr($x, " R") - $xct - 2)
	Return $xon
EndFunc   ;==>GetObj
Func ReadObj($fc, $xon)
	$objh = _StringToHex(" obj")
	$objendh = _StringToHex("endobj")
	$xonh = _StringToHex($xon)
	$xonhs = "0D" & $xonh & $objh
	$x = StringMid($fc, StringInStr($fc, $xonhs, 0, -1))
	If $x = "" Then $x = StringMid($fc, StringInStr($fc, "0A" & $xonh & $objh, 0, -1))
	$xoch = StringMid($x, 1, StringInStr($x, $objendh) - 1)
	$xoc = _HexToString($xoch)
	Return $xoc
EndFunc   ;==>ReadObj
Func GetCount($xoc)
	$xocx = StringMid($xoc, StringInStr($xoc, "/Count ") + 7)
	$xct = ""
	For $i = 1 To 5
		$x = StringMid($xocx, $i, 1)
		$y = StringIsInt($x)
		If $y = 1 Then
			$xct &= $x
		Else
			ExitLoop
		EndIf
	Next
	Return $xct
EndFunc   ;==>GetCount

Falls das nicht funktioniert, musst du drei Variablen auswechseln ... alle unter dem Kommentar "Reader-Spezifische Variablen". Diese Informationen bekommst du alle mit dem Tool "AU3Info", welches Du im Editor unter "Tools" findest, sofern du ihn von dieser Seite bezogen hast. Ich hoffe, du weißt, wie du damit umgehen musst?

$sAdobeClass => Die Klasse des Adobe-Fensters
$sAdobeEdit_Class => Die Klasse des Inputfeldes in dem die aktuelle Seite steht
$iAdobeEdit_Instance => Die Instanz des Inputfeldes

Bitte denk daran, die gewünschte Datei auch anzugeben - ich bin mir nicht sicher, ob du das Laufwerk "O:\" mit dieser PDF besitzt...

Grundsätzlich ist das möglich.

Jetzt ist die Frage, wie - und dazu muss erst die Frage geklärt werden, welches Programm ihr zum Anzeigen der PDF im Augenblick verwendet...

Zum Anzeigen von PDF-Dateien gibt es ja unzählige - auch kostenlose - Programme, die alle einen anderen Lösungsweg erfordern würden... und bei manchen Kandidaten könntest du dort auch noch versionsbedingt zu Problemen kommen, die man hier nicht abfangen kann. Hier mal eine Liste an PDF-Viewern, die ich alleine vom Umgang mit unseren Kunden kenne:

Adobe Acrobat Reader DC
Foxit Reader
PDF-XChange Viewer
Adobe Acrobat XI Pro

....

Schon diese vier hätten grundlegend andere Ansätze um dieses Problem zu beseitigen...