Discussion :

[nicorem]

Bonjour,

Dans une appli web, je dois afficher des données issues d'un fichier xml dans un tableau.
les données affichées varient selon un parametre fonction du choix de l'utilisateur.
en fait il s'agit d'une appli météo.
le fichier xml contient les prévisions de 100 zones géographiques
et les données affichées dans le tableau sont les prévisions de la zone qu'aura choisi l'utilisateur.
le fichier xml, source de données, est mis à jour 3 fois par jour.

pour optimiser tout ça, je compte utiliser la mise en cache d'asp.net

2 solutions :

1) mise en cache de données d'application dans un dataview:
je mets l'ensemble des données du fichier xml dans un dataview, et je mets ce dataview en cache avec une dépendance sur le fichier xml.
dès que le fichier xml change le dataview est mis à jour.
reste à créer à chaque demande le tableau avec les données du dataview issu du cache.

2) mise en cache de pages ASP.net ou plutot mise en cache de plusieurs versions d'une page.
je mets toute la page en cache en utilisant VaryByparam pour prendre en compte le choix de l'utilisateur et tjrs une dépendance sur le fichier xml.


cl° : dans la première solution, je traine dans le cache un dataview qui contient les données des 100 zones et à chaque demande, je dois créer mon tableau pour présenter les données d'une seule zone.

Dans la deuxième, je mets dans le cache au pire 100 versions de la page puisque 100 zones météo, donc 100 choix possibles.
reste aussi la solution de ne pas utiliser le cache et de "parser" le fichier xml à chaque demande pour afficher uniquement les données de la zone météo choisi par l'utilisateur.

selon vous quelle est la meilleure solution ?, par meilleure j'entends la plus performante.

merci de vos réponses

[CUCARACHA]

Salut,

Avant d'optimiser, tu peux nous dire la taille de ton fichier XML ?
Etant donné que les informations météorologiques ne varient pas d'un utilisateur à l'autre, et que par définition un fichier XML peut être considéré comme le résultat d'un sérialisation, je créerais un petit proxy capable de mettre à jour une variable de type liste générique de ta ligne d'information vidéo stocké dans l'objet application. La mise à jour de l'objet application n'aurait lieu qu'une fois par jour, dès qu'un utilisateur sollicite la liste et que celle ci n'est pas à jour sans quoi, elle serait tout le temps dispo et interrogeable par Linq To Object.

A mon avis c'est beaucoup plus simple que l'usine à gaz à laquelle tu penses mais je n'ai pas autant réfléchi que toi à la question et je ne suis certainement pas au courant des contraintes.

++

Laurent

[nicorem]

bonjour,

le fichier fait 300 ko
Désolé mais j'avoue ne pas tout comprendre
"mettre à jour une variable de type liste générique de ta ligne d'information vidéo"
donc si tu peux prendre le temps de m'expliquer, ce serait sympa, sinon tant pis et merci quand même pour la réponse.

[CUCARACHA]

pardon c'était ligne d'information Météo...

Chaque ligne de ton fichier XML peut être injecté dans une classe. Les instances de cette classe peuvent remplir une liste générique dont le Type correspond à la structure de ta ligne XML.

Dans ton global.asax :

Code :

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

1
2
3
4
5
6
7
8
9
10
DateTime dateDerniereMiseAJour;
DateTime dateDerniereVersion;
List<TonTypeMeteo> lst;
 
dateDerniereVersion = VerifDateMiseAjour()
if(dateDerniereMiseAJour !=dateDerniereVersion) {
    lst = remplissageDepuisFichierXML();
    dateDerniereMiseAJour = dateDerniereVersion
    Application.Add("MesDonneesMeteo",lst);
}

depuis les pages aspx :

Code :

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

List<TonTypeMeteo> lst = (List<TonTypeMeteo>)Application["MesDonneesMeteo"];

après tu requête en linq

Code :

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

1
2
3
var mesInfo = from DM in lst
                    where...
                    select...

Il faudra affiner un peu quand même et ranger tout ça...

++

Laurent

[Immobilis]

Salut,

Tu peux aussi utiliser une variable statique dans une classe statique

A+

[nicorem]

