如何解析XSD以获取信息 <xsd:simpleType> 使用C＃的元素？

Question

我有一个具有多种复杂类型和简单类型的XSD（文件的一部分如下所示）。 我需要解析此文档以从复杂类型中引用的每个简单类型中获取maxLength。 任何人都可以请求如何实现这一点？ 我需要以通用的方式实现它，所以如果我查询“Setup_Type”，它应该给出以下输出。 谢谢！

NewSetup / Amount = 12（元素标签的名称属性由“/”和嵌套的simpleType中的maxLength分隔）

NewSetup / Name = 50

<xsd:complexType name="Setup_Type">
  <xsd:sequence>
    <xsd:element name="NewSetup" type="NewSetup_Type" minOccurs="1" maxOccurs="1" />
  </xsd:sequence>
</xsd:complexType>

<xsd:complexType name="NewSetup_Type">
  <xsd:sequence>
    <xsd:element name="Amount" type="Amount_Type"  minOccurs="1" maxOccurs="1" />
    <xsd:element name="Name" type="Name_Type"  minOccurs="1" maxOccurs="1" />
  </xsd:sequence>
</xsd:complexType>

<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>

<xsd:simpleType name="Name_Type">
  <xsd:annotation>
    <xsd:documentation>Name</xsd:documentation>
  </xsd:annotation>
  <xsd:restriction base="xsd:string">
    <xsd:maxLength value="50" />
  </xsd:restriction>
</xsd:simpleType>

Answer 1

我已经看到过去提出的类似问题 （完全披露，我自己也问过类似的问题 ）。 解析XSD并不适合胆小的人。

您基本上有两个选项，第一个更容易实现，但可以通过对XSD的微小更改更容易地解决。 第二个是更强大但很难实现。

选项1：

使用LINQ（或其他C＃XML解析器，如果您愿意）解析XSD。 由于XSD只是一个XML，您可以将其加载到XDocument ，然后通过LINQ读取它。

仅为您自己的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>

您可以访问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();

这不提供一种非常简单的按类型名称解析的方法，特别是对于扩展类型。 要使用它，您需要知道要查找的每个元素的确切路径。

选项2：

这对于快速回答来说太复杂了（注意：请参阅下面的编辑 - 我有一些时间并制定了一个有效的解决方案） ，所以我鼓励你看看我上面提到的我自己的问题。 在其中，我链接了一个很棒的博客 ，该博客展示了如何将XSD严重分解为碎片并可能允许您执行所需的搜索类型。 您必须决定是否值得开发它（博客显示了一个包含XmlReader的实现，该实现包含针对相关XSD验证的XML，但您可以通过直接加载XSD并解析它来轻松实现此目的。

在博客中找到的2个关键想法是：

// 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));

我实际上去年尝试过同样的事情来解析XSD作为复杂数据验证方法的一部分。 我花了一个星期的时间来真正了解正在发生的事情，以便根据我的目的调整博客中的方法。 这绝对是实现您想要的最佳方式。

如果要使用独立模式尝试此操作，可以将XSD加载到XmlSchemaSet对象中，然后使用GlobalTypes属性来帮助您查找要查找的特定类型。

---

编辑：我提取了我的旧代码并开始整理代码来帮助你。

首先加载你的架构：

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();
}

根据您提供的XSD，以下方法可以让您接近您想要的内容。 它应该非常适合处理更复杂的结构。

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;
}

然后使用非常简单，您只需要调用GetElementMaxLength(String)方法，它将返回您提供的格式的名称字典，其值为最大长度：

var results = GetElementMaxLength("Setup_Type");

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

Answer 2

public class result_tree
{
    public string nodevalue = "";

    public bool IsTerminal { get { return ChildCount == 0; } }

    public List<result_tree> children = new List<result_tree>();

    public int ChildCount { get { return children.Count; } }

    public result_tree(string v) { nodevalue = v; }

    private void print_children(bool skip, string prefix)
    {
        if (IsTerminal)
            Console.WriteLine(prefix + (prefix.Length==0?"":"/") + nodevalue);
        else
            foreach (result_tree rt in children)
                rt.print_children(false,prefix + (prefix.Length == 0 ? "" : "/") + (skip?"":nodevalue));
    }

    public void print_children()
    {
        print_children(true,"");
    }
}

static class Program
{
    private static void ValidationCallBack(object sender, ValidationEventArgs args)
    {
        Console.WriteLine(args.Message);
    }

    public static result_tree results;



    static string deref_simple(XmlSchemaSimpleType simp)
    {
        XmlSchemaSimpleTypeRestriction xsstr = (XmlSchemaSimpleTypeRestriction)simp.Content;
        foreach (object o in xsstr.Facets)
        {
            if (o.GetType() == typeof(XmlSchemaMaxLengthFacet))
            {
                XmlSchemaMaxLengthFacet fac = (XmlSchemaMaxLengthFacet)o;
                return fac.Value;
            }
        }
        return "";
    }

    static result_tree deref_complex(XmlSchema xs, XmlSchemaComplexType cplx)
    {
        result_tree rt = new result_tree(cplx.Name);

        if (cplx.Particle.GetType() == typeof(XmlSchemaSequence))
        {
            XmlSchemaSequence seq = (XmlSchemaSequence)cplx.Particle;
            foreach (object o in seq.Items)
            {
                if (o.GetType() == typeof(XmlSchemaElement))
                {
                    XmlSchemaElement elem = (XmlSchemaElement)o;

                    XmlQualifiedName name = elem.SchemaTypeName;

                    result_tree branch;

                    object referto = xs.SchemaTypes[name];
                    if (referto.GetType() == typeof(XmlSchemaComplexType))
                    {
                        branch = deref_complex(xs,(XmlSchemaComplexType)referto);
                        branch.nodevalue = elem.Name;
                    }
                    else if (referto.GetType() == typeof(XmlSchemaSimpleType))
                    {
                        XmlSchemaSimpleType st = (XmlSchemaSimpleType)referto;

                        branch = new result_tree(elem.Name + " = " + deref_simple(st).ToString());
                    }
                    else
                    {
                        branch = null;
                    }
                    if( branch != null )
                        rt.children.Add(branch);

                }
            }
        }

        return rt;
    }

    /// <summary>
    /// The main entry point for the application.
    /// </summary>
    [STAThread]
    static void Main()
    {

        StreamReader sr = new StreamReader("aschema.xml");
        XmlSchema xs = XmlSchema.Read(sr, ValidationCallBack);
        XmlSchemaSet xss = new XmlSchemaSet();
        xss.Add(xs);
        xss.Compile();

        Console.WriteLine("Query: ");
        string q = Console.ReadLine();

        XmlQualifiedName xqn = new XmlQualifiedName(q);

        if (xs.SchemaTypes.Contains(xqn))
        {
            object o = xs.SchemaTypes[xqn];
            if (o.GetType() == typeof(XmlSchemaComplexType))
            {
                results = deref_complex(xs, (XmlSchemaComplexType)o);
                results.print_children();
            }   
        }
        else
        {
            Console.WriteLine("Not found!");
        }

    }
}

Answer 3

我的解决方案可能并不完全符合您的要求。 您可能更喜欢使用System.Xml类来处理此类信息。 我不知道你喜欢这个解析器的通用程度，无论如何这些只是我的2美分。 我的代码只使用正则表达式来正确面对99％的可能性（我猜）。 有人会称之为用枪射击苍蝇。 无论如何就是这样：

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)
    {
    }

}