Discussion :

[wil4linux]

Bonjour,

je cherche une solution me permettant de synchroniser des données entre plusieurs instances d'une mm application.

Par exemple, j'ai 2 instances.

Dans la 1ere, je lance un calcul via un bouton qui peut durer assez longtemps.

Il faut que dans ma 2e instance, le bouton soit désactivé le temps que la 1e instance est finie ce traitement.

Comment forcer cette communication ?
via WCF et les NamedPipe. Ca, c'est ok !

Dans l'idée, les clients communiquent avec le serveur WCF hébergé via l'application WPF dans le sens client => server.

Comment notifier chaque instances qu'un traitement est en cours pour désactiver des commandes spécifiques ? est-ce possible ?

Voir une sorte de Messenger (send/register) avec une portée mutli-instances...

(Soit ce n'est pas possible et il faut que lors qu'un instance déclenche un traitement, elle interroge le serveur pour savoir si cette commande est possible et renvoi un retour à l'utilisateur dans le cas négatif...)

Si vous avez des idées...

[Graffito]

Il faut que dans ma 2e instance, le bouton soit désactivé le temps que la 1e instance est finie ce traitement.

On ne peut jamais assurer une synchro à 100% :

• à l'instant t, l'instance I1 et l'instance I2 sont activable,
• à l'instant t+epsilon1, I1 s'active
• à l'instant t+epsilon2,l'événement d'activation (méthode à définir) est reçu par I2.
• entre t+epsilon1 et t+epsilon2, I2 reste activable.

Une instance affichée comme "activable" doit donc systématiquement vérifier au moment où on essaie de l'activer si c'est encore possible.

[wil4linux]

On ne peut jamais assurer une synchro à 100% :

• à l'instant t, l'instance I1 et l'instance I2 sont activable,
• à l'instant t+epsilon1, I1 s'active
• à l'instant t+epsilon2,l'événement d'activation (méthode à définir) est reçu par I2.
• entre t+epsilon1 et t+epsilon2, I2 reste activable.

Une instance affichée comme "activable" doit donc systématiquement vérifier au moment où on essaie de l'activer si c'est encore possible.

je suis d'accord avec toi. Il faut vérifier au moment d'un appel si c'est possible de le faire (même si notre interface affiche le contraire).

[Graffito]

Le principal problème réside dans les contraintes suivantes :
1) possibilité d'obtenir l'indication de blocage si on lance une instance 2 après que l'instance 1 ait activé le blocage,
2) gestion de de blocage concurrent (instance 1 et 2 testent le blocage au "même" moment)
3) possibilité de positionner un indicateur de blocage sans que cet indicateur persiste si le programme l'ayant positionné crashe,
4) "reception" des blocages par event.

Les points 1) et 2) imposent un mécanisme de gestion d'accès concurrent (via un SGBD par exemple).
Le point 3) peut se résoudre en horodatant le blocage, en faisant en sorte que le processus actif le réactive régulièrement et qu'un processus candidat ignore les blocages trop anciens.
Le point 4) peut être contourné via un event Timer qui testerait le blocge.

Questions subsidiaires :

• Les instances sont-elles sur le même PC ?
• Utilisent-elles un SGBD ?

[wil4linux]

oui. Je cherche à faire le plus simple possible.
les instances seront sur le mm pc et l'appli utilise des bases de données sqlite.

effectivement, je peux gérer cette synchro via une bdd, et mettre en place un listener sur les fonctions utilisables. En fait il faudrait mettre en place un système de push entre un contrôleur commun et les IHM.
pour ce qui est des blocages, ce nest pas trop le pb, on peut utiliser des events et les exceptions.

[Graffito]

Je cherche à faire le plus simple possible.

On peut utiliser un fichier "free.txt" que l'on renomme en "lock.txt" et vice-versa.
Le FileSystemWatcher permet d'être averti des renommages, donc des blocages/déblocages.

[wil4linux]

On peut utiliser un fichier "free.txt" que l'on renomme en "lock.txt" et vice-versa.
Le FileSystemWatcher permet d'être averti des renommages, donc des blocages/déblocages.

oui en effet... pas bête

Sinon pour en revenir à un module de synchro entre les instances, le WCF NamedPipe est elle la meilleure solution pour communiquer ?

[sfxzeus]

