Discussion :

[Harry_polin]

Bonjour,

J'ai un SequenceWorkflow dans lequel il y a des CallExternalMethodActivities qui appellent des méthodes dans une librairie, qui mettent à jour des données dans un DataSet, qui sont bindées par un BindingSource à des contrôles winform.

Lors de l'exécution, les données sont bien mises à jour, mais les contrôles ne sont pas rafraichis.

Si je lance les mêmes fonctions dans le même ordre sans passer par le workflow, les contrôles sont bien rafraichis.

J'ai essayé les Applications.DoEvents() ou les Refresh() forcés de Form, ça ne marche pas.

Je n'ai pas d'autres idées, et ca me bloque complètement. Que faut-il faire ?

[Paul Musso]

Bonjour,

A vu de nez, je pense que cela vient du fait que ton workflow est exécuté dans un thread séparé. Du coup, cela doit bloquer le rafraichissement de ton contrôle.

Essaie d'utiliser un backgroundworker dans ton activité et d'exécuter ta logique dedans. Normalement, tu devrais retrouver le même comportement que celui sans le workflow.

[Harry_polin]

C'est possible que ca soit une histoire comme ca.
Je ne suis pas très familier de l'usage des backgroundWorkers.

Dois-je créer un backgroundWorker à chaque appel de fonction ?

Sinon il existe une autre technique pour synchroniser des threads avec des fenetres winforms, qui est je crois de faire un Invoke de la méthode ou lieu de l'appeler directement, mais je ne sais plus exactement comment ca marche.

[Harry_polin]

Bonjour,

Je n'ai pas choisi de faire avec un backgroundworker, car pour une bonne découpe architecturale en terme de dépendances, je ne veux pas introduire de composants winforms dans ma lib qui gère les accès au dataset.

Je suis donc parti sur un synchronizationContext, et je gère donc les problématiques de synchronisation d'affichage uniquement dans l'assembly qui sait ce que c'est que les winforms.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
        SynchronizationContext m_synchronizationContext = null;
        public Form1()
        {
            InitializeComponent();
 
            m_synchronizationContext = WindowsFormsSynchronizationContext.Current;
 
            foreach(System.ComponentModel.Component l_component in this.components.Components)
            {
                if (l_component is BindingSource)
                {
                    BindingSource l_bindingSource = (BindingSource)l_component;
                    bool l_res = l_bindingSource.IsSynchronized;
                    l_bindingSource.ListChanged += new System.ComponentModel.ListChangedEventHandler(l_bindingSource_ListChanged);
                }
            }
 
            StartWorkflow();
        }
 
        void l_bindingSource_ListChanged(object sender, System.ComponentModel.ListChangedEventArgs e)
        {
            ((BindingSource)sender).ListChanged -= new System.ComponentModel.ListChangedEventHandler(l_bindingSource_ListChanged);
                        m_synchronizationContext.Send(new SendOrPostCallback(delegate
                            {
                                ((BindingSource)sender).ResetBindings(false);
                            }), null);                        
            ((BindingSource)sender).ListChanged += new System.ComponentModel.ListChangedEventHandler(l_bindingSource_ListChanged);
        }

Le seul inconvénient, c'est que ResetBindings réappelle l_bindingSource_ListChanged, donc il semble que sur chaque modif du dataset le traitement du binding soit fait deux foix. Il m'aurait fallu un ListChanging() avec possibility de mettre un flag "handled" pour l'empecher de processer un deuxième fois.

Je n'ai pas trouvé de solution qui satisfasse les problématiques à la fois architecturales et de performances, si vous avez des idées, lâchez-vous.