Beiträge von chesstiger

Zitat von Bitnugger

Ja, bin sehr erstaunt, dass es mit WndProc nicht (mehr) geht...

So, ich hab's gelöst. Des Rätsels Lösung liegt im GWL_USERDATA-Feld. AutoIt scheint dort Informationen zu speichern. Um den Zugriff auf globale Variablen zu vermeiden, hatte ich in meinem Minimalbeispiel die Adresse der alten WNDPROC in diesem Feld abgelegt. Ohne funktioniert's.

Dazu fällt mir dieser Thread hier ein:

Script mit Login versehen

Einmal die SSD, eine Samsung 850 EVO M.2:

ASM-Code-Size:	34 Bytes


Schreibe Datei: "c:\temp\0001.ft"
Zeit: 1823 ms
Schreibrate: 588.9 MB/s


Schreibe Datei: "c:\temp\0002.ft"
Zeit: 2186 ms
Schreibrate: 491.1 MB/s


Schreibe Datei: "c:\temp\0003.ft"
Zeit: 2281 ms
Schreibrate: 470.6 MB/s


Schreibe Datei: "c:\temp\0004.ft"
Zeit: 3766 ms
Schreibrate: 285.1 MB/s

Und einmal die Hybridplatte Seagate FireCuda 2TB über SATA (ST2000LX001):

ASM-Code-Size:	34 Bytes


Schreibe Datei: "d:\temp\0001.ft"
Zeit: 9067 ms
Schreibrate: 118.4 MB/s


Schreibe Datei: "d:\temp\0002.ft"
Zeit: 14395 ms
Schreibrate: 74.6 MB/s


Schreibe Datei: "d:\temp\0003.ft"
Zeit: 16070 ms
Schreibrate: 66.8 MB/s


Schreibe Datei: "d:\temp\0004.ft"
Zeit: 18653 ms
Schreibrate: 57.6 MB/s

Mit den verschieden komplexen Bytemustern würde mich jetzt auch interessieren.

Ich habe jetzt nicht weiter rumprobiert, aber es kann durchaus sein, dass du da an die Grenzen von normalen GUI-Controls kommst. Evtl. müsstest du für so schnelles Zeichnen auf GDIPlus (ö.Ä.) ausweichen.

Ich hab mal für ein Theaterstück einen Countdown bis zum Beginn programmiert. Das war aber so eine "Es geht in einer halben Stunde los, kriegen wir das noch hin?"-Aktion, daher... Keine Resourcenfreigabe oder so. Bitte so nicht produktiv verwenden!

#include <GDIPlus.au3>
#include <WindowsConstants.au3>


Global Const $PI = 3.141592654


Opt("GUIOnEventMode", True)
DllCall("User32.dll","bool","SetProcessDPIAware")
_GDIPlus_Startup()


;changeable
$iWndW = @DesktopWidth
$iWndH = @DesktopHeight
;end changeable


