Discussion :

[Marick Biokou]

Bonjour à toutes et à tous,

J'explique mon problème :

Je réalise une application en C# qui est relié à une base de données MySQL en Ligne. Pour l'instant j'ai pas de souci quand à la connexion, la lecture et l'écriture de données sur celle ci.

Cette application est installée sur plusieurs machines qui ont tous accès à cette base en lecture /écriture. il n'y a pas de hiérarchie, tout le monde peut lire et écrire.

Pour la synchronisation des données, si la machine A fait une modification, la machine B doit d'abord appuyé sur le bouton " Actualiser " pour voir ces modifications dans un control Datagridview.

1 - Comment est ce que je peux faire pour automatiser ce rafraîchissement au niveau des applications clients sans qu'ils aient besoin de cliquer sur le bouton " Actualiser " pour que ces données soit actualisées dans la Datagrid automatiquement.

2- Est ce qu'il y a d'autres possibilités ou technologies me permettant de faire ceci. Et peut être que vous avez des conseils à me donner pour ce type de réalisations.

Merci à vous pour vos réponses.

[Pol63]

c'est rarement simple

en connexion directe sur la base de données tu ne peux pas recevoir les infos modifiées, et tu ne peux pas deviner s'il y a eut des modifs depuis le moment où tu as eut les données
donc la plupart des gens mettent à jour avec un timer ou disent à l'utilisateur de cliquer sur refresh
en mettant des triggers sur toutes les tables tu peux coder un mécanisme moins gourmand en bande passante pour détecter un changement mais il faudra quand même au final faire plusieurs requetes

avec un web service en intermédiaire entre l'appli et la base de données c'est déjà plus simple (connexion bidirectionnelle etc...)

[DotNetMatt]

Avec MySQMerde pas possible d'etre notifie... SQL Server propose un mecanisme, ce qui serait la solution la plus simple.

S'il n'est pas envisageable de migrer vers SQL Server, tu peux te tourner vers SignalR. Ca a ete initialement cree pour les applis Web en ASP.NET, mais l'architecture a ete ajustee de maniere a pouvoir avoir des hubs heberges en dehors d'IIS. Donc tu peux facilement heberger ton/tes hub au sein d'un service Windows et/ou WCF, ou meme une appli console ou Windows Forms.

Sinon, tu peux tout reecrire toi-meme avec un web service maison auquel tu t'abonneras et qui verifiera la DB de maniere reguliere. Autre option, faire transiter les modifications de DB via un Service Bus auquel tes clients pourront souscrire et donc recevoir les notifications de modifications.

Le plus propre reste quand meme SignalR...

[Marick Biokou]

Je vais exploré ces différentes options, et je reviendrai faire un retour de la solution que j'ai adopté. Merci à vous pour vos réponses

Rebonjour tout le monde,
Alors voici ce que j'ai pu faire avec aussi l'aide de MSDN. Cela Fonctionne. Peut être qu'il y a moyen de faire autrement, et / ou mieux optimiser le code, mais je pense avoir fait attention à ce dernier.
J'ai travaillé avec les " Timers " et les " Threads ".

Je mets la solution. Cela peut aider d'autres personnes ;-)

Dans ma forme principale contenant mon control Datagridview, j'ai :

