Failed to Deserialize XML to C# object, what am I doing wrong?

Question

Hi I need to deserialize XML into object of Parameters class.

I defined this generic function that does the serialization:

public static T Deserialize<T>(string xml) where T : class
{
    XmlSerializer serializer = new XmlSerializer(typeof(T));
    using (StringReader reader = new StringReader(xml))
    {
        return (T)serializer.Deserialize(reader);
    }
}

XML string I want to deserialize:

<Parameters>
    <UserProfileState>0</UserProfileState>
    <Parameter>
        <Name>Country</Name>
        <Type>String</Type>
        <Nullable>False</Nullable>
        <AllowBlank>False</AllowBlank>
        <MultiValue>True</MultiValue>
        <UsedInQuery>True</UsedInQuery>
        <State>MissingValidValue</State>
        <Prompt>Country</Prompt>
        <DynamicPrompt>False</DynamicPrompt>
        <PromptUser>True</PromptUser>
        <DynamicValidValues>True</DynamicValidValues>
        <DynamicDefaultValue>True</DynamicDefaultValue>
    </Parameter>
    <Parameter>
        <Name>City</Name>
        <Type>String</Type>
        <Nullable>False</Nullable>
        <AllowBlank>False</AllowBlank>
        <MultiValue>True</MultiValue>
        <UsedInQuery>True</UsedInQuery>
        <State>MissingValidValue</State>
        <Prompt>City</Prompt>
        <DynamicPrompt>False</DynamicPrompt>
        <PromptUser>True</PromptUser>
        <Dependencies>
            <Dependency>Country</Dependency>
        </Dependencies>
        <DynamicValidValues>True</DynamicValidValues>
        <DynamicDefaultValue>True</DynamicDefaultValue>
    </Parameter>
</Parameters>

Type (class) I want to deserialize my XML into:

[Serializable, XmlRoot(ElementName = "Parameters")]
public class ParametersModel
{
    [XmlElement(ElementName = "UserProfileState")]
    public int UserProfileState { get; set; }
    [XmlArray(ElementName = "Parameter")]
    public List<ParameterModel> Parameter { get; set; }
}

[Serializable]
public class ParameterModel
{
    [XmlElement(ElementName = "Name")]
    public string Name { get; set; }
    [XmlElement(ElementName = "Type")]
    public string Type { get; set; }
    [XmlElement(ElementName = "Nullable")]
    public bool Nullable { get; set; }
    [XmlElement(ElementName = "AllowBlank")]
    public bool AllowBlank { get; set; }
    [XmlElement(ElementName = "MultiValue")]
    public bool MultiValue { get; set; }
    [XmlElement(ElementName = "UsedInQuery")]
    public bool UsedInQuery { get; set; }
    [XmlElement(ElementName = "State")]
    public string State { get; set; }
    [XmlElement(ElementName = "Prompt")]
    public string Prompt { get; set; }
    [XmlElement(ElementName = "DynamicPrompt")]
    public bool DynamicPrompt { get; set; }
    [XmlElement(ElementName = "PromptUser")]
    public bool PromptUser { get; set; }
    [XmlElement(ElementName = "DynamicValidValues")]
    public bool DynamicValidValues { get; set; }
    [XmlElement(ElementName = "DynamicDefaultValue")]
    public bool DynamicDefaultValue { get; set; }

}

I call my Deserialize function from code, passing this XML:

var parameters = Utility.Deserialize<ParametersModel>(xml);

Now I dont get an exception, but Parameter collection is Empty

What is wrong?

Thank you

UPDATE1

<?xml version="1.0" encoding="utf-16"?>
<Parameters xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
  <UserProfileState>0</UserProfileState>
  <Parameters>
    <Parameter />
    <Parameter />
  </Parameters>
</Parameters>

There is an extra node under UserProfileState.

Do you guys know why I get this extra node, some attribute is defined incorrectly?

UPDATE2

