XmlSerializer Class

FYI there is an excellent discussion here: http://stackoverflow.com/questions/109318/using-net-what-limitations-if-any-are-there-in-using-the-xmlserializer on the limitations of XMLSerializer.

Hashtable serializers = new Hashtable();// Use the constructor that takes a type and XmlRootAttribute.

// the following line would appear to be unnecessary
XmlSerializer s = new XmlSerializer(typeof(MyClass), myRoot);

// Implement a method named GenerateKey that creates unique keys 
// for each instance of the XmlSerializer. The code should take 
// into account all parameters passed to the XmlSerializer 
// constructor.
object key = GenerateKey(typeof(MyClass), myRoot);

// Check the local cache for a matching serializer.
XmlSerializer ser = (XmlSerializer)serializers[key];
if (ser == null) 
{
    ser = new XmlSerializer(typeof(MyClass), myRoot);
    // Cache the serializer.
    serializers[key] = ser;
}

  // the following lines would appear to be unnecessary
else
{
    // Use the serializer to serialize, or deserialize.
}

seriali xml
program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO; // cal afegir els dos Namespaces per serialitzar i tractar  fitxers
using System.Xml.Serialization;
using System.Text;
   
namespace serialitzacioSoap
{
    class Program
    {
        static void Main(string[] args)
        {
            string fitxer = @"C:\temp\prova.xml";
            Equip e = new Equip("Barca", 100);
            Equip ee = new Equip("madrid", 90);
            Equip eee = new Equip("valencia", 80);
            guardar(e,ee,eee, fitxer);
            Console.WriteLine("s'han guardat correctament els equips {0:2d},{1:2d},{2:2d}",e.Nom,ee.Nom,eee.Nom);
            Console.WriteLine(" Final... apreti intro per sortir ");
            Console.ReadLine();
        }
        static void guardar(Equip xe, Equip xee,Equip xeee, string xfitxer)
        {
            string fitxer = @"C:\temp\prova.xml";
            // creem un objecte XmlSerializer que sera el que guardara
            // les dades del equip, li passem el typeof(Equip) per tal que
            // sapigi quina informacio té equip
            XmlSerializer xs = new XmlSerializer(typeof(Equip));
            // creem un Filestream  del fitxer
            if (File.Exists(fitxer))
            {
                File.Delete(fitxer);
            }
            FileStream fs = new FileStream(xfitxer,
                FileMode.Append, FileAccess.Write);
            // aqui guardem al textwriter l'objecte xe rebut com argument
            xs.Serialize(fs, xe);
            xs.Serialize(fs, xee);
            xs.Serialize(fs, xeee);
            fs.Flush(); // tenquem els fitxers
            fs.Close();
            fs.Dispose();
        }
        static Equip Recuperar(string xfitxer)
        {
            Equip e = null;
            // creem un XmlSerializer que sera el que recuperar l'objecte de tipus Equip
            // typeof equip indica a xs que recuperarà equip, amb nom (string) i punts (integer)
            XmlSerializer xs = new XmlSerializer(typeof(Equip));
            // obrim el fitxer que conté el xml
            FileStream fs = new FileStream(xfitxer, FileMode.Open, FileAccess.Read);
            // per recuperar l'equip, fem servir Deserialize, que retorna UN OBJECT
            // per tant cal fer un casting a Equip per assignar-lo a e
            e = (Equip)xs.Deserialize(fs);
            fs.Close();// tenquem els fitxers
            fs.Dispose();
            return e;
        }
    }
}
--------------------------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
namespace serialitzacioSoap
{
    [Serializable] // cal posar aixo per fer la classe Serializable
        // ha de ser public
    public class Equip
    {
        private string _nom;
        private int _punts;
        public string Nom
        {
            get { return _nom; }
            set { _nom = value; }
        }
        public int Punts
        {
            get { return _punts; }
            set { _punts = value; }
        }
        public Equip()
        {
            this.Nom = "";
            this.Punts = 0;
        }
        public Equip(string xnom, int xpunts)
        {
            this.Nom = xnom;
            this.Punts = xpunts;
        }
        public override string ToString()
        {
            string cad = string.Format("{0,10} {1,3:d}", this.Nom, this.Punts);
            return cad;
        }
    }
}
--------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------
seril soap
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Soap;
namespace serialitzacioSoap
{
    class Program
    {
        static void Main(string[] args)
        {
            string fitxer = @"C:\temp\prova.soap";
            Equip e = new Equip("Barca", 1330);
            guardar(e, fitxer);
            Equip e2 = Recuperar(fitxer);
            Console.WriteLine("{0}", e2.ToString());
            Console.WriteLine(" Final... apreti intro per sortir ");
            Console.ReadLine();
        }
        static void guardar(Equip xe, string xfitxer)
        {
            // creem un objecte SoapFormatter que sera el que guardara
            // les dades del equip,
            SoapFormatter sf = new SoapFormatter();
            // creem un filestream associat al fitxer
            FileStream fs = new FileStream(xfitxer,
                FileMode.Create, FileAccess.Write);
            // aqui guardem al filestream l'objecte xe rebut com argument
            sf.Serialize(fs, xe);
            fs.Flush(); // tenquem els fitxers
            fs.Close();
            fs.Dispose();
        }
        static Equip Recuperar(string xfitxer)
        {
            Equip e = null;
            // creem un SoapFormatter que sera el que recuperar l'objecte de tipus Equip
            SoapFormatter sf = new SoapFormatter();
            // obrim el fitxer que conté el xml
            FileStream fs = new FileStream(xfitxer, FileMode.Open, FileAccess.Read);
            // per recuperar l'equip, fem servir Deserialize, que retorna UN OBJECT
            // per tant cal fer un casting a Equip per assignar-lo a e
            e = (Equip)sf.Deserialize(fs);
            fs.Close();// tenquem els fitxers
            fs.Dispose();
            return e;
        }
    }
}
--------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------
serial bin
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;// afegim el namespace IO I
// el de Serialization.Formatters.Binary
using System.Runtime.Serialization.Formatters.Binary;
namespace serialitzacioSoap
{
    class Program
    {
        static void Main(string[] args)
        {
            string fitxer = @"C:\temp\provabin.dat";
            Equip e = new Equip("Barca", 122);
            guardar(e, fitxer);
            Equip e2 = Recuperar(fitxer);
            Console.WriteLine("{0}", e2.ToString());
            Console.WriteLine(" Final... apreti intro per sortir ");
            Console.ReadLine();
        }
        static void guardar(Equip xe, string xfitxer)
        {
            // creem un objecte BinaryFormatter que sera el que guardara
            // les dades del equip
            BinaryFormatter bf = new BinaryFormatter();
            // creem un textWriter que associem al StreamWriter del fitxer
            FileStream fs = new FileStream(xfitxer, FileMode.Create, FileAccess.Write);
            // aqui guardem al textwriter l'objecte xe rebut com argument
            bf.Serialize(fs, xe);
            fs.Flush(); // tenquem els fitxers
            fs.Close();
            fs.Dispose();
        }
        static Equip Recuperar(string xfitxer)
        {
            Equip e = null;
            // creem un binaryFormatter que sera el que recuperar l'objecte de tipus Equip
            // typeof equip indica a xs que recuperarà equip, amb nom (string) i punts (integer)
            BinaryFormatter bf = new BinaryFormatter();
            // obrim el fitxer que conté el xml
            FileStream fs = new FileStream(xfitxer, FileMode.Open, FileAccess.Read);
            // per recuperar l'equip, fem servir Deserialize, que retorna UN OBJECT
            // per tant cal fer un casting a Equip per assignar-lo a e
            e = (Equip)bf.Deserialize(fs);
            fs.Close();// tenquem els fitxers
            fs.Dispose();
            return e;
        }
    }
}