La Classe Form1 :

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
 
     public delegate void Raffraichissement();
     public Raffraichissement myDelegate;
     private Thread myThread;
     private static System.Timers.Timer aTimer;
 
    class form1class
    {
        public form1class()
        {
            InitializeComponent();
            Raffraichir_Liste_des_Comptes();// Méthodes de chargement de ma datagridview
 
            myDelegate = new Raffraichissement(Raffraichir_Liste_des_Comptes);
 
            SetTimer();
        }
 
        private void ThreadFunction()
        {
            MyThreadClass myThreadClassObject = new MyThreadClass(this);
            myThreadClassObject.Run();
        }
 
        private void SetTimer()
        {
            // Create a timer with a two second interval.
            aTimer = new System.Timers.Timer(10000);
            // Hook up the Elapsed event for the timer. 
            aTimer.Elapsed += Event_Lancer_Par_MonTimer;
 
            aTimer.AutoReset = true;
            aTimer.Enabled = true;
        }
 
        public void Event_Lancer_Par_MonTimer(Object source, ElapsedEventArgs e)
        {         
            myThread = new Thread(new ThreadStart(ThreadFunction));
            myThread.Start();
        }
 
private void ActualiserListeDesComptes()
        {
 
            DataTable MyDataTable = new DataTable();
            try
            {
                MySQL_Connexion = MyCon.Connexion_MySql_BDD();
                MySqlDataAdapter DataAdapter = new MySqlDataAdapter("SELECT * FROM Comptes_Connexions ORDER BY Site_Connexion ASC", MySQL_Connexion);
                DataAdapter.Fill(MyDataTable);
 
                this.dataGridView_Comptes_Connexions.DataSource = MyDataTable;
 
                this.dataGridView_Comptes_Connexions.ColumnHeadersDefaultCellStyle.Alignment = DataGridViewContentAlignment.MiddleCenter;
                this.dataGridView_Comptes_Connexions.AutoSizeColumnsMode = DataGridViewAutoSizeColumnsMode.Fill;
                this.dataGridView_Comptes_Connexions.Columns[0].Visible = false;//Id_Comptes
                this.dataGridView_Comptes_Connexions.AllowUserToResizeRows = false;
                this.dataGridView_Comptes_Connexions.AllowUserToResizeColumns = false;
                this.dataGridView_Comptes_Connexions.RowHeadersVisible = false;
 
                MySQL_Connexion.Close();
 
            }
            catch (Exception Ex)
            {
                MessageBox.Show(Ex.ToString());
            }
        }
    }

La classe Gérant mon Thread :

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
 
class MyThreadClass
    {
        Form1 myFormControl1;
        public MyThreadClass(Form1 myForm)
        {
            myFormControl1 = myForm;
        }
 
        public void Run()
        {
            // Exécutez le délégué spécifié sur le thread qui possède le handle de fenêtre sous-jacente du contrôle 'myFormControl1'.
            myFormControl1.Invoke(myFormControl1.myDelegate);
        }
    }

Merci pour vos aides ;-) très appréciable.

[StringBuilder]

Le souci des timers, c'est qu'il y a deux gros défauts :

1/ Si l'utilisateur laisse le logiciel allumé pendant qu'il ne travaille pas dessus, le programme continue à exécuter des requêtes plus ou moins consommatrices à intervalle régulier, en pure perte.
1bis/ Cela implique aussi que s'il y a plus d'utilisateurs que la taille du pool de connexion, le SGBD va passer son temps à ouvrir et fermer des connections, alors que la plupart ne servent rigoureusement à rien.
1ter/ Si les connexion restes ouvertes côté client, tu risques de saturer le SGBD avec trop de connexion simultanées... toujours pour rien.
2/ Rien ne garanti que depuis le dernier chargement il n'y a pas eu de modification : ainsi ton utilisateur peut modifier une donnée périmée sans le savoir.

Je t'invite à te pencher sur une solution plus ancienne que les solutions présentées ci-dessus, mais qui a fait ses preuves et qui a le mérite d'être simple.

1/ Tu charges tes datagrid comme actuellement.
2/ Chaque fois que tu passes en édition sur une ligne, alors tu :
a) pose un lock logique sur la ligne dans la base
b) recharge la ligne avant de la rendre modifiable
3/ Chaque fois que tu quittes l'édition d'une ligne, tu relâches le lock logique. Avant de sauvegarder en base, tu vérifies que ton lock est toujours valide.

Un lock logique pourra par exemple être géré sous la forme d'une table ayant 4 colonnes par exemple :
- Table
- ID
- Utilisateur
- Date/Heure du lock

Ainsi, quand un utilisateur Toto passe en modification sur le produit 4, alors dans la table, tu insères une ligne "PRO;4;Toto;2018-01-17 21:38:00"
Une contrainte unique sur (Table, ID)
Et éventuellement une tâche planifiée qui détruit les locks qui ont plus de X minutes (histoire que si Gisèle passe en édition sur une fiche avant de faire sa pause déjeuner, qu'elle ne bloque pas Marcel au dépôt pendant ce temps...)

L'avantage, c'est que ça reste simple, léger à gérer, et que ça marchera avec n'importe quel SGBD.
Après, c'est de la méthode des années 80...

[Marick Biokou]

Merci StringBuilder, je vais regardé aussi de ce coté la et revenir vers toi.
J'aime apprendre alors, on verras ce que ca donnera.
Merci encore