How to Serialize List<T>?

Solution 1:

You could use the XMLSerializer:

var aSerializer = new XmlSerializer(typeof(A));
StringBuilder sb = new StringBuilder();
StringWriter sw = new StringWriter(sb);
aSerializer.Serialize(sw, new A()); // pass an instance of A
string xmlResult = sw.GetStringBuilder().ToString();

For this to work properly you will also want xml annotations on your types to make sure it is serialized with the right naming, i.e.:

public enum NSystem { A = 0, B = 1, C = 2 }

[Serializable]
[XmlRoot(ElementName = "A")]
Class A 
{
 //Few Properties of Class A
 [XmlArrayItem("ListOfB")]
 List<B> list1;

 [XmlArrayItem("ListOfC")]
 List<C> list2;

 NSystem NotSystem { get; set; } 
}

Edit:

Enum properties are serialized by default with the name of the property as containing XML element and its enum value as XML value, i.e. if the property NotSystem in your example has the value C it would be serialized as

<NotSystem>C</NotSystem>

Of course you can always change the way the property is serialized by doing a proper annotation, i.e using [XmlAttribute] so it's serialized as an attribute, or [XmlElement("Foobar")] so it's serialized using Foobar as element name. More extensive documentation is available on MSDN, check the link above.

Solution 2:

Easiest way: to do BINARY serialization of any object (Images also and lot of other data!) with IO error catching.

To the class that we need to serialize we need to add [Serializable]

[Serializable]//this like
public class SomeItem
{}

Serialization wrapper:

public static class Serializator
{
    private static BinaryFormatter _bin = new BinaryFormatter();

    public static void Serialize(string pathOrFileName, object objToSerialise)
    {
        using (Stream stream = File.Open(pathOrFileName, FileMode.Create))
        {
            try 
            {
                _bin.Serialize(stream, objToSerialise);
            }
            catch (SerializationException e) 
            {
                Console.WriteLine("Failed to serialize. Reason: " + e.Message);
                throw;
            }
        }
    }

    public static T Deserialize<T>(string pathOrFileName) 
    {
        T items;

        using (Stream stream = File.Open(pathOrFileName, FileMode.Open))
        {
            try 
            {
                items = (T) _bin.Deserialize(stream);
            }
            catch (SerializationException e) 
            {
                Console.WriteLine("Failed to deserialize. Reason: " + e.Message);
                throw;
            }
        }

        return items;
    }
}

and using of the solution:

List<SomeItem> itemsCollected; //list with some data

Serializator.Serialize("data.dat", itemsCollected); // trying to serialise


var a = Serializator.Deserialize<%dataType%>("%dataPath%");

var a = Serializator.Deserialize<List<SomeItem>>("data.dat");
// trying to DeSerialize; 
// And important thing that you need to write here 
// correct data format instead of List<SomeItem>

in case of error was occured, error will be written to the console.

Solution 3:

    public IList<Object> Deserialize(string a_fileName)
    {
        XmlSerializer deserializer = new XmlSerializer(typeof(List<Object>));

        TextReader reader = new StreamReader(a_fileName);

        object obj = deserializer.Deserialize(reader);

        reader.Close();

        return (List<Object>)obj;
    }

    public void Serialization(IList<Object> a_stations,string a_fileName)
    {
        XmlSerializer serializer = new XmlSerializer(typeof(List<Object>));

        using (var stream = File.OpenWrite(a_fileName))
        {
            serializer.Serialize(stream, a_stations);
        }
    }