$hWnd = GUICreate("", $iWndW, $iWndH, 0, 0, $WS_POPUP, $WS_EX_TOPMOST)
GUISetOnEvent(-3, OnCloseClick)
;basic graphics
$hGfx = _GDIPlus_GraphicsCreateFromHWND($hWnd)
$hBmp = _GDIPlus_BitmapCreateFromGraphics($iWndW, $iWndH, $hGfx)
$hBuf = _GDIPlus_ImageGetGraphicsContext($hBmp)
_GDIPlus_GraphicsSetSmoothingMode($hGfx, 2)
_GDIPlus_GraphicsSetSmoothingMode($hBuf, 2)
;generate watch base image
$hWatchBmp = _GDIPlus_BitmapCreateFromScan0(500, 500) ;fix, resize later
$hWatchGfx = _GDIPlus_ImageGetGraphicsContext($hWatchBmp)
_GDIPlus_GraphicsSetSmoothingMode($hWatchGfx, 2)
$hWatchPen = _GDIPlus_PenCreate(0xffffffff, 10) ;better use solid color...
$hWatchBrush = _GDIPlus_BrushCreateSolid(0xffffffff)
$hDotPen = _GDIPlus_PenCreate(0xffdddddd, 5) ;better use solid color...
_GDIPlus_GraphicsDrawEllipse($hWatchGfx, 10, 10, 480, 480, $hWatchPen)
$iInnerR = 200
$iOuterR = 240
For $i = 0 To 59 ;60 minute dots
$iOuterX = 250 + Cos((2 * $PI / 60) * $i) * ($iOuterR - 20)
$iOuterY = 250 + Sin((2 * $PI / 60) * $i) * ($iOuterR - 20)
_GDIPlus_GraphicsDrawEllipse($hWatchGfx, $iOuterX - 2, $iOuterY - 2, 4, 4, $hDotPen)
Next
For $i = 0 To 11 ;12 hour lines
$iInnerX = 250 + Cos((2 * $PI / 12) * $i) * $iInnerR
$iInnerY = 250 + Sin((2 * $PI / 12) * $i) * $iInnerR
$iOuterX = 250 + Cos((2 * $PI / 12) * $i) * $iOuterR
$iOuterY = 250 + Sin((2 * $PI / 12) * $i) * $iOuterR
_GDIPlus_GraphicsDrawLine($hWatchGfx, $iInnerX, $iInnerY, $iOuterX, $iOuterY, $hWatchPen)
Next
GUISetState()


