Comment mettre à jour en toute sécurité une interface utilisateur WPF à partir d'un thread distinct dans une classe différente ?

Mise à jour de l'interface utilisateur à partir d'un autre thread dans une classe distincte

Vous rencontrez le problème courant de la mise à jour d'une interface utilisateur WPF à partir d'un thread exécutant une classe distincte . L'interface utilisateur se fige pendant les longs calculs et vous devez informer l'utilisateur de la progression.

Solution utilisant le fil de discussion et les événements

1. Dispatcher. Invoke : Pour mettre à jour l'interface utilisateur à partir d'un autre fil de discussion, utilisez Dispatcher.Invoke. Pour l'invoquer à partir d'une classe distincte, utilisez des événements.
2. Inscription à l'événement : Dans la classe principale, inscrivez-vous au(x) événement(s) déclenché(s) par la classe de calcul.
3. Notification d'événement : Dans la classe de calcul, déclenchez l'événement pour avertir l'interface utilisateur lorsque les mises à jour sont nécessaire.

Exemple de code :

class MainWindow : Window
{
    private void startCalc()
    {
        // Prepare input
        inputValues input = ...;

        // Create calculation class and register to its event
        CalcClass calc = new CalcClass();
        calc.ProgressUpdate += (s, e) => Dispatcher.Invoke(() => { /* UI Update */ });

        // Start calculation in a separate thread
        Thread calcthread = new Thread(new ParameterizedThreadStart(calc.testMethod));
        calcthread.Start(input);
    }
}

class CalcClass
{
    public event EventHandler ProgressUpdate;

    public void testMethod(object input)
    {
        // Raise event to trigger UI update
        if (ProgressUpdate != null)
            ProgressUpdate(this, new YourEventArgs(status)); // Notify UI with status updates
    }
}

Alternatives avec .NET 4.5 et versions ultérieures

Considérez les alternatives suivantes utilisant des fonctionnalités plus récentes :

Utilisation Tâches : Remplacez le thread par une tâche pour simplifier la gestion des threads.

Utilisation d'Async/Await : Différez le calcul jusqu'à ce qu'il soit nécessaire en marquant la méthode de mise à jour de l'interface utilisateur comme asynchrone.

Utilisation d'événements génériques fortement typés : Transmettez des types de données personnalisés à l'événement à l'aide d'événements génériques fortement typés événements.

Exemple amélioré avec extensions :

class MainWindow : Window
{
    Task calcTask = null; // Stores task for later checking

    void StartCalc()
    {
        var calc = PrepareCalc();
        calcTask = Task.Run(() => calc.TestMethod(input)); // Start in background
    }

    async Task CalcAsync()
    {
        var calc = PrepareCalc();
        await Task.Run(() => calc.TestMethod(input)); // Await completion
    }

    CalcClass PrepareCalc()
    {
        // Prepare input and create calc object
        var calc = new CalcClass();
        calc.ProgressUpdate += (s, e) => Dispatcher.Invoke(() => { /* UI Update */ });
        return calc;
    }
}

class CalcClass
{
    public event EventHandler<EventArgs<YourStatus>> ProgressUpdate;

    public TestMethod(InputValues input)
    {
        // Raise event to trigger UI update
        ProgressUpdate?.Raise(this, new EventArgs<YourStatus>(status)); // Raise with status
    }
}

Remarques supplémentaires :

• Assurer une gestion efficace des événements pour éviter les conditions de concurrence ou les blocages potentiels.
• Considérez les implications sur les performances des mises à jour de l'interface utilisateur d'un point de vue distinct. fil.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!