Linq + XML; je suis un peu perdu

Version imprimable

Salut !

Je débute tout juste avec Linq et XML et j'ai un petit souci :

Voici classe sur laquelle je travaille :

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
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
 
public class Extrait
    {
        private String _Artiste;
        private String _Titre;
        private double _PointA;
        private double _PointT;
        private double _PointAT;
        private List<String> _JoueurA;
        private List<String> _JoueurT;
        private List<String> _JoueurAT;
 
        public String Artiste
        {
            get { return _Artiste; }
            set { _Artiste = value; }
        }
 
        public String Titre
        {
            get { return _Titre; }
            set { _Titre = value; }
        }
 
        public Double PointA
        {
            get { return _PointA; }
            set { _PointA = value; }
        }
 
        public Double PointT
        {
            get { return _PointT; }
            set { _PointT = value; }
        }
 
        public Double PointAT
        {
            get { return _PointAT; }
            set { _PointAT = value; }
        }
 
        public List<String> JoueurA
        {
            get { return _JoueurA; }
            set { _JoueurA = value; }
        }
 
        public List<String> JoueurT
        {
            get { return _JoueurT; }
            set { _JoueurT = value; }
        }
 
        public List<String> JoueurAT
        {
            get { return _JoueurAT; }
            set { _JoueurAT = value; }
        }
 
        public Extrait(String Artiste, String Titre, Double PointA, Double PointT, Double PointAT, List<String> JoueurA, List<String> JoueurT, List<String> JoueurAT)
        {
            _Artiste = Artiste;
            _Titre = Titre;
            _PointA = PointA;
            _PointT = PointT;
            _PointAT = PointAT;
            _JoueurA = JoueurA;
            _JoueurT = JoueurT;
            _JoueurAT = JoueurAT;
        }
    }

Dans ma form, est déclaré ceci :

Code:

1
2
3
4
public partial class Form1 : Form
    {        
        private Extrait[] extraits;
        ...

Voici le début de ma méthode pour sérialiser :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
private void button3_Click(object sender, EventArgs e)
        {
            XDocument xDoc = new XDocument(                    
                        new XElement("blind",
                        new XElement("nombre_titres", nbextrait),
                        new XElement("numero", textBox1.Text),
                        new XElement("theme", textBox4.Text),
                        new XElement ("mdp",textBox2.Text),
                        new XElement("lien",textBox5.Text),
                        new XElement ("playlist",
                        from ex in extraits
                        select new XElement("extrait",
                        new XElement("artiste",ex.Artiste),
                        new XElement("titre",ex.Titre),
                        new XElement("blindeur_tout",ex.JoueurAT[0]),
                        new XElement("blindeur_artiste", ex.JoueurA[0]),
                        new XElement("blindeur_titre", ex.JoueurT[0])
                        )
                        )
                        )                       
                        );
            xDoc.Save(_folder + "Blind.xml");
        }

Je souhaite à présent accéder au contenu des list JoueurAT, JoueurA et JoueurT; comme vous le voyez ci-dessus, j'ai déjà accédé à l'indice 0 de l'élément. Maintenant, je voudrais la liste complète des indices supérieurs à zéro, s'ils existent.
Mais voilà, je ne vois pas du tout comment faire ...

Merci de votre aide ! ;)

24/03/2019, 11h21
wallace1

Bonjour,

Tu parles de Link et et de Serialization or tu construis ton xml à l'aide de la classe XDocument (ce n'est pas de la serialization) et il n'y a pas de Link :aie:

La Serialization requiert la décoration de tes classes et de tes propriétés avec l'attribut "Serlializable" (Les champs ne sont pas décorables). Pour plus d'informations j'ai déjà traité ce type de sujet ici :

https://www.developpez.net/forums/d1...alisation-xml/
https://www.developpez.net/forums/d1...l/#post8797998

PS1 : Bon d'acord c'est en VbNet mais le principe est identique.;)
PS2 : Attention les champs ne sont pas Serializable il faut donc les décorer avec l'attribut "XmlIgnore".
24/03/2019, 11h51
Mike888

Merci pour ton post ! Comme je disais, j'en touche pas une en XML, donc... :aie:

En fait, je vais poser ma question autrement : est-il obligatoire de passer par la sérialisation pour sauvegarder les données de mon appli ? Peut-on remplir un fichier XML avec ces données sans passer par la sérialisation ?

J'ai l'impression que je parle de sérialisation alors qu'en fait, je fais tout autre chose...
24/03/2019, 12h21
Pol63

Citation:

Envoyé par wallace1

Tu parles de Link et et de Serialization or tu construis ton xml à l'aide de la classe XDocument (ce n'est pas de la serialization) et il n'y a pas de Link :aie:

