Wie analysieren Sie ein XSD, um die Informationen von <xsd:simpleType> - Elemente, die mithilfe von C#?

Ich habe ähnliche Fragen in der Vergangenheit (vollständige Offenlegung, ich habe Fragen eine ähnliche Frage mich). In der Analyse einer XSD ist nicht für das schwache des Herzens.

Haben Sie grundsätzlich 2 Möglichkeiten, die erste ist einfacher zu implementieren, aber kann gebrochen werden, mehr leicht durch geringfügige änderungen an der XSD. der 2. ist ein robuster, aber schwer zu implementieren.

Option 1:

Parsen der XSD mit LINQ (oder andere C# - XML-parser, wenn Sie bevorzugen). Da eine XSD ist nur eine XML ist, können Sie laden Sie Sie in einem XDocument und es gerade gelesen über LINQ.

Nur für eine Stichprobe von eigenen XSD:

<xsd:simpleType name="Amount_Type">
  <xsd:annotation>
    <xsd:documentation>Amount</xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="xsd:string">
    <xsd:maxLength value="12" />
  </xsd:restriction>
</xsd:simpleType>

Können Sie den Zugriff auf die MaxLength:

var xDoc = XDocument.Load("your XSD path");
var ns = XNamespace.Get(@"http://www.w3.org/2001/XMLSchema");

var length = (from sType in xDoc.Element(ns + "schema").Elements(ns + "simpleType")
              where sType.Attribute("name").Value == "Amount_Type"
              from r in sType.Elements(ns + "restriction")
              select r.Element(ns + "maxLength").Attribute("value")
                      .Value).FirstOrDefault();

Diese nicht bieten eine sehr einfache Methode für die Analyse von Typ-Namen, besonders für extended-Typen. Um diese zu verwenden müssen Sie wissen, den genauen Pfad für jedes element, die Sie suchen.

Option 2:

Dies ist viel zu Komplex für eine schnelle Antwort (Hinweis: siehe edit unten - ich hatte einige Zeit und zusammen eine funktionierende Lösung), so werde ich Sie dazu ermutigen, einen Blick auf meine eigene Frage, die ich weiter oben verlinkt. In es, ich verlinkte einen toller blog, das zeigt, wie ernst brechen die XSD in Stücke und vielleicht erlauben Sie zum ausführen der Art der Suche, die Sie möchten. Sie haben zu entscheiden, ob es der Mühe Wert ist, Sie zu entwickeln (das blog zeigt eine Implementierung mit XmlReader enthält eine XML-Datei validiert gegen XSD-Frage, aber Sie können ganz einfach erreichen dies durch direktes laden der XSD und analysieren es.

2 entscheidende Idee zu finden, in dem blog sind:

//in the getRestriction method (reader in this context is an `XmlReader` that 
// contains a XML that is being validated against the specific XSD
if (reader.SchemaInfo.SchemaElement == null) return null;
simpleType = reader.SchemaInfo.SchemaElement.ElementSchemaType as XmlSchemaSimpleType;
if (simpleType == null) return null;
restriction = simpleType.Content as XmlSchemaSimpleTypeRestriction;

//then in the getMaxLength method
if (restriction == null) return null;
List<int> result = new List<int>();
foreach (XmlSchemaObject facet in restriction.Facets) {
if (facet is XmlSchemaMaxLengthFacet) result.Add(int.Parse(((XmlSchemaFacet) facet).Value));

Ich tatsächlich versucht, die gleiche Sache im letzten Jahr zu analysieren, eine XSD-Datei als Teil eines umfangreichen Daten-validation-Methode. Es hat mich den besseren Teil von einer Woche, um wirklich zu verstehen, was passiert war, eine Anpassung der Methoden in den blog, um für meine Zwecke. Es ist definitiv die beste Art der Umsetzung genau das, was Sie wollen.

Wenn Sie möchten, um zu versuchen, dies mit einem eigenständigen schema, laden Sie die XSD in ein XmlSchemaSet Objekt und verwenden Sie dann GlobalTypes - Eigenschaft, um zu helfen, finden Sie die spezifische Art Sie sind auf der Suche nach.

EDIT:
Ich zog meinen alten code und begann mit der Zusammenstellung der code, um Ihnen zu helfen.

Ersten Ihren laden schema:

XmlSchemaSet set; //this needs to be accessible to the methods below,
                  // so should be a class level field or property

using (var fs = new FileStream(@"your path here", FileMode.Open)
{
    var schema = XmlSchema.Read(fs, null);

    set = new XmlSchemaSet();
    set.Add(schema);
    set.Compile();
}

Die folgenden Methoden sollten Sie in der Nähe, was Sie wollen, basierend auf dem XSD-Sie zur Verfügung gestellt. Es sollte ziemlich anpassungsfähig Umgang mit komplexeren Strukturen.

public Dictionary<string, int> GetElementMaxLength(String xsdElementName)
{
    if (xsdElementName == null) throw new ArgumentException();
    //if your XSD has a target namespace, you need to replace null with the namespace name
    var qname = new XmlQualifiedName(xsdElementName, null);

    //find the type you want in the XmlSchemaSet    
    var parentType = set.GlobalTypes[qname];

    //call GetAllMaxLength with the parentType as parameter
    var results = GetAllMaxLength(parentType);

    return results;
}

private Dictionary<string, int> GetAllMaxLength(XmlSchemaObject obj)
{
    Dictionary<string, int> dict = new Dictionary<string, int>();

    //do some type checking on the XmlSchemaObject
    if (obj is XmlSchemaSimpleType)
    {
        //if it is a simple type, then call GetMaxLength to get the MaxLength restriction
        var st = obj as XmlSchemaSimpleType;
        dict[st.QualifiedName.Name] = GetMaxLength(st);
    }
    else if (obj is XmlSchemaComplexType)
    {

        //if obj is a complexType, cast the particle type to a sequence
        // and iterate the sequence
        // warning - this will fail if it is not a sequence, so you might need
        // to make some adjustments if you have something other than a xs:sequence
        var ct = obj as XmlSchemaComplexType;
        var seq = ct.ContentTypeParticle as XmlSchemaSequence;

        foreach (var item in seq.Items)
        {
            //item will be an XmlSchemaObject, so just call this same method
            // with item as the parameter to parse it out
            var rng = GetAllMaxLength(item);

            //add the results to the dictionary
            foreach (var kvp in rng)
            {
                dict[kvp.Key] = kvp.Value;
            }
        }
    }
    else if (obj is XmlSchemaElement)
    {
        //if obj is an XmlSchemaElement, the you need to find the type
        // based on the SchemaTypeName property.  This is why your 
        // XmlSchemaSet needs to have class-level scope
        var ele = obj as XmlSchemaElement;
        var type = set.GlobalTypes[ele.SchemaTypeName];

        //once you have the type, call this method again and get the dictionary result
        var rng = GetAllMaxLength(type);

        //put the results in this dictionary.  The difference here is the dictionary
        // key is put in the format you specified
        foreach (var kvp in rng)
        {
            dict[String.Format("{0}/{1}", ele.QualifiedName.Name, kvp.Key)] = kvp.Value;
        }
    }

    return dict;
}

private Int32 GetMaxLength(XmlSchemaSimpleType xsdSimpleType)
{
    //get the content of the simple type
    var restriction = xsdSimpleType.Content as XmlSchemaSimpleTypeRestriction;

    //if it is null, then there are no restrictions and return -1 as a marker value
    if (restriction == null) return -1;

    Int32 result = -1;

    //iterate the facets in the restrictions, look for a MaxLengthFacet and parse the value
    foreach (XmlSchemaObject facet in restriction.Facets)
    {
        if (facet is XmlSchemaMaxLengthFacet)
        {
            result = int.Parse(((XmlSchemaFacet)facet).Value);
            break;
        }
    }

    return result;
}

Dann die Verwendung ist ziemlich einfach, Sie brauchen nur zu rufen GetElementMaxLength(String) Methode und wird es wieder ein Wörterbuch der Namen in dem format, das Sie zur Verfügung gestellt, mit dem Wert der max Länge:

var results = GetElementMaxLength("Setup_Type");

foreach (var item in results)
{
    Console.WriteLine("{0} | {1}", item.Key, item.Value);                
}

Meine Lösung ist vielleicht nicht genau das, was Sie suchen. Wahrscheinlich möchten Sie lieber mit System.Xml Klassen, um solche Informationen. Ich weiß nicht, wie viel Generika Sie möchten diese parser werden, sowieso, das sind nur meine 2 Cent. Mein code gerade verwendet reguläre Ausdrücke entwickelt, um richtig zu Gesicht 99% der Möglichkeiten (denke ich). Jemand rufen würde dies wie das Schießen eine fliege mit einem Maschinengewehr. Sowieso ist es:

using System.Text.RegularExpressions;
using System.IO;

static class Program
{
    static void main()
    {
        XsdFile file = new XsdFile(@"c:\temp\test.xsd");
        Console.WriteLine(file.Query("Setup_Type"));
    }
}

public class XsdFile
{

    Dictionary<string, XsdType> types;

    public XsdFile(string path)
    {
        string xsdBody = File.ReadAllText(path);
        types = XsdType.CreateTypes(xsdBody);
    }

    public string Query(string typename) {
        return Query(typename, "");
    }

    private string Query(string typename, string parent)
    {
        XsdType type;
        if (types.TryGetValue(typename, out type))
        {
            if (type.GetType() == typeof(ComplexType))
            {
                StringBuilder sb = new StringBuilder();
                ComplexType complexType = (ComplexType)type;
                foreach (string elementName in complexType.elements.Keys)
                {
                    string elementType = complexType.elements[elementName];
                    sb.AppendLine(Query(elementType, parent + "/" + elementName));
                }
                return sb.ToString();
            }
            else if (type.GetType() == typeof(SimpleType))
            {
                SimpleType simpleType = (SimpleType)type;
                return string.Format("{0} = {1}", parent, simpleType.maxLength);
            }
            else {
                return "";
            }
        }
        else
        {
            return "";
        }
    }
}

public abstract class XsdType
{

    string name;

    public XsdType(string name)
    {
        this.name = name;
    }

    public static Dictionary<string, XsdType> CreateTypes(string xsdBody)
    {

        Dictionary<string, XsdType> types = new Dictionary<string, XsdType>();

        MatchCollection mc_types = Regex.Matches(xsdBody, @"<xsd:(?<kind>complex|simple)Type[\s\t]+(?<attributes>[^>]+)>(?<body>.+?)</xsd:\1Type>", RegexOptions.Singleline);
        foreach (Match m_type in mc_types)
        {
            string typeKind = m_type.Groups["kind"].Value;
            string typeAttributes = m_type.Groups["attributes"].Value;
            string typeBody = m_type.Groups["body"].Value;
            string typeName;
            Match m_nameattribute = Regex.Match(typeAttributes, @"name[\s\t]*=[\s\t]*""(?<name>[^""]+)""", RegexOptions.Singleline);
            if (m_nameattribute.Success)
            {
                typeName = m_nameattribute.Groups["name"].Value;
                if (typeKind == "complex")
                {
                    ComplexType current_type = new ComplexType(typeName);
                    MatchCollection mc_elements = Regex.Matches(typeBody, @"<xsd:element(?<attributes>.+?)/>", RegexOptions.Singleline);
                    foreach (Match m_element in mc_elements)
                    {
                        Dictionary<string, string> elementAttributes = ParseAttributes(m_element.Groups["attributes"].Value);
                        string elementName;
                        string elementType;
                        if (!elementAttributes.TryGetValue("name", out elementName))
                            continue;
                        if (!elementAttributes.TryGetValue("type", out elementType))
                            continue;
                        current_type.elements.Add(elementName, elementType);
                    }
                    types.Add(current_type.name, current_type);
                }
                else if (typeKind == "simple")
                {
                    Match m_maxLength = Regex.Match(typeBody, @"<xsd:restriction[^>]+>.+?<xsd:maxLength.+?value=""(?<maxLength>[^""]+)""", RegexOptions.Singleline);
                    if (m_maxLength.Success)
                    {
                        string maxLength = m_maxLength.Groups["maxLength"].Value;
                        SimpleType current_type = new SimpleType(typeName);
                        current_type.maxLength = maxLength;
                        types.Add(current_type.name, current_type);
                    }
                }
            }
            else
            {
                continue;
            }
        }
        return types;
    }

    private static Dictionary<string, string> ParseAttributes(string value)
    {
        Dictionary<string, string> attributes = new Dictionary<string, string>();
        MatchCollection mc_attributes = Regex.Matches(value, @"(?<name>[^=\s\t]+)[\s\t]*=[\s\t]*""(?<value>[^""]+)""", RegexOptions.Singleline);
        foreach (Match m_attribute in mc_attributes)
        {
            attributes.Add(m_attribute.Groups["name"].Value, m_attribute.Groups["value"].Value);
        }
        return attributes;
    }

}

public class SimpleType : XsdType
{

    public string maxLength;

    public SimpleType(string name)
        : base(name)
    {
    }

}

public class ComplexType : XsdType
{

    //(name-type)
    public Dictionary<string, string> elements = new Dictionary<string,string>();

    public ComplexType(string name)
        : base(name)
    {
    }

}