Question

I use the following code to serialize xml file.

I wonder whether should I use the CanDeserialize function in this case.

I noticed that CanDeserialize throws XmlException if the file is empty.

Deserialize throws InvalidOperationException in that case.

My question is should I remove that extra check and if Deserialize does some sort of check anyway?

EDIT: After reading some comments and answers, I wonder when to use CanDeserialize ?

public static T RestoreFromXml(string filename)
{
    Object res = null;
    using (var stream = new FileStream(filename, FileMode.Open))
    {
        XmlReader reader = new XmlTextReader(stream);
        try
        {
            if (xs.CanDeserialize(reader))
            {
                res = xs.Deserialize(reader);
            }
        }
        catch (XmlException ex)
        {
            throw ex;
        }            
    }
    return (T)res;
}

Answer 1

You can do some checkings before trying to deserialize – check if the file name is not null or empty, check if the file exists, etc. Here’s some code to deserialize a file:

/// <summary>
/// XML serializer helper class. Serializes and deserializes objects from/to XML
/// </summary>
/// <typeparam name="T">The type of the object to serialize/deserialize.
/// Must have a parameterless constructor and implement <see cref="Serializable"/></typeparam>
public class XmlSerializer<T> where T: class, new()
{
    /// <summary>
    /// Deserializes a XML file.
    /// </summary>
    /// <param name="filename">The filename of the XML file to deserialize</param>
    /// <returns>An object of type <c>T</c></returns>
    public static T DeserializeFromFile(string filename)
    {
        return DeserializeFromFile(filename, new XmlReaderSettings());
    }

    /// <summary>
    /// Deserializes a XML file.
    /// </summary>
    /// <param name="filename">The filename of the XML file to deserialize</param>
    /// <param name="settings">XML serialization settings. <see cref="System.Xml.XmlReaderSettings"/></param>
    /// <returns>An object of type <c>T</c></returns>
    public static T DeserializeFromFile(string filename, XmlReaderSettings settings)
    {
        if (string.IsNullOrEmpty(filename))
            throw new ArgumentException("filename", "XML filename cannot be null or empty");

        if (! File.Exists(filename))
            throw new FileNotFoundException("Cannot find XML file to deserialize", filename);

        // Create the stream writer with the specified encoding
        using (XmlReader reader = XmlReader.Create(filename, settings))
        {
            System.Xml.Serialization.XmlSerializer xmlSerializer = new System.Xml.Serialization.XmlSerializer(typeof(T));
            return (T) xmlSerializer.Deserialize(reader);
        }
    }
} 

}

You can use it like this:

string filename = "...";

Foo foo = XmlSerializer<Foo>.DeserializeFromFile(filename);

This code was taken from an article that I wrote, you can find it here:

XML serialization using Generics