Discussion :

[Invité]

Bonjour

J'ai les classes suivante (j'ai supprimé les méthodes qui ne sont pas utilisées pour la sérialisation.

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 TOPathsContainer
{
	private List<TOPath> pathsList;
 
	public TOPathsContainer()
	{
		pathsList = new List<TOPath>();
		TOPath.pathsList = pathsList;
	}
 
	public void save()
	{
		TextWriter tw = new StreamWriter("test.xml");
		XmlSerializer xs = new XmlSerializer(typeof(TOPathsContainer));
		xs.Serialize(tw, this);
		tw.Close();
	}
 
	public List<TOPath> pPathsList
	{
		get
		{
			return pathsList;
		}
 
		set
		{
			pathsList = value;
		}
	}
}

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
public class TOPath
{
	private List<TOWayPoint> wayPoints = new List<TOWayPoint>();
 
	private int width;
 
	private Color color;
 
	[XmlIgnore]
	public static List<TOPath> pathsList;
 
	public TOPath(int width, Color color)
	{
		this.width = width;
		this.color = color;
	}
 
	public TOPath() { }
 
 
	[XmlAttribute("width")]
	public int pWidth
	{
		get
		{
			return width;
		}
 
		set
		{
			width = value;
		}
	}
 
	[XmlIgnore]
	public Color pColor
	{
		get
		{
			return color;
		}
	}
 
	[XmlAttribute("colorName")]
	public string pColorName
	{
		get 
		{ 
			return ColorTranslator.ToHtml(color);
		}
 
		set 
		{ 
			color = ColorTranslator.FromHtml(value); 
		}
	}
 
	public List<TOWayPoint> pWayPoints
	{
		get
		{
			return wayPoints;
		}
 
		set
		{
			wayPoints = value;
		}
	}
}

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
public partial class TOWayPoint : UserControl
{
	private SharpMap.Geometries.Point worldPosition;
 
 
	[XmlIgnore]
	public const int wayPointDimension = 8;
 
 
	public TOWayPoint(Point position, TOPath path)
	{
		InitializeComponent();
 
		this.path = path;
		worldPosition = TOPathsContainer.mapImage.Map.ImageToWorld((PointF)position);
 
		Width = wayPointDimension;
		Height = wayPointDimension;
 
		Location = new Point(position.X - wayPointDimension / 2, position.Y - wayPointDimension / 2);
 
		BackColor = path.pColor;
 
		BorderStyle = BorderStyle.FixedSingle; 
	}
 
	public TOWayPoint() { }
}

En gros j'ai une classe TOPathsContainer qui contient une liste de TOPath, contenant eux-même une liste de TOWayPoint.

Le problème : lors de la sérialisation j'obtiens l'erreur suivante :

Une erreur s'est produite lors de la réflexion du type 'Topographie3D.Views.Map.Path.TOPathsContainer'.

En regardant un peu plus loin je trouve :

{"Une erreur s'est produite lors de la réflexion du type 'Topographie3D.Views.Map.Path.TOPath'."}

Apparemment le problème provient de la liste wayPoints, si j'ignore la propriété pWayPoints de TOPath ([XmlIgnore] public List<TOWayPoint> pWayPoints).

Je n'ai pas d'erreur et le fichier xml est générer.

Donc, comment faire pour sérialiser aussi mes objets wayPoints ? Qu'ai-je fait de faux ?

[SaumonAgile]

Je dirais que c'est parce que TOWayPoint n'est pas sérialisable.
Quelqu'un peut confirmer ?

[Invité]

Je dirais que c'est parce que TOWayPoint n'est pas sérialisable.
Quelqu'un peut confirmer ?

Hem... oui, mais pourquoi ?

[SaumonAgile]

Je suis tenté de dire : 'est-ce bien raisonnable de sérialiser des UserControls ?'

[Invité]

C'est vrai, je te l'accorde

Voici ce que je suis en train de réaliser : j'ai une image (une carte) sur laquelle je dois pouvoir tracer des chemins (que je dois pouvoir modifier). Pour cela je me suis inspiré de cet exemple : http://www.codeproject.com/csharp/lineditor.asp

Diverses manipulation doivent pouvoir être fait sur les points, c'est pourquoi l'utilisation d'un control (comme dans l'exemple donné par le lien ci-dessus) me semblait le plus approprié.


Maintenant reste à voir comment je peux sauvegarder les chemins. La sérialisation semblait tellement simple, ça m'embêterait de devoir le faire "à la main"

[Invité]

Bon, j'ai imaginé deux solutions :

1. Création d'un struct (par ex TOWayPointStruct) qui contiendrait les informations que je veux sérialiser. Dans TOPath, une List de ces struct.
Lors de la sérialisation, je copierais les infos de la liste de userControl dans la liste de struct (chemin inverse pour la désérialisation).

2. Il me semble avoir lu quelque part que la sérialisation binaire permet de sérialiser les types non standard. Est-ce que ça peut fonctionner dans mon cas ?


Mais je pense plutôt utiliser la 1e solution. Etant donné que la sérialisation XML fonctionne déjà en partie, ça me prendra, je pense, moins de temps d'ajouter une liste de struct.


Qu'en pensez-vous ?