I have modified the target object class as was suggested into this, and the deserialization now works fine, with the only problem is that I had to change type from bool to string for some properties... now I need to figure out how to keep bool properties and still have conversion working....

[Serializable]
[XmlRoot(ElementName = "Parameters")]
public class ParametersModel
{
    [XmlElement(ElementName = "UserProfileState")]
    public int UserProfileState { get; set; }
    [XmlElement(ElementName = "Parameter")]
    public List<ParameterModel> Parameters { get; set; }
}

[Serializable]
public class ParameterModel
{
    [XmlElement(ElementName = "Name")]
    public string Name { get; set; }
    [XmlElement(ElementName = "Type")]
    public string Type { get; set; }
    [XmlElement(ElementName = "Nullable")]
    public string Nullable { get; set; }
    [XmlElement(ElementName = "AllowBlank")]
    public string AllowBlank { get; set; }
    [XmlElement(ElementName = "MultiValue")]
    public string MultiValue { get; set; }
    [XmlElement(ElementName = "UsedInQuery")]
    public string UsedInQuery { get; set; }
    [XmlElement(ElementName = "State")]
    public string State { get; set; }
    [XmlElement(ElementName = "Prompt")]
    public string Prompt { get; set; }
    [XmlElement(ElementName = "DynamicPrompt")]
    public string DynamicPrompt { get; set; }
    [XmlElement(ElementName = "PromptUser")]
    public string PromptUser { get; set; }
    [XmlElement(ElementName = "DynamicValidValues")]
    public string DynamicValidValues { get; set; }
    [XmlElement(ElementName = "DynamicDefaultValue")]
    public string DynamicDefaultValue { get; set; }
}

UPDATE3

For boolean properties I implemented suggested workaround, "Nullable" property is of type bool, so I had to define additional property that will translate string to bool and bool to string automatically. Thank you guys for this suggestion.

[Serializable]
public class ParameterModel
{
    [XmlElement(ElementName = "Name")]
    public string Name { get; set; }
    [XmlElement(ElementName = "Type")]
    public string Type { get; set; }

    [XmlIgnore]
    public bool Nullable { get; set; }

    [XmlElement("Nullable")]
    public string NullableSerialize
    {
        get { return this.Nullable.ToString(); }
        set { this.Nullable = Convert.ToBoolean(value); }
    }

    [XmlElement(ElementName = "AllowBlank")]
    public string AllowBlank { get; set; }
    [XmlElement(ElementName = "MultiValue")]
    public string MultiValue { get; set; }
    [XmlElement(ElementName = "UsedInQuery")]
    public string UsedInQuery { get; set; }
    [XmlElement(ElementName = "State")]
    public string State { get; set; }
    [XmlElement(ElementName = "Prompt")]
    public string Prompt { get; set; }
    [XmlElement(ElementName = "DynamicPrompt")]
    public string DynamicPrompt { get; set; }
    [XmlElement(ElementName = "PromptUser")]
    public string PromptUser { get; set; }
    [XmlElement(ElementName = "DynamicValidValues")]
    public string DynamicValidValues { get; set; }
    [XmlElement(ElementName = "DynamicDefaultValue")]
    public string DynamicDefaultValue { get; set; }
}

Answer 1

You could serialize your xml if you define your classes this way:

[Serializable]
[XmlRoot("Parameters")]
public class ParametersModel
{
    [XmlElement]
    public int UserProfileState { get; set; }   

    [XmlElement("Parameter")]   
    public List<ParameterModel> Parameters { get; set; }
}

but it won't work, becasue XmlSerialize could not parse your False/True to bool values. So you should either change all your bool properties to string or consider to use this from microsoft suggested workaround: https://blogs.msdn.microsoft.com/helloworld/2009/04/03/workaround-to-deserialize-true-false-using-xmlserializer/

Answer 2

I think the following should get you pretty close. First, your top-level class

[XmlRoot(nameof(Parameters))]
public sealed class ParametersModel
{
    public int UserProfileState { get; set; }

