XML Serialization and Schema without xsd.exe

Question

I use XML serialization for the reading of my Config-POCOs.

To get intellisense support in Visual Studio for XML files I need a schema file. I can create the schema with xsd.exe mylibrary.dll and this works fine.

But I want that the schema is always created if I serialize an object to the file system. Is there any way without using xsd.exe?

Answer 1

thank you, this was the right way for me. solution:

XmlReflectionImporter importer = new XmlReflectionImporter();
XmlSchemas schemas = new XmlSchemas();
XmlSchemaExporter exporter = new XmlSchemaExporter(schemas);
Type type = toSerialize.GetType();
XmlTypeMapping map = importer.ImportTypeMapping(type);
exporter.ExportTypeMapping(map);

TextWriter tw = new StreamWriter(fileName + ".xsd");
schemas[0].Write(tw);
tw.Close();

Answer 2

The solution posted above by Will worked wonderfully, except I realized that the schema generated did not reflect the attributes on the different class members. For example a class decorated with serialization hint attributes (see the sample below), would have not rendered correctly.

    public class Test
    {
        [XmlAttribute()]
        public string Attribute { get; set; }
        public string Description { get; set; }

        [XmlArray(ElementName = "Customers")]
        [XmlArrayItem(ElementName = "Customer")]
        public List<CustomerClass> blah { get; set; }

    }

To address this, I created a few helper functions that use reflection to traverse the class hierarchy, read the attributes, and populate a XmlAttributeOverrides object that can be passed into the XmlReflectionImporter.

    public static void AttachXmlAttributes(XmlAttributeOverrides xao, Type t)
    {
        List<Type> types = new List<Type>();
        AttachXmlAttributes(xao, types, t);
    }

    public static void AttachXmlAttributes(XmlAttributeOverrides xao, List<Type> all, Type t)
    {
        if(all.Contains(t))
            return;
        else
            all.Add(t);

        XmlAttributes list1 = GetAttributeList(t.GetCustomAttributes(false));
        xao.Add(t, list1);

        foreach (var prop in t.GetProperties())
        {
            XmlAttributes list2 = GetAttributeList(prop.GetCustomAttributes(false));
            xao.Add(t, prop.Name, list2);
            AttachXmlAttributes(xao, all, prop.PropertyType);
        }
    }

    private static XmlAttributes GetAttributeList(object[] attributes)
    {
        XmlAttributes list = new XmlAttributes();
        foreach (var attribute in attributes)
        {
            Type type = attribute.GetType();
            if (type.Name == "XmlAttributeAttribute") list.XmlAttribute = (XmlAttributeAttribute)attribute;
            else if (type.Name == "XmlArrayAttribute") list.XmlArray = (XmlArrayAttribute)attribute;
            else if (type.Name == "XmlArrayItemAttribute") list.XmlArrayItems.Add((XmlArrayItemAttribute)attribute);

        }
        return list;
    }
    public static string GetSchema<T>()
    {
        XmlAttributeOverrides xao = new XmlAttributeOverrides();
        AttachXmlAttributes(xao, typeof(T));

        XmlReflectionImporter importer = new XmlReflectionImporter(xao);
        XmlSchemas schemas = new XmlSchemas();
        XmlSchemaExporter exporter = new XmlSchemaExporter(schemas);
        XmlTypeMapping map = importer.ImportTypeMapping(typeof(T));
        exporter.ExportTypeMapping(map);

        using (MemoryStream ms = new MemoryStream())
        {
            schemas[0].Write(ms);
            ms.Position = 0;
            return new StreamReader(ms).ReadToEnd();
        }
    }

Hope this helps someone else.

Answer 3

Look at the System.Xml.Serialization.XmlSchemaExporter class. I can't recall the exact details, but there is enough functionality in that namespace to do what you require.

Answer 4

Improvement to Matt Murrell version: to apply XmlAttributes recursively for nested property user type (for example CustomerClass property).

private static void AttachXmlAttributes(XmlAttributeOverrides xao, List<Type> all, Type t)
{
    if (all.Contains(t))
    {
        return;
    }
    else
    {
        all.Add(t);
    }

    var list1 = GetAttributeList(t.GetCustomAttributes(false));
    xao.Add(t, list1);

    foreach (var prop in t.GetProperties())
    {
        var propType = prop.PropertyType;
        if (propType.IsGenericType) // is list?
        {
            var args = propType.GetGenericArguments();
            if (args != null && args.Length == 1)
            {                        
                var genType = args[0];
                if (genType.Name.ToLower() != "object")
                {
                    var list2 = GetAttributeList(prop.GetCustomAttributes(false));
                    xao.Add(t, prop.Name, list2);
                    AttachXmlAttributes(xao, all, genType);
                }                        
            }
        }
        else
        {
            var list2 = GetAttributeList(prop.GetCustomAttributes(false));
            xao.Add(t, prop.Name, list2);
            AttachXmlAttributes(xao, all, prop.PropertyType);
        }
    }
}        

private static XmlAttributes GetAttributeList(object[] attributes)
{
    var list = new XmlAttributes();
    foreach (var attr in attributes)
    {
        Type type = attr.GetType();
        switch (type.Name)
        {
            case "XmlAttributeAttribute":
                list.XmlAttribute = (XmlAttributeAttribute)attr;
                break;                    
            case "XmlRootAttribute":
                list.XmlRoot = (XmlRootAttribute)attr;
                break;
            case "XmlElementAttribute":
                list.XmlElements.Add((XmlElementAttribute)attr);
                break;
            case "XmlArrayAttribute":
                list.XmlArray = (XmlArrayAttribute)attr;
                break;
            case "XmlArrayItemAttribute":
                list.XmlArrayItems.Add((XmlArrayItemAttribute)attr);
                break;
        }
    }
    return list;
}