seriali xml
program.cs
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO; // cal afegir els dos Namespaces per serialitzar i tractar  fitxers
using System.Xml.Serialization;
using System.Text;
   
namespace serialitzacioSoap
{
    class Program
    {
        static void Main(string[] args)
        {
            string fitxer = @"C:\temp\prova.xml";
            Equip e = new Equip("Barca", 100);
            Equip ee = new Equip("madrid", 90);
            Equip eee = new Equip("valencia", 80);
            guardar(e,ee,eee, fitxer);
            Console.WriteLine("s'han guardat correctament els equips {0:2d},{1:2d},{2:2d}",e.Nom,ee.Nom,eee.Nom);
            Console.WriteLine(" Final... apreti intro per sortir ");
            Console.ReadLine();
        }
        static void guardar(Equip xe, Equip xee,Equip xeee, string xfitxer)
        {
            string fitxer = @"C:\temp\prova.xml";
            // creem un objecte XmlSerializer que sera el que guardara
            // les dades del equip, li passem el typeof(Equip) per tal que
            // sapigi quina informacio té equip
            XmlSerializer xs = new XmlSerializer(typeof(Equip));
            // creem un Filestream  del fitxer
            if (File.Exists(fitxer))
            {
                File.Delete(fitxer);
            }
            FileStream fs = new FileStream(xfitxer,
                FileMode.Append, FileAccess.Write);
            // aqui guardem al textwriter l'objecte xe rebut com argument
            xs.Serialize(fs, xe);
            xs.Serialize(fs, xee);
            xs.Serialize(fs, xeee);
            fs.Flush(); // tenquem els fitxers
            fs.Close();
            fs.Dispose();
        }
        static Equip Recuperar(string xfitxer)
        {
            Equip e = null;
            // creem un XmlSerializer que sera el que recuperar l'objecte de tipus Equip
            // typeof equip indica a xs que recuperarà equip, amb nom (string) i punts (integer)
            XmlSerializer xs = new XmlSerializer(typeof(Equip));
            // obrim el fitxer que conté el xml
            FileStream fs = new FileStream(xfitxer, FileMode.Open, FileAccess.Read);
            // per recuperar l'equip, fem servir Deserialize, que retorna UN OBJECT
            // per tant cal fer un casting a Equip per assignar-lo a e
            e = (Equip)xs.Deserialize(fs);
            fs.Close();// tenquem els fitxers
            fs.Dispose();
            return e;
        }
    }
}
--------------------------------------------------------------------------------------------
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Runtime.Serialization.Formatters.Binary;
namespace serialitzacioSoap
{
    [Serializable] // cal posar aixo per fer la classe Serializable
        // ha de ser public
    public class Equip
    {
        private string _nom;
        private int _punts;
        public string Nom
        {
            get { return _nom; }
            set { _nom = value; }
        }
        public int Punts
        {
            get { return _punts; }
            set { _punts = value; }
        }
        public Equip()
        {
            this.Nom = "";
            this.Punts = 0;
        }
        public Equip(string xnom, int xpunts)
        {
            this.Nom = xnom;
            this.Punts = xpunts;
        }
        public override string ToString()
        {
            string cad = string.Format("{0,10} {1,3:d}", this.Nom, this.Punts);
            return cad;
        }
    }
}
--------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------
seril soap
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Soap;
namespace serialitzacioSoap
{
    class Program
    {
        static void Main(string[] args)
        {
            string fitxer = @"C:\temp\prova.soap";
            Equip e = new Equip("Barca", 1330);
            guardar(e, fitxer);
            Equip e2 = Recuperar(fitxer);
            Console.WriteLine("{0}", e2.ToString());
            Console.WriteLine(" Final... apreti intro per sortir ");
            Console.ReadLine();
        }
        static void guardar(Equip xe, string xfitxer)
        {
            // creem un objecte SoapFormatter que sera el que guardara
            // les dades del equip,
            SoapFormatter sf = new SoapFormatter();
            // creem un filestream associat al fitxer
            FileStream fs = new FileStream(xfitxer,
                FileMode.Create, FileAccess.Write);
            // aqui guardem al filestream l'objecte xe rebut com argument
            sf.Serialize(fs, xe);
            fs.Flush(); // tenquem els fitxers
            fs.Close();
            fs.Dispose();
        }
        static Equip Recuperar(string xfitxer)
        {
            Equip e = null;
            // creem un SoapFormatter que sera el que recuperar l'objecte de tipus Equip
            SoapFormatter sf = new SoapFormatter();
            // obrim el fitxer que conté el xml
            FileStream fs = new FileStream(xfitxer, FileMode.Open, FileAccess.Read);
            // per recuperar l'equip, fem servir Deserialize, que retorna UN OBJECT
            // per tant cal fer un casting a Equip per assignar-lo a e
            e = (Equip)sf.Deserialize(fs);
            fs.Close();// tenquem els fitxers
            fs.Dispose();
            return e;
        }
    }
}
--------------------------------------------------------------------------------------------
--------------------------------------------------------------------------------------------
serial bin
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.IO;// afegim el namespace IO I
// el de Serialization.Formatters.Binary
using System.Runtime.Serialization.Formatters.Binary;
namespace serialitzacioSoap
{
    class Program
    {
        static void Main(string[] args)
        {
            string fitxer = @"C:\temp\provabin.dat";
            Equip e = new Equip("Barca", 122);
            guardar(e, fitxer);
            Equip e2 = Recuperar(fitxer);
            Console.WriteLine("{0}", e2.ToString());
            Console.WriteLine(" Final... apreti intro per sortir ");
            Console.ReadLine();
        }
        static void guardar(Equip xe, string xfitxer)
        {
            // creem un objecte BinaryFormatter que sera el que guardara
            // les dades del equip
            BinaryFormatter bf = new BinaryFormatter();
            // creem un textWriter que associem al StreamWriter del fitxer
            FileStream fs = new FileStream(xfitxer, FileMode.Create, FileAccess.Write);
            // aqui guardem al textwriter l'objecte xe rebut com argument
            bf.Serialize(fs, xe);
            fs.Flush(); // tenquem els fitxers
            fs.Close();
            fs.Dispose();
        }
        static Equip Recuperar(string xfitxer)
        {
            Equip e = null;
            // creem un binaryFormatter que sera el que recuperar l'objecte de tipus Equip
            // typeof equip indica a xs que recuperarà equip, amb nom (string) i punts (integer)
            BinaryFormatter bf = new BinaryFormatter();
            // obrim el fitxer que conté el xml
            FileStream fs = new FileStream(xfitxer, FileMode.Open, FileAccess.Read);
            // per recuperar l'equip, fem servir Deserialize, que retorna UN OBJECT
            // per tant cal fer un casting a Equip per assignar-lo a e
            e = (Equip)bf.Deserialize(fs);
            fs.Close();// tenquem els fitxers
            fs.Dispose();
            return e;
        }
    }
}