    [XmlElement("Parameter")]
    public List<ParameterModel> Parameters { get; set; }
}

Your ParameterModel class is then

public sealed class ParameterModel
{
    public string Name { get; set; }
    public string Type { get; set; }
    public BooleanAsString Nullable { get; set; }
    public BooleanAsString AllowBlank { get; set; }
    public BooleanAsString MultiValue { get; set; }
    public BooleanAsString UsedInQuery { get; set; }
    public string State { get; set; }
    public string Prompt { get; set; }
    public BooleanAsString DynamicPrompt { get; set; }
    public BooleanAsString PromptUser { get; set; }
    public List<Dependency> Dependencies { get; set; }
    public BooleanAsString DynamicValidValues { get; set; }
    public BooleanAsString DynamicDefaultValue { get; set; }
}

public sealed class Dependency
{
    [XmlText]
    public string Value { get; set; }
}

I've done the bool/string stuff in a utility class

// https://blogs.msdn.microsoft.com/helloworld/2009/04/03/workaround-to-deserialize-true-false-using-xmlserializer/
public struct BooleanAsString
{
    public BooleanAsString(bool value = default(bool))
    {
        StringValue = null;
        Value = value;
    }
    public static implicit operator BooleanAsString(bool value)
    {
        return new BooleanAsString(value);
    }
    public static implicit operator bool(BooleanAsString value)
    {
        return value.Value;
    }

    [XmlIgnore]
    public bool Value
    {
        get { return Boolean.Parse(StringValue); }
        set { StringValue = value ? "True" : "False"; }
    }

    [XmlText]
    public string StringValue { get; set; }
}

Test code is:

    static string XmlSerialize(Object o)
    {
        var serializer = new XmlSerializer(o.GetType());
        using (var writer = new StringWriter())
        {
            serializer.Serialize(writer, o);
            return writer.ToString();
        }
    }

    static void Main(string[] args)
    {
        var parameters = new ParametersModel { UserProfileState = 0, Parameters = new List<ParameterModel>() };
        parameters.Parameters.Add(new ParameterModel
        { Name = "County", Type = "String", Nullable = false, AllowBlank = false, MultiValue = true, UsedInQuery = true, State = "MissingValidValue", Prompt = "County", DynamicPrompt = false, PromptUser = true, DynamicValidValues = true, DynamicDefaultValue = true});
        var pm = new ParameterModel
        { Name = "City", Type = "String", Nullable = false, AllowBlank = false, MultiValue = true, UsedInQuery = true, State = "MissingValidValue", Prompt = "City", DynamicPrompt = false, PromptUser = true, DynamicValidValues = true, DynamicDefaultValue = true };
        pm.Dependencies = new List<Dependency>() { new Dependency{ Value = "Country" } };
        parameters.Parameters.Add(pm);

        var s = XmlSerialize(parameters);
    }

which generates the following XML

<?xml version="1.0" encoding="utf-16"?>
<Parameters xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
  <UserProfileState>0</UserProfileState>
  <Parameter>
    <Name>County</Name>
    <Type>String</Type>
    <Nullable>False</Nullable>
    <AllowBlank>False</AllowBlank>
    <MultiValue>True</MultiValue>
    <UsedInQuery>True</UsedInQuery>
    <State>MissingValidValue</State>
    <Prompt>County</Prompt>
    <DynamicPrompt>False</DynamicPrompt>
    <PromptUser>True</PromptUser>
    <DynamicValidValues>True</DynamicValidValues>
    <DynamicDefaultValue>True</DynamicDefaultValue>
  </Parameter>
  <Parameter>
    <Name>City</Name>
    <Type>String</Type>
    <Nullable>False</Nullable>
    <AllowBlank>False</AllowBlank>
    <MultiValue>True</MultiValue>
    <UsedInQuery>True</UsedInQuery>
    <State>MissingValidValue</State>
    <Prompt>City</Prompt>
    <DynamicPrompt>False</DynamicPrompt>
    <PromptUser>True</PromptUser>
    <Dependencies>
      <Dependency>Country</Dependency>
    </Dependencies>
    <DynamicValidValues>True</DynamicValidValues>
    <DynamicDefaultValue>True</DynamicDefaultValue>
  </Parameter>
