[WPF] Abfangen wenn Thread fertig ist

  • C#

Es gibt 10 Antworten in diesem Thema. Der letzte Beitrag () ist von thefiloe.

    [WPF] Abfangen wenn Thread fertig ist

    Hey,

    ich möchte einen Thread starten und abfangen, wenn der Thread fertig ist / seine Arbeit erledigt hat.
    Das Ganze hängt mit einem ICommand zusammen, der dann das CanExecuteChanged-Event aufrufen soll.

    Mein Lösungsansatz ist folgender:

    C#-Quellcode

    1. Thread t = new Thread(new ThreadStart(this._OnRun));


    C#-Quellcode

    1. private void _OnRun()
    2. {
    3. this.OnRun(); // Methode nach der CanExecute geupdated werden soll
    4. this.RunCommand.RaiseCanExecuteChanged();
    5. }


    Mein RunCommand ist ein normaler Command aus dem MVVM-Pattern.
    Spoiler anzeigen

    C#-Quellcode

    1. public class ActionCommand : ICommand
    2. {
    3. private readonly Action<object> _executeHandler;
    4. private readonly Func<object, bool> _canExecuteHandler;
    6. public ActionCommand(Action<object> execute, Func<object, bool> canExecute)
    7. {
    8. if (execute == null)
    9. {
    10. throw new ArgumentNullException("execute cannot be null");
    11. }
    13. _executeHandler = execute;
    14. _canExecuteHandler = canExecute;
    15. }
    17. public event EventHandler CanExecuteChanged;
    19. public void Execute(object parameter)
    20. {
    21. _executeHandler(parameter);
    22. }
    24. public bool CanExecute(object parameter)
    25. {
    26. if (_canExecuteHandler == null)
    27. {
    28. return true;
    29. }
    31. return _canExecuteHandler(parameter);
    32. }
    34. public void RaiseCanExecuteChanged()
    35. {
    36. var handler = CanExecuteChanged;
    37. if (handler != null)
    38. {
    39. handler.Invoke(this, EventArgs.Empty);
    40. }
    41. }
    43. }



    Allerdings greife ich dann von einen Thread auf einen anderen zu und deshalb tritt folgender Fehler auf:

    Quellcode

    1. Eine nicht behandelte Ausnahme des Typs "System.InvalidOperationException" ist in WindowsBase.dll aufgetreten.
    3. Zusätzliche Informationen: Der aufrufende Thread kann nicht auf dieses Objekt zugreifen, da sich das Objekt im Besitz eines anderen Threads befindet.



    Habe es auch schon so versucht, funktioniert aber auch nicht. Wende ich lock falsch an?

    C#-Quellcode

    1. lock (this.RunCommand)
    2. {
    3. this.RunCommand.RaiseCanExecuteChanged();
    4. }


    Es wäre sehr nett, wenn ihr mir hier weiterhelfen könntet. :)

    Viele Grüße,
    Trudi

    Der fertige Thread könnte doch ein Event raisen.
    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!

    Hi, danke für die Antwort.
    Das funktioniert leider auch nicht, wenn ich das Event feuer kommt wieder der selbe Fehler.
    Habe es so umgesetzt (Alles in der selben Klasse):

    C#-Quellcode

    1. private event EventHandler RunningThreadEnded;

    C#-Quellcode

    1. private void _OnRun()
    2. {
    3. this.OnRun();
    4. RunningThreadEnded(this, EventArgs.Empty);
    5. }

    C#-Quellcode

    1. void BasicPlugin_RunningThreadEnded(object sender, EventArgs e)
    2. {
    3. this.RunCommand.RaiseCanExecuteChanged();
    4. }



    Der Fehler tritt übrigens immer im ICommand bei folgendem Aufruf auf:

    C#-Quellcode

    1. handler.Invoke(this, EventArgs.Empty);


    MfG

    Hey,
    habe es jetzt selbst gebacken bekommen.
    Ich habe mir einfach den Dispatcher vom Haupt-Thread zwischengespeichert und ich greife dann in dem neuen Thread auf den zurück, um den neuen Thread nach dem beenden zurückzusetzen. (Verwirrend nich?)

    C#-Quellcode

    1. this.dispatcher = Dispatcher.CurrentDispatcher;

    C#-Quellcode

    1. private void _OnRun()
    2. {
    3. this.OnRun();
    4. dispatcher.Invoke(new Action(this.ResetRunningThread), null);
    5. }

    C#-Quellcode

    1. private void ResetRunningThread()
    2. {
    3. this.RunningThread = null;
    4. this.RunCommand.RaiseCanExecuteChanged();
    5. }


    MfG Trudi

    Obwohl das Thema schon erledigt ist, gibt es einen kleinen Trick wodurch der RaiseCanExecuteChanged() aufruf hinfällig wird.
    Du kannst in deinem Command folgendes hinzufügen:

    Quellcode

    1. event EventHandler ICommand.CanExecuteChanged
    2. {
    3. add { CommandManager.RequerySuggested += value; }
    4. remove { CommandManager.RequerySuggested -= value; }
    5. }


    Dadurch sollte in 99% der Fälle der Aufruf RaiseCanExecuteChanged hinfällig werden.


    Opensource Audio-Bibliothek auf github: KLICK, im Showroom oder auf NuGet.

    Und wie rufe ich dann den EventHandler auf?
    Hatte bei meinem Command (aus nem WPF-Buch kopiert) genau das schon eingebaut, aber dann zu public event EventHandler CanExecuteChanged; geändert, damit ich das Event auch aus RaiseCanExecuteChanged aufrufen kann.
    Wie "invoke" ich das Event denn dann außerhalb vom Command?

    Bei mir kommt dann folgender Fehler:

    Quellcode

    1. Das Ereignis "ActionCommand.CanExecuteChanged" kann nur links von += oder -= verwendet werden.




    Würde mich interessieren, weil mein Buch schreibt mir das auch so vor...

    MfG

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

    Das sind meine zwei Commands. Der erste ist die Basis und funktioniert so wie deiner. Der zweite kann das Selbe wie der Erste nur eben, dass es auch automatisch aktualisiert:
    Spoiler anzeigen

    Quellcode

    1. public class DelegateCommand : ICommand
    2. {
    3. private readonly Predicate<object> _canExecute;
    4. private readonly Action<object> _execute;
    6. public event EventHandler CanExecuteChanged;
    8. public DelegateCommand(Action<object> execute)
    9. : this(execute, null)
    10. {
    11. }
    13. public DelegateCommand(Action<object> execute,
    14. Predicate<object> canExecute)
    15. {
    16. _execute = execute;
    17. _canExecute = canExecute;
    18. }
    20. public virtual bool CanExecute(object parameter)
    21. {
    22. if (_canExecute == null)
    23. {
    24. return true;
    25. }
    27. return _canExecute(parameter);
    28. }
    30. public virtual void Execute(object parameter)
    31. {
    32. _execute(parameter);
    33. }
    35. public virtual void RaiseCanExecuteChanged()
    36. {
    37. if (CanExecuteChanged != null)
    38. {
    39. CanExecuteChanged(this, EventArgs.Empty);
    40. }
    41. }
    42. }

    Quellcode

    1. public class AutoDelegateCommand : DelegateCommand, ICommand
    2. {
    3. public AutoDelegateCommand(Action<object> execute)
    4. : base(execute)
    5. {
    6. }
    8. public AutoDelegateCommand(Action<object> execute, Predicate<object> canExecute)
    9. : base(execute, canExecute)
    10. {
    11. }
    13. event EventHandler ICommand.CanExecuteChanged
    14. {
    15. add { CommandManager.RequerySuggested += value; }
    16. remove { CommandManager.RequerySuggested -= value; }
    17. }
    18. }


    Du hast einmal das Ereignis CanExecuteChanged implicit implementiert und einmal(für die automatische Version) explizit implementiert(siehe das ICommand.CanExecuteChanged).


    Opensource Audio-Bibliothek auf github: KLICK, im Showroom oder auf NuGet.

    Ja, habe ich. Ich glaube ich verstehe auch die Logik dahinter.

    Das ist die Änderung, bei der mein Button wieder erscheinen soll:

    C#-Quellcode

    1. this.RunningThread = null;


    Und so kommt das in meinem Command vor (Zeile 3):

    C#-Quellcode

    1. public bool OnRunCanExecute(object parameter = null)
    2. {
    3. if (this.DontRunMultiThreaded == true || this.RunningThread == null || this.RunningThread.IsAlive == false)
    4. {
    5. return true;
    6. }
    8. return false;
    9. }


    Zur Sicherheit poste ich auch nochmal meinen Basis-Command und die Vererbung:

    Basis

    C#-Quellcode

    1. public class ActionCommand : ICommand
    2. {
    3. private readonly Action<object> _executeHandler;
    4. private readonly Func<object, bool> _canExecuteHandler;
    6. public ActionCommand(Action<object> execute, Func<object, bool> canExecute)
    7. {
    8. if (execute == null)
    9. {
    10. throw new ArgumentNullException("execute cannot be null");
    11. }
    13. _executeHandler = execute;
    14. _canExecuteHandler = canExecute;
    15. }
    17. public event EventHandler CanExecuteChanged;
    19. public void Execute(object parameter)
    20. {
    21. _executeHandler(parameter);
    22. }
    24. public bool CanExecute(object parameter)
    25. {
    26. if (_canExecuteHandler == null)
    27. {
    28. return true;
    29. }
    31. return _canExecuteHandler(parameter);
    32. }
    34. public void RaiseCanExecuteChanged()
    35. {
    36. var handler = CanExecuteChanged;
    37. if (handler != null)
    38. {
    39. handler.Invoke(this, EventArgs.Empty);
    40. }
    41. }

    AutoCommand

    C#-Quellcode

    1. public class AutoActionCommand : ActionCommand, ICommand
    2. {
    4. public AutoActionCommand(Action<object> execute, Func<object, bool> canExecute)
    5. : base(execute, canExecute)
    6. {
    7. }
    9. event EventHandler ICommand.CanExecuteChanged
    10. {
    11. add { CommandManager.RequerySuggested += value; }
    12. remove { CommandManager.RequerySuggested -= value; }
    13. }
    14. }


    Wie soll die CLR denn da erkennen ob sich was geändert hat? :)

    MfG

    Hmm scheint richtig zu sein. Funktionieren tut dies über den CommandManager. Genaueres dazu kannst du dir auf msdn durchlesen.
    Außerdem kannst du trotzdem deinen den Code reduzieren.
    Dein CanExecute kommt mit genau einer Zeile aus:

    Quellcode

    1. return this.DontRunMultiThreaded || this.RunningThread == null || !this.RunningThread.IsAlive


    Leider scheint der Command hier wirklich nicht ganz zu funktionieren. Für normal funktioniert dies für fast alles(behalt es also im Hinterkopf). Du kannst es auch einmal bei z.b. einem Menu ausprobieren. Hatte dies grad erst gestern gemacht und da funktioniert es zu 100%.


    Opensource Audio-Bibliothek auf github: KLICK, im Showroom oder auf NuGet.

Facebook
Telefonspende