Polling avec OpenReadAsync pour lire un fichier XML

Version imprimable

21/04/2008, 16h09
GLoeKS

Polling avec OpenReadAsync pour lire un fichier XML

Bonjour,

J'effectue une lecture en local avec webClient.OpenReadAsync(uriXML)
J'ai un thread Each_Tick qui tourne en boucle, et qui appelle cette fonction a chaque fois que l'evenement OpenReadCompletedArgs a lieu.

Cela fonctionne très bien au début, mais quand je modifie mon fichier xml, la lecture ne tient pas compte de la modification,...Et l'affichage qui en découle, reste indifférent (il continue à me montrer les anciennes données lues)....

J'ai l'impression que mon appli garde en mémoire ce qu'elle a lu, et qu'elle ne lit pas vraiment quand je refais appel à OpenReadAsync.

Est-ce que quelqu'un pourrait m'expliquer d'où vient le problème ?

D'avance merci.
Si je n'ai pas été clair, je veux bien ré-expliquer.

GLoeKS
21/04/2008, 19h15
Thomas Lebrun

Tu veux dire que tu télécharges un fichier à la volée mais que si tu le modifies, celui-ci ne semble pas être mis à jour dans ton appli ?
21/04/2008, 19h26
anthyme

y a 3 point a vérifier :

a tu du cache ?
- coté serveur
- dans le navigateur
- dans cette methode SL

Je ne sais pas ce que tu entends par "à la volée", pour ce qui est du fichier, il est dans le meme dossier que mon appli en local, et l'appli le lit pour en faire un XmlReader.

En gros pour parler de code, voilà ce qu'il se passe :

Voila la fonction qui est appelée lorsque mon OpenReadAsync a fini son travail:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
void webClient_OpenReadCompleted(object sender, OpenReadCompletedEventArgs e)
        {
            if ((e.Error == null) && (e.Cancelled == false))
            {
                try
                {
                    content = Stream.Null;
                    content = e.Result;
                    sr = new StreamReader(content, Encoding.UTF8);
                }
                catch (Exception ex) { xmlFile =  ex.Message; }
                chercherNoeud();
            }
            else
            {
                xmlFile =" Erreur OpenRead "+ e.Error.ToString();
            }
        }

Je cherche les noeuds qui m'interesse pour en faire un String xmlFile:

Code:

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
 
public void chercherNoeud()
        {
            try
            {
                reader = XmlReader.Create(sr);
            }
            catch (Exception e)
            {
                xmlFile = "Error XmlReader : " + e.Message;
            }
            if (reader != null)
            {
                xmlFile = "";
                while (reader.Read())
                {
                   switch (reader.NodeType)
                    {
                   case XmlNodeType.Element:
                       if (reader.Name == "title")
                       {
                           while (reader.Read() && reader.NodeType != XmlNodeType.Text)
                           {
                           } 
                           xmlFile += reader.Value.ToString();
                           break;
                       }
                       break;
 
                   default:
                       break;
                   }
                }
                fichierLu = true;         
            }
        }

Et pour ce qui est du Polling, voilà comment je m'y prends:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
 
public void Each_Tick(object o, EventArgs sender)
{
            if (fichierLu)
            {
                webClient = new WebClient(); 
                webClient.DownloadProgressChanged += new DownloadProgressChangedEventHandler(webClient_DownloadProgressChanged);
                webClient.OpenReadCompleted += new OpenReadCompletedEventHandler(webClient_OpenReadCompleted);
                try
                {
                    Uri uri = new Uri("./une2.xml", UriKind.Relative);
                    webClient.OpenReadAsync(uri);
                }
                catch (Exception e)
                {
                    xmlFile = "ERROR webClient.Download " + e.Message;
                }
 
            }
}

Et effectivement lorsque je modifie mon fichier xml, la modification n'est pas prise en compte dans la lecture...

Pour ce qui est du cache ... Je suspecte effectivement ce problème... Mais comment puis-je vérifier ?

Coté serveur, je suis encore au stade local... ça change quelque chose?
Coté navigateur ... J'ai réussi le polling en AS3, donc j'aurais tendance à dire que c'est spécifique à SL.
Coté appli, j'ai créé un projet Visual Studio 2008 avec le même code sans les outils spécifiques à Silverlight (Canvas et compagnie), et tout se passe bien ...

Mes raisonnements peuvent être faux... Mais là va falloir me prévenir.

Merci beaucoup

GLoeKS

22/04/2008, 09h38
GLoeKS

Une petite précision, si je relance mon appli après avoir modifié mon fichier XML, la modification est prise en compte à ce moment là.

Merci

GLoeKS
22/04/2008, 10h16
Thomas Lebrun

Il doit y avoir du cache qui se produit coté Silverlight car sinon, je vois pas pourquoi cela ne marcherait pas :?
22/04/2008, 10h24
anthyme

j'ai déjà eu le problème avec un objet XMLDocument qui cache énormément sur basé le path du fichier et se met a jour que 2 fois par jour (quelque chose dans ce style) mais bon a priori t'est sur du XMLReader ca ne doit pas mettre en cache.

T'as essayer de printer le XML récupéré pour voir si il est différent AVANT d'avoir été parsé ?
22/04/2008, 15h50
GLoeKS

J'ai affiché le StreamReader avant, après, après lecture du fichier, et il se trouve qu'il est toujours le même.

Auriez vous une solution ?

Pour être simple, j'essaye de faire un lecteur RSS avec sylverlight, si vous avez une idée de comment faire, ou comment résoudre mon souci.

Merci encore.

GLoeKS
23/04/2008, 10h45
GLoeKS

J'aimerai utiliser une methode du style Finalize() ou Dispose() sur mon WebClient.

Quelle est la syntaxe à suivre?

Bon eh bien voilà... Je me suis réglé le problème.

Pour une raison que j'ignore, le thread du Timer ne permettait pas de relire une deuxième fois le fichier.

Du coup il m'a suffit de sortir la fonction

Code:

webClient.OpenReadAsync()

de la fonction

Code:

Each_Tick(object o, EventArgs sender)

(fonction appelée par le timer régulièrement suivant la configuration)

et de créer le polling de manière reccursive.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 public void openreadFunction() { webClient = new WebClient(); webClient.DownloadProgressChanged += new DownloadProgressChangedEventHandler(webClient_DownloadProgressChanged); webClient.OpenReadCompleted += new OpenReadCompletedEventHandler(webClient_OpenReadCompleted); try { if(!webClient.IsBusy) { webClient.OpenReadAsync(uri); } else { openreadFunction(); } }catch { webClient.CancelAsync(); openreadFunction(); } }
J'ai du faire quelques autres modifications, mais la plus importante est celle ci.
il faut encore appeler openreadFunction() à la fin de la fonction webClient_OpenReadCompleted()

je le mets au cas où un jour quelqu'un ait un esprit aussi tordu que moi pour en arriver à cette même problématique :) j'ai quand même des doutes.

en espérant ne pas m'etre trompé en recopiant...

Merci d'avoir un peu essayer de m'aider quand même.

Bonne suite, et surement à bientot

GLoeKS