Discussion :

[Varen]

Bonjour à tous,


Étant débutant en C#, soyez indulgents avec moi !

J'effectue des requêtes SQL sur une base de données pour récupérer des données financières.
Je stocke celles ci dans un dictionnaire nommé : NamedBars

Je voudrais mettre en cache ce dictionnaire afin de réutiliser ces données sans avoir à refaire toutes les requêtes SQL.

En gros, je voudrais stocker ce dictionnaire dans une sorte de cache de façon permanente.

Ceci est pour un projet étudiant et je suis dessus depuis 1 semaine. Je suis à bout ...


Je vous remercie d'avance et à très vite j'espère.

Merci !

[Klivor]

Bonjour Varen ,
Dit moi pourquoi tu ne stockerais pas ces résultats dans un fichier texte ?
Ce serait beaucoup plus facile non ?

Klivor

[Xahel]

je te conseil un DataSet

mais faut pas trop abuser d'un cache il n'est pas là pour stocker ta base de donnée entière ^^

[Xahel]

un fichier txt pas super à mon avis

encore tu aurai proposé MemoryStream pourquoi pas

[mermich]

Salut,

Pour faire ce que tu veux faire tu peux utiliser les variable static, un variable static a une seule instance pour toute ton application ex (nombre d'utilisateur connecté à un site)

Du coup dans ton cas tu devrais avoir:

Code :

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

1
2
3
4
 
MaClasseAccesDonnees
{
public static Dictionnary<plop,plop> NamedBars

Pour y acceder au lieu de faire MonInstance.NamedBars tu devra faire MaClasseAccesDonnees.NamedBars

[Varen]

Merci de vos réponses rapides !!

Alors pour un soucis de rapidité et de performance il me semble qu'utiliser un fichier texte n'est pas adapté.

Je vais regarder sur Dataset et je reviens vers vous en cas de soucis

Merci encore.

[Varen]

en fait il y un point essentiel que j'ai oublier de vous communiquer.
Je voudrais mettre en cache ce dictionnaire qui contient des données financières pour effectuer des stratégies.

En fait je veux lancer mon appli, la requête se lance, le resultat est stocké dans un dictionnaire namedbars.

Maintenant si je relance l'appli ultérieurement. Je veux plus que la requete se fasse mais plutot réutiliser mon dictionnaire avec les données stockées dedans. Je veux que le dictionnaire ne soit pas vidé à l'arret de l'appli. En gros on gagne du temps car on ne fait plus la requete.
Cela reviendrait il à stocker dans la mémoire cache de l'ordi? est-ce possible?

Désolé de ne pas être trop clair mais cela est dû au fait que je ne maitrise pas trop le sujet.

Maintenant que j'ai apporteé plus de précisions est ce que vous pensez que vos réponses sont appropriées à savoir dataset ou variable statique.

[StormimOn]

La sérialisation binaire devrait convenir.

Un exemple

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
using System;
using System.Collections.Generic;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main(string[] args)
        {
            Dictionary<MaClasseCle, MaClasseValeur> dico = new Dictionary<MaClasseCle, MaClasseValeur>();
            dico.Add(new MaClasseCle() { Valeur = "clé" }, new MaClasseValeur() { Valeur = new MaClasseSousValeur() { Valeur = "sous valeur" } });
 
            // Sérialisation du dico.
            byte[] data = null;
            using (MemoryStream ms = new MemoryStream())
            {
                new BinaryFormatter().Serialize(ms, dico);
                data = ms.ToArray();
            }
 
            // Désérialisation du dico.
            Dictionary<MaClasseCle, MaClasseValeur> dico2;
            using (MemoryStream ms = new MemoryStream(data))
            {
                dico2 = (Dictionary<MaClasseCle, MaClasseValeur>)new BinaryFormatter().Deserialize(ms);
            }
        }
    }
 
    [Serializable]
    public class MaClasseCle
    {
        public string Valeur { get; set; }
    }
 
    [Serializable]
    public class MaClasseValeur
    {
        public MaClasseSousValeur Valeur { get; set; }
    }
 
    [Serializable]
    public class MaClasseSousValeur
    {
        public string Valeur { get; set; }
    }
}