$hPenHour = _GDIPlus_PenCreate(0xffffffff, 15)
$hPenMinute = _GDIPlus_PenCreate(0xffffffff, 
$hPenSecond = _GDIPlus_PenCreate(0xffffffff, 3)


$hTimer = TimerInit()


While True
_GDIPlus_GraphicsClear($hBuf)
;input values
$iTime = TimerDiff($hTimer)
$nMilliSecond = Mod($iTime, 1000)
$nSecond = Mod($iTime / (1000), 60)
$nMinute = Mod($iTime / (1000 * 60), 60)
$nHour = $iTime / (1000 * 60 * 60)
;draw static watch image
_GDIPlus_GraphicsDrawImageRect($hBuf, $hWatchBmp, $iWndW / 2 - 250, $iWndH / 2 - 250, 500, 500)
;calculate and draw pointer
$iCenterX = $iWndW / 2
$iCenterY = $iWndH / 2
$iHourX = $iCenterX + Cos((2 * $PI / 12) * Mod($nHour, 12) - ($PI / 2)) * 150
$iHourY = $iCenterY + Sin((2 * $PI / 12) * Mod($nHour, 12) - ($PI / 2)) * 150
_GDIPlus_GraphicsDrawLine($hBuf, $iCenterX, $iCenterY, $iHourX, $iHourY, $hPenHour)
$iMinuteX = $iCenterX + Cos((2 * $PI / 60) * $nMinute - ($PI / 2)) * 190
$iMinuteY = $iCenterY + Sin((2 * $PI / 60) * $nMinute - ($PI / 2)) * 190
_GDIPlus_GraphicsDrawLine($hBuf, $iCenterX, $iCenterY, $iMinuteX, $iMinuteY, $hPenMinute)
$iSecondX = $iCenterX + Cos((2 * $PI / 60) * $nSecond - ($PI / 2)) * 230
$iSecondY = $iCenterY + Sin((2 * $PI / 60) * $nSecond - ($PI / 2)) * 230
_GDIPlus_GraphicsDrawLine($hBuf, $iCenterX, $iCenterY, $iSecondX, $iSecondY, $hPenSecond)
;draw center circle
_GDIPlus_GraphicsFillEllipse($hBuf, $iCenterX - 15, $iCenterY - 15, 30, 30, $hWatchBrush)
;draw current time in decimals
$sTime = StringFormat("%02d : %02d : %02d . %03d", $nHour, $nMinute, $nSecond, $nMilliSecond)
_GDIPlus_GraphicsDrawStringBox($hBuf, $sTime, 0, 0, "Segoe UI", 36, 0xffffffff, 1, $iWndW)


_GDIPlus_GraphicsDrawImage($hGfx, $hBmp, 0, 0)
WEnd


Func OnCloseClick()
Exit
EndFunc


Func _GDIPlus_GraphicsDrawStringBox($hGraphics, $sString, $nX, $nY, $sFont = "Arial", $nSize = 10, $iColor = 0xFF000000, $iAlignX = 0, $nW = 0.0, $iAlignY = 0, $nH = 0.0)
Local $hBrush = _GDIPlus_BrushCreateSolid($iColor)
Local $hFormat = _GDIPlus_StringFormatCreate(0)
_GDIPlus_StringFormatSetAlign($hFormat, $iAlignX)
_GDIPlus_StringFormatSetLineAlign($hFormat, $iAlignY)
Local $hFamily = _GDIPlus_FontFamilyCreate($sFont)
Local $hFont = _GDIPlus_FontCreate($hFamily, $nSize)
Local $tLayout = _GDIPlus_RectFCreate($nX, $nY, $nW, $nH)
Local $aInfo = _GDIPlus_GraphicsMeasureString($hGraphics, $sString, $hFont, $tLayout, $hFormat)
If @error Then Return SetError(@error, @extended, 0)
Local $aResult = _GDIPlus_GraphicsDrawStringEx($hGraphics, $sString, $hFont, $aInfo[0], $hFormat, $hBrush)
Local $iError = @error, $iExtended = @extended
_GDIPlus_FontDispose($hFont)
_GDIPlus_FontFamilyDispose($hFamily)
_GDIPlus_StringFormatDispose($hFormat)
_GDIPlus_BrushDispose($hBrush)
Return SetError($iError, $iExtended, $aResult)
EndFunc   ;==>_GDIPlus_GraphicsDrawStringBox

Wenn du es gern komfortabler hättest... Ich habe mal Musashis Idee aufgegriffen und die Tracing-Funktion durch modifizieren des Skriptes in mein SynSug (Syntaktischer Zucker für AutoIt) integriert. Daher kannst du jetzt ohne zusätzlichen Aufwand Tracing nutzen, indem du nach der Installation in SciTE kurz Strg+Umschalt+F5 drückst. Einfacher geht's eigentlich kaum. Geht etwas am Sinn des Projektes vorbei, aber da war halt schon ein Integrationsskript für SciTE und ein Parser vorhanden, daher war der Rest ziemlich schnell programmiert. Alles grundsätzliche zu SynSug im Thread, der neue Code mit Tracing im git-Repo.

Thread: SynSug - Syntaktischer Zucker für AutoIt (Update v1.1.0 Dictionaries)

Das folgende Testskript erzeugt dann den nachstehenden Output:

#SynSug_Enable=yes
#SynSug_ConsoleTracing=yes
#include <Array.au3>


$aDices = rollDices(3)
$sDices = _ArrayToString($aDices, ", ")
MsgBox(0, "Dices", "Rolled: " & @CRLF & $sDices)


Func rollDices($nDices)
Local $aDices[$nDices]
For $i = 0 To $nDices - 1
$aDices[$i] = rollDice()
Next
Return $aDices
EndFunc   ;==>rollDices


Func rollDice()
Return Random(1, 6, True)
EndFunc   ;==>rollDice

!TRACE> Entered function ROLLDICES().
!TRACE-> Entered function ROLLDICE().
!TRACE-> Leaved function ROLLDICE() after 0.0492307782073214 ms.
!TRACE-> Entered function ROLLDICE().
!TRACE-> Leaved function ROLLDICE() after 0.0185982939894325 ms.
!TRACE-> Entered function ROLLDICE().
!TRACE-> Leaved function ROLLDICE() after 0.0178689491271018 ms.
!TRACE> Leaved function ROLLDICES() after 0.257458736402733 ms.

Man kann sich jetzt über Tools > Syntactic Sugar (Debug to File) auch anschauen, was mein Parser daraus baut. Der relevante Ausschnitt:

#include <Array.au3>


$aDices = rollDices(3)
$sDices = _ArrayToString($aDices, ", ")
MsgBox(0, "Dices", "Rolled: " & @CRLF & $sDices)


Func rollDices($nDices)
Local $__SYNSUG_TRACE = __SynSug_TraceEnterFunc(rollDices)
Local $aDices[$nDices]
For $i = 0 To $nDices - 1
$aDices[$i] = rollDice()
Next
Return __SynSug_TraceLeaveFunc($__SYNSUG_TRACE, $aDices)
__SynSug_TraceLeaveFunc($__SYNSUG_TRACE, Null)
EndFunc   ;==>rollDices


Func rollDice()
Local $__SYNSUG_TRACE = __SynSug_TraceEnterFunc(rollDice)
Return __SynSug_TraceLeaveFunc($__SYNSUG_TRACE, Random(1, 6, True))
__SynSug_TraceLeaveFunc($__SYNSUG_TRACE, Null)
EndFunc   ;==>rollDice

Ich würde das Pferd mal von hinten aufzäumen. In der Funktion ist dir nicht bekannt, wie der aktuelle Scope benannt ist. Beim Aufruf aber schon. Also würde ich schon den UDF-Aufruf über eine Zwischenfunktion erledigen, innerhalb derer ich diverse Debug-Daten ausgeben kann. Statt eines myFunc(1, $b) schreibe ich dann in meinem Beispiel c(myFunc, 1, $b).

Die Zwischenfunktion muss leider so umständlich geschrieben werden, da AutoIt keine VarArgs-Definitionen unterstützt. Außerdem können so keine ByRef-Parameter oder Standardwerte für Parameter genutzt werden. Aber immerhin etwas.

#include <Array.au3>


;~ $aDices = rollDices(3)
$aDices = c(rollDices, 3)
$sDices = _ArrayToString($aDices, ", ")
MsgBox(0, "Dices", "Rolled: " & @CRLF & $sDices)


Func rollDices($nDices)
Local $aDices[$nDices]
For $i = 0 To $nDices - 1
$aDices[$i] = c(rollDice)
Next
Return $aDices
EndFunc


Func rollDice()
Return Random(1, 6, True)
EndFunc


;trace function
Func c($f, $a1 = Null, $a2 = Null, $a3 = Null, $a4 = Null, $a5 = Null, $a6 = Null, $a7 = Null, $a8 = Null, $a9 = Null, $a10 = Null)
Local $vRet, $iErr, $iExt, $aParams[@NumParams]
Local $hTimer
Local Static $nLevel = 0
$aParams[0] = "CallArgArray"
If @NumParams >  1 Then $aParams[1]  =  $a1
If @NumParams >  2 Then $aParams[2]  =  $a2
If @NumParams >  3 Then $aParams[3]  =  $a3
If @NumParams >  4 Then $aParams[4]  =  $a4
If @NumParams >  5 Then $aParams[5]  =  $a5
If @NumParams >  6 Then $aParams[6]  =  $a6
If @NumParams >  7 Then $aParams[7]  =  $a7
If @NumParams >  8 Then $aParams[8]  =  $a8
If @NumParams >  9 Then $aParams[9]  =  $a9
If @NumParams > 10 Then $aParams[10] = $a10
ConsoleWrite("!CT> ")
For $i = 1 To $nLevel
ConsoleWrite(@TAB)
Next
$nLevel += 1
ConsoleWrite("Entered " & FuncName($f) & "() with " & (@NumParams - 1) & " args." & @CRLF)
$hTimer = TimerInit()
$vRet = Call($f, $aParams)
$vErr = @error
$vExt = @extended
ConsoleWrite("!CT> ")
$nLevel -= 1
For $i = 1 To $nLevel
ConsoleWrite(@TAB)
Next
ConsoleWrite("Leaved " & FuncName($f) & "() after " & TimerDiff($hTimer) & " ms." & @CRLF)
Return SetError($iErr, $iExt, $vRet)
EndFunc

Oder einfach ProcessSetDpiAware aus der User32.dll aufrufen. Sofern du keine komplexen GUIs hast, geht das out of the Box.

Hi,

ich finde deine JSON-UDF grundsätzlich super und habe sie auch schon bei mehreren Gelegenheiten (Parsing von Web-Services) verwendet. Ich bin jetzt aber auf einen JSON-String gestoßen, der (laut Augenschein und Internet) standardkonform ist, aber die UDF zum Abschmieren bringt. Ist auch nicht sonderlich komplex, scheint an dem Array zu liegen:

{
 "name": "Sonderpreisliste",
 "description": "Sonderpreislistenformatierung",
 "exportSource": "Stammdaten / Preislisten-Definition",
 "autoDiscover": "???",
 "dataSql": "SELECT * FROM data",
 "templates": {
 "coverPageFile": "some.html",
 "tableBodyFile": "template.html"
 },
 "variables": [
 {
 "name": "title",
 "type": "sql",
 "data": "SELECT `Artikel-Nr.` FROM data"
 }
 ]
}

Es ging beim Auslagern der Postings in einen anderen Thread lediglich darum, den ursprünglichen Sinn des Threads zu erhalten, nämlich eine Sammlung von nützlichen regulären Ausdrücken. Nicht direkt auf den Schlips getreten fühlen.

Bei dem Punkt mit der Erklärung gebe ich dir grundsätzlich recht. Auch der Tipp zu regex101 war gut. Aber genau für solche Zwecke gibt es mindestens ein gutes, deutschsprachiges Tutorial hier im Forum, welches auch auf die Unterschiede zwischen AutoIt-PCRE und dem Rest eingeht. Link hab ich leider gerade wegen nicht funktionierender Suchfunktion nicht parat. Darüber hinaus gibt es noch etliche andere gute RegEx-Tutorials in Englisch oder Deutsch, die zwar nicht auf AutoIt eingehen, aber dennoch RegEx an sich anschaulich vermitteln. Das ist imho auch der bessere Weg, eine formale Sprache wie RegEx zu lernen. Jeden Ausdruck in der angesprochenen Sammlung nochmal haarklein zu erklären macht deswegen wenig Sinn und erzeugt eher Overhead. Wer RegEx (meinetwegen dank des Tutorials) kann, braucht es nicht. Und zum Lernen und Verstehen der Ausdrücke nützt eine komplette Erklärung ob der Komplexität und den fehlenden Grundlagen vermutlich auch eher wenig.

P.S.:

Eigene Beiträge in Foren in der Art zu löschen ist unhöflich. So kann man später nicht mehr nachvollziehen, was warum geschrieben worden ist. Man nimmt der Diskussion den Zusammenhang. In einem echten Gespräch kann man ja auch nicht einfach ganze Sätze im Nachhinein rausstreichen.

Hi,

ich bin im Rahmen eines größeren Projektes mit AutoIt auf ein kleines Problem gestoßen. Konkret betrifft das das Thema Subclassing, also Veränderung der internen Nachrichtenverarbeitung eines Fensters (und damit Controls). Dazu gibt es grundsätzlich mehrere Möglichkeiten. Man kann einmal die Subclassing-API verwenden, man kann aber auch simpel über SetWindowLong die WndProc verändern (siehe Code). Ich präferiere eigentlich die zweitere Möglichkeit, weil die Subclassing-API bei mir immer mal wieder Probleme verursacht hat.

Nun stehe ich jedoch vor dem Problem, dass beim Ersetzen der WndProc scheinbar AutoIts internes Nachrichtenhandling nicht mehr greift. Das heißt, ich kriege weder im OnEvent-Modus noch über GUIGetMsg() irgendwelche Aktionen mit dem Control mit. Auch ein Minimalbeispiel zeigt, dass das Problem nur beim Ersetzen der WndProc auftritt, nicht beim Nutzen der Subclassing-API. In den jeweiligen WndProcs/SubclassingProcs kommt jedoch die entsprechende Klick-Nachricht korrekt an. Übersehe ich etwas, oder geht hier AutoIt-Intern was gewaltig schief?

#include <WinAPI.au3>
#include <WinAPIShellEx.au3>
#include <ButtonConstants.au3>
#include <WindowsConstants.au3>

Opt("GUIOnEventMode", True)
$hWnd = GUICreate("Subclassing Example", 600, 400)
GUISetOnEvent(-3, onClosePressed)
$cButton1 = GUICtrlCreateButton("Button 1" & @CRLF & "AutoIt Internal", 0, 0, 200, 200, $BS_MULTILINE)
GUICtrlSetOnEvent(-1, onButtonPressed)
$cButton2 = GUICtrlCreateButton("Button 2" & @CRLF & "Subclassing", 200, 0, 200, 200, $BS_MULTILINE)
GUICtrlSetOnEvent(-1, onButtonPressed)
$cButton3 = GUICtrlCreateButton("Button 3" & @CRLF & "Replaced WndProc", 400, 0, 200, 200, $BS_MULTILINE)
GUICtrlSetOnEvent(-1, onButtonPressed)
$cLog = GUICtrlCreateEdit("=== Action Log ===", 0, 200, 600, 200)
;subclassing
$hSCCB = DllCallbackRegister(subclassProc, "lresult", "hwnd;uint;wparam;lparam;uint_ptr;dword_ptr")
$pSCCB = DllCallbackGetPtr($hSCCB)
_WinAPI_SetWindowSubclass(GUICtrlGetHandle($cButton2), $pSCCB, 1000, 0)
;replacing wndproc
$hRWCB = DllCallbackRegister(wndProc, "lresult", "hwnd;uint;wparam;lparam")
$pRWCB = DllCallbackGetPtr($hRWCB)
$pOldWndProc = _WinAPI_GetWindowLong(GUICtrlGetHandle($cButton3), $GWL_WNDPROC)
_WinAPI_SetWindowLong(GUICtrlGetHandle($cButton3), $GWL_USERDATA, $pOldWndProc)
_WinAPI_SetWindowLong(GUICtrlGetHandle($cButton3), $GWL_WNDPROC, $pRWCB)
;exit routine to free resources
OnAutoItExitRegister(onExitApp)
GUISetState()

While True
    Sleep(20)
WEnd

Func onClosePressed()
    Exit
EndFunc

Func onButtonPressed()
    writeLog("AutoIt: Button with ID " & @GUI_CtrlId & " pressed!")
EndFunc

Func onExitApp()
    _WinAPI_RemoveWindowSubclass(GUICtrlGetHandle($cButton2), $pSCCB, 1000)
    DllCallbackFree($hSCCB)
    _WinAPI_SetWindowLong(GUICtrlGetHandle($cButton3), $GWL_WNDPROC, $pOldWndProc)
    DllCallbackFree($hRWCB)
EndFunc

Func writeLog($s)
    GUICtrlSetData($cLog, GUICtrlRead($cLog) & @CRLF & StringFormat("[%02d:%02d:%02d.%03d] %s", @HOUR, @MIN, @SEC, @MSEC, $s))
EndFunc

;external called functions

Func subclassProc($hWnd, $iMsg, $iWParam, $iLParam, $iID, $pData)
    If $iMsg = $WM_LBUTTONDOWN Then writeLog("subclassProc: Button pressed")
    Return _WinAPI_DefSubclassProc($hWnd, $iMsg, $iWParam, $iLParam)
EndFunc

Func wndProc($hWnd, $iMsg, $iWParam, $iLParam)
    If $iMsg = $WM_LBUTTONDOWN Then writeLog("wndProc: Button pressed")
    $pOldWndProc = _WinAPI_GetWindowLong($hWnd, $GWL_USERDATA)
    Return _WinAPI_CallWindowProc($pOldWndProc, $hWnd, $iMsg, $iWParam, $iLParam)
EndFunc

Du solltest deinen Primary Key aber nicht als TEXT definieren, sondern wenn möglich als VARCHAR(n). Zumindest MySQL ist bei einem Index mit VARCHAR wesentlich performanter und deine GUIDs sind ja eh immer gleichlang.

Zunächst: Was ist eine ID? Nicht zwangsläufig ein aufsteigendes Nummernfeld. Eine Software, die wir im Haus verwenden, nutzt beispielsweise einen Hash aus UserId, Timestamp und Objektdaten. Da ich gar keine rein numerische ID habe, die sich aufsteigend bildet, kann ich Datensätze beliebig tauschen, ohne Angst vor doppelten IDs haben zu müssen.

Musashi

Ja, habe ich auch gelesen. Hatte aber noch nie Probleme mit dieser UDF. Verwende sie auch in Skripten, die 24/7 auf einem Server bei uns in der Firma laufen, von daher..

Wann immer ich in AutoIt mit TCP-Verbindungen hantiere, nutze ich Kips TCP-UDF. Diese basiert auf Events, d.h. du registrierst eine Funktion für ein Ereignis (bspw. Datenempfang), die dann von der UDF aufgerufen wird. Das finde ich wesentlich angenehmer zu programmieren. Dort gibt es auch die Möglichkeit, ein Verbindungsabbruch-Ereignis zu registrieren. Ich weiß nicht, wie Kip das intern umgesetzt hat, aber wenn du die Info in AutoIt irgendwie bekommen kannst, dann wird diese UDF das auch weiterreichen. Einfach mal probieren:

https://www.autoitscript.com/f…325-tcp-udf-event-driven/

Hm, vielleicht habe ich da einen anderen Grad an Professionalität im Kopf.

Wir hatten einen einzigen Computerraum mit insgesamt 14 Clients. Sind in meinem letzten Schuljahr alle auf Windows 8.1 umgestellt worden. Das waren einfache Desktoprechner mit Unterklasse-Ausstattung. Darauf lief dann wie bereits gesagt Windows in einer Home-Variante, nicht mal Pro (d.h. keine Domänenfunktionen). Zur Absicherung haben wir praktisch nur uralte PC-Wächter-Karten gehabt, mehr nicht. Der Switch war so ein TP-Link-Ding, ohne smarte Funktionen. Da haben wir auch sehr viel mit AutoIt-Skripten administriert, vorher (=> die AutoIt-Skripte habe ich in der 9. Klasse programmiert) wurde Turnschuh-Administration gemacht, d.h. bei einem Update von LibreOffice hat der zuständige Lehrer einen kompletten Nachmittag geopfert und jedes Update an jedem Rechner von Hand installiert.

Aber auch wir haben schon Prüfungen an diesen Rechnern geschrieben, damals noch auf Windows XP. Das war aber vor der Zeit, in der ich aktiv bei der Administration mitgewirkt habe. Lief damals über eine Software namens NetSupport School.

War bei uns nur begrenzt der Fall. Heißt: Die Verwaltung hatte zwar ein separiertes Netz, welches auch mit intelligenten Switches unterteilt war, aber wir (mit Wartung beauftragte Lehrer und Schüler) hatten nur Zugriff auf unser abgekapseltes Subnetz, ohne an die Switches zu dürfen.

Gut, das passiert ja hoffentlich, bevor Schüler den Raum betreteten. Sonst könnte man ja auch einfach den Au3-Prozess, der gpupdate ausführt, abschießen.

Das kannst du auch nicht. Das ist der von mir angesprochene Informationsverlust. Du kannst aus Tagen nicht wieder Monate oder Jahre machen.

Du musst bei der Differenzbildung schrittweise bei der größten Einheit (Jahre) anfangen. Wenn das nicht mehr geht, mit Monaten weitermachen usw...

So kann man das schön simpel machen:

#include <Date.au3>


$sDateA = "2018/10/26 19:03:43"
$sDateB = "2009/06/30 14:05:16"


$a = _DateDiffReal($sDateA, $sDateB)
ConsoleWrite(StringFormat("%d Jahre, %d Monate, %d Tage, %d Stunden, %d Minuten, %d Sekunden\n", $a[0], $a[1], $a[2], $a[3], $a[4], $a[5]))


Func _DateDiffReal($sDateA, $sDateB)
Local $sStartDate, $sEndDate, $sNewDate
If _DateDiff("s", $sDateA, $sDateB) > 0 Then
$sStartDate = $sDateA
$sEndDate = $sDateB
Else
$sStartDate = $sDateB
$sEndDate = $sDateA
EndIf
Local $aResult[6]
Local $aTypes[6] = ["Y", "M", "D", "h", "n", "s"]
Local $i
For $i = 0 To 5
$aResult[$i] = 0 ;initial value
While True
$sNewDate = _DateAdd($aTypes[$i], 1, $sStartDate)
If _DateDiff("s", $sNewDate, $sEndDate) < 0 Then ExitLoop
$sStartDate = $sNewDate
$aResult[$i] += 1
WEnd
Next


Return $aResult
EndFunc

Edit:

Kurz nochmal der Algorithmus in Worte gefasst. Mag effizienter gehen, aber so habe ich es auf einem Blatt Papier auch gelöst.

1. Beginne bei Einheit Jahren.

2. Addiere so lange 1 Einheit auf das Startdatum, bis es bei der nächsten Addition größer als das Enddatum wäre. Zähle dabei die Additionen.

3. Ausgehend von dem neuen Startdatum wiederhole Schritt 2 mit der nächstkleineren Einheit, bis keine nächstkleinere Einheit mehr existiert.

4. Die gezählten Additionen sind der Abstand der beiden Daten.

Naja, wer als Schüler die per GPO vorgegebene lokale Firewall aushebeln kann, der hat's auch verdient, zu spicken.

Grundsätzlich ist eine Hardware-Firewall natürlich besser geeignet, obwohl auch diese umgehbar ist. Aber verglichen mit einer reinen Software-Lösung (vorhandenes AD vorausgesetzt) steht hier ja ein anderer Kostenfaktor im Raum. Ich weiß noch, was es für ein Krampf war, in der Schule Anträge für neue Hardware durchzubekommen. Und ich war schon Mitglied in allen wichtigen Gremien wie SchuKo usw... Ich könnte mir schon denken, was für eine Diskussion bei 400 Euro für einen Switch mit Firewall fällig wären.

Zitat von misterspeed

- Per zentraler Firewall

Den Vorschlag finde ich tatsächlich am besten. Wenn ihr bei euch an der Schule schon so Microsoft-verbunden seid, dann habt ihr ja mit Sicherheit nicht nur 20 Client-Rechner in einem Raum stehen, sondern es existiert auch irgendwo ein Windows Server und ein Active Directory. Falls ja, würde ich einfach bei Bedarf über eine Gruppenrichtlinie die Firewall-Einstellungen auf den Zielrechnern so einstellen, dass ausschließlich Verbindungen zum DC und zu *.microsoft.com (o.Ä.) hergestellt werden dürfen. Per AutoIt könnte man dann noch ein gpupdate auf den Zielrechnern durchführen, weiß nicht, ob das zwingend nötig ist. Das ist allemal besser als selbstgeschriebene Frickellösungen. Und eine Gruppenrichtlinie in einem AD bekommt man ohne administrative Rechte auch nicht so schnell ausgehebelt.

Wir haben damals in der Schule viel mit der Windows Firewall administriert und gearbeitet. Es gab bspw. eine Software aus dem Fachbereich Biologie, deren Hersteller mittlerweile insolvent gewesen ist. Allerdings hat die Software bei jedem Start versucht, den Herstellerserver nach Updates zu fragen. Allerdings war da ein Timeout von ~10 Minuten gesetzt. Nervig ohne Ende. Also einfach die Verbindung zu diesem Host per Firewall deaktiviert und fertig, Programm startet ohne Verzögerung.

Zitat von kilo

weil ich nicht weiß, wie Schaltjahre etc. einzurechnen sind

Das ist - glaube ich - das größte Problem. Du hast bei der Angabe X Jahre, Y Monate, Z Tage zwangsläufig mit einem Informationsverlust zu kämpfen. Selbst nach alpines' Methode (die an sich eigentlich die richtige Lösung darstellt) unterscheidest du nicht zwischen normalen Jahren und Schaltjahren, geschweige denn nach Monaten mit unterschiedlich vielen Tagen (es wird pauschal 30 Tage angenommen).

Deshalb wird das nicht die gewünschte Genauigkeit erbringen. Wenn ich dich richtig verstehe, möchtest du ja, dass bspw...

- zwischen dem 1.1.2015 und dem 2.1.2016 genau 1 Jahr, 0 Monate und 1 Tag liegen.

- zwischen dem 1.1.2016 und dem 2.1.2017 genau 1 Jahr, 0 Monate und 1 Tag liegen. (2016 ist ein Schaltjahr, d.h. das eine Jahr sind 366 Tage)

Richtig?