Aller plus loin avec sérialisation XML en C#

Par Thomas Levesque

Le 2009-07-09 14:30:02, par tomlev, Rédacteur/Modérateur

Cette discussion est consacrée à l'article intitulé Aller plus loin avec la sérialisation XML. Vous pouvez y poster vos commentaires concernant l'article.

Synopsis :

Ce tutoriel s'adresse à des personnes maîtrisant déjà la sérialisation XML. Il aborde des concepts plus avancés que le précédent tutoriel et présente quelques astuces permettant de résoudre des problèmes fréquemment rencontrés.

Discussion forum

6 commentaires

teddyalbina
Membre confirmé

Très bon article merci

le 28/07/2009 à 13:53
StormimOn
Expert éminent

La partie concernant sgen m'intéresse. J'ai mis à jour une application en refondant un bloc d'objets métiers. La persistance est faite par sérialisation maintenant. Cela me permet en même temps de "simplifier" l'affichage des informations en passant par une transformation XSL basée sur le XML sérialisé.

Actuellement, au premier affichage il y a une lenteur. Normal car c'est lié à la génération dynamique de l'assembly pour manipuler les objets sérialisés comme indiqué dans l'article. J'ai donc voulu passer par sgen afin d'améliorer ça. Et j'ai malheureusement une erreur.

L'erreur est du type

Les types A.C et B.C utilisent le nom de type XML C à partir de l'espace de nom ''. Utilisez les attributs XML pour spécifier un nom XML unique et/ou un espace de noms pour le type.

Je n'ai rien trouvé pour le moment à ce sujet. Tu aurais des infos là dessus ?

L'assembly contient différent objets métiers, tous ne devant pas être sérialisés. Pour le moment ce sont ces derniers qui gênent. La solution serait à priori de séparer en deux assemblies (à moins que l'on puisse marquer un type pour éviter que sgen ne le traite), mais j'aimerais bien comprendre ce qui bloque tout de même.

le 07/08/2009 à 19:36
tomlev
Rédacteur/Modérateur
A priori c'est parce que tu as 2 types de même nom dans 2 namespaces différents, et que faute de précisions ils seront sérialisés avec le même nom d'élément XML.

Je suppose qu'en pratique ces 2 types ne sont pas sérialisés dans le même contexte, c'est pourquoi tu n'as pas d'erreur quand l'assembly de sérialisation est généré dynamiquement (parce que l'assembly généré ne prend en compte que les types qui peuvent être rencontrés dans le graphe de l'objet sérialisé).

Donc je vois 2 solutions :
- soit tu spécifies à sgen les types que tu veux sérialiser (par défaut il génère du code pour tous les types publics). Sgen n'a malheureusement pas d'option pour exclure un type...
- soit tu appliques aux classes qui posent problème un attribut XmlType (j'aurais sans doute dû en parler dans le tuto d'ailleurs...) pour spécifier un nom de type XML différent pour les 2 classes :
Code :
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
namespace A
{
    [XmlType("A.C")]
    public class C
    {
        ...
    }
}

namespace B
{
    [XmlType("B.C")]
    public class C
    {
        ...
    }
}
```
le 10/08/2009 à 0:21
StormimOn
Expert éminent
Pour sgen on peut spécifier un type (option /t), mais pas plusieurs à priori.
Je regarderais avec XmlType si effectivement ça corrige le problème, pour la culture personnelle.

Au final j'ai mis les classes à sérialiser dans un assembly à part, avec une classe pour gérer la sérialisation des objets dans le contexte. C'est beaucoup plus propre ainsi. Et puis cela oblige à revoir un peu la chose et supprimer des liaisons un peu trop fortes parfois.

Sinon le code de l'assembly ressemblait à quelque chose comme
Code :
```
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
namespace A
{
    public class B
    {
        public struct D
        {
        }
    }

    public class C
    {
        public struct D
        {
        }
    }
}
```
et c'est le type nested (D) qui pose souci. Ce sont des classes générées par un outil, donc ne me demande pas pourquoi une telle chose ^^
le 10/08/2009 à 21:04
tomlev
Rédacteur/Modérateur

Envoyé par StormimOn

Pour sgen on peut spécifier un type (option /t), mais pas plusieurs à priori.

Ah oui tiens... il me semblait que c'était possible
La solution d'un assembly séparé me semble pas mal en effet, d'autant plus que ça facilite la réutilisation

le 11/08/2009 à 0:33
tomlev
Rédacteur/Modérateur

Mise à jour

Une nouvelle section a été ajoutée à l'article :

Contrôler dynamiquement si un membre doit être sérialisé

le 04/10/2009 à 17:53

Poster une réponse