Ignore unknown types when deserializing xml

Question

I've got this code:

[XmlType( "Metadata" )]
[Serializable]
public class MetadataContainer : List<MetadataBase>
{
}

[XmlType( "Meta" )]
[XmlInclude( typeof( ReadonlyMetadata ) )]
[Serializable]
public abstract class MetadataBase
{
}

[XmlType( "Readonly" )]
[Serializable]
public class ReadonlyMetadata : MetadataBase
{
}

[TestFixture]
public class SerializationTests
{
    [Test]
    public void Can_deserialize_with_known_type()
    {
        const string text = @"<Metadata xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
                        <Meta xsi:type=""Readonly"" />
                    </Metadata>";

        var serializer = new XmlSerializer( typeof( MetadataContainer ) );
        var metas = (MetadataContainer)serializer.Deserialize( XmlReader.Create( new StringReader( text ) ) );

        Assert.That( metas.Count, Is.EqualTo( 1 ) );
        Assert.That( metas.First(), Is.InstanceOf<ReadonlyMetadata>() );
    }

    [Test]
    public void Can_deserialize_with_unknown_type()
    {
        const string text = @"<Metadata xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
                        <Meta xsi:type=""Hello"" />
                    </Metadata>";

        var serializer = new XmlSerializer( typeof( MetadataContainer ) );
        var metas = (MetadataContainer)serializer.Deserialize( XmlReader.Create( new StringReader( text ) ) );

        Assert.That( metas.Count, Is.EqualTo( 0 ) );
    }
}

The first test works, but when I run the second I get this error:

System.InvalidOperationException : There is an error in XML document (2, 9). ----> System.InvalidOperationException : The specified type was not recognized: name='Hello', namespace='', at .

Instead of getting this error I would like it to ignore not recognized types. Is there any way to do this?

I thought this would be a case of subscribing to one or more of the [`Unknown`- events](http://msdn.microsoft.com/en-us/library/0a51hxdw.aspx), but on trying it it seems not to help. Mysterious. — AakashM, Oct 30 '12 at 11:17
I also thought that, the results are wierd though. I did not manage to find a solution though. — flindeberg, Oct 31 '12 at 07:49

flindeberg · Accepted Answer · 2012-10-31T08:39:57.543

Generic solution for similar problems:

Have a look at unknown element event (link) and unknown attribute event (link) and see if they solve the problems, or we have to get dirty. Read on...

Working solution for this problem

Bear in mind that that I have no idea what your task is, AFAIK it is serializing xml into your datastructure. If you can change the datastructure I would recommend you to have a look at Linq2XML and create a smart factory for your purposes.

[TestMethod]
public void TestLinq2Xml()
{
  const string text = @"<Metadata xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"">
                            <Meta xsi:type=""Readonly"" />
                            <Meta xsi:type=""Garbage"" />
                      </Metadata>";

  // Get the "names" of all implementors of MetadataBase
  var types = AppDomain.CurrentDomain.GetAssemblies().ToList()
     .SelectMany(s => s.GetTypes())
         .Where(p => typeof(MetadataBase).IsAssignableFrom(p) && !p.IsAbstract && !p.IsInterface)
         .Where(t => t.GetCustomAttributes(typeof(XmlTypeAttribute), false).Any())
         .Select(t => t.GetCustomAttributes(typeof(XmlTypeAttribute), false)
             .Cast<XmlTypeAttribute>().First().TypeName);

  // Create a parser
  var parser = new XmlSerializer(typeof(MetadataBase));

  // Create metadatacontainer to fill
  var metas = new MetadataContainer();
  // Fill it with matching from from the XML
  metas.AddRange((from t in XDocument.Parse(text).Descendants("Meta")
                where types.Contains(t.Attribute(XName.Get("type", "http://www.w3.org/2001/XMLSchema-instance")).Value)
                select (MetadataBase)parser.Deserialize(t.CreateReader())).ToList());

  // Should be one guy present
  Assert.AreEqual(metas.Count, 1);
}

score 0 · Answer 2 · answered Jul 15 '14 at 12:37

0

Catch all unknown elements in an array. You can still work with them and attempt to deserialize later, but this allows the deserialization to complete. You will need this in each class you define to deserialize your elements where you suspect there will be unknown elements.

Per http://msdn.microsoft.com/en-us/library/system.xml.serialization.xmlanyelementattribute.aspx:

Public Class XClass
    ' Apply the XmlAnyElementAttribute to a field returning an array 
    ' of XmlElement objects.
    <XmlAnyElement()> Public AllElements() As XmlElement
End Class 'XClass

answered Jul 15 '14 at 12:37

VoteCoffee

4,692
1
41
44

1

Downvotes are fine but please leave feedback to help me revise my answer. – VoteCoffee Aug 08 '15 at 23:26
Very interesting answer. Will have to try that out. – AnthonyVO Sep 28 '17 at 16:36

Ignore unknown types when deserializing xml

2 Answers2