Problème de sérialisation

Version imprimable

Bonjour,

Je tente en vain de sérialiser une classe nommée Donnees lorsque j'utilise la méthode SauveFichier de la classe Form1. Mais systématiquement j'ai une exception qui se lance quand j'exécute la ligne "XmlSerializer serializer = new XmlSerializer(typeof(Donnees));"

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
 
public class Form1 : Form
{
	public Donnees Data;
 
	public Form1()
        {
            InitializeComponent();
            Data = new Donnees();
        }
 
	void SauveFichier(string fichierXML)
	{
		try
	        {
	        	FileStream file = File.Create(fichierXML);
	                XmlSerializer serializer = new XmlSerializer(typeof(Donnees));
	                serializer.Serialize(fileXML, Data);
	                file.Close();
	        }
	        catch
		{
	        	MessageBox.Show("Sérialisation impossible", "Erreur");
	                Application.Exit();
	        }
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
[Serializable()]
public class Donnees
{
	struct _Code
	{
		public int x;
		public int y;
	}
 
	public List<_Code> sauve;
 
	public Donnees()
        {
            sauve = new List<_Code>();
	}
}

Apparement la variable "List<_Code> sauve;" n'est pas admise.

Si quelqu'un a une idée du problème, merci d'avance.

02/11/2013, 21h01
Invité
Je ne sais pas comment t'as fait pour pouvoir compiler ton code sachant que le champ sauve est en public alors que la structure _Code est en private. Ton code actuel n'est pas admis par le compilateur.

Mets la structure _Code en public et réessaye pour voir.

Sinon tu peux :
- penser à mettre la définition de la structure au niveau de la classe Donnees
- retirer le caractère "_"
- mettre sauve en tant que propriété et non comme un champ.

Voilà la correction qui fonctionne:

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
 
public class Form1 : Form
{
	public Donnees Data;
 
	public Form1()
        {
            InitializeComponent();
            Data = new Donnees();
        }
 
	void SauveFichier(string fichierXML)
	{
		try
	        {
	        	FileStream file = File.Create(fichierXML);
	                XmlSerializer serializer = new XmlSerializer(typeof(List<Code>));
	                serializer.Serialize(fileXML, sauve);
	                file.Close();
	        }
	        catch
		{
	        	MessageBox.Show("Sérialisation impossible", "Erreur");
	                Application.Exit();
	        }
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
 
[Serializable()]
public class Donnees
{
	public struct Code
	{
		public int x;
		public int y;
	}
 
	public List<Code> sauve;
 
	public Donnees()
        {
            sauve = new List<Code>();
	}
}

Toutefois, je souhaiterai pouvoir sérialiser 2 List<Code> dans la classe Donnees. Donc j'ai modifier les classes, puis sérialiser et dé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
33
34
35
36
37
38
39
40
41
42
43
44
 
public class Form1 : Form
{
	public Donnees Data;
 
	public Form1()
        {
            InitializeComponent();
            Data = new Donnees();
        }
 
	void SauveFichier(string fichierXML)
	{
		try
	        {
	        	FileStream file = File.Create(fichierXML);
	                XmlSerializer serializer = new XmlSerializer(typeof(List<Code>));
	                serializer.Serialize(fileXML, sauve1);
	                serializer.Serialize(fileXML, sauve2);
	                file.Close();
	        }
	        catch
		{
	        	MessageBox.Show("Sérialisation impossible", "Erreur");
	                Application.Exit();
	        }
	}
 
	void RestaureFichier(string fichierXML)
	{
		try
		{
                	FileStream file = File.Open(fichier, FileMode.Open, FileAccess.Read);
	                XmlSerializer serializer = new XmlSerializer(typeof(List<Code>));
	                sauve1 = serializer.Deserialize(file) as List<Code>;
	                sauve2 = serializer.Deserialize(file) as List<Code>;
	                file.Close();
		}
		catch
		{
			MessageBox.Show("Désérialisation impossible", "Erreur");            
		}
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
[Serializable()]
public class Donnees
{
	public struct Code
	{
		public int x;
		public int y;
	}
 
	public List<Code> sauve1;
	public List<Code> sauve2;
 
	public Donnees()
        {
            sauve1 = new List<Code>();
            sauve2 = new List<Code>();
	}
}

Le fichier XML obtenu après sérialisation:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
<?xml version="1.0"?>
<ArrayOfCode xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Code>
    <v>2</v>
    <v>5</v>
  </Code>
</ArrayOfCode><?xml version="1.0"?>
<ArrayOfCode xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <Code>
    <v>3</v>
    <v>7</v>
  </Code>
</ArrayOfCode>

La sérialisation se passe bien, mais lorsque je désérialise, j'ai une exception qui se lève à la ligne suivante:

"sauve1 = serializer.Deserialize(file) as List<Code>;"

Que faut-il faire?

02/11/2013, 21h53
Invité

Pour te faciliter la vie ce que tu dois sérialiser et dé-sérialiser c'est l'instance de type Donnees.

Ca y est, tout marche !

Voici le code:

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
 
public class Form1 : Form
{
	public Donnees data;
 
	public Form1()
        {
            InitializeComponent();
            data = new Donnees();
        }
 
	void SauveFichier(string fichierXML)
	{
		try
	        {	        
			Stream file = File.Open(fichier, FileMode.Create);
			BinaryFormatter formatter = new BinaryFormatter();
	                formatter.Serialize(file, data);
        	        file.Close();
	        }
	        catch
		{
	        	MessageBox.Show("Sérialisation impossible", "Erreur");
	                Application.Exit();
	        }
	}
 
	void RestaureFichier(string fichierXML)
	{
		try
		{
			BinaryFormatter formatter = new BinaryFormatter();
			FileStream file = File.Open(fichier, FileMode.Open);
			data = (Donnees)formatter.Deserialize(file);
			file.Close();
		}
		catch
		{
			MessageBox.Show("Désérialisation impossible", "Erreur");            
		}
	}
}

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
 
[Serializable()]
public class Donnees
{
	public int valeur;
	[Serializable()]
	public struct Code
	{
		public int x;
		public int y;
	}
 
	public List<Code> sauve1;
	public List<Code> sauve2;
 
	public Donnees()
        {
            sauve1 = new List<Code>();
            sauve2 = new List<Code>();
	}
}

Merci encore pour vos pistes. comme vous le constatez, j'ai du passez à une sérialisation binaire, car le format XML n'est pas adapté et renvoye trop d'exceptions sur des instances plus complexes.
:D