</Parameters>

Answer 3

Your problem is that you have told it to deserialize to an object of type ParametersModel. You have given no hints for names of elements so it is using the class name as the element name. If you were to change the xml so that the root element was ParametersModel then you would find it would no longer error. It would however also not return the results you expected because of further similar problems elsewhere.

In comments Dan suggested that it is easiest to start with serialization and he is correct. If you try to create an instance of your ParametersModel object and then serialize that then you will see the names and structures that your model suggests. If you then tweak your models and their attributes until the output matches what you are expecting you are then in a good position to correctly deserialize xml documents.

Answer 4

You're probably missing the XML header tag, something like

<?xml version="1.0" encoding="utf-8"?>

Answer 5

Change the XmlRootAttribute declaration, on ParametersModel, from:

[XmlRoot]

to:

[XmlRoot(ElementName = "Parameters")]

Full posting:

class Program
{
    static void Main(string[] args)
    {
        var s = @"<Parameters>
<UserProfileState>1</UserProfileState>
<Parameter>
    <Name>Country</Name>
    <Type>String</Type>
    <Nullable>false</Nullable>
    <AllowBlank>false</AllowBlank>
    <MultiValue>true</MultiValue>
    <UsedInQuery>true</UsedInQuery>
    <State>MissingValidValue</State>
    <Prompt>Country</Prompt>
    <DynamicPrompt>false</DynamicPrompt>
    <PromptUser>true</PromptUser>
    <DynamicValidValues>true</DynamicValidValues>
    <DynamicDefaultValue>true</DynamicDefaultValue>
</Parameter>
<Parameter>
    <Name>City</Name>
    <Type>String</Type>
    <Nullable>false</Nullable>
    <AllowBlank>false</AllowBlank>
    <MultiValue>true</MultiValue>
    <UsedInQuery>true</UsedInQuery>
    <State>MissingValidValue</State>
    <Prompt>City</Prompt>
    <DynamicPrompt>false</DynamicPrompt>
    <PromptUser>true</PromptUser>
    <Dependencies>
        <Dependency>Country</Dependency>
    </Dependencies>
    <DynamicValidValues>true</DynamicValidValues>
    <DynamicDefaultValue>true</DynamicDefaultValue>
</Parameter>
</Parameters>";

        var serializer = new XmlSerializer(typeof(ParametersModel));
        using (var reader = new StringReader(s))
        {
            var result = (ParametersModel)serializer.Deserialize(reader);
            var sb = new StringBuilder();
            using (var writer = new StringWriter(sb))
            {
                serializer.Serialize(writer, result);
            }
        }

    }
}

[Serializable]
[XmlRoot(ElementName ="Parameters")]
public class ParametersModel
{
    [XmlElement]
    public int UserProfileState { get; set; }

    [XmlElement("Parameter")]
    public List<ParameterModel> Parameters { get; set; }
}

[Serializable]
public class ParameterModel
{
    [XmlElement]
    public string Name { get; set; }
    [XmlElement]
    public string Type { get; set; }
    [XmlElement]
    public bool Nullable { get; set; }
    [XmlElement]
    public bool AllowBlank { get; set; }
    [XmlElement]
    public bool MultiValue { get; set; }
    [XmlElement]
    public bool UsedInQuery { get; set; }
    [XmlElement]
    public string State { get; set; }
    [XmlElement]
    public string Prompt { get; set; }
    [XmlElement]
    public bool DynamicPrompt { get; set; }
    [XmlElement]
    public bool PromptUser { get; set; }
    [XmlElement]
    public bool DynamicValidValues { get; set; }
    [XmlElement]
    public bool DynamicDefaultValue { get; set; }

}