J'utilise un MemoryStream dans l'exemple, il suffit de sérialiser sur un flux de type fichier pour persister l'information de manière permanente dans ton cas.

Les classes du graphe d'objets à sérialiser doivent avoir l'attribut Serializable. Les types de base (String, Int32...) possèdent cet attribut.

[Xahel]

DataSet au toilette

un fichier xml reste le plus propre si tu as une structure qui reste stable

mais je vois pas l'utilité de stocker les données ailleurs que dans ta base de données.

c'est perdre de l'espace
et ne pas gérer les mise à jour apporter à ta base de donnée

[Xahel]

Un MemoryStream pour la vie

je trouve ça mignon ça laisse pas de trace, mais bon je suis pas pour

[ostenhard]

Bonjour,

Et pourquoi ne pas utiliser un framework de cache tel que le block Caching des entreprise libraries. Tu auras la possibilité de choisir où seront stockées tes données, pendant combien de temps car elles doivent bien expirer un jour.

[Xahel]

le block Caching des entreprise libraries.

block caching

je connais pas. Mais ça peu répondre à ton besoin à première vue

[mermich]

Étant débutant en C#, soyez indulgents avec moi !

Et

Ceci est pour un projet étudiant et je suis dessus depuis 1 semaine. Je suis à bout ...

C'est donc un étudiant pour une projet d'études...

Plutot qu'utiliser des bibliothèques complexes, utilise comme StormimOn l'a dit une simple serialisation de tes données, qui fera ce que tu cherches.

[ostenhard]

block caching
je connais pas. Mais ça peu répondre à ton besoin à première vue

Euh je parlais plutôt de The Caching Application Block

Après il est vrai qu'en tant qu'étudiant le but est d'apprendre, de chercher, de faire bouger ses méninges.

[Xahel]

You should consider using the .NET 4.0 System.Runtime.Caching classes instead of the Caching Application Block in future development.

faut vivre avec son temps.

j'ai passé ma certification Framework 3.5 il y a 7 mois elle tombe déjà à l'eau

si l'informatique avance et que je recul comment voulez vous que.... l'on bosse évidement !

[Varen]

Merci beaucoup pour vos réponses.
Je teste la sérialisation/désérialisation et je reviens vers vous pour vous donner des retours.

Merci encore

[Varen]

Que dois je faire pour sérialiser sur un flux de type fichier pour persister l'information de manière permanente ?

Je pose cette question car lorsque j'execute ce bout de code il m'est indiqué que je déserialise un flux vide. je pensais que mon fichier MyFile.bin était mon fichier cache ou alors j'ai toujours rien compris?

Voici le code

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
//mise en cache du dictionnaire de bars
 
            // Sérialisation du dico.
 
            using (Stream stream = new FileStream("MyFile.bin", FileMode.Create, FileAccess.Write, FileShare.None))
 
            {
                new BinaryFormatter().Serialize(stream, tdRun.NamedBars);
 
 
                // stream.Close();
            }
 
            // Désérialisation du dico.
            Dictionary<string, List<tdBar>> NamedBars2;
            using (Stream stream = new FileStream("MyFile.bin", FileMode.Create, FileAccess.Write, FileShare.None))
            {
                NamedBars2 = (Dictionary<string, List<tdBar>>)new BinaryFormatter().Deserialize(stream);
            }

[StormimOn]

Je pose cette question car lorsque j'execute ce bout de code il m'est indiqué que je déserialise un flux vide. je pensais que mon fichier MyFile.bin était mon fichier cache ou alors j'ai toujours rien compris?

C'est parce que lors de la lecture tu utilises des options d'écriture (FileMode.Create et FileAccess.Write).

Utilise plutôt

Code :

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

1
2
3
4
using (Stream stream = new FileStream("MyFile.bin", FileMode.Open, FileAccess.Read, FileShare.None))
{
...
}

[Varen]

merci beaucoup ça à l'air de fonctionner