même en passant par xdocument c'est de la sérialisation (manuelle), et perso je vois du linq dans son code
et l'attribut serializable est surtout utilisé par le sérialiseur binaire, le xml n'en a pas besoin à priori

la sérialisation consiste à transformer un objet en un tampon mémoire (octets/xml/json ...) de sorte qu'il puisse être reconstruit par le processus inverse
ca peut alors être stocké sur un disque dur, envoyé par un web service …
il existe des sérialiseurs (y compris dans le Framework) qui se débrouille pour savoir quoi sérialiser et comment, ce qui permet de sérialiser en 2 lignes de code (xmlserializer, binaryformatter, datacontractserializer …)
le faire à la main (xdocument ou autre) est général utilisé quand une sérialisation automatique peut poser problème ou qu'on veut différer du système prévu

après pour sauvegarder des choses sur le disque il y a les bases de données, mais pour peu de choses qui ne changent pas beaucoup la sérialisation est souvent appréciée car comme dit précédemment ca se fait en 2 lignes de code

xmlserializer sérialise les propriétés public, il faut que les getters et setters soient public aussi, il est possible d'utiliser xmlignore pour dire qu'une propriété n'est pas enregistrée
binaryformatter sérialise les fields (variables) même privés,il faut qu'il y ait l'attribut serializable au dessus de chaque classe à sérializer et chaque contenu dans l'arbre (si tu as des propriétés qui sont des classes il leur faut l'attribut)
datacontractserializer est utilisé par défaut par WCF et lui il requiert l'attribut DataContract au dessus de chaque classe et DataMember au dessus de chaque propriété à sérialiser

chacun a ses avantages et inconvénients
binaryformatter est performant et la sérialisation ne prend pas trop de place (un byte continuera de prendre un octet alors qu'en xml 255 prend 3 octets par exemple vu qu'il est écrit (en utf8 souvent), sans parler des balises xml)
il n'est compatible qu'avec .net alors que l'xml est interopérable
etc...
24/03/2019, 15h08
wallace1

@Pol63 :

Bon mea culpa pour le link je ne l avais pas vu .... (ça valait bien 1 doigt......:ptdr:)
Sinon moi perso je ne vois pas l intérêt d'utiliser une autre instance d'objet de type Xdocument alors qu'une classe (extrait) aussi simplement structurée peut facilement être gérée avec du xmlserializer et deserializer !
Au passage la construction xml manuelle d'OP n est pas très cohérente ..... les valeurs blind, thème...etc... ne devraient elles pas faire partie d une classe ....o_O....
Oui tu peux dire que la construction d un fichier plat à partir de la classe Xdocument correspond a une sorte de "serialization" mais l intérêt reste tout de même de récupérer le type "extrait" et pas un type Xdocument qu on transforme de nouveau en extrait !

Je suis ouvert au dialogue et je trouve que voter rouge n apporte rien de constructif. ;):plusser:
24/03/2019, 16h57
Pol63

ca faisait longtemps ^^ (les gens n'aiment pas que je leur mette des pouces rouges)

les pouces verts et rouges sont sur les messages, pas sur les gens, donc ce n'est pas toi que je vise (par ailleurs tes réponses sont souvent utiles sur le forum)
nous sommes sur un forum ou tout le monde peut poser une question et tout le monde peut y répondre, donc pour moi ces pouces servent à évaluer la qualité d'une réponse, ce qui peut aider aussi le posteur de départ quant à sa question
si quelqu'un dit une connerie et qu'il y a 5 pouces rouges ca aide à se dire que cette réponse est peut être à oublier, ou du moins à vérifier car elle n'a pas l'air de plaire à la communauté
c'est aussi valable pour les gens qui tombent là en venant d'un moteur de recherche, lire en diagonale en évitant les posts mal noté c'est souvent utile
le pouce rouge peut donc servir aux lecteurs, et à celui qui a posté pour qu'il puisse se poser des questions, que ca soit constructif n'est pas un adjectif pertinent ici
et sinon à quoi sert le pouce rouge ?

quand on regarde ton message les infos qu'on y trouve sont :
- utiliser xdocument ce n'est pas de la sérialisation
- l'attribut serializable est nécessaire
(et accessoirement "je ne vois pas de link")
malheuresement toutes ces affirmations me semble fausses, et link c'est dans zelda :D
donc mon pouce rouge me semble tout à faire approprié, je ne vois pas pourquoi je le retirerais
après oui j'ai pas regardé tes liens, ils sont peut etre utiles
de plus quant à être ouvert à la discussion, je t'ai cité et t'ai répondu pourquoi c'était faux, ca me semble assez constructif

pour la sérialisation je viens de vérifier, wikipedia précise que c'est découper un truc en plein de petits trucs pour le stocker ou l'envoyer, en ce sens ca a l'air de rejoindre ce que je dis
de plus la classe xmlserializer que fait elle à part écrire les propriétés chacune leur tour avec l'ancetre de xdocument ? donc c'est bien pareil...
quant à serializable j'ai déjà fait de la sérialisation xml sans l'utiliser alors que le binaryformatter plante quand on ne le met pas

bref je pense qu'il vaut mieux accepter ses erreurs, ca m'arrive aussi de prendre des pouces rouges justifiés, c'est pas bien grave, le forum vaut plus que ceux qui le compose
sinon concernant le problème ici, je suis d'accord avec toi que ca ne sert à rien de s'embêter avec xdocument alors qu'une classe (voire plusieurs) peuvent faire ce qu'il cherche bien plus simplement, je l'ai dit aussi, on s'embête que quand on a pas le choix, ca peut arriver, mais pour ca aussi il y a des attributs et des interfaces à implémenter qui permettent de modifier le comportement du sérialiseur
24/03/2019, 17h07
wallace1

Bah j aimais bien Zelda moi.....:mrgreen:
Pas grave pour le rouge..c juste que ça faisait longtemps qu' on ne m en avait pas mis. Mais ne t inquiète pas je saisis la philosophie de la pertinence aussi je ne croyais pas être autant à coté de la plaque d ou ma réponse.

Allez fin du hors sujet pour m part et je laisse OP s en depatouiller ;)
24/03/2019, 17h13
Pol63