merci c'est dèjà un peu plus claire
je vois bien que vous êtes des pro de la programmation.
moi un peu moins que vous forcement mais assez pour comprendre (enfin j'espère)
pour aller jusqu'au bout du raisonnement, il y a encore un truc qui m'échappe encore.
En quoi l'utilisation de variables statiques ou d'une liste générique, est-il plus performant que le fait de mettre un dataview dans le cache.

en quoi le parcours, la recherche dans la liste générique est-elle mieux que le parcours, la recherche dans un dataview ou dans un datatable

faut-il comprendre que les mécanismes de cache proposés dans asp.net sont là pour répondre aux besoins de développeurs qui ne connaissent pas ou peu la Programmation notamment objet.
autrement dit ce sont des raccourcis, des sortes d' utilitaires dont les fonctionnalités peuvent être obtenu autrement à condition d'avoir un certain niveau de programmation.
en tout cas merci de vos réponses

[CUCARACHA]

Un Dataview est un élément de présentation, dans la mesure du possible on ne mélange pas la présentation et les données (on peut quand même parfois faire quelques exceptions pour faire des maquettes).

Lorsque tu mets des données en cache dans la page web (pour moi ça veut dire dans le viewstate) elles sont sans cesse trimbalées entre le client et le serveur à chaque action de l'utilisateur.

Le problème est que l'ADSL est asynchrone, donc ce qui part de chez ton client va beaucoup moins vite que ce qui y arrive.

Côté serveur il faut multiplier dans ta tête le poids d'une page x le nombre de postback potentiellement exécutés à chaque utilisation x le nombre d'utilisateurs (ya encore beaucoup de trucs à compter mais tu as du comprendre où je veux en venir).

Si à chaque clique de chaque utilisateur tu balances, en plus de la déco, 200KB de donnée, tu vas vite créer des embouteillages sur ta ligne.

C'est vrai que vu les perfs des systèmes actuels, les djeuns ne font plus trop gaffe à ça, il s'en foutent ils code sur des machine qui vont juste 6000x plus vite que celles que j'utilisais il y a 20 ans... A l'époque, lorsuqu'on faisait 10 000 itérations ça prenait plusieurs minutes maintenant c'est à peine quelques nanosecondes.

Bref, soit tu fais un truc jetable et tu peux faire n'importe quoi,
soit tu bosses correctement et dans ce cas là, tu dois gamberger avant de coder. Te poser les bonnes questions etc. T'inkiet, on ne réfléchi jamais trop à un problème...

++

Laurent

[nicorem]

entièrement d'accord avec ce que tu dis, mais ici, je parle du cache coté serveur, pas du viewstate.
je cherche à savoir sous quelle forme, je vais devoir stocker dans le cache de l'application, les données issues de mon fichier xml
(dataview, dataset, XmlTextReader, variable statique, liste générique)
quelle est le type ou objet le mieux adapté ?

Nicolas

[Arthis]

je me permets de rajouter que je plussoie Laurent Jordi, mais que si il n'y a qu'un seul paramètre qui permette de passer d'une ligne à l'autre alors, j'utiliserais un Dictionnary avec la clé correspondant à ce paramètre.

C'est la façon la plus rapide alors de récupérer l'objet qui nous interesse.

[CUCARACHA]

Attention List<T> et Dictionary<T> ne sont pas serialisables donc il ne pourront pas toujours être stockés dans des tampons.

Il faut implémenter ces classes pour pouvoir le faire :

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
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Xml.Serialization;
using System.Runtime.Serialization;
 
namespace Common
{
    [XmlRoot("dictionary")]
    [Serializable]
    public class SerializableDictionary<TKey, TValue> : Dictionary<TKey, TValue>, IXmlSerializable
    {
        #region "Contructors"
        public SerializableDictionary() : base() { }
        public SerializableDictionary(IDictionary<TKey, TValue> dictionary) : base(dictionary) { }
        public SerializableDictionary(IEqualityComparer<TKey> comparer) : base(comparer) { }
        public SerializableDictionary(int capacity) : base(capacity) { }
        public SerializableDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) : base(dictionary, comparer) { }
        public SerializableDictionary(int capacity, IEqualityComparer<TKey> comparer) : base(capacity, comparer) { }
        protected SerializableDictionary(SerializationInfo info, StreamingContext context) : base(info, context) { }
        #endregion
        #region IXmlSerializable Members
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
 
        public void ReadXml(System.Xml.XmlReader reader)
        {
            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
            bool wasEmpty = reader.IsEmptyElement;
            reader.Read();
 
            if (wasEmpty)
                return;
 
            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
            {
                reader.ReadStartElement("item");
 
                reader.ReadStartElement("key");
                TKey key = (TKey)keySerializer.Deserialize(reader);
                reader.ReadEndElement();
 
                reader.ReadStartElement("value");
                TValue value = (TValue)valueSerializer.Deserialize(reader);
                reader.ReadEndElement();
 
                this.Add(key, value);
 
                reader.ReadEndElement();
                reader.MoveToContent();
            }
            reader.ReadEndElement();
        }
 
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            XmlSerializer keySerializer = new XmlSerializer(typeof(TKey));
            XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue));
 
            foreach (TKey key in this.Keys)
            {
                writer.WriteStartElement("item");
 
                writer.WriteStartElement("key");
                keySerializer.Serialize(writer, key);
                writer.WriteEndElement();
 
                writer.WriteStartElement("value");
                TValue value = this[key];
                valueSerializer.Serialize(writer, value);
                writer.WriteEndElement();
 
                writer.WriteEndElement();
            }
        }
        #endregion
    }
}