Bonjour,
Je m'incruste sur le sujet il y'a peut-être aussi la solution d'utiliser WCF avec MSMQ non ?
http://msdn.microsoft.com/fr-fr/library/ms789048.aspx

[wil4linux]

Bonjour,
Je m'incruste sur le sujet il y'a peut-être aussi la solution d'utiliser WCF avec MSMQ non ?
http://msdn.microsoft.com/fr-fr/library/ms789048.aspx

Ah petite précision. je suis limité au .NET 4.0 car je dois garder une compatibilité avec XP SP3.

Par contre j'ai testé le système du FileSystemWatcher avec une fichier lock.txt ou free.txt ==> ça marche super bien.

J'ai bindé des DelegateCommand sur mes boutons. L'event "Renamed" du watcher me Raise le CanExecute du DelegateCommand.

voir pj.

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
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
 
public partial class MainWindow : Window, INotifyPropertyChanged
    {
        private FileSystemWatcher _watcher;
        public event PropertyChangedEventHandler PropertyChanged;
 
        private bool _isBusy = false;
        public bool IsBusy
        {
            get { return _isBusy; }
            set
            {
                _isBusy = value;
                RaisePropertyChanged("IsBusy");
            }
        }
 
        private DelegateCommand _launchProcessCommand;
        public ICommand LaunchProcessCommand
        {
            get
            {
                if (_launchProcessCommand == null)
                {
                    _launchProcessCommand =
                        new DelegateCommand(
                            DoWork,
                            () => File.Exists("free.txt"));
                }
                return _launchProcessCommand;
            }
        }
 
        protected void RaisePropertyChanged(string prop)
        {
            if (string.IsNullOrWhiteSpace(prop) != null)
            {
                PropertyChanged(this, new PropertyChangedEventArgs(prop));
            }
        }
 
        public MainWindow()
        {
            InitializeComponent();
 
            this.DataContext = this;
 
            //Get currentPath
            string path;
            path = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
 
            _watcher = new FileSystemWatcher(path);
            _watcher.Path = path;
 
            _watcher.Renamed += (s, e) =>
            {
                _launchProcessCommand.RaiseCanExecuteChanged();
            };
 
            _watcher.NotifyFilter = NotifyFilters.FileName;
            _watcher.Filter = "*.txt";
            _watcher.EnableRaisingEvents = true;
        }
 
        private void DoWork()
        {
            IsBusy = true;
            LockProcess();
 
            Task.Factory.StartNew(() =>
            {
                Thread.Sleep(4000);
                //DO LONG PROCESS
 
                ReleaseProcess();
                Dispatcher.BeginInvoke(new Action(() =>
                    {
                        IsBusy = false;
                    }), null);
            });
        }
 
        private void LockProcess()
        {
            if (File.Exists("free.txt"))
                System.IO.File.Move(@"free.txt", @"lock.txt");
 
            _launchProcessCommand.RaiseCanExecuteChanged();
        }
 
        private void ReleaseProcess()
        {
            if (File.Exists("lock.txt"))
                System.IO.File.Move(@"lock.txt", @"free.txt");
 
            _launchProcessCommand.RaiseCanExecuteChanged();
        }
    }

[sfxzeus]

MSMQ est dispo sur 4.0 mais de toute façon je me dis que ce sera largement plus complexe qu'un système de fichier.

Par contre dans le cas où ton appli qui a bloqué plante tu vas faire comment ?
Il y'a aussi le cas de l'arrêt de windows et fermeture forcé des applications.

[wil4linux]

MSMQ est dispo sur 4.0 mais de toute façon je me dis que ce sera largement plus complexe qu'un système de fichier.

Par contre dans le cas où ton appli qui a bloqué plante tu vas faire comment ?
Il y'a aussi le cas de l'arrêt de windows et fermeture forcé des applications.

Oui ce sont des choses à gérer. Tester au lancement de la 1ere instance si on a un lock.txt ou un free.txt.
en fonction, remettre une config par defaut.

le système de fichier permet de faire un retour utilisateur en temps réel (Commande exécutable ou pas)
Sinon, développer un canal commun a chaque instance pour appeler le traitement, incluant un mécanisme de sémarphoe (mutex par exemple...).
Si mon mutex est "Release" et que le système de fichier me dit le contraire... je remet à jour mon système de fichier, ce qui dévérouillera la commande dans l'IHM.

Qu'en pensez vous ?