"You must have permission to write to the temporary directory (as defined by the TEMP environment variable) to deserialize an object."

If you are a user with restricted rights (not an administrator)(win server 2003) and you use in your application XmlSerializer then it is possible that you receive an exception (and it is even posssible that crc.exe crashes).
 In windows if show hidden folders is NOT active (hidden folders are not visible). While the program closes and the user logs out from windows xmlserializer tries to dynamically compile a dll in the temporary folder. This process either fails, or the dll is created but is not readable by the application that needs it. At this point it's possible that CSC.exe crashses along with the application.

Hello.

First I want to say a word about PapaJ's comment. In article it is said that the Arrays of Lists can't be serialized, not Lists. 

Now I would like to show my way to serialize the List<T> object. I use it in my little project few days ago.

I've got two classes

First class Account:

  
[Serializable]
  
public class Account
  
    {
  
    
        [XmlAttribute("UserName")]
    
        public string UserName { get; set; }
    
      
        [XmlAttribute("UserEmail")]
      
        public string UserEmail { get; set; }

      
        [XmlAttribute("UserPass")]
      
        public string UserPass { get; set; }

      
        [XmlArray]
      
        public List<Character> UserCharacters = new List<Character>();
      
      
//I've cut rest of the body to safe a place.
      
}
    
  

  
    
      
    
    
Second class Character:
  

