C# [XmlElement] attribute doesn't implicitly cast Type?

Question

So i have a class, Texture2DProcessor, that inherits IXmlSerializable and Implicitly casts to and from Texture2D

public static implicit operator Texture2D(Texture2DProcessor o)
{
    return o.Data;
}
public static implicit operator Texture2DProcessor(Texture2D o)
{
    return o == null ? null : new Texture2DProcessor(o);
}

I then have a struct, GunProperties, that contains a Texture2D property with an XmlElement attribute with the type set to Texture2DProcessor

Texture2D _sideSprite;
[XmlElement(typeof(Texture2DProcessor))]
public Texture2D SideSprite
{
    get { return _sideSprite; }
    set { _sideSprite = value; }
}

I get the following runtime error

Cannot serialize member '...GunProperties.SideSprite' of type 'Microsoft.Xna.Framework.Graphics.Texture2D'

why is XmlSerializer not using Texture2DProcessor to read and write the Xml data?

Also I know that my ReadXml and WriteXml methods work because this works fine and i am able to use the texture.

Texture2D texture;
XmlSerializer serializer = new XmlSerializer(typeof(Texture2DProcessor));
serializer.Deserialize(new FileStream(path, FileMode.Open), texture);

The reason I'm going through this trouble is I'm using monogame and the content pipeline is pretty messed up especially for custom types and other than this issue i have it all working.

Answer 1

It looks like this may be a Mono XmlSerializer limitation. I have a small test app which works under .NET, but not under Mono 3.0.6.

But this looks fairly simple to work around:

[XmlIgnore]
public Texture2D SideSprite { get; set; }

[XmlElement("SideSprite")]
[EditorBrowsable(EditorBrowsableState.Never)]
public Texture2DProcessor SideSpriteProcessor
{
    get { return SideSprite; }
    set { SideSprite = value; }
}

We have the same issue in my Noda Time project, as XML serialization doesn't mix well with immutable types. I've given pretty much the same advice there.

EDIT: Okay, so here's some sample code which does work:

using System;
using System.IO;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Serialization;

public class Person
{
    public string Name { get; set; }
}

public class PersonWrapper : IXmlSerializable
{
    public Person Person { get; set; }

    public static implicit operator Person(PersonWrapper wrapper)
    {
        return wrapper == null ? null : wrapper.Person;
    }

    public static implicit operator PersonWrapper(Person person)
    {
        return new PersonWrapper { Person = person };
    }

    public XmlSchema GetSchema()
    {
        return null;
    }

    public void ReadXml(XmlReader reader)
    {
        string name = reader.ReadString();
        reader.ReadEndElement();
        Person = new Person { Name = name };
    }

    public void WriteXml(XmlWriter writer)
    {
        writer.WriteString(Person.Name);
    }
}

public class Company
{
    [XmlElement(typeof(PersonWrapper))]
    public Person Director { get; set; }

    [XmlElement(typeof(PersonWrapper))]
    public Person Manager { get; set; }
}

class Test
{
    static void Main()
    {
        var serializer = new XmlSerializer(typeof(Company));

        var original = new Company
        {
            Director = new Person { Name = "Holly" },
            Manager = new Person { Name = "Jon" }
        };

        var writer = new StringWriter();
        serializer.Serialize(writer, original);
        Console.WriteLine("XML:");
        Console.WriteLine(writer.ToString());

        var reader = new StringReader(writer.ToString());
        var deserialized = (Company) serializer.Deserialize(reader);

        Console.WriteLine("Deserialized:");
        Console.WriteLine("Director: {0}", deserialized.Director.Name);
        Console.WriteLine("Manager: {0}", deserialized.Manager.Name);
    }
}