Problem mit Programmlogik

  • VB.NET

Es gibt 21 Antworten in diesem Thema. Der letzte Beitrag () ist von SAR-71.

    Problem mit Programmlogik

    Moin,

    wahrscheinlich ist es einfach zu spät, aber ich finde meinen Fehler einfach nicht.

    Folgende Situation: Ich habe zwei FileSystemWatcher - beide werden kurz nacheinander angeworfen und bei beiden tritt das Ereignis etwa zur gleichen Zeit auf (könnte aber auch andere Zeiten haben).
    Erst wenn BEIDE fertig sind, wird der nächste Sub aufgerufen.

    Folgender Sub bringt die Sache ins Rollen:

    VB.NET-Quellcode

    1. Sub Stein_beginnt_zu_rollen()
    2. AlleFertig = false
    3. watcher1 = New IO.FileSystemWatcher("Datei1")
    4. Shell("externe Anwendung 1")
    5. watcher1.EnableRaisingEvents = True
    7. watcher2 = New IO.FileSystemWatcher("Datei2")
    8. Shell("externe Anwendung 2")
    9. watcher2.EnableRaisingEvents = True
    11. End Sub


    Und hier die Subs der Watcher.

    VB.NET-Quellcode

    1. Sub watcher1(ByVal sender As Object, ByVal e As System.IO.FileSystemEventArgs) Handles watcher1.Deleted
    3. 'Verarbeitung
    5. If AlleFertig Then
    6. nextSub()
    7. End If
    8. AlleFertig = True
    9. End Sub
    12. Sub watcher2(ByVal sender As Object, ByVal e As System.IO.FileSystemEventArgs) Handles watcher2.Deleted
    14. 'Verarbeitung
    16. If AlleFertig Then
    17. nextSub()
    18. End If
    19. AlleFertig = True
    20. End Sub



    Beide Watcher machen ganz normal die Verarbeitung. Alles durchgetestet.
    Aber der "nextSub" wird nie aufgerufen. Jetzt stellt sich mir die Frage: Rein logisch müsste "nextSub" aufgerufen werden - praktisch aber nicht, jedoch warum?




    Mfg.
    SAR

    Hey,

    mach mal aus dem da.

    VB.NET-Quellcode

    1. Sub watcher1(ByVal sender As Object, ByVal e As System.IO.FileSystemEventArgs) Handles watcher1.Deleted
    3. 'Verarbeitung
    5. If AlleFertig Then
    6. nextSub()
    7. End If
    8. AlleFertig = True
    9. End Sub


    das da.

    VB.NET-Quellcode

    1. Sub watcher1(ByVal sender As Object, ByVal e As System.IO.FileSystemEventArgs) Handles watcher1.Deleted
    3. 'Verarbeitung
    5. AlleFertig = True
    7. If AlleFertig Then
    8. nextSub()
    9. End If
    11. End Sub


    Die nextSub kann nie aufgerufen werden, da Du das Flag erst nach der If-Abfrage auf True setzt. Logisch.

    EDIT: Aber da Du nicht wohl nicht weisst, wann jeder fertig ist, sollte vorher der Eine auf den Anderen warten.
    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    So kann ich mir ja alles sparen. Dann brauch ich nicht die Variable. :P

    Der Sinn dahinter ist, wenn watcher1 fertig ist, dass watcher2 (wenn er dann auch fertig ist) den Sub aufruft.
    Und nicht, wenn watcher1 fertig ist, den Sub aufruft (obwohl w2 nicht soweit ist) und danach würde w2 auch nochmal den Sub aufrufen.

    @Edit: Das Warten würde ich gerne vermeiden. Dass würde bedeuten das ich wieder neue Threads machen müsste etc.


    Mfg.
    SAR

    Dann werden wohl beide so ziemlich zur gleichen Zeit fertig und haben den If-Block schon beide hinter sich, bevor einer der Beiden das Flag auf True setzt.
    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    Ja, hat mich auch grad gewundert. Habs grad selber getestet. Vielleicht haben sie daran was geändert. Ich weiss auf alle Fälle, dass ich vor ein paar Jahren Probleme mit Cross-Thread-Calls hatte. Hab sogar noch die Webseite, wo ich damals die Lösung fand.

    vbcity.com/forums/t/99260.aspx

    Seitdem hab ich die Dinger nicht mehr gebraucht. Ich sehs ja selber, es geht, ohne zu meckern. Also entschuldige ich mich für die Falschaussage, ich hatte es noch so im Kopf. Oder jemand hat ne bessere Erklärung.

    Wieder zum Problem. Der Zugriff erfolgt aber dennoch parallel. Da die beiden Events quasi zur gleichen Zeit aufgerufen werden. Ich überleg noch an Deinem Problem.
    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    :P

    Selbst wenn ich die Prüfung von "AlleFertig" in "nextSub" verschiebe, habe ich nur nochmehr Probleme.
    Der erste Aufruf wird gemacht - wunderbar. Danach stürzt Programm ab bzw. es beendet sich einfach. (Ohne Fehlermeldung. Nichtmal die Meldung von Windows "123.exe reagiert nicht mehr".)
    Kann sein, dass ich es vorher auch hatte, aber da ist mir es nicht aufgefallen.

    Edit: Der erste Aufruf wird doch nicht gemacht. Obwohl da eig. nurnoch:

    VB.NET-Quellcode

    1. Sub watcher2(ByVal sender As Object, ByVal e As System.IO.FileSystemEventArgs) Handles watcher2.Deleted
    3. 'Verarbeitung
    5. nextSub()
    6. AlleFertig = True
    8. End Sub
    steht.



    Mfg.
    SAR

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „SAR-71“ ()

    Ich hab jetzt mal versucht, Dein Problem nachzustellen. Mach nur ein Flag, das angibt, ob die Sub ausgeführt wird und umschliesse die nextSub() mit einem SyncLock. So wird sichergestellt, dass jeweils nur ein gleichzeitiger Zugriff auf den umschlossenen Code erfolgt. Teste mal.

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private _file1 As String = "c:\test\1.txt"
    3. Private _file2 As String = "c:\test\2.txt"
    4. Private _subDone As Boolean = False
    5. Private _loc As New Object
    7. Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button1.Click
    8. File.Delete(_file1)
    9. File.Delete(_file2)
    10. End Sub
    12. Private Sub fW1_Deleted(sender As Object, e As System.IO.FileSystemEventArgs) Handles fW1.Deleted
    13. NextSub()
    14. End Sub
    16. Private Sub fW2_Deleted(sender As Object, e As System.IO.FileSystemEventArgs) Handles fW2.Deleted
    17. NextSub()
    18. End Sub
    20. Private Sub NextSub()
    21. SyncLock _loc
    22. If Not _subDone Then
    23. _subDone = True
    25. MessageBox.Show("huhu")
    26. End If
    27. End SyncLock
    28. End Sub
    29. End Class


    Was auch noch ne Möglichkeit ist, ist dieses Gebilde hier:

    VB.NET-Quellcode

    1. Public Class Form1
    2. Private _file1 As String = "c:\test\1.txt"
    3. Private _file2 As String = "c:\test\2.txt"
    4. Private _w1Done As Boolean = False
    5. Private _w2Done As Boolean = False
    6. Private WithEvents _t As New Timer
    8. Private Sub Button1_Click(sender As System.Object, e As System.EventArgs) Handles Button1.Click
    9. _t.Start()
    11. File.Delete(_file1)
    13. Threading.Thread.Sleep(1000)
    15. File.Delete(_file2)
    16. End Sub
    18. Private Sub fW1_Deleted(sender As Object, e As System.IO.FileSystemEventArgs) Handles fW1.Deleted
    19. _w1Done = True
    20. End Sub
    22. Private Sub fW2_Deleted(sender As Object, e As System.IO.FileSystemEventArgs) Handles fW2.Deleted
    23. _w2Done = True
    24. End Sub
    26. Private Sub NextSub()
    27. MessageBox.Show("huhu")
    28. End Sub
    30. Private Sub _t_Tick(sender As Object, e As System.EventArgs) Handles _t.Tick
    31. If _w1Done And _w2Done Then
    32. _t.Stop()
    34. NextSub()
    35. End If
    36. End Sub
    38. Private Sub Form1_Load(sender As System.Object, e As System.EventArgs) Handles MyBase.Load
    39. _t.Interval = 100
    40. End Sub
    41. End Class
    Die Unendlichkeit ist weit. Vor allem gegen Ende. ?(
    Manche Menschen sind gar nicht dumm. Sie haben nur Pech beim Denken. 8o

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „SpaceyX“ ()

    Es sah vielsprechend aus, aber wirkt bei mir nicht.

    VB.NET-Quellcode

    1. SyncLock einObject
    2. If Not AlleFertig then
    3. AlleFertig = True
    4. Exit Sub
    5. End If
    6. End SyncLock
    7. 'Verarbeitung


    So sieht es gerade in "NextSub" aus.
    Ergebnis: Es passiert nichts und irgendwann verschwindet der Prozess aus dem TaskManager einfach (keine Fehlermeldung). Etwa 10s nachdem die FileWatcher fertig waren.

    Wenn ich noch eine MsgBox reinziehe, dann verschwindet der Prozess komischerweise nicht mehr. Aber mir die MsgBox auch nicht angezeigt.

    Edit: Vllt. sollte ich mal nebenbei erwähnen, dass die Subs alle "Shared" sind. Und somit auch die Watcher.
    Edit2: Um so ein Timer gefummle komme ich wohl nicht rum. Es sei denn, man Ereignisse auf die Veränderung von Variablen legen.



    Mfg.
    SAR

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „SAR-71“ ()

    SAR-71 schrieb:

    Vllt. sollte ich mal nebenbei erwähnen, dass die Subs alle "Shared" sind. Und somit auch die Watcher.
    Schmeiß alles Shared und Modul raus :!:
    Arbeite mit Instanzen und Events.
    Leg Dir 2 Instanzen einer Klasse mit dem Watcher an und lass sie bei Eintreffen des Ereignisses an das Hauptprogramm ein Event senden. Wenn beide Events da waren, mach weiter.
    Einen Timer brauchst Du nicht.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

    So. Ich hab mal einen Test gemacht.
    Das Prinzip stimmt schon. Nur sollest Du
    1. Invoke verwenden.
    2. Eine eigene Klasse für die beiden FileSystemWatcher verwenden. Dadurch kannst Du Code aus der Hauptform auslagern.
    3. SyncLock verwenden, um doppeltes Auslösen des Events zu verhindern.

    Bei mir ist das herausgekommen:

    VB.NET-Quellcode

    1. Class TwoWatchers
    3. Public Event WatchersFinished()
    5. Dim WithEvents Watcher1 As New System.IO.FileSystemWatcher
    6. Dim WithEvents Watcher2 As New System.IO.FileSystemWatcher
    8. Dim Watcher1Handled As Boolean = False
    9. Dim Watcher2Handled As Boolean = False
    11. Dim EventRaised As Boolean = False
    13. Dim LockObject As New Object
    15. Public Sub New(Directory1 As String, Directory2 As String)
    16. 'Anpassen.
    17. 'Optional:
    18. ' Über Parameter die benötigten Werte verlangen.
    19. ' Über Parameter die FileSystemWatcher-Instanzen verlangen.
    20. Watcher1.Path = Directory1
    21. Watcher1.EnableRaisingEvents = True
    22. Watcher1.IncludeSubdirectories = False
    23. Watcher2.Path = Directory2
    24. Watcher2.EnableRaisingEvents = True
    25. Watcher2.IncludeSubdirectories = False
    26. End Sub
    28. Private Sub Watcher1Handler() Handles Watcher1.Deleted
    29. Form1.Shared_AddLog("Watcher1")
    30. Watcher1.EnableRaisingEvents = False
    31. Watcher1Handled = True
    32. Check()
    33. End Sub
    35. Private Sub Watcher2Handler() Handles Watcher2.Deleted
    36. Form1.Shared_AddLog("Watcher2")
    37. Watcher2.EnableRaisingEvents = False
    38. Watcher2Handled = True
    39. Check()
    40. End Sub
    42. Private Sub Check()
    43. Form1.Shared_AddLog("Check.VorSyncLock")
    44. SyncLock LockObject
    45. Form1.Shared_AddLog("Check.InSyncLock")
    46. If Watcher1Handled AndAlso Watcher2Handled AndAlso Not EventRaised Then
    47. 'Falls der jeweils andere Thread bereits auf den Eintritt in den SyncLock-Block wartet, würde der event zweimal ausgelöst werden.
    48. 'Durch ein Flag wird das verhindert.
    49. EventRaised = True
    50. RaiseEvent WatchersFinished()
    51. End If
    52. End SyncLock
    53. End Sub
    55. End Class


    (Kopiere den Code bitte nicht einfach, sondern versuche zu verstehen, was ich gemacht habe. Wenn Du Fragen hast, dann frag ;) )

    In der Form1 habe ich per Shared Methode -> Shared Event -> Instanzmethode das Übergeben der Werte aus der einen Klasse zur anderen geregelt. Das ist aber Nebensache.

    In der Form1 steht dann nur noch

    VB.NET-Quellcode

    1. Dim WithEvents Watcher As New TwoWatchers("C:\Dokumente und Einstellungen\...\Desktop\1\", "C:\Dokumente und Einstellungen\...\Desktop\2\")
    3. Private Sub Finished() Handles Watcher.WatchersFinished
    4. Me.Invoke(Sub() AddLog("Beide fertig"))
    5. End Sub


    Ergebnis:


    Und um die Klasse wiederverwendbar zu machen, kannst Du ihr eine Reset-Methode geben, in der Du die Flags und die EnableRisingEvents-Eigenschaften der Watcher zurücksetzt.


    Edit:

    Ich habe mal testweise beide Watcher den selben Ordner überprüfen lassen und dann eine Datei darin gelöscht.


    Wie man sieht, wird der Event nur einmal ausgelöst.

    Wenn ich das richtig im Kopf habe, müsste auch Check.VorSyncLock zweimal hintereinander stehen. Vielleicht hat der Compiler da ein bisschen herumgewerkelt.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „Niko Ortner“ ()

    Sieht für mich alles klar aus.
    Nur eine Frage bleibt mir: Warum wird in "Finished()" der "AddLog" invoket? Das müsste da doch wieder (Thread-)Safe sein? Und warum wird in der Klasse nicht mit Inovkes gearbeitet?

    Ansonsten ein geiler Code. Gleich auch ein guter Einstieg in Klassen. (Hab mich mit verschiedenen Klassen noch nicht viel beschäftigt)



    Mfg.
    SAR

    Stell Dir zwei Personen anstelle von zwei Threads vor.
    Denen gibst Du Anleitungen, was sie zu tun haben (Code).

    Die eine Person (Person 1) kümmert sich um die GUI (Das ist der "normale" Thread, den man so hat, wenn man 'ne 0815 Anwendung hat).
    Die andere Person (Person 2) ist ein FileSystemWatcher-Thread.

    Wenn jetzt (2) drauf kommt, dass die Datei gelöscht wurde, dann verwendet sie die Sprungziele, die dem Deleted-Event der FileSystemWatcher-Klasse hinterlegt sind. Das ist im Moment nur eines, nämlich die Methode "Watcher1Handler()".
    (2) macht jetzt also das, was in dieser Methode steht ( (1) macht gerade ein Nickerchen oder mäht den Rasen oder sonswas).
    Jetzt überspringen wir mal den unwichtigen Teil und gehen direkt zu Zeile 50.
    Wieder werden die Sprungziele genommen (wieder nur eines) und dort wird hingesprungen. Also macht (2) jetzt das, was in der Methode Finished() steht.

    Jetzt wichtig: Me.Invoke(...) wird von (2) aufgerufen, nicht von (1).

    Durch Me.Invoke(Sub() ...) schreibt (2) sozusagen einen Zettel mit einer Anleitung für (1) und legt ihn ins Postfach. Damit ist die Arbeit von (2) getan und sie geht wieder zurück bis in den FileSystemWatcher.
    Wenn (1) mit dem Rasenmähen oder schlafen fertig ist und in den Briefkasten sieht (also wenn der GUI-Thread alle vorigen Aufgaben abgearbeitet hat), dann sieht sie "Aha, Jemand hat mir eine Anleitung geschickt. Da steht, ich solle doch nach der Anleitung in AddLog(String) den String "Beide fertig" bearbeiten."
    Also macht das (1) auch. Sie nimmt diesen String und macht nach der Anleitung AddLog(String) weiter.



    Das ist zwar etwas dämlich geschrieben, aber ich hoffe, dass ich Dir erklären konnte, warum der Code in der Finished() Methode von einem anderen Thread ausgeführt wird.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Ähm, nein. Erst nach dem dritten Mal konnte man Ansatzweise verstehen (bzw. die Zusammenhänge erahnen) was du da geschrieben hast. :D
    Die ganze Aussage kann man reduzieren auf:" Finished" wird von einem anderem Thread behandelt.

    Wenn aber "Finished" von einem anderem Thread abgearbeitet wird - deswegen wird invoket.
    Aber warum wird in "Watcher1Handler" nicht invoket? Ist doch auch ein anderer Thread.


    Mfg.
    SAR

    Du musst ja nur einmal in den GUI-Thread wechseln.
    Wenn ich will, dass Du Deinen Hut änderst (das darf ich nicht machen), dann sage ich es Dir einmal. Nicht mehrmals.
    "Luckily luh... luckily it wasn't poi-"
    -- Brady in Wonderland, 23. Februar 2015, 1:56
    Desktop Pinner | ApplicationSettings | OnUtils

    Das erklärt meine Frage nicht wirklich.
    (Für andere Leute mag es hilfreich sein, aber für mich ist es eine Last wenn du mit irgendwelchen Vergleichen ankommst. :P)

    Edit:
    @RodFromGermany: Ich hab keine Module und Shared benutze ich zwangsweise (Sind CodeDom-Programme).
    Deswegen helfen mir die Geschichten mit Me nicht weiter - weil ich kein Me habe. :D


    Mfg.
    SAR

    Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „SAR-71“ ()

    SAR-71 schrieb:

    weil ich kein Me habe.
    Von jeder Klasseninstanz aus gibst Du mit Me eine Referenz auf sich selbst weiter.
    Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
    Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
    Ein guter .NET-Snippetkonverter (der ist verfügbar).
    Programmierfragen über PN / Konversation werden ignoriert!

Facebook
Telefonspende