à côté de la plaque pas forcément, c'est juste qu'il y a toujours un niveau de détail plus profond que ce qu'on a compris d'une chose
peu importe son niveau de connaissance y en a toujours un qui en saura plus, et fera chuter notre approximation, approximation qui était quand même utile pour appréhender un concept
mais perso moi je trouve ca bien, quand François Dorin ou une autre pointure me reprend ca me fait toujours progresser

Je reviens vers vous !
J'ai bien lu tout ce que vous avez écrit, c'est intéressant ! Pour le moment, j'en suis resté à mon code de ci-dessus (à part la méthode pour "sérialiser"); ne m'en veuillez pas, je fais des tests :mrgreen: .

Pour "sérialiser", ça passe bien; néanmoins, je tourne un peu en rond pour l'inverse... je ne sais pas quoi mettre aux lignes 21, 23 et 25 après le "Select" dans le 1er code ci-dessous...

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
 
XElement xmle;
            xmle = XElement.Load(_folder + "Blind.xml");
            textBox1.Text = xmle.Element("numero").Value;
            textBox4.Text = xmle.Element("theme").Value;
            textBox3.Text = xmle.Element("heure_debut").Value;
            textBox5.Text = xmle.Element("lien").Value;
            textBox2.Text = xmle.Element("mdp").Value;
 
            XDocument xmld;
            xmld = XDocument.Load(_folder + "Blind.xml");
            extraits = (from ex in xmld.Element("playlist").Elements("extrait")
                        select new Extrait
                        {
                            Artiste = ex.Element("artiste").Value,
                            Titre = ex.Element("titre").Value,
                            PointAT = 0,
                            PointA = 0,
                            PointT = 0,
                            JoueurAT = from jat in ex.Element("JoueursAT").Elements("JoueurAT")
                                       select ,
                            JoueurA = from ja in ex.Element("JoueursA").Elements("JoueurA")
                                      select ,
                            JoueurT = from jt in ex.Element("JoueursT").Elements("JoueurT")
                                      select
                        }
                       );

Méthode pour "sérialiser" :

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
 
 XDocument xDoc = new XDocument(
                        new XElement("blind",
                        new XElement("folder", _folder),
                        new XElement("nombre_titres", nbextrait),
                        new XElement("numero", textBox1.Text),
                        new XElement("theme", textBox4.Text),
                        new XElement("heure_debut", textBox3.Text),
                        new XElement("mdp", textBox2.Text),
                        new XElement("lien", textBox5.Text),
                        new XElement("playlist",
                        from ex in extraits
                        select new XElement("extrait",
                        new XElement("artiste", ex.Artiste),
                        new XElement("titre", ex.Titre),
                        new XElement("JoueursAT",
                        from j in ex.JoueurAT
                        select new XElement("joueurAT", j)
                        ),
                        new XElement("JoueursA",
                        from j in ex.JoueurA
                        select new XElement("joueurA", j)
                        ),
                        new XElement("JoueursT",
                        from j in ex.JoueurT
                        select new XElement("joueurT", j)
                        )
                        )
                        )
                        )
                        );
            xDoc.Save(_folder + "Blind.xml");

Fichier XML :

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
37
38
39
40
41
42
 