et

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
 
using System;
using System.Collections.Generic;
using System.Linq;
using System.Web;
using System.Xml.Serialization;
using System.Runtime.Serialization;
 
namespace Common
{
    [XmlRoot("list")]
    [Serializable]
    public class SerializableList<T> : List<T>, IXmlSerializable
    {
        #region "Contructors"
        public SerializableList() : base() { }
        public SerializableList(IList<T> list) : base(list) { }
        public SerializableList(int capacity) : base(capacity) { }
        protected SerializableList(SerializationInfo info, StreamingContext context) { }
        #endregion
        #region IXmlSerializable Members
        public System.Xml.Schema.XmlSchema GetSchema()
        {
            return null;
        }
 
        public void ReadXml(System.Xml.XmlReader reader)
        {
            XmlSerializer itemSerializer = new XmlSerializer(typeof(T));
 
            bool wasEmpty = reader.IsEmptyElement;
            reader.Read();
 
            if (wasEmpty)
                return;
 
            while (reader.NodeType != System.Xml.XmlNodeType.EndElement)
            {
                reader.ReadStartElement("item");
                T item = (T)itemSerializer.Deserialize(reader);
                reader.ReadEndElement();
 
                this.Add(item);
 
                reader.ReadEndElement();
                reader.MoveToContent();
            }
            reader.ReadEndElement();
        }
 
        public void WriteXml(System.Xml.XmlWriter writer)
        {
            XmlSerializer itemSerializer = new XmlSerializer(typeof(T));
 
            foreach (T item in this)
            {
                writer.WriteStartElement("item");
                itemSerializer.Serialize(writer, item);
                writer.WriteEndElement();
            }
        }
        #endregion
    }
}

[CUCARACHA]

D'ailleurs, j'aimerais bien savoir si les List<T> et Dictionary<T> sont devenus sérialisables en C#4 ?

[Arthis]

mmhhh. pourquoi as tu besoin de rajouter quelque chose pour serialiser tes listes?

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
[Serializable]
public class monObjet
{
    public string Nom { get; set; }
}
 
public partial class nordic_content_test : System.Web.UI.Page
{
    protected List<monObjet> Liste
    {
        get
        {
            if (ViewState["Liste"] == null)
                ViewState["Liste"] = new List<monObjet>();
            return (List<monObjet>)ViewState["Liste"];
        }
        set
        {
            ViewState["Liste"] = value;
        }
    }
 
    protected void Page_Load(object sender, EventArgs e)
    {
        if (!IsPostBack)
        {
            Liste.Add(new monObjet { Nom = "toto" });
            Liste.Add(new monObjet { Nom = "tata" });
            Liste.Add(new monObjet { Nom = "titi" });
        }
    }
}

Dans ce petit bout de code je place une liste dans le viewstate, et par la même j'ai besoin de sérialiser ma liste. Pourtant a part mettre l'attribut Serializable sur ma classe T, je n'ai pas de souci ...

[CUCARACHA]

Il me semblait que pour pouvoir stocker quelque chose dans le viewstate il fallait que ce soit sérialisable (en tous les cas pour les objets et les collections).

++

[Arthis]

C'est bien pour cela que je comprends pas ton besoin de sérialiser un list<T>.

Peut être, un maître es Serialisation va passer dans ce thread et nous inonder de la lumière de sa connaissance ...

[CUCARACHA]

Je ne suis pas un grand maître en sérialisation mais il me semble avoir eu des messages d'erreur en voulant mettre des listes dans le view state. En conséquence, j'ai cherché et j'ai trouvé ces deux classes que j'utilise systématiquement. Je ne me pose plus la question.

Peut-être est-ce dû à une erreur d'interprétation d'un message mais lorsque je traite un problème avec une solution efficace, je l'adopte et je ne réfléchis plus trop...

++

Laurent

[Arthis]

Bon en tout cas, je me souviendrais de tes classes, au cas où je rencontre l'erreur moi aussi..

Bonne journée à toi,

[CUCARACHA]

Ca n'est pas de moi, j'ai trouvé ça sur internet...

[bacelar]

J'ai eu le même problème et la même solution que Laurent Jordi sur du .NET2.0.
C'est peut-être une évolution du Framework, car la non sérialisation des dictionnaires n'était pas une limitation technique mais un moyen d'éviter les boulets qui sérialisaient tout n'importe comment.