[Serializable]
public class Character
    {
        #region Stats
        [XmlAttribute("Name")]
        public string Name { get; set; }
        [XmlAttribute("Level")]
        public UInt16 Level { get; set; }
        [XmlAttribute("Experiance")]
        public UInt32 Experiance { get; set; }
        [XmlArray]
        public List<uint> Items;
        #endregion
}
  
    
        
    
When I serialize the Account class it also serialize the List<Character> which is a field in Account class. Xml file looks then like that:
    

    
<User xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" UserName="Arche" UserEmail="arche89@gmail.com" UserPass="'?o?q?8K?t'???<m??k?">
    
<UserCharacters>
    
   <Character Name="Astamo" Level="0" Experiance="0"/>
    
   <Character Name="Arche" Level="34" Experiance="35465"/>
    
</UserCharacters>
    
</User>


Thanks for reading.
A. Michajluk
    
    
  

        

1. XmlSerializer will call property setters when deserializing the property.
2. XMlSerializer does not serialize internal members.
3. To avoid serialization of public property use [XmlIgnore] attribute.
4. If property setter is private then XmlSerializer will generate run time exception. However if property setter does not exist then it will not generate exception.
5. Nullable types with null value gets serialized as <MyProperty p2:nil="true" xmlns:p2="http://www.w3.org/2001/XMLSchema-instance" />.
6. Null property values for non-nullable types does not generate XML element.
7. If there are extra elements in XML without corresponding properties then they are ignored.
8. For value types if XML element does not exist then they are set to their field initialization value.
9. XML serializer accepts strings formatted with "'yyyy'-'MM'-'dd'T'HH': 'mm': 'ss.fffffff'Z'" for deserializing. Strings compatible to InvariantCulture like "1/31/2011 2:23 PM" will generate run time error.

$0$0 $0

The documentation above is not exactly correct, you can serialize an ArrayList if you add types that the ArrayList points to a list of types: 

    Shared Sub Save(ByRef object As myObject)

        Try

            Dim objStreamWriter As New StreamWriter("object.xml")

            Dim extraTypes(0) As Type

            extraTypes(0) = GetType(PointedToType)

            Dim x As New XmlSerializer(object.GetType, extraTypes)

            x.Serialize(objStreamWriter, object)

            objStreamWriter.Close()

        Catch ex As Exception

            MsgBox(ex.Message)

        End Try

    End Sub

    Shared Function Load() As myObject

        Try

            Dim objStreamReader As New StreamReader("object.xml")

            Dim extraTypes(0) As Type

            extraTypes(0) = GetType(PointedToType)

            Dim x As New XmlSerializer(GetType(myObject), extraTypes)

            Dim object As New myObject

            object = x.Deserialize(objStreamReader)

            objStreamReader.Close()

            Return object 

        Catch ex As Exception

            Throw ex

        End Try

    End Function

I gleaned this information by reading artical by Sheo Narayan at http://www.dotnetfunda.com/articles/article123.aspx

Jacob Christ

insertmyfirstnamehere@pontech.com

$0 $0$0 $0