<blind>
  <folder>C:\Users\Michael\Desktop\BT 1 normal\Programme BT\</folder>
  <nombre_titres>25</nombre_titres>
  <numero></numero>
  <theme></theme>
  <heure_debut></heure_debut>
  <mdp>a</mdp>
  <lien></lien>
  <playlist>
    <extrait>
      <artiste>Abba</artiste>
      <titre>Take a chance on me</titre>
      <JoueursAT>
        <joueurAT>Ahkayaqua</joueurAT>
        <joueurAT>Angelene</joueurAT>
      </JoueursAT>
      <JoueursA>
        <joueurA></joueurA>
        <joueurA>Angellus2</joueurA>
      </JoueursA>
      <JoueursT>
        <joueurT></joueurT>
      </JoueursT>
    </extrait>
    <extrait>
      <artiste>B. Medley &amp; J. Warnes</artiste>
      <titre>Time of my life</titre>
      <JoueursAT>
        <joueurAT></joueurAT>
      </JoueursAT>
      <JoueursA>
        <joueurA>Azucar De Cebada</joueurA>
        <joueurA>Babyol</joueurA>
      </JoueursA>
      <JoueursT>
        <joueurT></joueurT>
      </JoueursT>
    </extrait>
    <extrait>
  </playlist>
</blind>

La classe Extrait est restée comme écrit dans le 1er post.

Je cherche donc à récupérer mes objets "extrait" et ça coince quand je dois "désérialiser" les List<String>...
Voyez-vous plus clair que moi ? :?

EDIT :

J'ai bien tenté ceci mais erreur (impossible de convertir blabla...)

Code:

select jat.Element("JoueurAT").Value.ToList(),

25/03/2019, 08h05
Pol63

pourtant on t'a dit 2x chacun d'utiliser le xmlserializer ... tu aurais beaucoup moins de code, ca marcherait tout de suite, et en plus c'est évolutif, à savoir si tu veux enregistrer un truc en plus plus tard tu n'auras pas à modifier le code de sérialisation
par contre pour ca il te faut une classe de support pour stocker les données de tous tes controles
25/03/2019, 09h29
Mike888

J'ai bien compris votre message à tous les 2, mais je veux y arriver avec cette façon de faire, pour voir comment ça marche !
Je changerai peut-être par la suite pour xmlserializer ! ;)
25/03/2019, 09h58
Pol63

le problème c'est que tu as mis les joueursAT en tant que string chacun leur tour, donc à la désérialisation c'est pas pratique, d'ailleurs ca doit se voir dans le fichier générer
il faudrait un element ayant des sous elements <JoueurATList><JoueurAT>..</JoueurAT><JoueurAT>..</JoueurAT></JoueurATList>

le xdocument s'utilise plus avec des ajouts successifs après instanciation qu'avec le constructeur et tout en vrac à la suite

Bon là, vraiment, je cale complètement (et ça m'énerve :mrgreen: ).

Pour désérialiser :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
...
                       XElement xmle;
                       xmle = XElement.Load(_folder + "Blind.xml");
                        extraits = (from ex in xmle.Element("playlist").Elements("extrait")
                        select new Extrait
                        (ex.Element("artiste").Value,
                        ex.Element("titre").Value,
                        0,
                        0,
                        0,
                        (from jat in ex.Element("JoueursAT").Elements("JoueurAT")
                         select jat.Element("JoueurAT").Value).ToList(),
                        (from ja in ex.Element("JoueursA").Elements("JoueurA")
                         select ja.Element("JoueurA").Value).ToList(),
                        (from jt in ex.Element("JoueursT").Elements("JoueurT")
                         select jt.Element("JoueurT").Value).ToList())).ToArray();

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
 
<blind>
  <folder>C:\Users\Michael\Desktop\BT 1 normal\Programme BT\</folder>
  <nombre_titres>25</nombre_titres>
  <numero></numero>
  <theme></theme>
  <heure_debut></heure_debut>
  <mdp>a</mdp>
  <lien></lien>
  <playlist>
    <extrait>
      <artiste>Abba</artiste>
      <titre>Take a chance on me</titre>
      <PointAT>1.25</PointAT>
      <PointA>0.5</PointA>
      <PointT>0.5</PointT>
      <JoueursAT>
        <joueurAT>Ahkayaqua</joueurAT>
        <joueurAT>Angelene</joueurAT>
      </JoueursAT>
      <JoueursA>
        <joueurA></joueurA>
      </JoueursA>
      <JoueursT>
        <joueurT></joueurT>
      </JoueursT>
    </extrait>
...

Il me retrouve bien artiste, titre,... mais on dirait que les List<String> sont créées mais qu'il n'y a rien dedans (alors qu'il y a 2 joueurs pour extrait[0].JoueurAT ... [0] et [1] --> lignes 18 et 19 dans le fichier xml).
Là, je suis à court d'idées ! :(